HG_REPOSITORIES/LPP/INSTRUMENTATION/libuc2 Commit - r72:6ad096835359

More cleanup, added subdirectories inside include dir, cleaned include tree,...

jeandet -

r72:6ad096835359 dev_alexis

parent child

Context file:

r72:6ad096835359

Expand all files

include/ADC/ads1278.h created 644 +72 0

			@@ -0,0 +1,72
		1	/*------------------------------------------------------------------------------
		2	#-- This file is a part of the libuc, microcontroler library
		3	#-- Copyright (C) 2011, Alexis Jeandet
		4	#--
		5	#-- This program is free software; you can redistribute it and/or modify
		6	#-- it under the terms of the GNU General Public License as published by
		7	#-- the Free Software Foundation; either version 3 of the License, or
		8	#-- (at your option) any later version.
		9	#--
		10	#-- This program is distributed in the hope that it will be useful,
		11	#-- but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	#-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	#-- GNU General Public License for more details.
		14	#--
		15	#-- You should have received a copy of the GNU General Public License
		16	#-- along with this program; if not, write to the Free Software
		17	#-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
		18	#-------------------------------------------------------------------------------
		19	#-- Author : Alexis Jeandet
		20	#-- Mail : alexis.jeandet@gmail.com
		21	#-------------------------------------------------------------------------------*/
		22	#ifndef ADS1278_H
		23	#define ADS1278_H
		24	#include <uhandle.h>
		25
		26	typedef void (*set_clkdiv_t)(int val);
		27	typedef void (*set_sync_t)(int val);
		28	typedef void (*set_mode0_t)(int val);
		29	typedef void (*set_mode1_t)(int val);
		30	typedef void (*set_fsync_t)(int val);
		31	typedef int (*ready_t)();
		32
		33	struct ads1278Regs
		34	{
		35	sspDev SSP_device;
		36	set_clkdiv_t set_clkdiv;
		37	set_sync_t set_sync;
		38	set_mode0_t set_mode0;
		39	set_mode1_t set_mode1;
		40	set_fsync_t set_fsync;
		41	ready_t ready;
		42	};
		43
		44	typedef struct ads1278Regs ads1278Dev;
		45
		46	void ads1278open(ads1278Dev* codec,sspDev dev);
		47	void ads1278sample(ads1278Dev* dev);
		48	void ads1278readresult(ads1278Dev* dev,unsigned int* CH1,unsigned int* CH2,unsigned int* CH3,unsigned int* CH4,unsigned int* CH5,unsigned int* CH6,unsigned int* CH7,unsigned int* CH8);
		49
		50	extern void bsp_ads1278_Sample();
		51	extern int bsp_ads1278_Ready();
		52	extern void bsp_ads1278_Synch();
		53
		54	#endif
		55
		56
		57
		58
		59
		60
		61
		62
		63
		64
		65
		66
		67
		68
		69
		70
		71
		72

include/AUDIO/CS43L22.h created 644 +86 0

			@@ -0,0 +1,86
		1	/*------------------------------------------------------------------------------
		2	-- This file is a part of the libuc, microcontroler library
		3	-- Copyright (C) 2011, Alexis Jeandet
		4	--
		5	-- This program is free software; you can redistribute it and/or modify
		6	-- it under the terms of the GNU General Public License as published by
		7	-- the Free Software Foundation; either version 3 of the License, or
		8	-- (at your option) any later version.
		9	--
		10	-- This program is distributed in the hope that it will be useful,
		11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	-- GNU General Public License for more details.
		14	--
		15	-- You should have received a copy of the GNU General Public License
		16	-- along with this program; if not, write to the Free Software
		17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
		18	-------------------------------------------------------------------------------
		19	-- Author : Alexis Jeandet
		20	-- Mail : alexis.jeandet@gmail.com
		21	-------------------------------------------------------------------------------*/
		22	#ifndef CS43L22_H
		23	#define CS43L22_H
		24
		25	#include <i2c.h>
		26
		27	typedef struct CS43L22_t
		28	{
		29	i2c_t i2cdev;
		30	uint8_t devAddress;
		31	}CS43L22_t;
		32
		33	extern int cs43l22open(CS43L22_t* dev,i2c_t i2cdev,uint8_t A0);
		34	extern uint8_t cs43l22getID(CS43L22_t* dev);
		35
		36	#define CS43L22_I2C_ADDRESS 0x4a
		37
		38
		39	#define CS43L22_MAP_ID 1
		40	#define CS43L22_MAP_Power_Ctl_1 2
		41	#define CS43L22_MAP_Power_Ctl_2 4
		42	#define CS43L22_MAP_Clocking_Ctl 5
		43	#define CS43L22_MAP_Interface_Ctl_1 6
		44	#define CS43L22_MAP_Interface_Ctl_2 7
		45	#define CS43L22_MAP_Passthrough_A 8
		46	#define CS43L22_MAP_Passthrough_B 9
		47	#define CS43L22_MAP_Analog_ZC_SR 0xA
		48	#define CS43L22_MAP_Passthrough 0xC
		49	#define CS43L22_MAP_Playback_Ctl_1 0xD
		50	#define CS43L22_MAP_Misc_Ctl 0xE
		51	#define CS43L22_MAP_Playback_Ctl_2 0xF
		52	#define CS43L22_MAP_Passthrough_A_Vol 0x14
		53	#define CS43L22_MAP_Passthrough_B_Vol 0x15
		54	#define CS43L22_MAP_PCMA_Vol 0x1A
		55	#define CS43L22_MAP_PCMB_Vol 0x1B
		56	#define CS43L22_MAP_BEEP_Freq 0x1C
		57	#define CS43L22_MAP_BEEP_Vol 0x1d
		58	#define CS43L22_MAP_BEEP_Tone_Cfg 0x1E
		59	#define CS43L22_MAP_Tone_Ctl 0x1F
		60	#define CS43L22_MAP_Master_A_Vol 0x20
		61	#define CS43L22_MAP_Master_B_Vol 0x21
		62	#define CS43L22_MAP_Headphone_A_Vol 0x22
		63	#define CS43L22_MAP_Headphone_B_Vol 0x23
		64	#define CS43L22_MAP_Speaker_A_Vol 0x24
		65	#define CS43L22_MAP_Speaker_B_Vol 0x25
		66	#define CS43L22_MAP_Channel_Mixer 0x26
		67	#define CS43L22_MAP_Limit_Ctl_1 0x27
		68	#define CS43L22_MAP_Limit Ctl_2 0x28
		69	#define CS43L22_MAP_Limiter_Attack 0x29
		70	#define CS43L22_MAP_Overflow_And_Clock_Status 0x2E
		71	#define CS43L22_MAP_Battery_Compensation 0x2F
		72	#define CS43L22_MAP_VP_Battery_Level 0x30
		73	#define CS43L22_MAP_Speaker_Status 0x31
		74	#define CS43L22_MAP_Temperature_Monitor_Control 0x32
		75	#define CS43L22_MAP_Thermal_Foldback 0x33
		76	#define CS43L22_MAP_Charge_Pump_Frequency 0x34
		77
		78
		79	#endif
		80
		81
		82
		83
		84
		85
		86

include/AUDIO/VS10XX.h created 644 +98 0

			@@ -0,0 +1,98
		1	/*------------------------------------------------------------------------------
		2	#-- This file is a part of the libuc, microcontroler library
		3	#-- Copyright (C) 2011, Alexis Jeandet
		4	#--
		5	#-- This program is free software; you can redistribute it and/or modify
		6	#-- it under the terms of the GNU General Public License as published by
		7	#-- the Free Software Foundation; either version 3 of the License, or
		8	#-- (at your option) any later version.
		9	#--
		10	#-- This program is distributed in the hope that it will be useful,
		11	#-- but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	#-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	#-- GNU General Public License for more details.
		14	#--
		15	#-- You should have received a copy of the GNU General Public License
		16	#-- along with this program; if not, write to the Free Software
		17	#-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
		18	#-------------------------------------------------------------------------------
		19	#-- Author : Alexis Jeandet
		20	#-- Mail : alexis.jeandet@member.fsf.org
		21	#-------------------------------------------------------------------------------*/
		22	#ifndef VS10XX_H
		23	#define VS10XX_H
		24	#include <spi.h>
		25
		26	#define VSMODE 0
		27	#define VSSTATUS 1
		28	#define VSBASS 2
		29	#define VSCLOCKF 3
		30	#define VSDECODE_TIME 4
		31	#define VSAUDATA 5
		32	#define VSWRAM 6
		33	#define VSWRAMADDR 7
		34	#define VSHDAT0 8
		35	#define VSHDAT1 9
		36	#define VSAIADDR 0xA
		37	#define VSVOL 0xB
		38	#define VSAICTRL0 0xC
		39	#define VSAICTRL1 0xD
		40	#define VSAICTRL2 0xE
		41	#define VSAICTRL3 0xF
		42
		43	// TODO real generic VS10XX driver + plugin and patch loader
		44
		45	typedef enum VS10XXVER_en
		46	{
		47	UNKNOWN,
		48	VS1001,
		49	VS1011,
		50	VS1002,
		51	VS1003,
		52	VS1053,
		53	VS1033,
		54	VS1103
		55	}VS10XXVER_en;
		56
		57	typedef struct vs10XXDev
		58	{
		59	spi_t SPIdev;
		60	void (*setxCS)(char);
		61	void (*setxRST)(char);
		62	void (*setxDCS)(char);
		63	int (*getDREQ)();
		64	VS10XXVER_en VERSION;
		65	}vs10XXDev;
		66
		67
		68	void vs10XXopen(vs10XXDev* codec,spi_t dev, void (setxCS)(char),void (setxRST)(char),void (setxDCS)(char),int (getDREQ)());
		69	void vs10XXsoftreset(vs10XXDev* dev);
		70	int vs10XXcmdread(vs10XXDev* dev,char address);
		71	void vs10XXcmdwrite(vs10XXDev* dev,char address,int value);
		72	void vs10XXstream32bytes(vs10XXDev* dev,char* buffer);
		73	void vs10XXsetCansel(vs10XXDev* dev);
		74	int vs10XXcanselAccepted(vs10XXDev* dev);
		75	void vs10XXsoftReset(vs10XXDev* dev);
		76	//extern void vs10XXclearXCS();
		77	//extern void vs10XXsetXCS();
		78	//extern int vs10XXDREQ();
		79
		80	#endif //VS10XX_H
		81
		82
		83
		84
		85
		86
		87
		88
		89
		90
		91
		92
		93
		94
		95
		96
		97
		98

include/EEPROMS/24LC0X.h created 644 +55 0

			@@ -0,0 +1,55
		1	/*------------------------------------------------------------------------------
		2	-- This file is a part of the libuc, microcontroler library
		3	-- Copyright (C) 2011, Alexis Jeandet
		4	--
		5	-- This program is free software; you can redistribute it and/or modify
		6	-- it under the terms of the GNU General Public License as published by
		7	-- the Free Software Foundation; either version 3 of the License, or
		8	-- (at your option) any later version.
		9	--
		10	-- This program is distributed in the hope that it will be useful,
		11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	-- GNU General Public License for more details.
		14	--
		15	-- You should have received a copy of the GNU General Public License
		16	-- along with this program; if not, write to the Free Software
		17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
		18	-------------------------------------------------------------------------------
		19	-- Author : Alexis Jeandet
		20	-- Mail : alexis.jeandet@member.fsf.org
		21	-------------------------------------------------------------------------------*/
		22	#ifndef B24LC0X_H
		23	#define B24LC0X_H
		24
		25	#include <i2c.h>
		26
		27	typedef struct eeprom24lc0xDev
		28	{
		29	i2c_t iicdev;
		30	unsigned char devAddress;
		31	unsigned char size;
		32	}eeprom24lc0xDev;
		33
		34
		35
		36	extern void eeprom24lc0xopen(eeprom24lc0xDev* dev,i2c_t iicdev,unsigned char A0_A1_A2_val,unsigned int size);
		37
		38	extern void eeprom24lc0xpagewrite(eeprom24lc0xDev* dev,unsigned char address,unsigned char* page);
		39	extern void eeprom24lc0xpageread(eeprom24lc0xDev* dev,unsigned char address,unsigned char* page);
		40	extern void eeprom24lc0xbytewrite(eeprom24lc0xDev* dev,unsigned char address,unsigned char data);
		41	extern unsigned char eeprom24lc0xbyteread(eeprom24lc0xDev* dev,unsigned char address);
		42	extern void eeprom24lc0xreadn(eeprom24lc0xDev* dev,unsigned char address,unsigned char* data, unsigned int count);
		43	extern void eeprom24lc0xwriten(eeprom24lc0xDev* dev,unsigned char address,unsigned char* data, unsigned int count);
		44
		45
		46
		47
		48	#endif
		49
		50
		51
		52
		53
		54
		55

include/EEPROMS/N25Q128.h created 644 +73 0

			@@ -0,0 +1,73
		1	/*------------------------------------------------------------------------------
		2	-- This file is a part of the libuc, microcontroler library
		3	-- Copyright (C) 2013, Alexis Jeandet
		4	--
		5	-- This program is free software; you can redistribute it and/or modify
		6	-- it under the terms of the GNU General Public License as published by
		7	-- the Free Software Foundation; either version 3 of the License, or
		8	-- (at your option) any later version.
		9	--
		10	-- This program is distributed in the hope that it will be useful,
		11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	-- GNU General Public License for more details.
		14	--
		15	-- You should have received a copy of the GNU General Public License
		16	-- along with this program; if not, write to the Free Software
		17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
		18	-------------------------------------------------------------------------------
		19	-- Author : Alexis Jeandet
		20	-- Mail : alexis.jeandet@member.fsf.org
		21	-------------------------------------------------------------------------------*/
		22	#ifndef N25Q128_H
		23	#define N25Q128_H
		24
		25	#include <spi.h>
		26
		27	typedef struct eepromN25Q128Dev
		28	{
		29	spi_t spidev;
		30	void (*select)(int sel);
		31	void (*writeprotect)(int wp);
		32	void (*holdreset)(int hr);
		33	}eepromN25Q128Dev;
		34
		35	#define N25Q128_PAGE_SZ 256
		36	#define N25Q128_CAPACITY_IN_BYTES (1024102416) /16MB/
		37
		38	#define N25Q128_READID 0x9E
		39	#define N25Q128_READ 0x03
		40	#define N25Q128_FASTREAD 0x0B
		41	#define N25Q128_DOFR 0x3B
		42	#define N25Q128_DIOFR 0xBB
		43	#define N25Q128_QOFR 0x6B
		44	#define N25Q128_QIOFR 0xEB
		45	#define N25Q128_ROTP 0x4B
		46	#define N25Q128_WREN 0x06
		47	#define N25Q128_WRDI 0x04
		48	#define N25Q128_PP 0x02
		49
		50
		51
		52
		53
		54	extern void eepromN25Q128open(eepromN25Q128Dev* dev,spi_t spidev,void (select)(int sel),void (writeprotect)(int wp),void (*holdreset)(int hr));
		55	extern void eepromN25Q128pagewrite(eepromN25Q128Dev* dev,uint32_t address,unsigned char* page);
		56	extern void eepromN25Q128pageread(eepromN25Q128Dev* dev,uint32_t address,unsigned char* page);
		57	extern void eepromN25Q128bytewrite(eepromN25Q128Dev* dev,uint32_t address,unsigned char data);
		58	extern unsigned char eepromN25Q128byteread(eepromN25Q128Dev* dev,uint32_t address);
		59	extern void eepromN25Q128readn(eepromN25Q128Dev* dev,uint32_t address,unsigned char* data, unsigned int count);
		60	extern void eepromN25Q128writen(eepromN25Q128Dev* dev,uint32_t address,unsigned char* data, unsigned int count);
		61	extern void eepromN25Q128enablewrite(eepromN25Q128Dev* dev);
		62
		63
		64
		65
		66	#endif
		67
		68
		69
		70
		71
		72
		73

include/FLASH/sdcard-sdio.h created 644 +62 0

			@@ -0,0 +1,62
		1	/*------------------------------------------------------------------------------
		2	-- This file is a part of the libuc, microcontroler library
		3	-- Copyright (C) 2012, Alexis Jeandet
		4	--
		5	-- This program is free software; you can redistribute it and/or modify
		6	-- it under the terms of the GNU General Public License as published by
		7	-- the Free Software Foundation; either version 3 of the License, or
		8	-- (at your option) any later version.
		9	--
		10	-- This program is distributed in the hope that it will be useful,
		11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	-- GNU General Public License for more details.
		14	--
		15	-- You should have received a copy of the GNU General Public License
		16	-- along with this program; if not, write to the Free Software
		17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
		18	-------------------------------------------------------------------------------
		19	-- Author : Alexis Jeandet
		20	-- Mail : alexis.jeandet@gmail.com
		21	-------------------------------------------------------------------------------*/
		22	#ifndef SDCARD_SDIO_H
		23	#define SDCARD_SDIO_H
		24	#include <sdcard.h>
		25
		26	extern void sdcardsdiomake(sdcardDev* sdcard,UHANDLE phy,void (rcvr_mmc) (UHANDLE,char ,uint32_t ),void (xmit_mmc) (UHANDLE,const char ,uint32_t ),void (setspeed) (UHANDLE phy,uint32_t speed),uint32_t (getspeed) (UHANDLE phy));
		27	extern void sdcardsdiomakeblkdev(blkdevice* dev,sdcardDev* sdcard, blkdevselect_t select,blkdevpower_t power,blkdevdetect_t detect,blkdevwriteprotected_t writeprotected);
		28
		29
		30	#endif //SDCARD_SDIO_H
		31
		32
		33
		34
		35
		36
		37
		38
		39
		40
		41
		42
		43
		44
		45
		46
		47
		48
		49
		50
		51
		52
		53
		54
		55
		56
		57
		58
		59
		60
		61
		62

include/FLASH/sdcard-spi.h created 644 +63 0

			@@ -0,0 +1,63
		1	/*------------------------------------------------------------------------------
		2	-- This file is a part of the libuc, microcontroler library
		3	-- Copyright (C) 2012, Alexis Jeandet
		4	--
		5	-- This program is free software; you can redistribute it and/or modify
		6	-- it under the terms of the GNU General Public License as published by
		7	-- the Free Software Foundation; either version 3 of the License, or
		8	-- (at your option) any later version.
		9	--
		10	-- This program is distributed in the hope that it will be useful,
		11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	-- GNU General Public License for more details.
		14	--
		15	-- You should have received a copy of the GNU General Public License
		16	-- along with this program; if not, write to the Free Software
		17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
		18	-------------------------------------------------------------------------------
		19	-- Author : Alexis Jeandet
		20	-- Mail : alexis.jeandet@gmail.com
		21	-------------------------------------------------------------------------------*/
		22	#ifndef SDCARD_SPI_H
		23	#define SDCARD_SPI_H
		24	#include <sdcard.h>
		25
		26
		27	extern void sdcardspimake(sdcardDev* sdcard,UHANDLE phy,void (rcvr_mmc) (UHANDLE,char ,uint32_t ),void (xmit_mmc) (UHANDLE,const char ,uint32_t ),void (setspeed) (UHANDLE phy,uint32_t speed),uint32_t (getspeed) (UHANDLE phy));
		28	extern void sdcardspimakeblkdev(blkdevice* dev,sdcardDev* sdcard, blkdevselect_t select,blkdevpower_t power,blkdevdetect_t detect,blkdevwriteprotected_t writeprotected);
		29
		30
		31	#endif
		32
		33
		34
		35
		36
		37
		38
		39
		40
		41
		42
		43
		44
		45
		46
		47
		48
		49
		50
		51
		52
		53
		54
		55
		56
		57
		58
		59
		60
		61
		62
		63

include/FLASH/sdcard.h created 644 +104 0

			@@ -0,0 +1,104
		1	/*------------------------------------------------------------------------------
		2	-- This file is a part of the libuc, microcontroler library
		3	-- Copyright (C) 2012, Alexis Jeandet
		4	--
		5	-- This program is free software; you can redistribute it and/or modify
		6	-- it under the terms of the GNU General Public License as published by
		7	-- the Free Software Foundation; either version 3 of the License, or
		8	-- (at your option) any later version.
		9	--
		10	-- This program is distributed in the hope that it will be useful,
		11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	-- GNU General Public License for more details.
		14	--
		15	-- You should have received a copy of the GNU General Public License
		16	-- along with this program; if not, write to the Free Software
		17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
		18	-------------------------------------------------------------------------------
		19	-- Author : Alexis Jeandet
		20	-- Mail : alexis.jeandet@member.fsf.org
		21	-------------------------------------------------------------------------------*/
		22	#ifndef SDCARD_H
		23	#define SDCARD_H
		24	#include <blkdevice.h>
		25
		26	/* MMC/SD command */
		27	#define CMD0 (0) /* GO_IDLE_STATE */
		28	#define CMD1 (1) /* SEND_OP_COND (MMC) */
		29	#define ACMD41 (0x80+41) /* SEND_OP_COND (SDC) */
		30	#define CMD8 (8) /* SEND_IF_COND */
		31	#define CMD9 (9) /* SEND_CSD */
		32	#define CMD10 (10) /* SEND_CID */
		33	#define CMD12 (12) /* STOP_TRANSMISSION */
		34	#define ACMD13 (0x80+13) /* SD_STATUS (SDC) */
		35	#define CMD16 (16) /* SET_BLOCKLEN */
		36	#define CMD17 (17) /* READ_SINGLE_BLOCK */
		37	#define CMD18 (18) /* READ_MULTIPLE_BLOCK */
		38	#define CMD23 (23) /* SET_BLOCK_COUNT (MMC) */
		39	#define ACMD23 (0x80+23) /* SET_WR_BLK_ERASE_COUNT (SDC) */
		40	#define CMD24 (24) /* WRITE_BLOCK */
		41	#define CMD25 (25) /* WRITE_MULTIPLE_BLOCK */
		42	#define CMD32 (32) /* ERASE_ER_BLK_START */
		43	#define CMD33 (33) /* ERASE_ER_BLK_END */
		44	#define CMD38 (38) /* ERASE */
		45	#define CMD55 (55) /* APP_CMD */
		46	#define CMD58 (58) /* READ_OCR */
		47
		48	/* Card type flags (CardType) */
		49	#define CT_MMC 0x01 /* MMC ver 3 */
		50	#define CT_SD1 0x02 /* SD ver 1 */
		51	#define CT_SD2 0x04 /* SD ver 2 */
		52	#define CT_SDC (CT_SD1\|CT_SD2) /* SD */
		53	#define CT_BLOCK 0x08 /* Block addressing */
		54
		55	struct sdcard_str
		56	{
		57	UHANDLE phy;
		58	int (rcvr_mmc) (UHANDLE phy,char buff,uint32_t bc);
		59	int (xmit_mmc) (UHANDLE phy,const char buff,uint32_t bc);
		60	int (*setspeed) (UHANDLE phy,uint32_t speed);
		61	uint32_t (*getspeed) (UHANDLE phy);
		62	DSTATUS Stat;
		63	char CardType;
		64	};
		65
		66	typedef volatile struct sdcard_str sdcardDev;
		67
		68	//extern void sdcardmake(sdcardDev* sdcard,UHANDLE phy,void (rcvr_mmc) (UHANDLE,char ,uint32_t ),void (xmit_mmc) (UHANDLE,const char ,uint32_t ),void (setspeed) (UHANDLE phy,uint32_t speed),uint32_t (getspeed) (UHANDLE phy));
		69	//extern void sdcardmakeblkdev(blkdevice* dev,sdcardDev* sdcard, blkdevselect_t select,blkdevpower_t power,blkdevdetect_t detect,blkdevwriteprotected_t writeprotected);
		70
		71
		72	#endif
		73
		74
		75
		76
		77
		78
		79
		80
		81
		82
		83
		84
		85
		86
		87
		88
		89
		90
		91
		92
		93
		94
		95
		96
		97
		98
		99
		100
		101
		102
		103
		104

include/FS/blkdevice.h created 644 +128 0

			@@ -0,0 +1,128
		1	/*------------------------------------------------------------------------------
		2	-- This file is a part of the libuc, microcontroler library
		3	-- Copyright (C) 2012, Alexis Jeandet
		4	--
		5	-- This program is free software; you can redistribute it and/or modify
		6	-- it under the terms of the GNU General Public License as published by
		7	-- the Free Software Foundation; either version 3 of the License, or
		8	-- (at your option) any later version.
		9	--
		10	-- This program is distributed in the hope that it will be useful,
		11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	-- GNU General Public License for more details.
		14	--
		15	-- You should have received a copy of the GNU General Public License
		16	-- along with this program; if not, write to the Free Software
		17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
		18	-------------------------------------------------------------------------------
		19	-- Author : Alexis Jeandet
		20	-- Mail : alexis.jeandet@gmail.com
		21	-------------------------------------------------------------------------------*/
		22	#ifndef BLKDEVICE_H
		23	#define BLKDEVICE_H
		24	#include <uhandle.h>
		25	/* Disk Status Bits (DSTATUS) */
		26
		27	#define STA_NOINIT 0x01 /* Drive not initialized */
		28	#define STA_NODISK 0x02 /* No medium in the drive */
		29	#define STA_PROTECT 0x04 /* Write protected */
		30
		31
		32	/* Command code for disk_ioctrl fucntion */
		33	/* Generic ioctl command (defined for FatFs) */
		34	#define CTRL_SYNC 0 /* Flush disk cache (for write functions) */
		35	#define GET_SECTOR_COUNT 1 /* Get media size (for only f_mkfs()) */
		36	#define GET_SECTOR_SIZE 2 /* Get sector size (for multiple sector size (_MAX_SS >= 1024)) */
		37	#define GET_BLOCK_SIZE 3 /* Get erase block size (for only f_mkfs()) */
		38	#define CTRL_ERASE_SECTOR 4 /* Force erased a block of sectors (for only _USE_ERASE) */
		39
		40	/* Generic ioctl command */
		41	#define CTRL_POWER 5 /* Get/Set power status */
		42	#define CTRL_LOCK 6 /* Lock/Unlock media removal */
		43	#define CTRL_EJECT 7 /* Eject media */
		44
		45	/* MMC/SDC specific ioctl command */
		46	#define MMC_GET_TYPE 10 /* Get card type */
		47	#define MMC_GET_CSD 11 /* Get CSD */
		48	#define MMC_GET_CID 12 /* Get CID */
		49	#define MMC_GET_OCR 13 /* Get OCR */
		50	#define MMC_GET_SDSTAT 14 /* Get SD status */
		51
		52	/* ATA/CF specific ioctl command */
		53	#define ATA_GET_REV 20 /* Get F/W revision */
		54	#define ATA_GET_MODEL 21 /* Get model name */
		55	#define ATA_GET_SN 22 /* Get serial number */
		56
		57	/* NAND specific ioctl command */
		58	#define NAND_FORMAT 30 /* Create physical format */
		59
		60	/* Status of Disk Functions */
		61	typedef unsigned char DSTATUS;
		62
		63	/* Results of Disk Functions */
		64	typedef enum {
		65	RES_OK = 0, /* 0: Successful */
		66	RES_ERROR, /* 1: R/W Error */
		67	RES_WRPRT, /* 2: Write Protected */
		68	RES_NOTRDY, /* 3: Not Ready */
		69	RES_PARERR /* 4: Invalid Parameter */
		70	} DRESULT;
		71
		72	typedef volatile struct blkdevice* blkdeviceptr;
		73
		74	typedef void (*blkdevselect_t)(char) ;
		75	typedef void (*blkdevpower_t)(char) ;
		76	typedef char (*blkdevdetect_t)() ;
		77	typedef char (*blkdevwriteprotected_t)() ;
		78	typedef DRESULT (blkdevwrite_t)(blkdeviceptr _this,const char buff,unsigned long sector,char count) ;
		79	typedef DRESULT (blkdevread_t)(blkdeviceptr _this,char buff,unsigned long sector,char count) ;
		80	typedef DRESULT (blkdevioctl_t)(blkdeviceptr _this,char ctrl,void buff) ;
		81	typedef DSTATUS (*blkdevinitialize_t)(blkdeviceptr _this) ;
		82	typedef DSTATUS (*blkdevstatus_t) (blkdeviceptr _this) ;
		83
		84	typedef struct blkdevice
		85	{
		86	UHANDLE phy;
		87	unsigned int size;
		88	unsigned int MaxSpeed;
		89	unsigned char Version;
		90	blkdevselect_t select;
		91	blkdevpower_t power;
		92	blkdevdetect_t detect;
		93	blkdevwriteprotected_t writeprotected;
		94	blkdevwrite_t write;
		95	blkdevread_t read;
		96	blkdevioctl_t ioctl;
		97	blkdevinitialize_t initialize;
		98	blkdevstatus_t status;
		99	}blkdevice;
		100
		101
		102
		103
		104
		105
		106	#endif
		107
		108
		109
		110
		111
		112
		113
		114
		115
		116
		117
		118
		119
		120
		121
		122
		123
		124
		125
		126
		127
		128

include/FS/fat32.h created 644 +194 0

			@@ -0,0 +1,194
		1	/*------------------------------------------------------------------------------
		2	-- This file is a part of the libuc, microcontroler library
		3	-- Copyright (C) 2012, Alexis Jeandet
		4	--
		5	-- This program is free software; you can redistribute it and/or modify
		6	-- it under the terms of the GNU General Public License as published by
		7	-- the Free Software Foundation; either version 3 of the License, or
		8	-- (at your option) any later version.
		9	--
		10	-- This program is distributed in the hope that it will be useful,
		11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	-- GNU General Public License for more details.
		14	--
		15	-- You should have received a copy of the GNU General Public License
		16	-- along with this program; if not, write to the Free Software
		17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
		18	-------------------------------------------------------------------------------
		19	-- Author : Alexis Jeandet
		20	-- Mail : alexis.jeandet@member.fsf.org
		21	-------------------------------------------------------------------------------*/
		22	#ifndef FAT32_H
		23	#define FAT32_H
		24	#include <mbr.h>
		25	#include <libucfs.h>
		26	#include <ucdirent.h>
		27	//#include <stdint.h>
		28	/BPB (Boot Sector) Offsets /
		29
		30	#define BS_jmpBootoff 0
		31	#define BS_OEMNameoff 3
		32	#define BPB_BytsPerSecoff 11
		33	#define BPB_SecPerClusoff 13
		34	#define BPB_RsvdSecCntoff 14
		35	#define BPB_NumFATsoff 16
		36	#define BPB_RootEntCntoff 17
		37	#define BPB_TotSec16off 19
		38	#define BPB_Mediaoff 21
		39	#define BPB_FATSz16off 22
		40	#define BPB_SecPerTrkoff 24
		41	#define BPB_NumHeadsoff 26
		42	#define BPB_HiddSecoff 28
		43	#define BPB_TotSec32off 32
		44	/FAT16/
		45	#define BS_DrvNumFAT16off 36
		46	#define BS_Reserved1FAT16off 37
		47	#define BS_BootSigFAT16off 38
		48	#define BS_VolIDFAT16off 39
		49	#define BS_VolLabFAT16off 43
		50	#define BS_FilSysTypeFAT16off 54
		51	/FAT32/
		52	#define BPB_FATSz32off 36
		53	#define BPB_ExtFlagsoff 40
		54	#define BPB_FSVeroff 42
		55	#define BPB_RootClusoff 44
		56	#define BPB_FSInfooff 48
		57	#define BPB_BkBootSecoff 50
		58	#define BPB_Reservedoff 52
		59	#define BS_DrvNumFAT32off 64
		60	#define BS_Reserved1FAT32off 65
		61	#define BS_BootSigFAT32off 66
		62	#define BS_VolIDFAT32off 67
		63	#define BS_VolLabFAT32off 71
		64	#define BS_FilSysTypeFAT32off 82
		65
		66
		67	#define DIR_Nameoff 0
		68	#define DIR_Attroff 0xb
		69	#define DIR_FstClusHIoff 0x14
		70	#define DIR_FstClusLOoff 0x1A
		71	#define DIR_FileSizeoff 0x1c
		72	#define DIR_CrtTimeTenthoff 13
		73	#define DIR_CrtTimeoff 14
		74	#define DIR_CrtDateoff 16
		75	#define DIR_LstAccDateoff 18
		76	#define DIR_WrtTimeoff 22
		77	#define DIR_WrtDateoff 24
		78
		79
		80
		81	#define FATBadpart 1
		82	#define FATBabArg 2
		83	#define FATReadErr 3
		84	#define FATnoErr 0
		85
		86	/*
		87	TODO :
		88	intergrate a per BLKDEV or per partition buffer.
		89	*/
		90	typedef struct FAT32fs
		91	{
		92	uint16_t BPB_BytsPerSec;
		93	uint16_t BPB_RsvdSecCnt;
		94	uint32_t BPB_FATSz32;
		95	uint32_t BPB_RootClus;
		96	uint32_t fat_begin_lba;
		97	uint32_t cluster_begin_lba;
		98	uint8_t BPB_SecPerClus;
		99	uint8_t BPB_NumFATs;
		100	char valide;
		101	dikpartition* part;
		102	}FAT32fs;
		103
		104
		105	#define castUI64(val) ((uint64_t)(val))
		106	#define castUI32(val) ((uint32_t)(val))
		107	#define castUI16(val) ((uint16_t)(val))
		108	#define castUI8(val) ((uint8_t)(val))
		109
		110	#define castI64(val) ((int64_t)(val))
		111	#define castI32(val) ((int32_t)(val))
		112	#define castI16(val) ((int16_t)(val))
		113	#define castI8(val) ((int8_t)(val))
		114
		115	/*
		116	TODO :
		117	Should add global function for casting with endianness care.
		118	have a look at REV, REV16, REVSH, and RBIT ARMV7m asm
		119	*/
		120
		121	#if __BYTE_ORDER__==__ORDER_BIG_ENDIAN__
		122	#define fat32Ui8_2_Ui32(table,lsBindex) ((uint32_t)((0xFF&(table[lsBindex]))+(0xFF00&(((uint32_t)table[lsBindex+1])<<8))+(0xFF0000&(((uint32_t)table[lsBindex+2])<<16))+(0xFF000000&(((uint32_t)table[lsBindex+3])<<24))))
		123	#define fat32Ui8_2_Ui16(table,lsBindex) ((uint16_t)((0xFF&(table[lsBindex]))+(0xFF00&(((uint16_t)table[lsBindex+1])<<8))))
		124	#define fat32extract16b(table, LSBOffset) (uint16_t)(( (uint16_t) ((uint8_t)table[(LSBOffset)]) ) + (uint16_t)( ((uint8_t)table[(LSBOffset)+1]) << 8 ))
		125	#define fat32extract32b(table, LSBOffset) (uint32_t)(( (uint32_t) ((uint8_t)table[(LSBOffset)]) ) + (uint32_t)( ((uint8_t)table[(LSBOffset)+1]) << 8 )+ (uint32_t)( ((uint8_t)table[(LSBOffset)+2]) << 16 )+ (uint32_t)( ((uint8_t)table[(LSBOffset)+3]) << 24 ))
		126	#else
		127	#define fat32Ui8_2_Ui32(table,lsBindex) ((uint32_t)((0xFF&(table[lsBindex]))+(0xFF00&(((uint32_t)table[lsBindex+1])<<8))+(0xFF0000&(((uint32_t)table[lsBindex+2])<<16))+(0xFF000000&(((uint32_t)table[lsBindex+3])<<24))))
		128	#define fat32Ui8_2_Ui16(table,lsBindex) ((uint16_t)((0xFF&(table[lsBindex]))+(0xFF00&(((uint16_t)table[lsBindex+1])<<8))))
		129	#define fat32extract16b(table, LSBOffset) (uint16_t)(( (uint16_t) ((uint8_t)table[(LSBOffset)]) ) + (uint16_t)( ((uint8_t)table[(LSBOffset)+1]) << 8 ))
		130	#define fat32extract32b(table, LSBOffset) (uint32_t)(( (uint32_t) ((uint8_t)table[(LSBOffset)]) ) + (uint32_t)( ((uint8_t)table[(LSBOffset)+1]) << 8 )+ (uint32_t)( ((uint8_t)table[(LSBOffset)+2]) << 16 )+ (uint32_t)( ((uint8_t)table[(LSBOffset)+3]) << 24 ))
		131	#endif
		132
		133
		134	/* Get the first sector lba of given cluster number*/
		135	#define clusterlba(fs,cluster_number) ((uint32_t)fs->cluster_begin_lba + (((uint32_t)cluster_number) - (2)) * (uint32_t)fs->BPB_SecPerClus)
		136
		137	//#define fat32clusterinfatsect(fs,cluster_number) ((((uint32_t)(cluster_number))>>6) + fs->fat_begin_lba)
		138	#define fat32clusterinfatsect(fs,cluster_number) ((((uint32_t)(cluster_number))>>7) + fs->fat_begin_lba)
		139	#define fat32clusterinfatoff(cluster_number) (((cluster_number)&0x7F)*4)
		140
		141	/Get cluster index in FAT Table from sector address/
		142	#define fat32masksectorlba(sectorlba,fs) (sectorlba)//(sectorlba & (castUI32(-1)^castUI32(fs->BPB_SecPerClus-1)))
		143	#define fat32sectorlbatoclusternum(fs,sectorlba) (((fat32masksectorlba(castUI32(sectorlba),fs) -(castUI32(fs->cluster_begin_lba)))/castUI32(fs->BPB_SecPerClus))+castUI32(2))
		144
		145
		146	#ifdef FAT32_PRIVATE
		147	#define fat32sectorreadout(fs,fatsec) \
		148	if((lastSecAddrs!=(fatsec)) \|\| (lastFATFS!=(fs))) /Check if sector already buffered/ \
		149	{\
		150	if((fs)->part->phy->read((fs)->part->phy,fat32buff,(fatsec),1)!=RES_OK) \
		151	{\
		152	return DIRENT_ReadErr;\
		153	}\
		154	}\
		155	lastSecAddrs=(fatsec);\
		156	lastFATFS=(fs);
		157	#endif
		158
		159	extern int fat32open(FAT32fs* fs,dikpartition* part);
		160	extern int fat32mkdirent(FAT32fs* fs,ucdirent* dirent);
		161	extern int fat32getVolName(FAT32fs* fs,char* Name);
		162	extern int fat32getrootfirstent(ucdirent* entry);
		163	extern int fat32nextdirent(ucdirent* entry);
		164	extern int fat32nextsectorlba(FAT32fs* fs,uint32_t lastsector_lba,uint32_t* nextsector_lba);
		165	extern int fat32prevsectorlba(FAT32fs* fs,uint32_t lastsector_lba,uint32_t *nextsector_lba);
		166	extern int fat32prevsectorlba2(FAT32fs* fs,ucdirent* entry,uint32_t lastsector_lba,uint32_t *nextsector_lba);
		167	extern uint32_t fat32getdirentlba(ucdirent* entry);
		168	extern int fat32getdirentname(ucdirent* entry,char* nameBuffer);
		169
		170	#endif
		171
		172
		173
		174
		175
		176
		177
		178
		179
		180
		181
		182
		183
		184
		185
		186
		187
		188
		189
		190
		191
		192
		193
		194

include/FS/libucfs.h created 644 +77 0

			@@ -0,0 +1,77
		1	/*------------------------------------------------------------------------------
		2	-- This file is a part of the libuc, microcontroler library
		3	-- Copyright (C) 2012, Alexis Jeandet
		4	--
		5	-- This program is free software; you can redistribute it and/or modify
		6	-- it under the terms of the GNU General Public License as published by
		7	-- the Free Software Foundation; either version 3 of the License, or
		8	-- (at your option) any later version.
		9	--
		10	-- This program is distributed in the hope that it will be useful,
		11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	-- GNU General Public License for more details.
		14	--
		15	-- You should have received a copy of the GNU General Public License
		16	-- along with this program; if not, write to the Free Software
		17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
		18	-------------------------------------------------------------------------------
		19	-- Author : Alexis Jeandet
		20	-- Mail : alexis.jeandet@gmail.com
		21	-------------------------------------------------------------------------------*/
		22	#ifndef FS_H
		23	#define FS_H
		24	#include <blkdevice.h>
		25
		26	struct fs_str
		27	{
		28	UHANDLE fat;
		29	};
		30
		31	typedef struct fs_str filesys_t;
		32
		33
		34
		35	#endif
		36
		37
		38
		39
		40
		41
		42
		43
		44
		45
		46
		47
		48
		49
		50
		51
		52
		53
		54
		55
		56
		57
		58
		59
		60
		61
		62
		63
		64
		65
		66
		67
		68
		69
		70
		71
		72
		73
		74
		75
		76
		77

include/FS/mbr.h created 644 +71 0

			@@ -0,0 +1,71
		1	/*------------------------------------------------------------------------------
		2	-- This file is a part of the libuc, microcontroler library
		3	-- Copyright (C) 2012, Alexis Jeandet
		4	--
		5	-- This program is free software; you can redistribute it and/or modify
		6	-- it under the terms of the GNU General Public License as published by
		7	-- the Free Software Foundation; either version 3 of the License, or
		8	-- (at your option) any later version.
		9	--
		10	-- This program is distributed in the hope that it will be useful,
		11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	-- GNU General Public License for more details.
		14	--
		15	-- You should have received a copy of the GNU General Public License
		16	-- along with this program; if not, write to the Free Software
		17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
		18	-------------------------------------------------------------------------------
		19	-- Author : Alexis Jeandet
		20	-- Mail : alexis.jeandet@member.fsf.org
		21	-------------------------------------------------------------------------------*/
		22	#ifndef MBR_H
		23	#define MBR_H
		24	#include <blkdevice.h>
		25
		26	#define BootFlagoffset 0
		27	#define TypeCodeoffset 4
		28	#define LBABeginoffset 8
		29	#define NumOfSecoffset 12
		30
		31	#define MBRBadMbr 1
		32	#define MBRBabArg 2
		33	#define MBRReadErr 3
		34	#define MBRnoErr 0
		35
		36	#define isFat32(TypeCode) (((TypeCode)==0x0b)\|\|((TypeCode)==0x0c))
		37
		38	typedef struct dikpartition
		39	{
		40	char TypeCode;
		41	char valide;
		42	unsigned int LBABegin;
		43	unsigned int NumOfSec;
		44	blkdevice* phy;
		45	}dikpartition;
		46
		47
		48	int mbropen(blkdevice* phy,dikpartition* part,char partNum);
		49
		50
		51	#endif
		52
		53
		54
		55
		56
		57
		58
		59
		60
		61
		62
		63
		64
		65
		66
		67
		68
		69
		70
		71

include/FS/ucdirent.h created 644 +131 0

			@@ -0,0 +1,131
		1	/*------------------------------------------------------------------------------
		2	-- This file is a part of the libuc, microcontroler library
		3	-- Copyright (C) 2012, Alexis Jeandet
		4	--
		5	-- This program is free software; you can redistribute it and/or modify
		6	-- it under the terms of the GNU General Public License as published by
		7	-- the Free Software Foundation; either version 3 of the License, or
		8	-- (at your option) any later version.
		9	--
		10	-- This program is distributed in the hope that it will be useful,
		11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	-- GNU General Public License for more details.
		14	--
		15	-- You should have received a copy of the GNU General Public License
		16	-- along with this program; if not, write to the Free Software
		17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
		18	-------------------------------------------------------------------------------
		19	-- Author : Alexis Jeandet
		20	-- Mail : alexis.jeandet@gmail.com
		21	-------------------------------------------------------------------------------*/
		22	#ifndef UCDIRENT_H
		23	#define UCDIRENT_H
		24	#include <blkdevice.h>
		25
		26
		27	#define ATTR_READ_ONLY 0x01
		28	#define ATTR_HIDDEN 0x02
		29	#define ATTR_SYSTEM 0x04
		30	#define ATTR_VOLUME_ID 0x08
		31	#define ATTR_DIRECTORY 0x10
		32	#define ATTR_ARCHIVE 0x20
		33	#define ATTR_LONGNAME 0x0F
		34
		35	#define DIRENT_EndOfDir 1
		36	#define DIRENT_BabArg 2
		37	#define DIRENT_ReadErr 3
		38	#define DIRENT_LastSect 4
		39	#define DIRENT_BadSect 5
		40	#define DIRENT_noErr 0
		41
		42	typedef struct ucdirent* ucdirentptr;
		43	typedef int (*getrootfirstent_t)(ucdirentptr entry);
		44	typedef int (*nextdirent_t)(ucdirentptr entry);
		45	typedef int (getname_t)(ucdirentptr entry,char name);
		46
		47	typedef struct dirent
		48	{
		49	unsigned char DIR_Name[16];
		50	unsigned char DIR_Attr;
		51	unsigned char DIR_CrtTimeTenth;
		52	unsigned short DIR_CrtTime;
		53	unsigned short DIR_CrtDate;
		54	unsigned short DIR_LstAccDate;
		55	unsigned short DIR_FstClusHI;
		56	unsigned short DIR_WrtTime;
		57	unsigned short DIR_WrtDate;
		58	unsigned short DIR_FstClustLO;
		59	unsigned int DIR_FileSize;
		60	unsigned int CurrentSec;
		61	unsigned char Currententry;
		62	UHANDLE fs;
		63	getrootfirstent_t getrootfirstent;
		64	nextdirent_t nextdirent;
		65	getname_t getname;
		66	}dirent;
		67
		68	typedef struct ucdirent{
		69	uint8_t DIR_Name[16];
		70	uint8_t DIR_Attr;
		71	uint8_t DIR_CrtTimeTenth;
		72	uint16_t DIR_CrtTime;
		73	uint16_t DIR_CrtDate;
		74	uint16_t DIR_LstAccDate;
		75	uint16_t DIR_FstClusHI;
		76	uint16_t DIR_WrtTime;
		77	uint16_t DIR_WrtDate;
		78	uint16_t DIR_FstClustLO;
		79	uint32_t DIR_FileSize;
		80	uint32_t CurrentSec;
		81	uint8_t Currententry;
		82	UHANDLE fs;
		83	getrootfirstent_t getrootfirstent;
		84	nextdirent_t nextdirent;
		85	getname_t getname;
		86	}ucdirent;
		87
		88
		89
		90	#define direntgetroot(dirent) (dirent).getrootfirstent(&dirent)
		91	#define direntgetnext(dirent) (dirent).nextdirent(&dirent)
		92
		93	#endif
		94
		95
		96
		97
		98
		99
		100
		101
		102
		103
		104
		105
		106
		107
		108
		109
		110
		111
		112
		113
		114
		115
		116
		117
		118
		119
		120
		121
		122
		123
		124
		125
		126
		127
		128
		129
		130
		131

include/GRAPHIC/GUI/Widgets/hexviewer.h created 644 +51 0

			@@ -0,0 +1,51
		1	/*------------------------------------------------------------------------------
		2	#-- This file is a part of the libuc, microcontroler library
		3	#-- Copyright (C) 2011, Alexis Jeandet
		4	#--
		5	#-- This program is free software; you can redistribute it and/or modify
		6	#-- it under the terms of the GNU General Public License as published by
		7	#-- the Free Software Foundation; either version 3 of the License, or
		8	#-- (at your option) any later version.
		9	#--
		10	#-- This program is distributed in the hope that it will be useful,
		11	#-- but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	#-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	#-- GNU General Public License for more details.
		14	#--
		15	#-- You should have received a copy of the GNU General Public License
		16	#-- along with this program; if not, write to the Free Software
		17	#-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
		18	#-------------------------------------------------------------------------------
		19	#-- Author : Alexis Jeandet
		20	#-- Mail : alexis.jeandet@gmail.com
		21	#-------------------------------------------------------------------------------*/
		22	#ifndef HEXVIEWER_H
		23	#define HEXVIEWER_H
		24
		25
		26
		27
		28
		29	extern void hexviewershow(const char* table,unsigned int size,unsigned int offset);
		30
		31
		32	#endif
		33
		34
		35
		36
		37
		38
		39
		40
		41
		42
		43
		44
		45
		46
		47
		48
		49
		50
		51

include/PERIPHERALS/adc.h created 644 +138 0

			@@ -0,0 +1,138
		1	/*------------------------------------------------------------------------------
		2	-- This file is a part of the libuc, microcontroler library
		3	-- Copyright (C) 2012, Alexis Jeandet
		4	--
		5	-- This program is free software; you can redistribute it and/or modify
		6	-- it under the terms of the GNU General Public License as published by
		7	-- the Free Software Foundation; either version 3 of the License, or
		8	-- (at your option) any later version.
		9	--
		10	-- This program is distributed in the hope that it will be useful,
		11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	-- GNU General Public License for more details.
		14	--
		15	-- You should have received a copy of the GNU General Public License
		16	-- along with this program; if not, write to the Free Software
		17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
		18	-------------------------------------------------------------------------------
		19	-- Author : Alexis Jeandet
		20	-- Mail : alexis.jeandet@gmail.com
		21	-------------------------------------------------------------------------------*/
		22	/*
		23	*/
		24
		25	#ifndef ADC_H
		26	#define ADC_H
		27	#include <uhandle.h>
		28
		29	#ifdef __cplusplus
		30	extern "C" {
		31	#endif
		32
		33
		34	typedef struct adc_t
		35	{
		36	void* _dev;
		37	int cfg;
		38	int rate;
		39	}adc_t;
		40
		41
		42	typedef enum
		43	{
		44	adc6bits = 0x1,
		45	adc7bits = 0x2,
		46	adc8bits = 0x3,
		47	adc9bits = 0x4,
		48	adc10bits = 0x5,
		49	adc11bits = 0x6,
		50	adc12bits = 0x7,
		51	adc13bits = 0x8,
		52	adc14bits = 0x9,
		53	adc15bits = 0xA,
		54	adc16bits = 0xB,
		55	adc17bits = 0xC,
		56	adc18bits = 0xD,
		57	adc19bits = 0xE,
		58	adc20bits = 0xF,
		59	adc21bits = 0x10,
		60	adc22bits = 0x11,
		61	adc23bits = 0x12,
		62	adc24bits = 0x13
		63	}adcbits_t;
		64
		65	#define ADCBITSMASK 0xF
		66
		67	typedef enum
		68	{
		69	adcsingle = 0x00,
		70	adcmaster = 0x10
		71	}adcconvmode_t;
		72
		73	#define ADCCONVMODEMASK 0x10
		74
		75	typedef enum
		76	{
		77	spiclkinhlow = 0x00,
		78	spiclkinhhigh = 0x20
		79	}spiclkinhlvl_t;
		80
		81	#define SPICLKINHLVLMASK 0x20
		82
		83
		84	typedef enum
		85	{
		86	spiclkfirstedge = 0x00,
		87	spiclksecondedge = 0x40
		88	}spiclkphase_t;
		89
		90	#define SPICLKPHASEMASK 0x40
		91
		92	typedef enum
		93	{
		94	spimsbfirst = 0x00,
		95	spilsbfirst = 0x80
		96	}spibitorder_t;
		97
		98	#define SPIBITORDERMASK 0x80
		99
		100
		101	extern int spiopen(int count,spi_t* spidev);
		102	extern int spiopenandconfig(int count,spi_t* spidev,uint32_t cfg,uint32_t speed,uint32_t MOSIpin,uint32_t MISOpin,uint32_t SCKpin,uint32_t SCSpin);
		103	extern int spiclose(spi_t* spidev);
		104	extern int spisetpins(spi_t* spidev,uint32_t MOSIpin,uint32_t MISOpin,uint32_t SCKpin,uint32_t SCSpin);
		105	extern int spienable(spi_t* spidev);
		106	extern int spidisable(spi_t* spidev);
		107	extern int spisetconfig(spi_t* spidev);
		108	extern int spisetspeed(spi_t* spidev, uint32_t speed);
		109	extern int spisetbitorder(spi_t* spidev,spibitorder_t order);
		110	extern int spisetdatabits(spi_t* spidev,spibits_t bitscnt);
		111	extern int spisetclkinhlevel(spi_t* spidev,spiclkinhlvl_t level);
		112	extern int spisetclkphase(spi_t* spidev,spiclkphase_t phase);
		113	extern int spiputw(spi_t* spidev,uint16_t data);
		114	extern uint16_t spigetw(spi_t* spidev);
		115	extern int spiputs(spi_t* spidev,char* s);
		116	extern int spigets(spi_t* spidev,char* s);
		117	extern int spiputnw(spi_t* spidev,uint16_t* w,int n);
		118	extern int spigetnw(spi_t* spidev,uint16_t* w,int n);
		119	extern int spiputnc(spi_t* spidev,char* c,int n);
		120	extern int spigetnc(spi_t* spidev,char* c,int n);
		121	extern int spiavailiabledata(spi_t* spidev);
		122
		123	#ifdef __cplusplus
		124	}
		125	#endif
		126	#endif //ADC_H
		127
		128
		129
		130
		131
		132
		133
		134
		135
		136
		137
		138

include/PERIPHERALS/gpio.h created 644 +590 0

This diff has been collapsed as it changes many lines, (590 lines changed) Show them Hide them
		@@ -0,0 +1,590
	1	/*------------------------------------------------------------------------------
	2	-- This file is a part of the libuc, microcontroler library
	3	-- Copyright (C) 2012, Alexis Jeandet
	4	--
	5	-- This program is free software; you can redistribute it and/or modify
	6	-- it under the terms of the GNU General Public License as published by
	7	-- the Free Software Foundation; either version 3 of the License, or
	8	-- (at your option) any later version.
	9	--
	10	-- This program is distributed in the hope that it will be useful,
	11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	-- GNU General Public License for more details.
	14	--
	15	-- You should have received a copy of the GNU General Public License
	16	-- along with this program; if not, write to the Free Software
	17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	18	-------------------------------------------------------------------------------
	19	-- Author : Alexis Jeandet
	20	-- Mail : alexis.jeandet@gmail.com
	21	-------------------------------------------------------------------------------*/
	22
	23	/*! \file gpio.h
	24	\brief GPIO api.
	25
	26	The gpio api gives you a standard way to drive any gpio on any processor.
	27	With this api you will be able to open and configure your gpios and set/clear read them.
	28
	29	A simple example to drive PA0 and read PA1.
	30	\code
	31	// lets open PA0 and PA1
	32	gpio_t mygpio1 gpioopen(PA0);
	33	gpioopen(PA1);
	34	mygpio1 \|= gpiohighspeed \| gpiooutdir \| gpiopushpulltype \| gpionopulltype;
	35	gpiosetconfig(mygpio1);
	36	//you can also configure with the pin name
	37	gpiosetconfig(PA1\|gpiohighspeed \| gpioindir);
	38	//to set PA0
	39	gpioset(mygpio1);
	40	//to clear it
	41	gpioclr(PA0); //PA0 also works and save 4 bytes!
	42	//Let read PA1 and write it to PA0
	43	gpiosetval(PA0,gpiogetval(PA1));
	44	\endcode
	45
	46	*/
	47	#ifndef GPIO_H
	48	#define GPIO_H
	49	#include <stdint.h>
	50	#ifdef __cplusplus
	51	extern "C" {
	52	#endif
	53
	54
	55	typedef uint32_t gpio_t;
	56
	57	typedef enum gpiospeed_t
	58	{
	59	gpiolowspeed = 0x00000,
	60	gpiomediumspeed = 0x10000,
	61	gpiofastspeed = 0x20000,
	62	gpiohighspeed = 0x30000
	63	}gpiospeed_t;
	64
	65
	66
	67	typedef enum gpiodir_t
	68	{
	69	gpioindir = 0x00000,
	70	gpiooutdir = 0x40000,
	71	gpioaf = 0x80000,
	72	gpioan = 0xC0000
	73	}gpiodir_t;
	74
	75
	76
	77
	78	typedef enum gpioouttype_t
	79	{
	80	gpiopushpulltype = 0x000000,
	81	gpioopendraintype = 0x100000
	82	}gpioouttype_t;
	83
	84
	85
	86	typedef enum gpiopulltype_t
	87	{
	88	gpionopulltype = 0x000000,
	89	gpiopulluptype = 0x200000,
	90	gpiopulldowntype = 0x400000
	91	}gpiopulltype_t;
	92
	93	#ifndef DOXYGEN_SHOULD_SKIP_THIS
	94	#define GPIOSPEEDMASK 0x30000
	95	#define GPIODIRMASK 0xC0000
	96	#define GPIOOUTTYPEMASK 0x100000
	97	#define GPIOPULLTYPEMASK 0x600000
	98	#endif
	99
	100
	101	extern gpio_t gpioopen(uint32_t gpio);
	102	extern void gpioclose(gpio_t gpio);
	103	extern void gpiosetconfig(gpio_t* gpio);
	104	extern void gpiosetdir(gpio_t* gpio,gpiodir_t dir);
	105	extern void gpiosetouttype(gpio_t* gpio, gpioouttype_t outtype);
	106	extern void gpiosetpulltype(gpio_t* gpio,gpiopulltype_t pulltype);
	107	extern void gpiosetspeed(gpio_t* gpio,gpiospeed_t speed);
	108	extern void gpioset(gpio_t gpio);
	109	extern void gpioclr(gpio_t gpio);
	110	extern void gpiosetval(gpio_t gpio,int val);
	111	extern int gpiogetval(gpio_t gpio);
	112
	113	#define GPIOISINPUT(gpio) (((gpio) & GPIODIRMASK)==gpioindir)
	114	#define GPIOISOUTPUT(gpio) (((gpio) & GPIOSPEEDMASK)==gpiooutdir)
	115
	116	#define GPIOISLOWSPEED(gpio) (((gpio) & GPIOSPEEDMASK)==gpiolowspeed)
	117	#define GPIOISMEDIUMSPEED(gpio) (((gpio) & GPIOSPEEDMASK)==gpiomediumspeed)
	118	#define GPIOISFASTPEED(gpio) (((gpio) & GPIOSPEEDMASK)==gpiofastspeed)
	119	#define GPIOISHIGHSPEED(gpio) (((gpio) & GPIOSPEEDMASK)==gpiohighspeeds)
	120
	121	#define GPIOISPUSHPULL(gpio) (((gpio) & GPIOOUTTYPEMASK)==gpiopushpulltype)
	122	#define GPIOISOPENDRAIN(gpio) (((gpio) & GPIOOUTTYPEMASK)==gpioopendraintype)
	123
	124	#define GPIOISNOPULL(GPIO) (((gpio) & GPIOPULLTYPEMASK)==gpionopulltype)
	125	#define GPIOISPULLUP(GPIO) (((gpio) & GPIOPULLTYPEMASK)==gpiopulluptype)
	126	#define GPIOISPULLDOWN(GPIO) (((gpio) & GPIOPULLTYPEMASK)==gpiopulldowntype)
	127
	128	#ifndef DOXYGEN_SHOULD_SKIP_THIS
	129
	130	#define PA0 ((0<<8)+0)
	131	#define PA1 ((0<<8)+1)
	132	#define PA2 ((0<<8)+2)
	133	#define PA3 ((0<<8)+3)
	134	#define PA4 ((0<<8)+4)
	135	#define PA5 ((0<<8)+5)
	136	#define PA6 ((0<<8)+6)
	137	#define PA7 ((0<<8)+7)
	138	#define PA8 ((0<<8)+8)
	139	#define PA9 ((0<<8)+9)
	140	#define PA10 ((0<<8)+10)
	141	#define PA11 ((0<<8)+11)
	142	#define PA12 ((0<<8)+12)
	143	#define PA13 ((0<<8)+13)
	144	#define PA14 ((0<<8)+14)
	145	#define PA15 ((0<<8)+15)
	146	#define PAX ((0<<8)+255)
	147	#define PB0 ((1<<8)+0)
	148	#define PB1 ((1<<8)+1)
	149	#define PB2 ((1<<8)+2)
	150	#define PB3 ((1<<8)+3)
	151	#define PB4 ((1<<8)+4)
	152	#define PB5 ((1<<8)+5)
	153	#define PB6 ((1<<8)+6)
	154	#define PB7 ((1<<8)+7)
	155	#define PB8 ((1<<8)+8)
	156	#define PB9 ((1<<8)+9)
	157	#define PB10 ((1<<8)+10)
	158	#define PB11 ((1<<8)+11)
	159	#define PB12 ((1<<8)+12)
	160	#define PB13 ((1<<8)+13)
	161	#define PB14 ((1<<8)+14)
	162	#define PB15 ((1<<8)+15)
	163	#define PBX ((1<<8)+255)
	164	#define PC0 ((2<<8)+0)
	165	#define PC1 ((2<<8)+1)
	166	#define PC2 ((2<<8)+2)
	167	#define PC3 ((2<<8)+3)
	168	#define PC4 ((2<<8)+4)
	169	#define PC5 ((2<<8)+5)
	170	#define PC6 ((2<<8)+6)
	171	#define PC7 ((2<<8)+7)
	172	#define PC8 ((2<<8)+8)
	173	#define PC9 ((2<<8)+9)
	174	#define PC10 ((2<<8)+10)
	175	#define PC11 ((2<<8)+11)
	176	#define PC12 ((2<<8)+12)
	177	#define PC13 ((2<<8)+13)
	178	#define PC14 ((2<<8)+14)
	179	#define PC15 ((2<<8)+15)
	180	#define PCX ((2<<8)+255)
	181	#define PD0 ((3<<8)+0)
	182	#define PD1 ((3<<8)+1)
	183	#define PD2 ((3<<8)+2)
	184	#define PD3 ((3<<8)+3)
	185	#define PD4 ((3<<8)+4)
	186	#define PD5 ((3<<8)+5)
	187	#define PD6 ((3<<8)+6)
	188	#define PD7 ((3<<8)+7)
	189	#define PD8 ((3<<8)+8)
	190	#define PD9 ((3<<8)+9)
	191	#define PD10 ((3<<8)+10)
	192	#define PD11 ((3<<8)+11)
	193	#define PD12 ((3<<8)+12)
	194	#define PD13 ((3<<8)+13)
	195	#define PD14 ((3<<8)+14)
	196	#define PD15 ((3<<8)+15)
	197	#define PDX ((3<<8)+255)
	198	#define PE0 ((4<<8)+0)
	199	#define PE1 ((4<<8)+1)
	200	#define PE2 ((4<<8)+2)
	201	#define PE3 ((4<<8)+3)
	202	#define PE4 ((4<<8)+4)
	203	#define PE5 ((4<<8)+5)
	204	#define PE6 ((4<<8)+6)
	205	#define PE7 ((4<<8)+7)
	206	#define PE8 ((4<<8)+8)
	207	#define PE9 ((4<<8)+9)
	208	#define PE10 ((4<<8)+10)
	209	#define PE11 ((4<<8)+11)
	210	#define PE12 ((4<<8)+12)
	211	#define PE13 ((4<<8)+13)
	212	#define PE14 ((4<<8)+14)
	213	#define PE15 ((4<<8)+15)
	214	#define PEX ((4<<8)+255)
	215	#define PF0 ((5<<8)+0)
	216	#define PF1 ((5<<8)+1)
	217	#define PF2 ((5<<8)+2)
	218	#define PF3 ((5<<8)+3)
	219	#define PF4 ((5<<8)+4)
	220	#define PF5 ((5<<8)+5)
	221	#define PF6 ((5<<8)+6)
	222	#define PF7 ((5<<8)+7)
	223	#define PF8 ((5<<8)+8)
	224	#define PF9 ((5<<8)+9)
	225	#define PF10 ((5<<8)+10)
	226	#define PF11 ((5<<8)+11)
	227	#define PF12 ((5<<8)+12)
	228	#define PF13 ((5<<8)+13)
	229	#define PF14 ((5<<8)+14)
	230	#define PF15 ((5<<8)+15)
	231	#define PFX ((5<<8)+255)
	232	#define PG0 ((6<<8)+0)
	233	#define PG1 ((6<<8)+1)
	234	#define PG2 ((6<<8)+2)
	235	#define PG3 ((6<<8)+3)
	236	#define PG4 ((6<<8)+4)
	237	#define PG5 ((6<<8)+5)
	238	#define PG6 ((6<<8)+6)
	239	#define PG7 ((6<<8)+7)
	240	#define PG8 ((6<<8)+8)
	241	#define PG9 ((6<<8)+9)
	242	#define PG10 ((6<<8)+10)
	243	#define PG11 ((6<<8)+11)
	244	#define PG12 ((6<<8)+12)
	245	#define PG13 ((6<<8)+13)
	246	#define PG14 ((6<<8)+14)
	247	#define PG15 ((6<<8)+15)
	248	#define PGX ((6<<8)+255)
	249	#define PH0 ((7<<8)+0)
	250	#define PH1 ((7<<8)+1)
	251	#define PH2 ((7<<8)+2)
	252	#define PH3 ((7<<8)+3)
	253	#define PH4 ((7<<8)+4)
	254	#define PH5 ((7<<8)+5)
	255	#define PH6 ((7<<8)+6)
	256	#define PH7 ((7<<8)+7)
	257	#define PH8 ((7<<8)+8)
	258	#define PH9 ((7<<8)+9)
	259	#define PH10 ((7<<8)+10)
	260	#define PH11 ((7<<8)+11)
	261	#define PH12 ((7<<8)+12)
	262	#define PH13 ((7<<8)+13)
	263	#define PH14 ((7<<8)+14)
	264	#define PH15 ((7<<8)+15)
	265	#define PHX ((7<<8)+255)
	266	#define PI0 ((8<<8)+0)
	267	#define PI1 ((8<<8)+1)
	268	#define PI2 ((8<<8)+2)
	269	#define PI3 ((8<<8)+3)
	270	#define PI4 ((8<<8)+4)
	271	#define PI5 ((8<<8)+5)
	272	#define PI6 ((8<<8)+6)
	273	#define PI7 ((8<<8)+7)
	274	#define PI8 ((8<<8)+8)
	275	#define PI9 ((8<<8)+9)
	276	#define PI10 ((8<<8)+10)
	277	#define PI11 ((8<<8)+11)
	278	#define PI12 ((8<<8)+12)
	279	#define PI13 ((8<<8)+13)
	280	#define PI14 ((8<<8)+14)
	281	#define PI15 ((8<<8)+15)
	282	#define PIX ((8<<8)+255)
	283	#define PJ0 ((9<<8)+0)
	284	#define PJ1 ((9<<8)+1)
	285	#define PJ2 ((9<<8)+2)
	286	#define PJ3 ((9<<8)+3)
	287	#define PJ4 ((9<<8)+4)
	288	#define PJ5 ((9<<8)+5)
	289	#define PJ6 ((9<<8)+6)
	290	#define PJ7 ((9<<8)+7)
	291	#define PJ8 ((9<<8)+8)
	292	#define PJ9 ((9<<8)+9)
	293	#define PJ10 ((9<<8)+10)
	294	#define PJ11 ((9<<8)+11)
	295	#define PJ12 ((9<<8)+12)
	296	#define PJ13 ((9<<8)+13)
	297	#define PJ14 ((9<<8)+14)
	298	#define PJ15 ((9<<8)+15)
	299	#define PJX ((9<<8)+255)
	300	#define PK0 ((10<<8)+0)
	301	#define PK1 ((10<<8)+1)
	302	#define PK2 ((10<<8)+2)
	303	#define PK3 ((10<<8)+3)
	304	#define PK4 ((10<<8)+4)
	305	#define PK5 ((10<<8)+5)
	306	#define PK6 ((10<<8)+6)
	307	#define PK7 ((10<<8)+7)
	308	#define PK8 ((10<<8)+8)
	309	#define PK9 ((10<<8)+9)
	310	#define PK10 ((10<<8)+10)
	311	#define PK11 ((10<<8)+11)
	312	#define PK12 ((10<<8)+12)
	313	#define PK13 ((10<<8)+13)
	314	#define PK14 ((10<<8)+14)
	315	#define PK15 ((10<<8)+15)
	316	#define PKX ((10<<8)+255)
	317	#define PL0 ((11<<8)+0)
	318	#define PL1 ((11<<8)+1)
	319	#define PL2 ((11<<8)+2)
	320	#define PL3 ((11<<8)+3)
	321	#define PL4 ((11<<8)+4)
	322	#define PL5 ((11<<8)+5)
	323	#define PL6 ((11<<8)+6)
	324	#define PL7 ((11<<8)+7)
	325	#define PL8 ((11<<8)+8)
	326	#define PL9 ((11<<8)+9)
	327	#define PL10 ((11<<8)+10)
	328	#define PL11 ((11<<8)+11)
	329	#define PL12 ((11<<8)+12)
	330	#define PL13 ((11<<8)+13)
	331	#define PL14 ((11<<8)+14)
	332	#define PL15 ((11<<8)+15)
	333	#define PLX ((11<<8)+255)
	334	#define PM0 ((12<<8)+0)
	335	#define PM1 ((12<<8)+1)
	336	#define PM2 ((12<<8)+2)
	337	#define PM3 ((12<<8)+3)
	338	#define PM4 ((12<<8)+4)
	339	#define PM5 ((12<<8)+5)
	340	#define PM6 ((12<<8)+6)
	341	#define PM7 ((12<<8)+7)
	342	#define PM8 ((12<<8)+8)
	343	#define PM9 ((12<<8)+9)
	344	#define PM10 ((12<<8)+10)
	345	#define PM11 ((12<<8)+11)
	346	#define PM12 ((12<<8)+12)
	347	#define PM13 ((12<<8)+13)
	348	#define PM14 ((12<<8)+14)
	349	#define PM15 ((12<<8)+15)
	350	#define PMX ((12<<8)+255)
	351	#define PN0 ((13<<8)+0)
	352	#define PN1 ((13<<8)+1)
	353	#define PN2 ((13<<8)+2)
	354	#define PN3 ((13<<8)+3)
	355	#define PN4 ((13<<8)+4)
	356	#define PN5 ((13<<8)+5)
	357	#define PN6 ((13<<8)+6)
	358	#define PN7 ((13<<8)+7)
	359	#define PN8 ((13<<8)+8)
	360	#define PN9 ((13<<8)+9)
	361	#define PN10 ((13<<8)+10)
	362	#define PN11 ((13<<8)+11)
	363	#define PN12 ((13<<8)+12)
	364	#define PN13 ((13<<8)+13)
	365	#define PN14 ((13<<8)+14)
	366	#define PN15 ((13<<8)+15)
	367	#define PNX ((13<<8)+255)
	368	#define PO0 ((14<<8)+0)
	369	#define PO1 ((14<<8)+1)
	370	#define PO2 ((14<<8)+2)
	371	#define PO3 ((14<<8)+3)
	372	#define PO4 ((14<<8)+4)
	373	#define PO5 ((14<<8)+5)
	374	#define PO6 ((14<<8)+6)
	375	#define PO7 ((14<<8)+7)
	376	#define PO8 ((14<<8)+8)
	377	#define PO9 ((14<<8)+9)
	378	#define PO10 ((14<<8)+10)
	379	#define PO11 ((14<<8)+11)
	380	#define PO12 ((14<<8)+12)
	381	#define PO13 ((14<<8)+13)
	382	#define PO14 ((14<<8)+14)
	383	#define PO15 ((14<<8)+15)
	384	#define POX ((14<<8)+255)
	385	#define PP0 ((15<<8)+0)
	386	#define PP1 ((15<<8)+1)
	387	#define PP2 ((15<<8)+2)
	388	#define PP3 ((15<<8)+3)
	389	#define PP4 ((15<<8)+4)
	390	#define PP5 ((15<<8)+5)
	391	#define PP6 ((15<<8)+6)
	392	#define PP7 ((15<<8)+7)
	393	#define PP8 ((15<<8)+8)
	394	#define PP9 ((15<<8)+9)
	395	#define PP10 ((15<<8)+10)
	396	#define PP11 ((15<<8)+11)
	397	#define PP12 ((15<<8)+12)
	398	#define PP13 ((15<<8)+13)
	399	#define PP14 ((15<<8)+14)
	400	#define PP15 ((15<<8)+15)
	401	#define PPX ((15<<8)+255)
	402	#define PQ0 ((16<<8)+0)
	403	#define PQ1 ((16<<8)+1)
	404	#define PQ2 ((16<<8)+2)
	405	#define PQ3 ((16<<8)+3)
	406	#define PQ4 ((16<<8)+4)
	407	#define PQ5 ((16<<8)+5)
	408	#define PQ6 ((16<<8)+6)
	409	#define PQ7 ((16<<8)+7)
	410	#define PQ8 ((16<<8)+8)
	411	#define PQ9 ((16<<8)+9)
	412	#define PQ10 ((16<<8)+10)
	413	#define PQ11 ((16<<8)+11)
	414	#define PQ12 ((16<<8)+12)
	415	#define PQ13 ((16<<8)+13)
	416	#define PQ14 ((16<<8)+14)
	417	#define PQ15 ((16<<8)+15)
	418	#define PQX ((16<<8)+255)
	419	#define PR0 ((17<<8)+0)
	420	#define PR1 ((17<<8)+1)
	421	#define PR2 ((17<<8)+2)
	422	#define PR3 ((17<<8)+3)
	423	#define PR4 ((17<<8)+4)
	424	#define PR5 ((17<<8)+5)
	425	#define PR6 ((17<<8)+6)
	426	#define PR7 ((17<<8)+7)
	427	#define PR8 ((17<<8)+8)
	428	#define PR9 ((17<<8)+9)
	429	#define PR10 ((17<<8)+10)
	430	#define PR11 ((17<<8)+11)
	431	#define PR12 ((17<<8)+12)
	432	#define PR13 ((17<<8)+13)
	433	#define PR14 ((17<<8)+14)
	434	#define PR15 ((17<<8)+15)
	435	#define PRX ((17<<8)+255)
	436	#define PS0 ((18<<8)+0)
	437	#define PS1 ((18<<8)+1)
	438	#define PS2 ((18<<8)+2)
	439	#define PS3 ((18<<8)+3)
	440	#define PS4 ((18<<8)+4)
	441	#define PS5 ((18<<8)+5)
	442	#define PS6 ((18<<8)+6)
	443	#define PS7 ((18<<8)+7)
	444	#define PS8 ((18<<8)+8)
	445	#define PS9 ((18<<8)+9)
	446	#define PS10 ((18<<8)+10)
	447	#define PS11 ((18<<8)+11)
	448	#define PS12 ((18<<8)+12)
	449	#define PS13 ((18<<8)+13)
	450	#define PS14 ((18<<8)+14)
	451	#define PS15 ((18<<8)+15)
	452	#define PSX ((18<<8)+255)
	453	#define PT0 ((19<<8)+0)
	454	#define PT1 ((19<<8)+1)
	455	#define PT2 ((19<<8)+2)
	456	#define PT3 ((19<<8)+3)
	457	#define PT4 ((19<<8)+4)
	458	#define PT5 ((19<<8)+5)
	459	#define PT6 ((19<<8)+6)
	460	#define PT7 ((19<<8)+7)
	461	#define PT8 ((19<<8)+8)
	462	#define PT9 ((19<<8)+9)
	463	#define PT10 ((19<<8)+10)
	464	#define PT11 ((19<<8)+11)
	465	#define PT12 ((19<<8)+12)
	466	#define PT13 ((19<<8)+13)
	467	#define PT14 ((19<<8)+14)
	468	#define PT15 ((19<<8)+15)
	469	#define PTX ((19<<8)+255)
	470	#define PU0 ((20<<8)+0)
	471	#define PU1 ((20<<8)+1)
	472	#define PU2 ((20<<8)+2)
	473	#define PU3 ((20<<8)+3)
	474	#define PU4 ((20<<8)+4)
	475	#define PU5 ((20<<8)+5)
	476	#define PU6 ((20<<8)+6)
	477	#define PU7 ((20<<8)+7)
	478	#define PU8 ((20<<8)+8)
	479	#define PU9 ((20<<8)+9)
	480	#define PU10 ((20<<8)+10)
	481	#define PU11 ((20<<8)+11)
	482	#define PU12 ((20<<8)+12)
	483	#define PU13 ((20<<8)+13)
	484	#define PU14 ((20<<8)+14)
	485	#define PU15 ((20<<8)+15)
	486	#define PUX ((20<<8)+255)
	487	#define PV0 ((21<<8)+0)
	488	#define PV1 ((21<<8)+1)
	489	#define PV2 ((21<<8)+2)
	490	#define PV3 ((21<<8)+3)
	491	#define PV4 ((21<<8)+4)
	492	#define PV5 ((21<<8)+5)
	493	#define PV6 ((21<<8)+6)
	494	#define PV7 ((21<<8)+7)
	495	#define PV8 ((21<<8)+8)
	496	#define PV9 ((21<<8)+9)
	497	#define PV10 ((21<<8)+10)
	498	#define PV11 ((21<<8)+11)
	499	#define PV12 ((21<<8)+12)
	500	#define PV13 ((21<<8)+13)
	501	#define PV14 ((21<<8)+14)
	502	#define PV15 ((21<<8)+15)
	503	#define PVX ((21<<8)+255)
	504	#define PW0 ((22<<8)+0)
	505	#define PW1 ((22<<8)+1)
	506	#define PW2 ((22<<8)+2)
	507	#define PW3 ((22<<8)+3)
	508	#define PW4 ((22<<8)+4)
	509	#define PW5 ((22<<8)+5)
	510	#define PW6 ((22<<8)+6)
	511	#define PW7 ((22<<8)+7)
	512	#define PW8 ((22<<8)+8)
	513	#define PW9 ((22<<8)+9)
	514	#define PW10 ((22<<8)+10)
	515	#define PW11 ((22<<8)+11)
	516	#define PW12 ((22<<8)+12)
	517	#define PW13 ((22<<8)+13)
	518	#define PW14 ((22<<8)+14)
	519	#define PW15 ((22<<8)+15)
	520	#define PWX ((22<<8)+255)
	521	#define PX0 ((23<<8)+0)
	522	#define PX1 ((23<<8)+1)
	523	#define PX2 ((23<<8)+2)
	524	#define PX3 ((23<<8)+3)
	525	#define PX4 ((23<<8)+4)
	526	#define PX5 ((23<<8)+5)
	527	#define PX6 ((23<<8)+6)
	528	#define PX7 ((23<<8)+7)
	529	#define PX8 ((23<<8)+8)
	530	#define PX9 ((23<<8)+9)
	531	#define PX10 ((23<<8)+10)
	532	#define PX11 ((23<<8)+11)
	533	#define PX12 ((23<<8)+12)
	534	#define PX13 ((23<<8)+13)
	535	#define PX14 ((23<<8)+14)
	536	#define PX15 ((23<<8)+15)
	537	#define PXX ((23<<8)+255)
	538	#define PY0 ((24<<8)+0)
	539	#define PY1 ((24<<8)+1)
	540	#define PY2 ((24<<8)+2)
	541	#define PY3 ((24<<8)+3)
	542	#define PY4 ((24<<8)+4)
	543	#define PY5 ((24<<8)+5)
	544	#define PY6 ((24<<8)+6)
	545	#define PY7 ((24<<8)+7)
	546	#define PY8 ((24<<8)+8)
	547	#define PY9 ((24<<8)+9)
	548	#define PY10 ((24<<8)+10)
	549	#define PY11 ((24<<8)+11)
	550	#define PY12 ((24<<8)+12)
	551	#define PY13 ((24<<8)+13)
	552	#define PY14 ((24<<8)+14)
	553	#define PY15 ((24<<8)+15)
	554	#define PYX ((24<<8)+255)
	555	#define PZ0 ((25<<8)+0)
	556	#define PZ1 ((25<<8)+1)
	557	#define PZ2 ((25<<8)+2)
	558	#define PZ3 ((25<<8)+3)
	559	#define PZ4 ((25<<8)+4)
	560	#define PZ5 ((25<<8)+5)
	561	#define PZ6 ((25<<8)+6)
	562	#define PZ7 ((25<<8)+7)
	563	#define PZ8 ((25<<8)+8)
	564	#define PZ9 ((25<<8)+9)
	565	#define PZ10 ((25<<8)+10)
	566	#define PZ11 ((25<<8)+11)
	567	#define PZ12 ((25<<8)+12)
	568	#define PZ13 ((25<<8)+13)
	569	#define PZ14 ((25<<8)+14)
	570	#define PZ15 ((25<<8)+15)
	571	#define PZX ((25<<8)+255)
	572
	573	#endif
	574
	575	#ifdef __cplusplus
	576	}
	577	#endif
	578	#endif //GPIO_H
	579
	580
	581
	582
	583
	584
	585
	586
	587
	588
	589
	590

include/PERIPHERALS/i2c.h created 644 +72 0

			@@ -0,0 +1,72
		1	/*------------------------------------------------------------------------------
		2	-- This file is a part of the libuc, microcontroler library
		3	-- Copyright (C) 2012, Alexis Jeandet
		4	--
		5	-- This program is free software; you can redistribute it and/or modify
		6	-- it under the terms of the GNU General Public License as published by
		7	-- the Free Software Foundation; either version 3 of the License, or
		8	-- (at your option) any later version.
		9	--
		10	-- This program is distributed in the hope that it will be useful,
		11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	-- GNU General Public License for more details.
		14	--
		15	-- You should have received a copy of the GNU General Public License
		16	-- along with this program; if not, write to the Free Software
		17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
		18	-------------------------------------------------------------------------------
		19	-- Author : Alexis Jeandet
		20	-- Mail : alexis.jeandet@gmail.com
		21	-------------------------------------------------------------------------------*/
		22	#ifndef I2C_H
		23	#define I2C_H
		24	#include <streamdevices.h>
		25
		26	#ifdef __cplusplus
		27	extern "C" {
		28	#endif
		29
		30	typedef int i2c_t;
		31
		32	#define i2c1 0
		33	#define i2c2 1
		34	#define i2c3 2
		35	#define i2c4 3
		36	#define i2c5 4
		37	#define i2c6 5
		38	#define i2c7 6
		39	#define i2c8 7
		40	#define i2c9 8
		41
		42	extern int i2ctimeout;
		43
		44	extern i2c_t i2copen(int count);
		45	extern i2c_t i2copenandconfig(int count ,uint32_t cfg,uint32_t speed,uint32_t SDA,uint32_t SCL);
		46	extern int i2cclose(i2c_t dev);
		47	extern int i2csetpins(i2c_t dev,uint32_t SDA,uint32_t SCL);
		48	extern int i2cenable(i2c_t dev);
		49	extern int i2cdisable(i2c_t dev);
		50	//extern int i2csetconfig(i2c_t dev);
		51	extern int i2csetspeed(i2c_t dev,uint32_t speed);
		52	//extern int i2csetdatabits(i2c_t* dev,uartbits_t databits);
		53	extern int i2cwrite(i2c_t dev,char address,char* data,int count);
		54	extern int i2cread(i2c_t dev,char address,char* data,int count);
		55	extern int i2cbusy(i2c_t dev);
		56	extern int i2cStatusCheck(i2c_t dev,int32_t flagMask);
		57	#ifdef __cplusplus
		58	}
		59	#endif
		60	#endif //I2C_H
		61
		62
		63
		64
		65
		66
		67
		68
		69
		70
		71
		72

include/PERIPHERALS/spi.h created 644 +150 0

			@@ -0,0 +1,150
		1	/*------------------------------------------------------------------------------
		2	-- This file is a part of the libuc, microcontroler library
		3	-- Copyright (C) 2012, Alexis Jeandet
		4	--
		5	-- This program is free software; you can redistribute it and/or modify
		6	-- it under the terms of the GNU General Public License as published by
		7	-- the Free Software Foundation; either version 3 of the License, or
		8	-- (at your option) any later version.
		9	--
		10	-- This program is distributed in the hope that it will be useful,
		11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	-- GNU General Public License for more details.
		14	--
		15	-- You should have received a copy of the GNU General Public License
		16	-- along with this program; if not, write to the Free Software
		17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
		18	-------------------------------------------------------------------------------
		19	-- Author : Alexis Jeandet
		20	-- Mail : alexis.jeandet@member.fsf.org
		21	-------------------------------------------------------------------------------*/
		22	/*
		23	TODO:
		24	Add SPI slave mode
		25	Add interrupt interface
		26	*/
		27
		28	#ifndef SPI_H
		29	#define SPI_H
		30	#include <uhandle.h>
		31
		32	#ifdef __cplusplus
		33	extern "C" {
		34	#endif
		35
		36	/*
		37	typedef struct spi_t
		38	{
		39	void* _dev;
		40	int cfg;
		41	int speed;
		42	}spi_t;*/
		43
		44	typedef int spi_t;
		45
		46	#define spi1 ((spi_t)0)
		47	#define spi2 ((spi_t)1)
		48	#define spi3 ((spi_t)2)
		49	#define spi4 ((spi_t)3)
		50	#define spi5 ((spi_t)4)
		51	#define spi6 ((spi_t)5)
		52	#define spi7 ((spi_t)6)
		53	#define spi8 ((spi_t)7)
		54	#define spi9 ((spi_t)8)
		55
		56
		57	typedef enum
		58	{
		59	spi4bits = 0x3,
		60	spi5bits = 0x4,
		61	spi6bits = 0x5,
		62	spi7bits = 0x6,
		63	spi8bits = 0x7,
		64	spi9bits = 0x8,
		65	spi10bits = 0x9,
		66	spi11bits = 0xA,
		67	spi12bits = 0xB,
		68	spi13bits = 0xC,
		69	spi14bits = 0xD,
		70	spi15bits = 0xE,
		71	spi16bits = 0xF
		72	}spibits_t;
		73
		74	#define SPIBITSMASK 0xF
		75
		76	typedef enum
		77	{
		78	spislave = 0x00,
		79	spimaster = 0x10
		80	}spimode_t;
		81
		82	#define SPIMODEMASK 0x10
		83
		84	typedef enum
		85	{
		86	spiclkinhlow = 0x00,
		87	spiclkinhhigh = 0x20
		88	}spiclkinhlvl_t;
		89
		90	#define SPICLKINHLVLMASK 0x20
		91
		92
		93	typedef enum
		94	{
		95	spiclkfirstedge = 0x00,
		96	spiclksecondedge = 0x40
		97	}spiclkphase_t;
		98
		99	#define SPICLKPHASEMASK 0x40
		100
		101	typedef enum
		102	{
		103	spimsbfirst = 0x00,
		104	spilsbfirst = 0x80
		105	}spibitorder_t;
		106
		107	#define SPIBITORDERMASK 0x80
		108
		109
		110	extern spi_t spiopen(int count);
		111	extern spi_t spiopenandconfig(int count,uint32_t cfg,uint32_t speed,uint32_t MOSIpin,uint32_t MISOpin,uint32_t SCKpin,uint32_t SCSpin);
		112	extern int spiclose(spi_t spidev);
		113	extern int spisetpins(spi_t spidev,uint32_t MOSIpin,uint32_t MISOpin,uint32_t SCKpin,uint32_t SCSpin);
		114	extern int spienable(spi_t spidev);
		115	extern int spidisable(spi_t spidev);
		116	extern int spitransactionfinished(spi_t spidev);
		117	extern int spisetconfig(spi_t spidev,uint32_t config,uint32_t speed);
		118	extern int spisetspeed(spi_t spidev, uint32_t speed);
		119	extern uint32_t spigetspeed(spi_t spidev);
		120	extern int spisetbitorder(spi_t spidev,spibitorder_t order);
		121	extern int spisetdatabits(spi_t spidev,spibits_t bitscnt);
		122	extern int spisetclkinhlevel(spi_t spidev,spiclkinhlvl_t level);
		123	extern int spisetclkphase(spi_t spidev,spiclkphase_t phase);
		124	extern int spiputw(spi_t spidev,uint16_t data);
		125	extern uint16_t spigetw(spi_t spidev);
		126	extern uint16_t spigetw2(spi_t spidev,uint16_t data);
		127	extern int spiputs(spi_t spidev,char* s);
		128	extern int spigets(spi_t spidev,char* s);
		129	extern int spiputnw(spi_t spidev,uint16_t* w,int n);
		130	extern int spigetnw(spi_t spidev,uint16_t* w,int n);
		131	extern int spiputnc(spi_t spidev,char* c,int n);
		132	extern int spigetnc(spi_t spidev,char* c,int n);
		133	extern int spiavailiabledata(spi_t spidev);
		134
		135	#ifdef __cplusplus
		136	}
		137	#endif
		138	#endif //SPI_H
		139
		140
		141
		142
		143
		144
		145
		146
		147
		148
		149
		150

include/PERIPHERALS/uart.h created 644 +319 0

			@@ -0,0 +1,319
		1	/*------------------------------------------------------------------------------
		2	-- This file is a part of the libuc, microcontroler library
		3	-- Copyright (C) 2012, Alexis Jeandet
		4	--
		5	-- This program is free software; you can redistribute it and/or modify
		6	-- it under the terms of the GNU General Public License as published by
		7	-- the Free Software Foundation; either version 3 of the License, or
		8	-- (at your option) any later version.
		9	--
		10	-- This program is distributed in the hope that it will be useful,
		11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	-- GNU General Public License for more details.
		14	--
		15	-- You should have received a copy of the GNU General Public License
		16	-- along with this program; if not, write to the Free Software
		17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
		18	-------------------------------------------------------------------------------
		19	-- Author : Alexis Jeandet
		20	-- Mail : alexis.jeandet@gmail.com
		21	-------------------------------------------------------------------------------*/
		22	/*! \file uart.h
		23	\brief UART api.
		24
		25	The uart api gives you a standard way to drive any uart on any processor.
		26	With this api you will be able to open and configure your UART define the
		27	associated pins when applicable and read/write on it. Note that depending
		28	on the target architecture you can have soft or hard UART.
		29
		30	A simple example to read or writes on uart1.
		31	\code
		32	// lets open uart1
		33	//config :
		34	// -parity = No
		35	// -data bits = 8
		36	// -stop bits = 1
		37	// -speed = 115200 bauds
		38	// -TX = PA9
		39	// -RX = PA10
		40	// -CTS = unused (-1)
		41	// -RTS = unused (-1)
		42	uart_t uart = uartopenandconfig(uart1,uartparitynone \| uart8bits \| uartonestop,115200,PA9,PA10,-1,-1);
		43	//check that everything is ok
		44	if(uart==uart1)
		45	{
		46	//to write 0xFF on uart1
		47	uartputc(uart,0xFF);
		48	//you can also send a string on uart1
		49	char* buffer="hello";
		50	uartputs(uart,buffer);
		51	//to read a char
		52	char result = uartgetc(uart);
		53	}
		54
		55	\endcode
		56
		57	*/
		58
		59	#ifndef UART_H
		60	#define UART_H
		61	#include <streamdevices.h>
		62
		63	#ifdef __cplusplus
		64	extern "C" {
		65	#endif
		66
		67	/*
		68	typedef volatile struct uart_t
		69	{
		70	volatile void* _dev;
		71	volatile int cfg;
		72	volatile int speed;
		73	}uart_t;
		74	*/
		75
		76	/**
		77	* @brief uart handle
		78	*
		79	* uart_t is the handle type you will use for all uart related functions.
		80	*/
		81	typedef int uart_t;
		82
		83	#define uart1 0 ///< uart1
		84	#define uart2 1 ///< uart2
		85	#define uart3 2 ///< uart3
		86	#define uart4 3 ///< uart4
		87	#define uart5 4 ///< uart5
		88	#define uart6 5 ///< uart6
		89	#define uart7 6 ///< uart7
		90	#define uart8 7 ///< uart8
		91	#define uart9 8 ///< uart9
		92
		93	#ifndef DOXYGEN_SHOULD_SKIP_THIS
		94	#define UARTPARITYMASK 0x3
		95	#define UARTBITSMASK 0xC
		96	#define UARTSTOPBITSMASK 0x70
		97	#endif
		98
		99	/**
		100	* @brief Uart parity enum
		101	*
		102	* Use uartparity_t values to configure the parity of your UART port with
		103	* uartsetparity function or uartsetconfig. Don't try to use numerical values
		104	* directly!
		105	*/
		106	typedef enum uartparity_t
		107	{
		108	uartparitynone = 0x1, /*< No parity /
		109	uartparityeven = 0x2, /*< Even parity /
		110	uartparityodd = 0x3 /*< Odd parity /
		111	}uartparity_t;
		112
		113	/**
		114	* @brief Uart data bits enum
		115	*
		116	* Use uartbits_t values to configure the number of data bits of your UART port with
		117	* uartsetdatabits function or uartsetconfig. Don't try to use numerical values
		118	* directly!
		119	*/
		120	typedef enum uartbits_t
		121	{
		122	uart7bits = 0x4, /*< 7 data bits communication /
		123	uart8bits = 0x8, /*< 8 data bits communication /
		124	uart9bits = 0xC /*< 9 data bits communication /
		125	}uartbits_t;
		126
		127	/**
		128	* @brief Uart stop bits enum
		129	*
		130	* Use uartstopbits_t values to configure the number of stop bits of your UART port with
		131	* uartsetstopbits function or uartsetconfig. Don't try to use numerical values
		132	* directly!
		133	*/
		134	typedef enum uartstopbits_t
		135	{
		136	uarthalfstop = 0x10, /*< 0.5 stop bits communication /
		137	uartonestop = 0x20, /*< 1 stop bits communication /
		138	uartonehalfstop = 0x30, /*< 1.5 stop bits communication /
		139	uarttwostop = 0x40 /*< 2 stop bits communication /
		140	}uartstopbits_t;
		141
		142
		143
		144	/**
		145	* @brief Uart open function
		146	*
		147	* This function opens the given uart, it should turn it ON iff needed and enable it.
		148	* @param count The uart identifier uart1 for example
		149	* @return The uart identifier on success or -1 if it fails.
		150	*/
		151	extern uart_t uartopen(int count);
		152	/**
		153	* @brief Uart open and configure function
		154	*
		155	* This function call uartopen and configure the UART with the given parameters.
		156	* @param count The uart identifier uart1 for example
		157	* @param cfg The configuration of the UART, build from an or mask.
		158	* @param speed The target speed of the UART in bauds, the real speed depend on the implementation
		159	* and the target.
		160	* @param TXpin The TXpin look gpio api.
		161	* @param RXpin The RXpin look gpio api.
		162	* @param RTSpin The RTSpin look gpio api.
		163	* @param CTSpin The CTSpin look gpio api.
		164	* @return The uart identifier on success or -1 if it fails.
		165	* @sa uartclose(uart_t uart), uartopenandconfig(int count ,uint32_t cfg,uint32_t speed,uint32_t TXpin,uint32_t RXpin,uint32_t RTSpin,uint32_t CTSpin), uartsetconfig(uart_t uart,uint32_t cfg,uint32_t speed)
		166	*/
		167	extern uart_t uartopenandconfig(int count ,uint32_t cfg,uint32_t speed,uint32_t TXpin,uint32_t RXpin,uint32_t RTSpin,uint32_t CTSpin);
		168	/**
		169	* @brief Uart close function
		170	*
		171	* This function should at least reset the UART configuration.
		172	* @param uart The uart identifier uart1 for example.
		173	* @return 1 on success or -1 on error.
		174	*/
		175	extern int uartclose(uart_t uart);
		176	/**
		177	* @brief uart set pins function
		178	*
		179	* This function sets the Uart pins, you have to check for each target that the pins you selected
		180	* are compatible with the desired function.
		181	* @param uart The uart identifier uart1 for example.
		182	* @param TXpin The TXpin look gpio api.
		183	* @param RXpin The RXpin look gpio api.
		184	* @param RTSpin The RTSpin look gpio api.
		185	* @param CTSpin The CTSpin look gpio api.
		186	* @return 1 on success or -1 on error.
		187	* @sa uartopen(int count)
		188	*/
		189	extern int uartsetpins(uart_t uart,uint32_t TXpin,uint32_t RXpin,uint32_t RTSpin,uint32_t CTSpin);
		190	/**
		191	* @brief Enable uart functionnable
		192	*
		193	*This function enables given uart, it makes sens on target where you can enable or disable
		194	*the uart.
		195	* @param uart The uart identifier uart1 for example.
		196	* @return 1 on success or -1 on error.
		197	* @sa uartenable(uart_t uart)
		198	*/
		199	extern int uartenable(uart_t uart);
		200	/**
		201	* @brief Disable uart function
		202	*
		203	*This function disables given uart, it makes sens on target where you can enable or disable
		204	*the uart.
		205	* @param uart The uart identifier uart1 for example.
		206	* @return 1 on success or -1 on error.
		207	*/
		208	extern int uartdisable(uart_t uart);
		209	/**
		210	* @brief uart set configuration function
		211	*
		212	* This function configure the given uart.
		213	* @param uart The uart identifier uart1 for example.
		214	* @param cfg
		215	* @param speed
		216	* @return
		217	*/
		218	extern int uartsetconfig(uart_t uart,uint32_t cfg,uint32_t speed);
		219	/**
		220	* @brief uartsetspeed
		221	* @param uart The uart identifier uart1 for example.
		222	* @param speed
		223	* @return
		224	*/
		225	extern int uartsetspeed(uart_t uart,uint32_t speed);
		226	/**
		227	* @brief uartsetparity
		228	* @param uart The uart identifier uart1 for example.
		229	* @param parity
		230	* @return
		231	*/
		232	extern int uartsetparity(uart_t uart,uartparity_t parity);
		233	/**
		234	* @brief uartsetdatabits
		235	* @param uart The uart identifier uart1 for example.
		236	* @param databits
		237	* @return
		238	*/
		239	extern int uartsetdatabits(uart_t uart,uartbits_t databits);
		240	/**
		241	* @brief uartsetstopbits
		242	* @param uart The uart identifier uart1 for example.
		243	* @param stopbits
		244	* @return
		245	*/
		246	extern int uartsetstopbits(uart_t uart,uartstopbits_t stopbits);
		247	/**
		248	* @brief uartputc
		249	* @param uart The uart identifier uart1 for example.
		250	* @param c
		251	* @return
		252	*/
		253	extern int uartputc(uart_t uart,char c);
		254	/**
		255	* @brief uartgetc
		256	* @param uart The uart identifier uart1 for example.
		257	* @return
		258	*/
		259	extern char uartgetc(uart_t uart);
		260	/**
		261	* @brief uartputs
		262	* @param uart The uart identifier uart1 for example.
		263	* @param s
		264	* @return
		265	*/
		266	extern int uartputs(uart_t uart,char* s);
		267	/**
		268	* @brief uartgets
		269	* @param uart The uart identifier uart1 for example.
		270	* @param s
		271	* @return
		272	*/
		273	extern int uartgets(uart_t uart,char* s);
		274	/**
		275	* @brief uartputnc
		276	* @param uart The uart identifier uart1 for example.
		277	* @param c
		278	* @param n
		279	* @return
		280	*/
		281	extern int uartputnc(uart_t uart,char* c,int n);
		282	/**
		283	* @brief uartgetnc
		284	* @param uart The uart identifier uart1 for example.
		285	* @param c
		286	* @param n
		287	* @return
		288	*/
		289	extern int uartgetnc(uart_t uart,char* c,int n);
		290	/**
		291	* @brief uartavailiabledata
		292	* @param uart The uart identifier uart1 for example.
		293	* @return
		294	*/
		295	extern int uartavailiabledata(uart_t uart);
		296	/**
		297	* @brief uartmkstreamdev
		298	* @param uart The uart identifier uart1 for example.
		299	* @param strdev
		300	* @return
		301	*/
		302	extern int uartmkstreamdev(uart_t uart,streamdevice* strdev);
		303
		304	#ifdef __cplusplus
		305	}
		306	#endif
		307	#endif //SPI_H
		308
		309
		310
		311
		312
		313
		314
		315
		316
		317
		318
		319

include/POWER/ina226.h created 644 +104 0

			@@ -0,0 +1,104
		1	/*------------------------------------------------------------------------------
		2	-- This file is a part of the libuc, microcontroler library
		3	-- Copyright (C) 2011, Alexis Jeandet
		4	--
		5	-- This program is free software; you can redistribute it and/or modify
		6	-- it under the terms of the GNU General Public License as published by
		7	-- the Free Software Foundation; either version 3 of the License, or
		8	-- (at your option) any later version.
		9	--
		10	-- This program is distributed in the hope that it will be useful,
		11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	-- GNU General Public License for more details.
		14	--
		15	-- You should have received a copy of the GNU General Public License
		16	-- along with this program; if not, write to the Free Software
		17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
		18	-------------------------------------------------------------------------------
		19	-- Author : Alexis Jeandet
		20	-- Mail : alexis.jeandet@gmail.com
		21	-------------------------------------------------------------------------------*/
		22	#ifndef INA226_H
		23	#define INA226_H
		24
		25	#include <i2c.h>
		26	//#include <uhandle.h>
		27
		28	typedef struct INA226_t
		29	{
		30	i2c_t i2cdev;
		31	uint8_t devAddress;
		32	uint32_t shuntmOhm;
		33	uint32_t CurrentRangeuAmp;
		34	}INA226_t;
		35
		36	extern int ina226open(INA226_t* dev,i2c_t i2cdev,uint16_t config,uint8_t A0,uint8_t A1,uint32_t shuntmOhm, uint32_t CurrentRangeuAmp);
		37	extern uint16_t ina226getID(INA226_t* dev);
		38	extern int ina226calibrate(INA226_t* dev,uint32_t shuntmOhm, uint32_t CurrentRangeuAmp);
		39	extern uint32_t ina226getBusVoltage(INA226_t* dev);
		40	extern uint32_t ina226getPower(INA226_t* dev);
		41	extern int32_t ina226getCurrent(INA226_t* dev);
		42	extern uint16_t ina226getReg(INA226_t* dev,char reg);
		43	extern int ina226setReg(INA226_t* dev,char reg,int16_t value);
		44
		45
		46	#define INA226_I2C_ADDRESS 0x40
		47
		48
		49	#define INA226_Die_ID_Reg 0xFF
		50	#define INA226_Configuration_Reg 0
		51	#define INA226_Shunt_Voltage_Reg 1
		52	#define INA226_Bus_Voltage_Reg 2
		53	#define INA226_Power_Reg 3
		54	#define INA226_Current_Reg 4
		55	#define INA226_Calibration_Reg 5
		56	#define INA226_Mask_Enable_Reg 6
		57	#define INA226_Alert_Limit_Reg 7
		58
		59	#define INA226_AVERAGES_1 0
		60	#define INA226_AVERAGES_4 (1<<9)
		61	#define INA226_AVERAGES_16 (2<<9)
		62	#define INA226_AVERAGES_64 (3<<9)
		63	#define INA226_AVERAGES_128 (4<<9)
		64	#define INA226_AVERAGES_256 (5<<9)
		65	#define INA226_AVERAGES_512 (6<<9)
		66	#define INA226_AVERAGES_1024 (7<<9)
		67
		68	#define INA226_BUS_CONV_140us 0
		69	#define INA226_BUS_CONV_204us (1<<6)
		70	#define INA226_BUS_CONV_332us (2<<6)
		71	#define INA226_BUS_CONV_588us (3<<6)
		72	#define INA226_BUS_CONV_1100us (4<<6)
		73	#define INA226_BUS_CONV_2116us (5<<6)
		74	#define INA226_BUS_CONV_4156us (6<<6)
		75	#define INA226_BUS_CONV_8244us (7<<6)
		76
		77	#define INA226_SHUNT_CONV_140us 0
		78	#define INA226_SHUNT_CONV_204us (1<<3)
		79	#define INA226_SHUNT_CONV_332us (2<<3)
		80	#define INA226_SHUNT_CONV_588us (3<<3)
		81	#define INA226_SHUNT_CONV_1100us (4<<3)
		82	#define INA226_SHUNT_CONV_2116us (5<<3)
		83	#define INA226_SHUNT_CONV_4156us (6<<3)
		84	#define INA226_SHUNT_CONV_8244us (7<<3)
		85
		86	#define INA226_MODE_POWER_DOWN 0
		87	#define INA226_MODE_SHUNT_VOLTAGE_TRIGGERRED 1
		88	#define INA226_MODE_BUS_VOLTAGE_TRIGGERRED 2
		89	#define INA226_MODE_SHUNT_AND_BUS_TRIGGERRED 3
		90	#define INA226_MODE_SHUNT_VOLTAGE_CONTINUOUS 5
		91	#define INA226_MODE_BUS_VOLTAGE_CONTINUOUS 6
		92	#define INA226_MODE_SHUNT_AND_BUS_CONTINUOUS 7
		93
		94
		95
		96
		97	#endif
		98
		99
		100
		101
		102
		103
		104

Doxyfile +11 -11

              # Doxyfile 1.8.3.1
              # This file describes the settings to be used by the documentation system
              # doxygen (www.doxygen.org) for a project
              #
              # All text after a hash (#) is considered a comment and will be ignored
              # The format is:
              #       TAG = value [value, ...]
              # For lists items can also be appended using:
              #       TAG += value [value, ...]
              # Values that contain spaces should be placed between quotes (" ")
              #---------------------------------------------------------------------------
              # Project related configuration options
              #---------------------------------------------------------------------------
              # This tag specifies the encoding used for all characters in the config file
              # that follow. The default is UTF-8 which is also the encoding used for all
              # text before the first occurrence of this tag. Doxygen uses libiconv (or the
              # iconv built into libc) for the transcoding. See
              # http://www.gnu.org/software/libiconv for the list of possible encodings.
              DOXYFILE_ENCODING      = UTF-8
              # The PROJECT_NAME tag is a single word (or sequence of words) that should
              # identify the project. Note that if you do not use Doxywizard you need
              # to put quotes around the project name if it contains spaces.
              PROJECT_NAME           = libuc2
              # The PROJECT_NUMBER tag can be used to enter a project or revision number.
              # This could be handy for archiving the generated documentation or
              # if some version control system is used.
              PROJECT_NUMBER         =
              # Using the PROJECT_BRIEF tag one can provide an optional one line description
              # for a project that appears at the top of each page and should give viewer
              # a quick idea about the purpose of the project. Keep the description short.
              PROJECT_BRIEF          =
              # With the PROJECT_LOGO tag one can specify an logo or icon that is
              # included in the documentation. The maximum height of the logo should not
              # exceed 55 pixels and the maximum width should not exceed 200 pixels.
              # Doxygen will copy the logo to the output directory.
              PROJECT_LOGO           =
              # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute)
              # base path where the generated documentation will be put.
              # If a relative path is entered, it will be relative to the location
              # where doxygen was started. If left blank the current directory will be used.
-             OUTPUT_DIRECTORY       = /opt/libuc2/Doc/doxygen
+             OUTPUT_DIRECTORY       = doc/doxygen
              # If the CREATE_SUBDIRS tag is set to YES, then doxygen will create
              # 4096 sub-directories (in 2 levels) under the output directory of each output
              # format and will distribute the generated files over these directories.
              # Enabling this option can be useful when feeding doxygen a huge amount of
              # source files, where putting all generated files in the same directory would
              # otherwise cause performance problems for the file system.
              CREATE_SUBDIRS         = NO
              # The OUTPUT_LANGUAGE tag is used to specify the language in which all
              # documentation generated by doxygen is written. Doxygen will use this
              # information to generate all constant output in the proper language.
              # The default language is English, other supported languages are:
              # Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional,
              # Croatian, Czech, Danish, Dutch, Esperanto, Farsi, Finnish, French, German,
              # Greek, Hungarian, Italian, Japanese, Japanese-en (Japanese with English
              # messages), Korean, Korean-en, Lithuanian, Norwegian, Macedonian, Persian,
              # Polish, Portuguese, Romanian, Russian, Serbian, Serbian-Cyrillic, Slovak,
              # Slovene, Spanish, Swedish, Ukrainian, and Vietnamese.
              OUTPUT_LANGUAGE        = English
              # If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will
              # include brief member descriptions after the members that are listed in
              # the file and class documentation (similar to JavaDoc).
              # Set to NO to disable this.
              BRIEF_MEMBER_DESC      = YES
              # If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend
              # the brief description of a member or function before the detailed description.
              # Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
              # brief descriptions will be completely suppressed.
              REPEAT_BRIEF           = YES
              # This tag implements a quasi-intelligent brief description abbreviator
              # that is used to form the text in various listings. Each string
              # in this list, if found as the leading text of the brief description, will be
              # stripped from the text and the result after processing the whole list, is
              # used as the annotated text. Otherwise, the brief description is used as-is.
              # If left blank, the following values are used ("$name" is automatically
              # replaced with the name of the entity): "The $name class" "The $name widget"
              # "The $name file" "is" "provides" "specifies" "contains"
              # "represents" "a" "an" "the"
              ABBREVIATE_BRIEF       = "The $name class" \
                                       "The $name widget" \
                                       "The $name file" \
                                       is \
                                       provides \
                                       specifies \
                                       contains \
                                       represents \
                                       a \
                                       an \
                                       the
              # If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
              # Doxygen will generate a detailed section even if there is only a brief
              # description.
              ALWAYS_DETAILED_SEC    = NO
              # If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
              # inherited members of a class in the documentation of that class as if those
              # members were ordinary class members. Constructors, destructors and assignment
              # operators of the base classes will not be shown.
              INLINE_INHERITED_MEMB  = NO
              # If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full
              # path before files name in the file list and in the header files. If set
              # to NO the shortest path that makes the file name unique will be used.
              FULL_PATH_NAMES        = YES
              # If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag
              # can be used to strip a user-defined part of the path. Stripping is
              # only done if one of the specified strings matches the left-hand part of
              # the path. The tag can be used to show relative paths in the file list.
              # If left blank the directory from which doxygen is run is used as the
              # path to strip. Note that you specify absolute paths here, but also
              # relative paths, which will be relative from the directory where doxygen is
              # started.
              STRIP_FROM_PATH        =
              # The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of
              # the path mentioned in the documentation of a class, which tells
              # the reader which header file to include in order to use a class.
              # If left blank only the name of the header file containing the class
              # definition is used. Otherwise one should specify the include paths that
              # are normally passed to the compiler using the -I flag.
              STRIP_FROM_INC_PATH    =
              # If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter
              # (but less readable) file names. This can be useful if your file system
              # doesn't support long names like on DOS, Mac, or CD-ROM.
              SHORT_NAMES            = NO
              # If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen
              # will interpret the first line (until the first dot) of a JavaDoc-style
              # comment as the brief description. If set to NO, the JavaDoc
              # comments will behave just like regular Qt-style comments
              # (thus requiring an explicit @brief command for a brief description.)
              JAVADOC_AUTOBRIEF      = NO
              # If the QT_AUTOBRIEF tag is set to YES then Doxygen will
              # interpret the first line (until the first dot) of a Qt-style
              # comment as the brief description. If set to NO, the comments
              # will behave just like regular Qt-style comments (thus requiring
              # an explicit \brief command for a brief description.)
              QT_AUTOBRIEF           = NO
              # The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen
              # treat a multi-line C++ special comment block (i.e. a block of //! or ///
              # comments) as a brief description. This used to be the default behaviour.
              # The new default is to treat a multi-line C++ comment block as a detailed
              # description. Set this tag to YES if you prefer the old behaviour instead.
              MULTILINE_CPP_IS_BRIEF = NO
              # If the INHERIT_DOCS tag is set to YES (the default) then an undocumented
              # member inherits the documentation from any documented member that it
              # re-implements.
              INHERIT_DOCS           = YES
              # If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce
              # a new page for each member. If set to NO, the documentation of a member will
              # be part of the file/class/namespace that contains it.
              SEPARATE_MEMBER_PAGES  = NO
              # The TAB_SIZE tag can be used to set the number of spaces in a tab.
              # Doxygen uses this value to replace tabs by spaces in code fragments.
              TAB_SIZE               = 4
              # This tag can be used to specify a number of aliases that acts
              # as commands in the documentation. An alias has the form "name=value".
              # For example adding "sideeffect=\par Side Effects:\n" will allow you to
              # put the command \sideeffect (or @sideeffect) in the documentation, which
              # will result in a user-defined paragraph with heading "Side Effects:".
              # You can put \n's in the value part of an alias to insert newlines.
              ALIASES                =
              # This tag can be used to specify a number of word-keyword mappings (TCL only).
              # A mapping has the form "name=value". For example adding
              # "class=itcl::class" will allow you to use the command class in the
              # itcl::class meaning.
              TCL_SUBST              =
              # Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C
              # sources only. Doxygen will then generate output that is more tailored for C.
              # For instance, some of the names that are used will be different. The list
              # of all members will be omitted, etc.
              OPTIMIZE_OUTPUT_FOR_C  = YES
              # Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java
              # sources only. Doxygen will then generate output that is more tailored for
              # Java. For instance, namespaces will be presented as packages, qualified
              # scopes will look different, etc.
              OPTIMIZE_OUTPUT_JAVA   = NO
              # Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran
              # sources only. Doxygen will then generate output that is more tailored for
              # Fortran.
              OPTIMIZE_FOR_FORTRAN   = NO
              # Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL
              # sources. Doxygen will then generate output that is tailored for
              # VHDL.
              OPTIMIZE_OUTPUT_VHDL   = NO
              # Doxygen selects the parser to use depending on the extension of the files it
              # parses. With this tag you can assign which parser to use for a given
              # extension. Doxygen has a built-in mapping, but you can override or extend it
              # using this tag. The format is ext=language, where ext is a file extension,
              # and language is one of the parsers supported by doxygen: IDL, Java,
              # Javascript, CSharp, C, C++, D, PHP, Objective-C, Python, Fortran, VHDL, C,
              # C++. For instance to make doxygen treat .inc files as Fortran files (default
              # is PHP), and .f files as C (default is Fortran), use: inc=Fortran f=C. Note
              # that for custom extensions you also need to set FILE_PATTERNS otherwise the
              # files are not read by doxygen.
              EXTENSION_MAPPING      =
              # If MARKDOWN_SUPPORT is enabled (the default) then doxygen pre-processes all
              # comments according to the Markdown format, which allows for more readable
              # documentation. See http://daringfireball.net/projects/markdown/ for details.
              # The output of markdown processing is further processed by doxygen, so you
              # can mix doxygen, HTML, and XML commands with Markdown formatting.
              # Disable only in case of backward compatibilities issues.
              MARKDOWN_SUPPORT       = YES
              # When enabled doxygen tries to link words that correspond to documented classes,
              # or namespaces to their corresponding documentation. Such a link can be
              # prevented in individual cases by by putting a % sign in front of the word or
              # globally by setting AUTOLINK_SUPPORT to NO.
              AUTOLINK_SUPPORT       = YES
              # If you use STL classes (i.e. std::string, std::vector, etc.) but do not want
              # to include (a tag file for) the STL sources as input, then you should
              # set this tag to YES in order to let doxygen match functions declarations and
              # definitions whose arguments contain STL classes (e.g. func(std::string); v.s.
              # func(std::string) {}). This also makes the inheritance and collaboration
              # diagrams that involve STL classes more complete and accurate.
              BUILTIN_STL_SUPPORT    = NO
              # If you use Microsoft's C++/CLI language, you should set this option to YES to
              # enable parsing support.
              CPP_CLI_SUPPORT        = NO
              # Set the SIP_SUPPORT tag to YES if your project consists of sip sources only.
              # Doxygen will parse them like normal C++ but will assume all classes use public
              # instead of private inheritance when no explicit protection keyword is present.
              SIP_SUPPORT            = NO
              # For Microsoft's IDL there are propget and propput attributes to indicate
              # getter and setter methods for a property. Setting this option to YES (the
              # default) will make doxygen replace the get and set methods by a property in
              # the documentation. This will only work if the methods are indeed getting or
              # setting a simple type. If this is not the case, or you want to show the
              # methods anyway, you should set this option to NO.
              IDL_PROPERTY_SUPPORT   = YES
              # If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
              # tag is set to YES, then doxygen will reuse the documentation of the first
              # member in the group (if any) for the other members of the group. By default
              # all members of a group must be documented explicitly.
              DISTRIBUTE_GROUP_DOC   = NO
              # Set the SUBGROUPING tag to YES (the default) to allow class member groups of
              # the same type (for instance a group of public functions) to be put as a
              # subgroup of that type (e.g. under the Public Functions section). Set it to
              # NO to prevent subgrouping. Alternatively, this can be done per class using
              # the \nosubgrouping command.
              SUBGROUPING            = YES
              # When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and
              # unions are shown inside the group in which they are included (e.g. using
              # @ingroup) instead of on a separate page (for HTML and Man pages) or
              # section (for LaTeX and RTF).
              INLINE_GROUPED_CLASSES = NO
              # When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and
              # unions with only public data fields will be shown inline in the documentation
              # of the scope in which they are defined (i.e. file, namespace, or group
              # documentation), provided this scope is documented. If set to NO (the default),
              # structs, classes, and unions are shown on a separate page (for HTML and Man
              # pages) or section (for LaTeX and RTF).
              INLINE_SIMPLE_STRUCTS  = NO
              # When TYPEDEF_HIDES_STRUCT is enabled, a typedef of a struct, union, or enum
              # is documented as struct, union, or enum with the name of the typedef. So
              # typedef struct TypeS {} TypeT, will appear in the documentation as a struct
              # with name TypeT. When disabled the typedef will appear as a member of a file,
              # namespace, or class. And the struct will be named TypeS. This can typically
              # be useful for C code in case the coding convention dictates that all compound
              # types are typedef'ed and only the typedef is referenced, never the tag name.
-             TYPEDEF_HIDES_STRUCT   = NO
+             TYPEDEF_HIDES_STRUCT   = YES
              # The SYMBOL_CACHE_SIZE determines the size of the internal cache use to
              # determine which symbols to keep in memory and which to flush to disk.
              # When the cache is full, less often used symbols will be written to disk.
              # For small to medium size projects (<1000 input files) the default value is
              # probably good enough. For larger projects a too small cache size can cause
              # doxygen to be busy swapping symbols to and from disk most of the time
              # causing a significant performance penalty.
              # If the system has enough physical memory increasing the cache will improve the
              # performance by keeping more symbols in memory. Note that the value works on
              # a logarithmic scale so increasing the size by one will roughly double the
              # memory usage. The cache size is given by this formula:
              # 2^(16+SYMBOL_CACHE_SIZE). The valid range is 0..9, the default is 0,
              # corresponding to a cache size of 2^16 = 65536 symbols.
              SYMBOL_CACHE_SIZE      = 0
              # Similar to the SYMBOL_CACHE_SIZE the size of the symbol lookup cache can be
              # set using LOOKUP_CACHE_SIZE. This cache is used to resolve symbols given
              # their name and scope. Since this can be an expensive process and often the
              # same symbol appear multiple times in the code, doxygen keeps a cache of
              # pre-resolved symbols. If the cache is too small doxygen will become slower.
              # If the cache is too large, memory is wasted. The cache size is given by this
              # formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range is 0..9, the default is 0,
              # corresponding to a cache size of 2^16 = 65536 symbols.
              LOOKUP_CACHE_SIZE      = 0
              #---------------------------------------------------------------------------
              # Build related configuration options
              #---------------------------------------------------------------------------
              # If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in
              # documentation are documented, even if no documentation was available.
              # Private class members and static file members will be hidden unless
              # the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES
-             EXTRACT_ALL            = NO
+             EXTRACT_ALL            = YES
              # If the EXTRACT_PRIVATE tag is set to YES all private members of a class
              # will be included in the documentation.
              EXTRACT_PRIVATE        = NO
              # If the EXTRACT_PACKAGE tag is set to YES all members with package or internal
              # scope will be included in the documentation.
              EXTRACT_PACKAGE        = NO
              # If the EXTRACT_STATIC tag is set to YES all static members of a file
              # will be included in the documentation.
              EXTRACT_STATIC         = NO
              # If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs)
              # defined locally in source files will be included in the documentation.
              # If set to NO only classes defined in header files are included.
              EXTRACT_LOCAL_CLASSES  = YES
              # This flag is only useful for Objective-C code. When set to YES local
              # methods, which are defined in the implementation section but not in
              # the interface are included in the documentation.
              # If set to NO (the default) only methods in the interface are included.
              EXTRACT_LOCAL_METHODS  = NO
              # If this flag is set to YES, the members of anonymous namespaces will be
              # extracted and appear in the documentation as a namespace called
              # 'anonymous_namespace{file}', where file will be replaced with the base
              # name of the file that contains the anonymous namespace. By default
              # anonymous namespaces are hidden.
              EXTRACT_ANON_NSPACES   = NO
              # If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all
              # undocumented members of documented classes, files or namespaces.
              # If set to NO (the default) these members will be included in the
              # various overviews, but no documentation section is generated.
              # This option has no effect if EXTRACT_ALL is enabled.
              HIDE_UNDOC_MEMBERS     = NO
              # If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all
              # undocumented classes that are normally visible in the class hierarchy.
              # If set to NO (the default) these classes will be included in the various
              # overviews. This option has no effect if EXTRACT_ALL is enabled.
              HIDE_UNDOC_CLASSES     = NO
              # If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all
              # friend (class|struct|union) declarations.
              # If set to NO (the default) these declarations will be included in the
              # documentation.
              HIDE_FRIEND_COMPOUNDS  = NO
              # If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any
              # documentation blocks found inside the body of a function.
              # If set to NO (the default) these blocks will be appended to the
              # function's detailed documentation block.
              HIDE_IN_BODY_DOCS      = NO
              # The INTERNAL_DOCS tag determines if documentation
              # that is typed after a \internal command is included. If the tag is set
              # to NO (the default) then the documentation will be excluded.
              # Set it to YES to include the internal documentation.
              INTERNAL_DOCS          = NO
              # If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate
              # file names in lower-case letters. If set to YES upper-case letters are also
              # allowed. This is useful if you have classes or files whose names only differ
              # in case and if your file system supports case sensitive file names. Windows
              # and Mac users are advised to set this option to NO.
              CASE_SENSE_NAMES       = NO
              # If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen
              # will show members with their full class and namespace scopes in the
              # documentation. If set to YES the scope will be hidden.
              HIDE_SCOPE_NAMES       = YES
              # If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen
              # will put a list of the files that are included by a file in the documentation
              # of that file.
              SHOW_INCLUDE_FILES     = YES
              # If the FORCE_LOCAL_INCLUDES tag is set to YES then Doxygen
              # will list include files with double quotes in the documentation
              # rather than with sharp brackets.
              FORCE_LOCAL_INCLUDES   = NO
              # If the INLINE_INFO tag is set to YES (the default) then a tag [inline]
              # is inserted in the documentation for inline members.
              INLINE_INFO            = YES
              # If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen
              # will sort the (detailed) documentation of file and class members
              # alphabetically by member name. If set to NO the members will appear in
              # declaration order.
              SORT_MEMBER_DOCS       = YES
              # If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the
              # brief documentation of file, namespace and class members alphabetically
              # by member name. If set to NO (the default) the members will appear in
              # declaration order.
              SORT_BRIEF_DOCS        = NO
              # If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen
              # will sort the (brief and detailed) documentation of class members so that
              # constructors and destructors are listed first. If set to NO (the default)
              # the constructors will appear in the respective orders defined by
              # SORT_MEMBER_DOCS and SORT_BRIEF_DOCS.
              # This tag will be ignored for brief docs if SORT_BRIEF_DOCS is set to NO
              # and ignored for detailed docs if SORT_MEMBER_DOCS is set to NO.
              SORT_MEMBERS_CTORS_1ST = NO
              # If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the
              # hierarchy of group names into alphabetical order. If set to NO (the default)
              # the group names will appear in their defined order.
              SORT_GROUP_NAMES       = NO
              # If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be
              # sorted by fully-qualified names, including namespaces. If set to
              # NO (the default), the class list will be sorted only by class name,
              # not including the namespace part.
              # Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
              # Note: This option applies only to the class list, not to the
              # alphabetical list.
              SORT_BY_SCOPE_NAME     = NO
              # If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to
              # do proper type resolution of all parameters of a function it will reject a
              # match between the prototype and the implementation of a member function even
              # if there is only one candidate or it is obvious which candidate to choose
              # by doing a simple string match. By disabling STRICT_PROTO_MATCHING doxygen
              # will still accept a match between prototype and implementation in such cases.
              STRICT_PROTO_MATCHING  = NO
              # The GENERATE_TODOLIST tag can be used to enable (YES) or
              # disable (NO) the todo list. This list is created by putting \todo
              # commands in the documentation.
              GENERATE_TODOLIST      = YES
              # The GENERATE_TESTLIST tag can be used to enable (YES) or
              # disable (NO) the test list. This list is created by putting \test
              # commands in the documentation.
              GENERATE_TESTLIST      = YES
              # The GENERATE_BUGLIST tag can be used to enable (YES) or
              # disable (NO) the bug list. This list is created by putting \bug
              # commands in the documentation.
              GENERATE_BUGLIST       = YES
              # The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or
              # disable (NO) the deprecated list. This list is created by putting
              # \deprecated commands in the documentation.
              GENERATE_DEPRECATEDLIST= YES
              # The ENABLED_SECTIONS tag can be used to enable conditional
              # documentation sections, marked by \if section-label ... \endif
              # and \cond section-label ... \endcond blocks.
              ENABLED_SECTIONS       =
              # The MAX_INITIALIZER_LINES tag determines the maximum number of lines
              # the initial value of a variable or macro consists of for it to appear in
              # the documentation. If the initializer consists of more lines than specified
              # here it will be hidden. Use a value of 0 to hide initializers completely.
              # The appearance of the initializer of individual variables and macros in the
              # documentation can be controlled using \showinitializer or \hideinitializer
              # command in the documentation regardless of this setting.
              MAX_INITIALIZER_LINES  = 30
              # Set the SHOW_USED_FILES tag to NO to disable the list of files generated
              # at the bottom of the documentation of classes and structs. If set to YES the
              # list will mention the files that were used to generate the documentation.
              SHOW_USED_FILES        = YES
              # Set the SHOW_FILES tag to NO to disable the generation of the Files page.
              # This will remove the Files entry from the Quick Index and from the
              # Folder Tree View (if specified). The default is YES.
              SHOW_FILES             = YES
              # Set the SHOW_NAMESPACES tag to NO to disable the generation of the
              # Namespaces page.  This will remove the Namespaces entry from the Quick Index
              # and from the Folder Tree View (if specified). The default is YES.
              SHOW_NAMESPACES        = YES
              # The FILE_VERSION_FILTER tag can be used to specify a program or script that
              # doxygen should invoke to get the current version for each file (typically from
              # the version control system). Doxygen will invoke the program by executing (via
              # popen()) the command <command> <input-file>, where <command> is the value of
              # the FILE_VERSION_FILTER tag, and <input-file> is the name of an input file
              # provided by doxygen. Whatever the program writes to standard output
              # is used as the file version. See the manual for examples.
              FILE_VERSION_FILTER    =
              # The LAYOUT_FILE tag can be used to specify a layout file which will be parsed
              # by doxygen. The layout file controls the global structure of the generated
              # output files in an output format independent way. To create the layout file
              # that represents doxygen's defaults, run doxygen with the -l option.
              # You can optionally specify a file name after the option, if omitted
              # DoxygenLayout.xml will be used as the name of the layout file.
              LAYOUT_FILE            =
              # The CITE_BIB_FILES tag can be used to specify one or more bib files
              # containing the references data. This must be a list of .bib files. The
              # .bib extension is automatically appended if omitted. Using this command
              # requires the bibtex tool to be installed. See also
              # http://en.wikipedia.org/wiki/BibTeX for more info. For LaTeX the style
              # of the bibliography can be controlled using LATEX_BIB_STYLE. To use this
              # feature you need bibtex and perl available in the search path. Do not use
              # file names with spaces, bibtex cannot handle them.
              CITE_BIB_FILES         =
              #---------------------------------------------------------------------------
              # configuration options related to warning and progress messages
              #---------------------------------------------------------------------------
              # The QUIET tag can be used to turn on/off the messages that are generated
              # by doxygen. Possible values are YES and NO. If left blank NO is used.
              QUIET                  = NO
              # The WARNINGS tag can be used to turn on/off the warning messages that are
              # generated by doxygen. Possible values are YES and NO. If left blank
              # NO is used.
              WARNINGS               = YES
              # If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings
              # for undocumented members. If EXTRACT_ALL is set to YES then this flag will
              # automatically be disabled.
              WARN_IF_UNDOCUMENTED   = YES
              # If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for
              # potential errors in the documentation, such as not documenting some
              # parameters in a documented function, or documenting parameters that
              # don't exist or using markup commands wrongly.
              WARN_IF_DOC_ERROR      = YES
              # The WARN_NO_PARAMDOC option can be enabled to get warnings for
              # functions that are documented, but have no documentation for their parameters
              # or return value. If set to NO (the default) doxygen will only warn about
              # wrong or incomplete parameter documentation, but not about the absence of
              # documentation.
              WARN_NO_PARAMDOC       = NO
              # The WARN_FORMAT tag determines the format of the warning messages that
              # doxygen can produce. The string should contain the $file, $line, and $text
              # tags, which will be replaced by the file and line number from which the
              # warning originated and the warning text. Optionally the format may contain
              # $version, which will be replaced by the version of the file (if it could
              # be obtained via FILE_VERSION_FILTER)
              WARN_FORMAT            = "$file:$line: $text"
              # The WARN_LOGFILE tag can be used to specify a file to which warning
              # and error messages should be written. If left blank the output is written
              # to stderr.
              WARN_LOGFILE           =
              #---------------------------------------------------------------------------
              # configuration options related to the input files
              #---------------------------------------------------------------------------
              # The INPUT tag can be used to specify the files and/or directories that contain
              # documented source files. You may enter file names like "myfile.cpp" or
              # directories like "/usr/src/myproject". Separate the files or directories
              # with spaces.
-             INPUT                  = /opt/libuc2
+             INPUT                  = include
              # This tag can be used to specify the character encoding of the source files
              # that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is
              # also the default input encoding. Doxygen uses libiconv (or the iconv built
              # into libc) for the transcoding. See http://www.gnu.org/software/libiconv for
              # the list of possible encodings.
              INPUT_ENCODING         = UTF-8
              # If the value of the INPUT tag contains directories, you can use the
              # FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
              # and *.h) to filter out the source-files in the directories. If left
              # blank the following patterns are tested:
              # *.c *.cc *.cxx *.cpp *.c++ *.d *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh
              # *.hxx *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.dox *.py
              # *.f90 *.f *.for *.vhd *.vhdl
              FILE_PATTERNS          = *.c \
                                       *.cc \
                                       *.cxx \
                                       *.cpp \
                                       *.c++ \
                                       *.d \
                                       *.java \
                                       *.ii \
                                       *.ixx \
                                       *.ipp \
                                       *.i++ \
                                       *.inl \
                                       *.h \
                                       *.hh \
                                       *.hxx \
                                       *.hpp \
                                       *.h++ \
                                       *.idl \
                                       *.odl \
                                       *.cs \
                                       *.php \
                                       *.php3 \
                                       *.inc \
                                       *.m \
                                       *.markdown \
                                       *.md \
                                       *.mm \
                                       *.dox \
                                       *.py \
                                       *.f90 \
                                       *.f \
                                       *.for \
                                       *.vhd \
                                       *.vhdl
              # The RECURSIVE tag can be used to turn specify whether or not subdirectories
              # should be searched for input files as well. Possible values are YES and NO.
              # If left blank NO is used.
              RECURSIVE              = YES
              # The EXCLUDE tag can be used to specify files and/or directories that should be
              # excluded from the INPUT source files. This way you can easily exclude a
              # subdirectory from a directory tree whose root is specified with the INPUT tag.
              # Note that relative paths are relative to the directory from which doxygen is
              # run.
              EXCLUDE                =
              # The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
              # directories that are symbolic links (a Unix file system feature) are excluded
              # from the input.
              EXCLUDE_SYMLINKS       = NO
              # If the value of the INPUT tag contains directories, you can use the
              # EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
              # certain files from those directories. Note that the wildcards are matched
              # against the file with absolute path, so to exclude all test directories
              # for example use the pattern */test/*
              EXCLUDE_PATTERNS       =
              # The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
              # (namespaces, classes, functions, etc.) that should be excluded from the
              # output. The symbol name can be a fully qualified name, a word, or if the
              # wildcard * is used, a substring. Examples: ANamespace, AClass,
              # AClass::ANamespace, ANamespace::*Test
              EXCLUDE_SYMBOLS        =
              # The EXAMPLE_PATH tag can be used to specify one or more files or
              # directories that contain example code fragments that are included (see
              # the \include command).
              EXAMPLE_PATH           =
              # If the value of the EXAMPLE_PATH tag contains directories, you can use the
              # EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
              # and *.h) to filter out the source-files in the directories. If left
              # blank all files are included.
              EXAMPLE_PATTERNS       = *
              # If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
              # searched for input files to be used with the \include or \dontinclude
              # commands irrespective of the value of the RECURSIVE tag.
              # Possible values are YES and NO. If left blank NO is used.
              EXAMPLE_RECURSIVE      = NO
              # The IMAGE_PATH tag can be used to specify one or more files or
              # directories that contain image that are included in the documentation (see
              # the \image command).
              IMAGE_PATH             =
              # The INPUT_FILTER tag can be used to specify a program that doxygen should
              # invoke to filter for each input file. Doxygen will invoke the filter program
              # by executing (via popen()) the command <filter> <input-file>, where <filter>
              # is the value of the INPUT_FILTER tag, and <input-file> is the name of an
              # input file. Doxygen will then use the output that the filter program writes
              # to standard output.  If FILTER_PATTERNS is specified, this tag will be
              # ignored.
              INPUT_FILTER           =
              # The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
              # basis.  Doxygen will compare the file name with each pattern and apply the
              # filter if there is a match.  The filters are a list of the form:
              # pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further
              # info on how filters are used. If FILTER_PATTERNS is empty or if
              # non of the patterns match the file name, INPUT_FILTER is applied.
              FILTER_PATTERNS        =
              # If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
              # INPUT_FILTER) will be used to filter the input files when producing source
              # files to browse (i.e. when SOURCE_BROWSER is set to YES).
              FILTER_SOURCE_FILES    = NO
              # The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file
              # pattern. A pattern will override the setting for FILTER_PATTERN (if any)
              # and it is also possible to disable source filtering for a specific pattern
              # using *.ext= (so without naming a filter). This option only has effect when
              # FILTER_SOURCE_FILES is enabled.
              FILTER_SOURCE_PATTERNS =
              # If the USE_MD_FILE_AS_MAINPAGE tag refers to the name of a markdown file that
              # is part of the input, its contents will be placed on the main page (index.html).
              # This can be useful if you have a project on for instance GitHub and want reuse
              # the introduction page also for the doxygen output.
              USE_MDFILE_AS_MAINPAGE =
              #---------------------------------------------------------------------------
              # configuration options related to source browsing
              #---------------------------------------------------------------------------
              # If the SOURCE_BROWSER tag is set to YES then a list of source files will
              # be generated. Documented entities will be cross-referenced with these sources.
              # Note: To get rid of all source code in the generated output, make sure also
              # VERBATIM_HEADERS is set to NO.
              SOURCE_BROWSER         = NO
              # Setting the INLINE_SOURCES tag to YES will include the body
              # of functions and classes directly in the documentation.
              INLINE_SOURCES         = NO
              # Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct
              # doxygen to hide any special comment blocks from generated source code
              # fragments. Normal C, C++ and Fortran comments will always remain visible.
              STRIP_CODE_COMMENTS    = YES
              # If the REFERENCED_BY_RELATION tag is set to YES
              # then for each documented function all documented
              # functions referencing it will be listed.
              REFERENCED_BY_RELATION = NO
              # If the REFERENCES_RELATION tag is set to YES
              # then for each documented function all documented entities
              # called/used by that function will be listed.
              REFERENCES_RELATION    = NO
              # If the REFERENCES_LINK_SOURCE tag is set to YES (the default)
              # and SOURCE_BROWSER tag is set to YES, then the hyperlinks from
              # functions in REFERENCES_RELATION and REFERENCED_BY_RELATION lists will
              # link to the source code.  Otherwise they will link to the documentation.
              REFERENCES_LINK_SOURCE = YES
              # If the USE_HTAGS tag is set to YES then the references to source code
              # will point to the HTML generated by the htags(1) tool instead of doxygen
              # built-in source browser. The htags tool is part of GNU's global source
              # tagging system (see http://www.gnu.org/software/global/global.html). You
              # will need version 4.8.6 or higher.
              USE_HTAGS              = NO
              # If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen
              # will generate a verbatim copy of the header file for each class for
              # which an include is specified. Set to NO to disable this.
              VERBATIM_HEADERS       = YES
              #---------------------------------------------------------------------------
              # configuration options related to the alphabetical class index
              #---------------------------------------------------------------------------
              # If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index
              # of all compounds will be generated. Enable this if the project
              # contains a lot of classes, structs, unions or interfaces.
              ALPHABETICAL_INDEX     = YES
              # If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then
              # the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns
              # in which this list will be split (can be a number in the range [1..20])
              COLS_IN_ALPHA_INDEX    = 5
              # In case all classes in a project start with a common prefix, all
              # classes will be put under the same header in the alphabetical index.
              # The IGNORE_PREFIX tag can be used to specify one or more prefixes that
              # should be ignored while generating the index headers.
              IGNORE_PREFIX          =
              #---------------------------------------------------------------------------
              # configuration options related to the HTML output
              #---------------------------------------------------------------------------
              # If the GENERATE_HTML tag is set to YES (the default) Doxygen will
              # generate HTML output.
              GENERATE_HTML          = YES
              # The HTML_OUTPUT tag is used to specify where the HTML docs will be put.
              # If a relative path is entered the value of OUTPUT_DIRECTORY will be
              # put in front of it. If left blank `html' will be used as the default path.
              HTML_OUTPUT            = html
              # The HTML_FILE_EXTENSION tag can be used to specify the file extension for
              # each generated HTML page (for example: .htm,.php,.asp). If it is left blank
              # doxygen will generate files with .html extension.
              HTML_FILE_EXTENSION    = .html
              # The HTML_HEADER tag can be used to specify a personal HTML header for
              # each generated HTML page. If it is left blank doxygen will generate a
              # standard header. Note that when using a custom header you are responsible
              # for the proper inclusion of any scripts and style sheets that doxygen
              # needs, which is dependent on the configuration options used.
              # It is advised to generate a default header using "doxygen -w html
              # header.html footer.html stylesheet.css YourConfigFile" and then modify
              # that header. Note that the header is subject to change so you typically
              # have to redo this when upgrading to a newer version of doxygen or when
              # changing the value of configuration settings such as GENERATE_TREEVIEW!
              HTML_HEADER            =
              # The HTML_FOOTER tag can be used to specify a personal HTML footer for
              # each generated HTML page. If it is left blank doxygen will generate a
              # standard footer.
              HTML_FOOTER            =
              # The HTML_STYLESHEET tag can be used to specify a user-defined cascading
              # style sheet that is used by each HTML page. It can be used to
              # fine-tune the look of the HTML output. If left blank doxygen will
              # generate a default style sheet. Note that it is recommended to use
              # HTML_EXTRA_STYLESHEET instead of this one, as it is more robust and this
              # tag will in the future become obsolete.
              HTML_STYLESHEET        =
              # The HTML_EXTRA_STYLESHEET tag can be used to specify an additional
              # user-defined cascading style sheet that is included after the standard
              # style sheets created by doxygen. Using this option one can overrule
              # certain style aspects. This is preferred over using HTML_STYLESHEET
              # since it does not replace the standard style sheet and is therefor more
              # robust against future updates. Doxygen will copy the style sheet file to
              # the output directory.
              HTML_EXTRA_STYLESHEET  =
              # The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
              # other source files which should be copied to the HTML output directory. Note
              # that these files will be copied to the base HTML output directory. Use the
              # $relpath$ marker in the HTML_HEADER and/or HTML_FOOTER files to load these
              # files. In the HTML_STYLESHEET file, use the file name only. Also note that
              # the files will be copied as-is; there are no commands or markers available.
              HTML_EXTRA_FILES       =
              # The HTML_COLORSTYLE_HUE tag controls the color of the HTML output.
              # Doxygen will adjust the colors in the style sheet and background images
              # according to this color. Hue is specified as an angle on a colorwheel,
              # see http://en.wikipedia.org/wiki/Hue for more information.
              # For instance the value 0 represents red, 60 is yellow, 120 is green,
              # 180 is cyan, 240 is blue, 300 purple, and 360 is red again.
              # The allowed range is 0 to 359.
              HTML_COLORSTYLE_HUE    = 220
              # The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of
              # the colors in the HTML output. For a value of 0 the output will use
              # grayscales only. A value of 255 will produce the most vivid colors.
              HTML_COLORSTYLE_SAT    = 100
              # The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to
              # the luminance component of the colors in the HTML output. Values below
              # 100 gradually make the output lighter, whereas values above 100 make
              # the output darker. The value divided by 100 is the actual gamma applied,
              # so 80 represents a gamma of 0.8, The value 220 represents a gamma of 2.2,
              # and 100 does not change the gamma.
              HTML_COLORSTYLE_GAMMA  = 80
              # If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML
              # page will contain the date and time when the page was generated. Setting
              # this to NO can help when comparing the output of multiple runs.
              HTML_TIMESTAMP         = YES
              # If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
              # documentation will contain sections that can be hidden and shown after the
              # page has loaded.
              HTML_DYNAMIC_SECTIONS  = NO
              # With HTML_INDEX_NUM_ENTRIES one can control the preferred number of
              # entries shown in the various tree structured indices initially; the user
              # can expand and collapse entries dynamically later on. Doxygen will expand
              # the tree to such a level that at most the specified number of entries are
              # visible (unless a fully collapsed tree already exceeds this amount).
              # So setting the number of entries 1 will produce a full collapsed tree by
              # default. 0 is a special value representing an infinite number of entries
              # and will result in a full expanded tree by default.
              HTML_INDEX_NUM_ENTRIES = 100
              # If the GENERATE_DOCSET tag is set to YES, additional index files
              # will be generated that can be used as input for Apple's Xcode 3
              # integrated development environment, introduced with OSX 10.5 (Leopard).
              # To create a documentation set, doxygen will generate a Makefile in the
              # HTML output directory. Running make will produce the docset in that
              # directory and running "make install" will install the docset in
              # ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find
              # it at startup.
              # See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html
              # for more information.
              GENERATE_DOCSET        = NO
              # When GENERATE_DOCSET tag is set to YES, this tag determines the name of the
              # feed. A documentation feed provides an umbrella under which multiple
              # documentation sets from a single provider (such as a company or product suite)
              # can be grouped.
              DOCSET_FEEDNAME        = "Doxygen generated docs"
              # When GENERATE_DOCSET tag is set to YES, this tag specifies a string that
              # should uniquely identify the documentation set bundle. This should be a
              # reverse domain-name style string, e.g. com.mycompany.MyDocSet. Doxygen
              # will append .docset to the name.
              DOCSET_BUNDLE_ID       = org.doxygen.Project
              # When GENERATE_PUBLISHER_ID tag specifies a string that should uniquely
              # identify the documentation publisher. This should be a reverse domain-name
              # style string, e.g. com.mycompany.MyDocSet.documentation.
              DOCSET_PUBLISHER_ID    = org.doxygen.Publisher
              # The GENERATE_PUBLISHER_NAME tag identifies the documentation publisher.
              DOCSET_PUBLISHER_NAME  = Publisher
              # If the GENERATE_HTMLHELP tag is set to YES, additional index files
              # will be generated that can be used as input for tools like the
              # Microsoft HTML help workshop to generate a compiled HTML help file (.chm)
              # of the generated HTML documentation.
              GENERATE_HTMLHELP      = NO
              # If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can
              # be used to specify the file name of the resulting .chm file. You
              # can add a path in front of the file if the result should not be
              # written to the html output directory.
              CHM_FILE               =
              # If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can
              # be used to specify the location (absolute path including file name) of
              # the HTML help compiler (hhc.exe). If non-empty doxygen will try to run
              # the HTML help compiler on the generated index.hhp.
              HHC_LOCATION           =
              # If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag
              # controls if a separate .chi index file is generated (YES) or that
              # it should be included in the master .chm file (NO).
              GENERATE_CHI           = NO
              # If the GENERATE_HTMLHELP tag is set to YES, the CHM_INDEX_ENCODING
              # is used to encode HtmlHelp index (hhk), content (hhc) and project file
              # content.
              CHM_INDEX_ENCODING     =
              # If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag
              # controls whether a binary table of contents is generated (YES) or a
              # normal table of contents (NO) in the .chm file.
              BINARY_TOC             = NO
              # The TOC_EXPAND flag can be set to YES to add extra items for group members
              # to the contents of the HTML help documentation and to the tree view.
              TOC_EXPAND             = NO
              # If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and
              # QHP_VIRTUAL_FOLDER are set, an additional index file will be generated
              # that can be used as input for Qt's qhelpgenerator to generate a
              # Qt Compressed Help (.qch) of the generated HTML documentation.
              GENERATE_QHP           = NO
              # If the QHG_LOCATION tag is specified, the QCH_FILE tag can
              # be used to specify the file name of the resulting .qch file.
              # The path specified is relative to the HTML output folder.
              QCH_FILE               =
              # The QHP_NAMESPACE tag specifies the namespace to use when generating
              # Qt Help Project output. For more information please see
              # http://doc.trolltech.com/qthelpproject.html#namespace
              QHP_NAMESPACE          = org.doxygen.Project
              # The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating
              # Qt Help Project output. For more information please see
              # http://doc.trolltech.com/qthelpproject.html#virtual-folders
              QHP_VIRTUAL_FOLDER     = doc
              # If QHP_CUST_FILTER_NAME is set, it specifies the name of a custom filter to
              # add. For more information please see
              # http://doc.trolltech.com/qthelpproject.html#custom-filters
              QHP_CUST_FILTER_NAME   =
              # The QHP_CUST_FILT_ATTRS tag specifies the list of the attributes of the
              # custom filter to add. For more information please see
              # <a href="http://doc.trolltech.com/qthelpproject.html#custom-filters">
              # Qt Help Project / Custom Filters</a>.
              QHP_CUST_FILTER_ATTRS  =
              # The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
              # project's
              # filter section matches.
              # <a href="http://doc.trolltech.com/qthelpproject.html#filter-attributes">
              # Qt Help Project / Filter Attributes</a>.
              QHP_SECT_FILTER_ATTRS  =
              # If the GENERATE_QHP tag is set to YES, the QHG_LOCATION tag can
              # be used to specify the location of Qt's qhelpgenerator.
              # If non-empty doxygen will try to run qhelpgenerator on the generated
              # .qhp file.
              QHG_LOCATION           =
              # If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files
              # will be generated, which together with the HTML files, form an Eclipse help
              # plugin. To install this plugin and make it available under the help contents
              # menu in Eclipse, the contents of the directory containing the HTML and XML
              # files needs to be copied into the plugins directory of eclipse. The name of
              # the directory within the plugins directory should be the same as
              # the ECLIPSE_DOC_ID value. After copying Eclipse needs to be restarted before
              # the help appears.
              GENERATE_ECLIPSEHELP   = NO
              # A unique identifier for the eclipse help plugin. When installing the plugin
              # the directory name containing the HTML and XML files should also have
              # this name.
              ECLIPSE_DOC_ID         = org.doxygen.Project
              # The DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs)
              # at top of each HTML page. The value NO (the default) enables the index and
              # the value YES disables it. Since the tabs have the same information as the
              # navigation tree you can set this option to NO if you already set
              # GENERATE_TREEVIEW to YES.
              DISABLE_INDEX          = NO
              # The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
              # structure should be generated to display hierarchical information.
              # If the tag value is set to YES, a side panel will be generated
              # containing a tree-like index structure (just like the one that
              # is generated for HTML Help). For this to work a browser that supports
              # JavaScript, DHTML, CSS and frames is required (i.e. any modern browser).
              # Windows users are probably better off using the HTML help feature.
              # Since the tree basically has the same information as the tab index you
              # could consider to set DISABLE_INDEX to NO when enabling this option.
              GENERATE_TREEVIEW      = NO
              # The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values
              # (range [0,1..20]) that doxygen will group on one line in the generated HTML
              # documentation. Note that a value of 0 will completely suppress the enum
              # values from appearing in the overview section.
              ENUM_VALUES_PER_LINE   = 4
              # If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be
              # used to set the initial width (in pixels) of the frame in which the tree
              # is shown.
              TREEVIEW_WIDTH         = 250
              # When the EXT_LINKS_IN_WINDOW option is set to YES doxygen will open
              # links to external symbols imported via tag files in a separate window.
              EXT_LINKS_IN_WINDOW    = NO
              # Use this tag to change the font size of Latex formulas included
              # as images in the HTML documentation. The default is 10. Note that
              # when you change the font size after a successful doxygen run you need
              # to manually remove any form_*.png images from the HTML output directory
              # to force them to be regenerated.
              FORMULA_FONTSIZE       = 10
              # Use the FORMULA_TRANPARENT tag to determine whether or not the images
              # generated for formulas are transparent PNGs. Transparent PNGs are
              # not supported properly for IE 6.0, but are supported on all modern browsers.
              # Note that when changing this option you need to delete any form_*.png files
              # in the HTML output before the changes have effect.
              FORMULA_TRANSPARENT    = YES
              # Enable the USE_MATHJAX option to render LaTeX formulas using MathJax
              # (see http://www.mathjax.org) which uses client side Javascript for the
              # rendering instead of using prerendered bitmaps. Use this if you do not
              # have LaTeX installed or if you want to formulas look prettier in the HTML
              # output. When enabled you may also need to install MathJax separately and
              # configure the path to it using the MATHJAX_RELPATH option.
              USE_MATHJAX            = NO
              # When MathJax is enabled you can set the default output format to be used for
              # thA MathJax output. Supported types are HTML-CSS, NativeMML (i.e. MathML) and
              # SVG. The default value is HTML-CSS, which is slower, but has the best
              # compatibility.
              MATHJAX_FORMAT         = HTML-CSS
              # When MathJax is enabled you need to specify the location relative to the
              # HTML output directory using the MATHJAX_RELPATH option. The destination
              # directory should contain the MathJax.js script. For instance, if the mathjax
              # directory is located at the same level as the HTML output directory, then
              # MATHJAX_RELPATH should be ../mathjax. The default value points to
              # the MathJax Content Delivery Network so you can quickly see the result without
              # installing MathJax.  However, it is strongly recommended to install a local
              # copy of MathJax from http://www.mathjax.org before deployment.
              MATHJAX_RELPATH        = http://cdn.mathjax.org/mathjax/latest
              # The MATHJAX_EXTENSIONS tag can be used to specify one or MathJax extension
              # names that should be enabled during MathJax rendering.
              MATHJAX_EXTENSIONS     =
              # When the SEARCHENGINE tag is enabled doxygen will generate a search box
              # for the HTML output. The underlying search engine uses javascript
              # and DHTML and should work on any modern browser. Note that when using
              # HTML help (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets
              # (GENERATE_DOCSET) there is already a search function so this one should
              # typically be disabled. For large projects the javascript based search engine
              # can be slow, then enabling SERVER_BASED_SEARCH may provide a better solution.
              SEARCHENGINE           = YES
              # When the SERVER_BASED_SEARCH tag is enabled the search engine will be
              # implemented using a web server instead of a web client using Javascript.
              # There are two flavours of web server based search depending on the
              # EXTERNAL_SEARCH setting. When disabled, doxygen will generate a PHP script for
              # searching and an index file used by the script. When EXTERNAL_SEARCH is
              # enabled the indexing and searching needs to be provided by external tools.
              # See the manual for details.
              SERVER_BASED_SEARCH    = NO
              # When EXTERNAL_SEARCH is enabled doxygen will no longer generate the PHP
              # script for searching. Instead the search results are written to an XML file
              # which needs to be processed by an external indexer. Doxygen will invoke an
              # external search engine pointed to by the SEARCHENGINE_URL option to obtain
              # the search results. Doxygen ships with an example indexer (doxyindexer) and
              # search engine (doxysearch.cgi) which are based on the open source search engine
              # library Xapian. See the manual for configuration details.
              EXTERNAL_SEARCH        = NO
              # The SEARCHENGINE_URL should point to a search engine hosted by a web server
              # which will returned the search results when EXTERNAL_SEARCH is enabled.
              # Doxygen ships with an example search engine (doxysearch) which is based on
              # the open source search engine library Xapian. See the manual for configuration
              # details.
              SEARCHENGINE_URL       =
              # When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the unindexed
              # search data is written to a file for indexing by an external tool. With the
              # SEARCHDATA_FILE tag the name of this file can be specified.
              SEARCHDATA_FILE        = searchdata.xml
              # When SERVER_BASED_SEARCH AND EXTERNAL_SEARCH are both enabled the
              # EXTERNAL_SEARCH_ID tag can be used as an identifier for the project. This is
              # useful in combination with EXTRA_SEARCH_MAPPINGS to search through multiple
              # projects and redirect the results back to the right project.
              EXTERNAL_SEARCH_ID     =
              # The EXTRA_SEARCH_MAPPINGS tag can be used to enable searching through doxygen
              # projects other than the one defined by this configuration file, but that are
              # all added to the same external search index. Each project needs to have a
              # unique id set via EXTERNAL_SEARCH_ID. The search mapping then maps the id
              # of to a relative location where the documentation can be found.
              # The format is: EXTRA_SEARCH_MAPPINGS = id1=loc1 id2=loc2 ...
              EXTRA_SEARCH_MAPPINGS  =
              #---------------------------------------------------------------------------
              # configuration options related to the LaTeX output
              #---------------------------------------------------------------------------
              # If the GENERATE_LATEX tag is set to YES (the default) Doxygen will
              # generate Latex output.
              GENERATE_LATEX         = YES
              # The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put.
              # If a relative path is entered the value of OUTPUT_DIRECTORY will be
              # put in front of it. If left blank `latex' will be used as the default path.
              LATEX_OUTPUT           = latex
              # The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
              # invoked. If left blank `latex' will be used as the default command name.
              # Note that when enabling USE_PDFLATEX this option is only used for
              # generating bitmaps for formulas in the HTML output, but not in the
              # Makefile that is written to the output directory.
              LATEX_CMD_NAME         = latex
              # The MAKEINDEX_CMD_NAME tag can be used to specify the command name to
              # generate index for LaTeX. If left blank `makeindex' will be used as the
              # default command name.
              MAKEINDEX_CMD_NAME     = makeindex
              # If the COMPACT_LATEX tag is set to YES Doxygen generates more compact
              # LaTeX documents. This may be useful for small projects and may help to
              # save some trees in general.
              COMPACT_LATEX          = NO
              # The PAPER_TYPE tag can be used to set the paper type that is used
              # by the printer. Possible values are: a4, letter, legal and
              # executive. If left blank a4wide will be used.
              PAPER_TYPE             = a4
              # The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX
              # packages that should be included in the LaTeX output.
              EXTRA_PACKAGES         =
              # The LATEX_HEADER tag can be used to specify a personal LaTeX header for
              # the generated latex document. The header should contain everything until
              # the first chapter. If it is left blank doxygen will generate a
              # standard header. Notice: only use this tag if you know what you are doing!
              LATEX_HEADER           =
              # The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for
              # the generated latex document. The footer should contain everything after
              # the last chapter. If it is left blank doxygen will generate a
              # standard footer. Notice: only use this tag if you know what you are doing!
              LATEX_FOOTER           =
              # If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated
              # is prepared for conversion to pdf (using ps2pdf). The pdf file will
              # contain links (just like the HTML output) instead of page references
              # This makes the output suitable for online browsing using a pdf viewer.
              PDF_HYPERLINKS         = YES
              # If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of
              # plain latex in the generated Makefile. Set this option to YES to get a
              # higher quality PDF documentation.
              USE_PDFLATEX           = YES
              # If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode.
              # command to the generated LaTeX files. This will instruct LaTeX to keep
              # running if errors occur, instead of asking the user for help.
              # This option is also used when generating formulas in HTML.
              LATEX_BATCHMODE        = NO
              # If LATEX_HIDE_INDICES is set to YES then doxygen will not
              # include the index chapters (such as File Index, Compound Index, etc.)
              # in the output.
              LATEX_HIDE_INDICES     = NO
              # If LATEX_SOURCE_CODE is set to YES then doxygen will include
              # source code with syntax highlighting in the LaTeX output.
              # Note that which sources are shown also depends on other settings
              # such as SOURCE_BROWSER.
              LATEX_SOURCE_CODE      = NO
              # The LATEX_BIB_STYLE tag can be used to specify the style to use for the
              # bibliography, e.g. plainnat, or ieeetr. The default style is "plain". See
              # http://en.wikipedia.org/wiki/BibTeX for more info.
              LATEX_BIB_STYLE        = plain
              #---------------------------------------------------------------------------
              # configuration options related to the RTF output
              #---------------------------------------------------------------------------
              # If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output
              # The RTF output is optimized for Word 97 and may not look very pretty with
              # other RTF readers or editors.
              GENERATE_RTF           = NO
              # The RTF_OUTPUT tag is used to specify where the RTF docs will be put.
              # If a relative path is entered the value of OUTPUT_DIRECTORY will be
              # put in front of it. If left blank `rtf' will be used as the default path.
              RTF_OUTPUT             = rtf
              # If the COMPACT_RTF tag is set to YES Doxygen generates more compact
              # RTF documents. This may be useful for small projects and may help to
              # save some trees in general.
              COMPACT_RTF            = NO
              # If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated
              # will contain hyperlink fields. The RTF file will
              # contain links (just like the HTML output) instead of page references.
              # This makes the output suitable for online browsing using WORD or other
              # programs which support those fields.
              # Note: wordpad (write) and others do not support links.
              RTF_HYPERLINKS         = NO
              # Load style sheet definitions from file. Syntax is similar to doxygen's
              # config file, i.e. a series of assignments. You only have to provide
              # replacements, missing definitions are set to their default value.
              RTF_STYLESHEET_FILE    =
              # Set optional variables used in the generation of an rtf document.
              # Syntax is similar to doxygen's config file.
              RTF_EXTENSIONS_FILE    =
              #---------------------------------------------------------------------------
              # configuration options related to the man page output
              #---------------------------------------------------------------------------
              # If the GENERATE_MAN tag is set to YES (the default) Doxygen will
              # generate man pages
              GENERATE_MAN           = NO
              # The MAN_OUTPUT tag is used to specify where the man pages will be put.
              # If a relative path is entered the value of OUTPUT_DIRECTORY will be
              # put in front of it. If left blank `man' will be used as the default path.
              MAN_OUTPUT             = man
              # The MAN_EXTENSION tag determines the extension that is added to
              # the generated man pages (default is the subroutine's section .3)
              MAN_EXTENSION          = .3
              # If the MAN_LINKS tag is set to YES and Doxygen generates man output,
              # then it will generate one additional man file for each entity
              # documented in the real man page(s). These additional files
              # only source the real man page, but without them the man command
              # would be unable to find the correct page. The default is NO.
              MAN_LINKS              = NO
              #---------------------------------------------------------------------------
              # configuration options related to the XML output
              #---------------------------------------------------------------------------
              # If the GENERATE_XML tag is set to YES Doxygen will
              # generate an XML file that captures the structure of
              # the code including all documentation.
              GENERATE_XML           = NO
              # The XML_OUTPUT tag is used to specify where the XML pages will be put.
              # If a relative path is entered the value of OUTPUT_DIRECTORY will be
              # put in front of it. If left blank `xml' will be used as the default path.
              XML_OUTPUT             = xml
              # The XML_SCHEMA tag can be used to specify an XML schema,
              # which can be used by a validating XML parser to check the
              # syntax of the XML files.
              XML_SCHEMA             =
              # The XML_DTD tag can be used to specify an XML DTD,
              # which can be used by a validating XML parser to check the
              # syntax of the XML files.
              XML_DTD                =
              # If the XML_PROGRAMLISTING tag is set to YES Doxygen will
              # dump the program listings (including syntax highlighting
              # and cross-referencing information) to the XML output. Note that
              # enabling this will significantly increase the size of the XML output.
              XML_PROGRAMLISTING     = YES
              #---------------------------------------------------------------------------
              # configuration options for the AutoGen Definitions output
              #---------------------------------------------------------------------------
              # If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will
              # generate an AutoGen Definitions (see autogen.sf.net) file
              # that captures the structure of the code including all
              # documentation. Note that this feature is still experimental
              # and incomplete at the moment.
              GENERATE_AUTOGEN_DEF   = NO
              #---------------------------------------------------------------------------
              # configuration options related to the Perl module output
              #---------------------------------------------------------------------------
              # If the GENERATE_PERLMOD tag is set to YES Doxygen will
              # generate a Perl module file that captures the structure of
              # the code including all documentation. Note that this
              # feature is still experimental and incomplete at the
              # moment.
              GENERATE_PERLMOD       = NO
              # If the PERLMOD_LATEX tag is set to YES Doxygen will generate
              # the necessary Makefile rules, Perl scripts and LaTeX code to be able
              # to generate PDF and DVI output from the Perl module output.
              PERLMOD_LATEX          = NO
              # If the PERLMOD_PRETTY tag is set to YES the Perl module output will be
              # nicely formatted so it can be parsed by a human reader.  This is useful
              # if you want to understand what is going on.  On the other hand, if this
              # tag is set to NO the size of the Perl module output will be much smaller
              # and Perl will parse it just the same.
              PERLMOD_PRETTY         = YES
              # The names of the make variables in the generated doxyrules.make file
              # are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX.
              # This is useful so different doxyrules.make files included by the same
              # Makefile don't overwrite each other's variables.
              PERLMOD_MAKEVAR_PREFIX =
              #---------------------------------------------------------------------------
              # Configuration options related to the preprocessor
              #---------------------------------------------------------------------------
              # If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will
              # evaluate all C-preprocessor directives found in the sources and include
              # files.
              ENABLE_PREPROCESSING   = YES
              # If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro
              # names in the source code. If set to NO (the default) only conditional
              # compilation will be performed. Macro expansion can be done in a controlled
              # way by setting EXPAND_ONLY_PREDEF to YES.
              MACRO_EXPANSION        = NO
              # If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES
              # then the macro expansion is limited to the macros specified with the
              # PREDEFINED and EXPAND_AS_DEFINED tags.
              EXPAND_ONLY_PREDEF     = NO
              # If the SEARCH_INCLUDES tag is set to YES (the default) the includes files
              # pointed to by INCLUDE_PATH will be searched when a #include is found.
              SEARCH_INCLUDES        = YES
              # The INCLUDE_PATH tag can be used to specify one or more directories that
              # contain include files that are not input files but should be processed by
              # the preprocessor.
              INCLUDE_PATH           =
              # You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
              # patterns (like *.h and *.hpp) to filter out the header-files in the
              # directories. If left blank, the patterns specified with FILE_PATTERNS will
              # be used.
              INCLUDE_FILE_PATTERNS  =
              # The PREDEFINED tag can be used to specify one or more macro names that
              # are defined before the preprocessor is started (similar to the -D option of
              # gcc). The argument of the tag is a list of macros of the form: name
              # or name=definition (no spaces). If the definition and the = are
              # omitted =1 is assumed. To prevent a macro definition from being
              # undefined via #undef or recursively expanded use the := operator
              # instead of the = operator.
-             PREDEFINED             =
+             PREDEFINED             = DOXYGEN_SHOULD_SKIP_THIS
              # If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then
              # this tag can be used to specify a list of macro names that should be expanded.
              # The macro definition that is found in the sources will be used.
              # Use the PREDEFINED tag if you want to use a different macro definition that
              # overrules the definition found in the source code.
              EXPAND_AS_DEFINED      =
              # If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then
              # doxygen's preprocessor will remove all references to function-like macros
              # that are alone on a line, have an all uppercase name, and do not end with a
              # semicolon, because these will confuse the parser if not removed.
              SKIP_FUNCTION_MACROS   = YES
              #---------------------------------------------------------------------------
              # Configuration::additions related to external references
              #---------------------------------------------------------------------------
              # The TAGFILES option can be used to specify one or more tagfiles. For each
              # tag file the location of the external documentation should be added. The
              # format of a tag file without this location is as follows:
              #   TAGFILES = file1 file2 ...
              # Adding location for the tag files is done as follows:
              #   TAGFILES = file1=loc1 "file2 = loc2" ...
              # where "loc1" and "loc2" can be relative or absolute paths
              # or URLs. Note that each tag file must have a unique name (where the name does
              # NOT include the path). If a tag file is not located in the directory in which
              # doxygen is run, you must also specify the path to the tagfile here.
              TAGFILES               =
              # When a file name is specified after GENERATE_TAGFILE, doxygen will create
              # a tag file that is based on the input files it reads.
              GENERATE_TAGFILE       =
              # If the ALLEXTERNALS tag is set to YES all external classes will be listed
              # in the class index. If set to NO only the inherited external classes
              # will be listed.
              ALLEXTERNALS           = NO
              # If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed
              # in the modules index. If set to NO, only the current project's groups will
              # be listed.
              EXTERNAL_GROUPS        = YES
              # The PERL_PATH should be the absolute path and name of the perl script
              # interpreter (i.e. the result of `which perl').
              PERL_PATH              = /usr/bin/perl
              #---------------------------------------------------------------------------
              # Configuration options related to the dot tool
              #---------------------------------------------------------------------------
              # If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will
              # generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base
              # or super classes. Setting the tag to NO turns the diagrams off. Note that
              # this option also works with HAVE_DOT disabled, but it is recommended to
              # install and use dot, since it yields more powerful graphs.
-             CLASS_DIAGRAMS         = YES
+             CLASS_DIAGRAMS         = NO
              # You can define message sequence charts within doxygen comments using the \msc
              # command. Doxygen will then run the mscgen tool (see
              # http://www.mcternan.me.uk/mscgen/) to produce the chart and insert it in the
              # documentation. The MSCGEN_PATH tag allows you to specify the directory where
              # the mscgen tool resides. If left empty the tool is assumed to be found in the
              # default search path.
              MSCGEN_PATH            =
              # If set to YES, the inheritance and collaboration graphs will hide
              # inheritance and usage relations if the target is undocumented
              # or is not a class.
              HIDE_UNDOC_RELATIONS   = YES
              # If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
              # available from the path. This tool is part of Graphviz, a graph visualization
              # toolkit from AT&T and Lucent Bell Labs. The other options in this section
              # have no effect if this option is set to NO (the default)
-             HAVE_DOT               = NO
+             HAVE_DOT               = YES
              # The DOT_NUM_THREADS specifies the number of dot invocations doxygen is
              # allowed to run in parallel. When set to 0 (the default) doxygen will
              # base this on the number of processors available in the system. You can set it
              # explicitly to a value larger than 0 to get control over the balance
              # between CPU load and processing speed.
-             DOT_NUM_THREADS        = 0
+             DOT_NUM_THREADS        = 4
              # By default doxygen will use the Helvetica font for all dot files that
              # doxygen generates. When you want a differently looking font you can specify
              # the font name using DOT_FONTNAME. You need to make sure dot is able to find
              # the font, which can be done by putting it in a standard location or by setting
              # the DOTFONTPATH environment variable or by setting DOT_FONTPATH to the
              # directory containing the font.
              DOT_FONTNAME           = Helvetica
              # The DOT_FONTSIZE tag can be used to set the size of the font of dot graphs.
              # The default size is 10pt.
              DOT_FONTSIZE           = 10
              # By default doxygen will tell dot to use the Helvetica font.
              # If you specify a different font using DOT_FONTNAME you can use DOT_FONTPATH to
              # set the path where dot can find it.
              DOT_FONTPATH           =
              # If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen
              # will generate a graph for each documented class showing the direct and
              # indirect inheritance relations. Setting this tag to YES will force the
              # CLASS_DIAGRAMS tag to NO.
              CLASS_GRAPH            = YES
              # If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen
              # will generate a graph for each documented class showing the direct and
              # indirect implementation dependencies (inheritance, containment, and
              # class references variables) of the class with other documented classes.
              COLLABORATION_GRAPH    = YES
              # If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen
              # will generate a graph for groups, showing the direct groups dependencies
              GROUP_GRAPHS           = YES
              # If the UML_LOOK tag is set to YES doxygen will generate inheritance and
              # collaboration diagrams in a style similar to the OMG's Unified Modeling
              # Language.
              UML_LOOK               = NO
              # If the UML_LOOK tag is enabled, the fields and methods are shown inside
              # the class node. If there are many fields or methods and many nodes the
              # graph may become too big to be useful. The UML_LIMIT_NUM_FIELDS
              # threshold limits the number of items for each type to make the size more
              # managable. Set this to 0 for no limit. Note that the threshold may be
              # exceeded by 50% before the limit is enforced.
              UML_LIMIT_NUM_FIELDS   = 10
              # If set to YES, the inheritance and collaboration graphs will show the
              # relations between templates and their instances.
              TEMPLATE_RELATIONS     = NO
              # If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT
              # tags are set to YES then doxygen will generate a graph for each documented
              # file showing the direct and indirect include dependencies of the file with
              # other documented files.
              INCLUDE_GRAPH          = YES
              # If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and
              # HAVE_DOT tags are set to YES then doxygen will generate a graph for each
              # documented header file showing the documented files that directly or
              # indirectly include this file.
              INCLUDED_BY_GRAPH      = YES
              # If the CALL_GRAPH and HAVE_DOT options are set to YES then
              # doxygen will generate a call dependency graph for every global function
              # or class method. Note that enabling this option will significantly increase
              # the time of a run. So in most cases it will be better to enable call graphs
              # for selected functions only using the \callgraph command.
-             CALL_GRAPH             = NO
+             CALL_GRAPH             = YES
              # If the CALLER_GRAPH and HAVE_DOT tags are set to YES then
              # doxygen will generate a caller dependency graph for every global function
              # or class method. Note that enabling this option will significantly increase
              # the time of a run. So in most cases it will be better to enable caller
              # graphs for selected functions only using the \callergraph command.
-             CALLER_GRAPH           = NO
+             CALLER_GRAPH           = YES
              # If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen
              # will generate a graphical hierarchy of all classes instead of a textual one.
              GRAPHICAL_HIERARCHY    = YES
              # If the DIRECTORY_GRAPH and HAVE_DOT tags are set to YES
              # then doxygen will show the dependencies a directory has on other directories
              # in a graphical way. The dependency relations are determined by the #include
              # relations between the files in the directories.
              DIRECTORY_GRAPH        = YES
              # The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
              # generated by dot. Possible values are svg, png, jpg, or gif.
              # If left blank png will be used. If you choose svg you need to set
              # HTML_FILE_EXTENSION to xhtml in order to make the SVG files
              # visible in IE 9+ (other browsers do not have this requirement).
              DOT_IMAGE_FORMAT       = png
              # If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to
              # enable generation of interactive SVG images that allow zooming and panning.
              # Note that this requires a modern browser other than Internet Explorer.
              # Tested and working are Firefox, Chrome, Safari, and Opera. For IE 9+ you
              # need to set HTML_FILE_EXTENSION to xhtml in order to make the SVG files
              # visible. Older versions of IE do not have SVG support.
-             INTERACTIVE_SVG        = NO
+             INTERACTIVE_SVG        = YES
              # The tag DOT_PATH can be used to specify the path where the dot tool can be
              # found. If left blank, it is assumed the dot tool can be found in the path.
              DOT_PATH               =
              # The DOTFILE_DIRS tag can be used to specify one or more directories that
              # contain dot files that are included in the documentation (see the
              # \dotfile command).
              DOTFILE_DIRS           =
              # The MSCFILE_DIRS tag can be used to specify one or more directories that
              # contain msc files that are included in the documentation (see the
              # \mscfile command).
              MSCFILE_DIRS           =
              # The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of
              # nodes that will be shown in the graph. If the number of nodes in a graph
              # becomes larger than this value, doxygen will truncate the graph, which is
              # visualized by representing a node as a red box. Note that doxygen if the
              # number of direct children of the root node in a graph is already larger than
              # DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note
              # that the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
              DOT_GRAPH_MAX_NODES    = 50
              # The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the
              # graphs generated by dot. A depth value of 3 means that only nodes reachable
              # from the root by following a path via at most 3 edges will be shown. Nodes
              # that lay further from the root node will be omitted. Note that setting this
              # option to 1 or 2 may greatly reduce the computation time needed for large
              # code bases. Also note that the size of a graph can be further restricted by
              # DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
              MAX_DOT_GRAPH_DEPTH    = 0
              # Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
              # background. This is disabled by default, because dot on Windows does not
              # seem to support this out of the box. Warning: Depending on the platform used,
              # enabling this option may lead to badly anti-aliased labels on the edges of
              # a graph (i.e. they become hard to read).
              DOT_TRANSPARENT        = NO
              # Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output
              # files in one run (i.e. multiple -o and -T options on the command line). This
              # makes dot run faster, but since only newer versions of dot (>1.8.10)
              # support this, this feature is disabled by default.
              DOT_MULTI_TARGETS      = NO
              # If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will
              # generate a legend page explaining the meaning of the various boxes and
              # arrows in the dot generated graphs.
              GENERATE_LEGEND        = YES
              # If the DOT_CLEANUP tag is set to YES (the default) Doxygen will
              # remove the intermediate dot files that are used to generate
              # the various graphs.
              DOT_CLEANUP            = YES

include/GRAPHIC/CONTROLERS/SDLCD.h 0 -1

              /*------------------------------------------------------------------------------
              --  This file is a part of the libuc, microcontroler library
              --  Copyright (C) 2013, Alexis Jeandet
              --
              --  This program is free software; you can redistribute it and/or modify
              --  it under the terms of the GNU General Public License as published by
              --  the Free Software Foundation; either version 3 of the License, or
              --  (at your option) any later version.
              --
              --  This program is distributed in the hope that it will be useful,
              --  but WITHOUT ANY WARRANTY; without even the implied warranty of
              --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              --  GNU General Public License for more details.
              --
              --  You should have received a copy of the GNU General Public License
              --  along with this program; if not, write to the Free Software
              --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
              -------------------------------------------------------------------------------
              --                 Author : Alexis Jeandet
              --                   Mail : alexis.jeandet@member.fsf.org
              -------------------------------------------------------------------------------*/
              #include <SDL.h>
              #include <ili9328.h>
-             #include <stdint.h>
              #define LCDILI9328 9328
              extern SDL_Surface *screen;
              extern SDL_Overlay     *bmp;
              extern void SDLCD_mkscreen(int resx,int resy,int bbp,int lcdtype);
              extern int SDLCD_init();
              extern void SDLCD_writereg(uint32_t reg,uint32_t data);
              extern uint32_t SDLCD_readreg(uint32_t reg);
              extern void SDLCD_writeGRAM(void* buffer,uint32_t count);
              extern void SDLCD_writeGRAM_16bpp(void* buffer,uint32_t count);
              extern void SDLCD_readGRAM(void* buffer,uint32_t count);
              extern void SDLCD_readGRAM_16bpp(void* buffer,uint32_t count);

include/GRAPHIC/CONTROLERS/genericLCD_Controler.h 0 -1

              /*------------------------------------------------------------------------------
              --  This file is a part of the libuc, microcontroler library
              --  Copyright (C) 2012, Alexis Jeandet
              --
              --  This program is free software; you can redistribute it and/or modify
              --  it under the terms of the GNU General Public License as published by
              --  the Free Software Foundation; either version 3 of the License, or
              --  (at your option) any later version.
              --
              --  This program is distributed in the hope that it will be useful,
              --  but WITHOUT ANY WARRANTY; without even the implied warranty of
              --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              --  GNU General Public License for more details.
              --
              --  You should have received a copy of the GNU General Public License
              --  along with this program; if not, write to the Free Software
              --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
              -------------------------------------------------------------------------------
              --                 Author : Alexis Jeandet
              --                   Mail : alexis.jeandet@gmail.com
              -------------------------------------------------------------------------------*/
              #ifndef GENERICLCD_CONTROLER_H
              #define GENERICLCD_CONTROLER_H
              #include <uhandle.h>
-             #include <stdint.h>
              #include <fonts.h>
              typedef struct LCD_IF_t
              {
                  int (*init)();
                  void (*writereg)(uint32_t reg,uint32_t data);
                  uint32_t (*readreg)(uint32_t reg);
                  void (*writeGRAM)(void* buffer,uint32_t count);
                  void (*readGRAM)(void* buffer,uint32_t count);
              }LCD_IF_t;
              typedef struct LCD_t
              {
                  LCD_IF_t* interface;
                  int (*init)(struct LCD_t* LCD);
                  void (*paint)(struct LCD_t* LCD,void* buffer,uint16_t Xpos,uint16_t Ypos,uint16_t Width,uint16_t Height);
                  void (*paintText)(struct LCD_t* LCD,char* buffer,uint16_t Xpos,uint16_t Ypos,sFONT *font,uint32_t color);
                  void (*paintFilRect)(struct LCD_t* LCD,uint16_t Xpos,uint16_t Ypos,uint16_t w,uint16_t h,uint32_t contColor,uint16_t contSz,uint32_t fillColor);
                  void (*getPix)(struct LCD_t* LCD,uint16_t* buffer,uint16_t Xpos,uint16_t Ypos,uint16_t w,uint16_t h);
                  void (*refreshenable)(struct LCD_t* LCD,int enable);
                  uint16_t width;
                  uint16_t height;
              }LCD_t;
              #endif              /*GENERICLCD_CONTROLER_H*/

include/GRAPHIC/CONTROLERS/ili9328.h 0 -3

              /*------------------------------------------------------------------------------
              --  This file is a part of the libuc, microcontroler library
              --  Copyright (C) 2012, Alexis Jeandet
              --
              --  This program is free software; you can redistribute it and/or modify
              --  it under the terms of the GNU General Public License as published by
              --  the Free Software Foundation; either version 3 of the License, or
              --  (at your option) any later version.
              --
              --  This program is distributed in the hope that it will be useful,
              --  but WITHOUT ANY WARRANTY; without even the implied warranty of
              --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              --  GNU General Public License for more details.
              --
              --  You should have received a copy of the GNU General Public License
              --  along with this program; if not, write to the Free Software
              --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
              -------------------------------------------------------------------------------
              --                 Author : Alexis Jeandet
              --                   Mail : alexis.jeandet@gmail.com
              -------------------------------------------------------------------------------*/
              #ifndef ILI9328_H
              #define ILI9328_H
-             #include <uhandle.h>
              #include <genericLCD_Controler.h>
-             #include <stdint.h>
-             #include <fonts.h>
              extern int  ili9328init(struct LCD_t* LCD);
              extern void ili9328setFrame(LCD_t* LCD,uint16_t X,uint16_t Y,uint16_t W,uint16_t H);
              extern void ili9328setGRAMaddress(LCD_t* LCD,uint16_t Haddress,uint16_t Vaddress);
              extern void ili9328paint(LCD_t* LCD,void* buffer,uint16_t Xpos,uint16_t Ypos,uint16_t Width,uint16_t Height);
              extern void ili9328paintText(LCD_t* LCD,char* buffer,uint16_t Xpos,uint16_t Ypos,sFONT *font,uint32_t color);
              extern void ili9328paintFilRect(LCD_t* LCD,uint16_t Xpos,uint16_t Ypos,uint16_t w,uint16_t h,uint32_t contColor,uint16_t contSz,uint32_t fillColor);
              extern void ili9328paintFilCirc(LCD_t* LCD,uint16_t Xpos,uint16_t Ypos,uint16_t r,uint32_t contColor,uint16_t contSz,uint32_t fillColor);
              extern void ili9328paintFilCircMidPoint(LCD_t* LCD,uint16_t Xpos,uint16_t Ypos,uint16_t r,uint32_t contColor,uint16_t contSz,uint32_t fillColor);
              extern void ili9328getPix(struct LCD_t* LCD,uint16_t* buffer,uint16_t Xpos,uint16_t Ypos,uint16_t w,uint16_t h);
              extern void ili9328refreshenable(struct LCD_t* LCD,int enable);
              extern void ili9328paintChar(LCD_t* LCD,char buffer,uint16_t Xpos,uint16_t Ypos,sFONT* font,uint32_t color);
              #define	ILI9328_REGISTER_DRIVERCODEREAD                 ((uint32_t) 0x0000 )
              #define	ILI9328_REGISTER_DRIVEROUTPUTCONTROL1           ((uint32_t) 0x0001 )
              #define	ILI9328_REGISTER_LCDDRIVINGCONTROL              ((uint32_t) 0x0002 )
              #define	ILI9328_REGISTER_ENTRYMODE                      ((uint32_t) 0x0003 )
              #define	ILI9328_REGISTER_RESIZECONTROL                  ((uint32_t) 0x0004 )
              #define	ILI9328_REGISTER_DISPLAYCONTROL1                ((uint32_t) 0x0007 )
              #define	ILI9328_REGISTER_DISPLAYCONTROL2                ((uint32_t) 0x0008 )
              #define	ILI9328_REGISTER_DISPLAYCONTROL3                ((uint32_t) 0x0009 )
              #define	ILI9328_REGISTER_DISPLAYCONTROL4                ((uint32_t) 0x000A )
              #define	ILI9328_REGISTER_RGBDISPLAYINTERFACECONTROL1    ((uint32_t) 0x000C )
              #define	ILI9328_REGISTER_FRAMEMAKERPOSITION             ((uint32_t) 0x000D )
              #define	ILI9328_REGISTER_RGBDISPLAYINTERFACECONTROL2    ((uint32_t) 0x000F )
              #define	ILI9328_REGISTER_POWERCONTROL1                  ((uint32_t) 0x0010 )
              #define	ILI9328_REGISTER_POWERCONTROL2                  ((uint32_t) 0x0011 )
              #define	ILI9328_REGISTER_POWERCONTROL3                  ((uint32_t) 0x0012 )
              #define	ILI9328_REGISTER_POWERCONTROL4                  ((uint32_t) 0x0013 )
              #define	ILI9328_REGISTER_HORIZONTALGRAMADDRESSSET       ((uint32_t) 0x0020 )
              #define	ILI9328_REGISTER_VERTICALGRAMADDRESSSET         ((uint32_t) 0x0021 )
              #define	ILI9328_REGISTER_WRITEDATATOGRAM                ((uint32_t) 0x0022 )
              #define	ILI9328_REGISTER_POWERCONTROL7                  ((uint32_t) 0x0029 )
              #define	ILI9328_REGISTER_FRAMERATEANDCOLORCONTROL       ((uint32_t) 0x002B )
              #define	ILI9328_REGISTER_GAMMACONTROL1                  ((uint32_t) 0x0030 )
              #define	ILI9328_REGISTER_GAMMACONTROL2                  ((uint32_t) 0x0031 )
              #define	ILI9328_REGISTER_GAMMACONTROL3                  ((uint32_t) 0x0032 )
              #define	ILI9328_REGISTER_GAMMACONTROL4                  ((uint32_t) 0x0035 )
              #define	ILI9328_REGISTER_GAMMACONTROL5                  ((uint32_t) 0x0036 )
              #define	ILI9328_REGISTER_GAMMACONTROL6                  ((uint32_t) 0x0037 )
              #define	ILI9328_REGISTER_GAMMACONTROL7                  ((uint32_t) 0x0038 )
              #define	ILI9328_REGISTER_GAMMACONTROL8                  ((uint32_t) 0x0039 )
              #define	ILI9328_REGISTER_GAMMACONTROL9                  ((uint32_t) 0x003C )
              #define	ILI9328_REGISTER_GAMMACONTROL10                 ((uint32_t) 0x003D )
              #define	ILI9328_REGISTER_HORIZONTALADDRESSSTARTPOSITION	((uint32_t)	0x0050 )
              #define	ILI9328_REGISTER_HORIZONTALADDRESSENDPOSITION	((uint32_t) 0x0051 )
              #define	ILI9328_REGISTER_VERTICALADDRESSSTARTPOSITION	((uint32_t) 0x0052 )
              #define	ILI9328_REGISTER_VERTICALADDRESSENDPOSITION     ((uint32_t) 0x0053 )
              #define	ILI9328_REGISTER_DRIVEROUTPUTCONTROL2           ((uint32_t) 0x0060 )
              #define	ILI9328_REGISTER_BASEIMAGEDISPLAYCONTROL        ((uint32_t) 0x0061 )
              #define	ILI9328_REGISTER_VERTICALSCROLLCONTROL          ((uint32_t) 0x006A )
              #define	ILI9328_REGISTER_PARTIALIMAGE1DISPLAYPOSITION   ((uint32_t) 0x0080 )
              #define	ILI9328_REGISTER_PARTIALIMAGE1AREASTARTLINE     ((uint32_t) 0x0081 )
              #define	ILI9328_REGISTER_PARTIALIMAGE1AREAENDLINE       ((uint32_t) 0x0082 )
              #define	ILI9328_REGISTER_PARTIALIMAGE2DISPLAYPOSITION   ((uint32_t) 0x0083 )
              #define	ILI9328_REGISTER_PARTIALIMAGE2AREASTARTLINE     ((uint32_t) 0x0084 )
              #define	ILI9328_REGISTER_PARTIALIMAGE2AREAENDLINE       ((uint32_t) 0x0085 )
              #define	ILI9328_REGISTER_PANELINTERFACECONTROL1         ((uint32_t) 0x0090 )
              #define	ILI9328_REGISTER_PANELINTERFACECONTROL2         ((uint32_t) 0x0092 )
              #define	ILI9328_REGISTER_PANELINTERFACECONTROL4         ((uint32_t) 0x0095 )
              #define	ILI9328_REGISTER_OTPVCMPROGRAMMINGCONTROL       ((uint32_t) 0x00A1 )
              #define	ILI9328_REGISTER_OTPVCMSTATUSANDENABLE          ((uint32_t) 0x00A2 )
              #define	ILI9328_REGISTER_OTPPROGRAMMINGIDKEY            ((uint32_t) 0x00A5 )
              #ifdef _PRVATE_ILI9328_
              void ili9328cpFrame(LCD_t* LCD,void* buffer,int x,int y,int w, int h);
              #endif
              #endif

include/GRAPHIC/CONTROLERS/ssd2119.h 0 -3

              /*------------------------------------------------------------------------------
              --  This file is a part of the libuc, microcontroler library
              --  Copyright (C) 2013, Alexis Jeandet
              --
              --  This program is free software; you can redistribute it and/or modify
              --  it under the terms of the GNU General Public License as published by
              --  the Free Software Foundation; either version 3 of the License, or
              --  (at your option) any later version.
              --
              --  This program is distributed in the hope that it will be useful,
              --  but WITHOUT ANY WARRANTY; without even the implied warranty of
              --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              --  GNU General Public License for more details.
              --
              --  You should have received a copy of the GNU General Public License
              --  along with this program; if not, write to the Free Software
              --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
              -------------------------------------------------------------------------------
              --                 Author : Alexis Jeandet
              --                   Mail : alexis.jeandet@gmail.com
              -------------------------------------------------------------------------------*/
              #ifndef SSD2119_H
              #define SSD2119_H
-             #include <uhandle.h>
              #include <genericLCD_Controler.h>
-             #include <stdint.h>
-             #include <fonts.h>
              extern int ssd2119init(struct LCD_t* LCD);
              extern void ssd2119setFrame(LCD_t* LCD,uint16_t X,uint16_t Y,uint16_t W,uint16_t H);
              extern void ssd2119setGRAMaddress(LCD_t* LCD,uint16_t Haddress,uint16_t Vaddress);
              extern void ssd2119paint(LCD_t* LCD,void* buffer,uint16_t Xpos,uint16_t Ypos,uint16_t Width,uint16_t Height);
              extern void ssd2119paintText(LCD_t* LCD,char* buffer,uint16_t Xpos,uint16_t Ypos,sFONT *font,uint32_t color);
              extern void ssd2119paintFilRect(LCD_t* LCD,uint16_t Xpos,uint16_t Ypos,uint16_t w,uint16_t h,uint32_t contColor,uint16_t contSz,uint32_t fillColor);
              extern void ssd2119paintFilCirc(LCD_t* LCD,uint16_t Xpos,uint16_t Ypos,uint16_t r,uint32_t contColor,uint16_t contSz,uint32_t fillColor);
              extern void ssd2119paintFilCircMidPoint(LCD_t* LCD,uint16_t Xpos,uint16_t Ypos,uint16_t r,uint32_t contColor,uint16_t contSz,uint32_t fillColor);
              extern void ssd2119refreshenable(struct LCD_t* LCD,int enable);
              /* SSD2119 registers */
                #define SSD2119_REGISTER_DEVICE_CODE_READ  ((uint32_t)0x00)
                #define SSD2119_REGISTER_OSC_START         ((uint32_t)0x00)
                #define SSD2119_REGISTER_OUTPUT_CTRL       ((uint32_t)0x01)
                #define SSD2119_REGISTER_LCD_DRIVE_AC_CTRL ((uint32_t)0x02)
                #define SSD2119_REGISTER_PWR_CTRL_1        ((uint32_t)0x03)
                #define SSD2119_REGISTER_DISPLAY_CTRL      ((uint32_t)0x07)
                #define SSD2119_REGISTER_FRAME_CYCLE_CTRL  ((uint32_t)0x0B)
                #define SSD2119_REGISTER_PWR_CTRL_2        ((uint32_t)0x0C)
                #define SSD2119_REGISTER_PWR_CTRL_3        ((uint32_t)0x0D)
                #define SSD2119_REGISTER_PWR_CTRL_4        ((uint32_t)0x0E)
                #define SSD2119_REGISTER_GATE_SCAN_START   ((uint32_t)0x0F)
                #define SSD2119_REGISTER_SLEEP_MODE_1      ((uint32_t)0x10)
                #define SSD2119_REGISTER_ENTRY_MODE        ((uint32_t)0x11)
                #define SSD2119_REGISTER_SLEEP_MODE_2      ((uint32_t)0x12)
                #define SSD2119_REGISTER_GEN_IF_CTRL       ((uint32_t)0x15)
                #define SSD2119_REGISTER_H_PORCH           ((uint32_t)0x16)
                #define SSD2119_REGISTER_V_PORCH            ((uint32_t)0x17)
                #define SSD2119_REGISTER_PWR_CTRL_5        ((uint32_t)0x1E)
                #define SSD2119_REGISTER_UNIFORMITY        ((uint32_t)0x20)
                #define SSD2119_REGISTER_RAM_DATA          ((uint32_t)0x22)
                #define SSD2119_REGISTER_FRAME_FREQ        ((uint32_t)0x25)
                #define SSD2119_REGISTER_ANALOG_SET        ((uint32_t)0x26)
                #define SSD2119_REGISTER_VCOM_OTP_1        ((uint32_t)0x28)
                #define SSD2119_REGISTER_VCOM_OTP_2        ((uint32_t)0x29)
                #define SSD2119_REGISTER_GAMMA_CTRL_1      ((uint32_t)0x30)
                #define SSD2119_REGISTER_GAMMA_CTRL_2      ((uint32_t)0x31)
                #define SSD2119_REGISTER_GAMMA_CTRL_3      ((uint32_t)0x32)
                #define SSD2119_REGISTER_GAMMA_CTRL_4      ((uint32_t)0x33)
                #define SSD2119_REGISTER_GAMMA_CTRL_5      ((uint32_t)0x34)
                #define SSD2119_REGISTER_GAMMA_CTRL_6      ((uint32_t)0x35)
                #define SSD2119_REGISTER_GAMMA_CTRL_7      ((uint32_t)0x36)
                #define SSD2119_REGISTER_GAMMA_CTRL_8      ((uint32_t)0x37)
                #define SSD2119_REGISTER_GAMMA_CTRL_9      ((uint32_t)0x3A)
                #define SSD2119_REGISTER_GAMMA_CTRL_10     ((uint32_t)0x3B)
                #define SSD2119_REGISTER_V_SCROLL_1        ((uint32_t)0x41)
                #define SSD2119_REGISTER_V_SCROLL_2        ((uint32_t)0x42)
                #define SSD2119_REGISTER_V_RAM_POS         ((uint32_t)0x44)
                #define SSD2119_REGISTER_H_RAM_START       ((uint32_t)0x45)
                #define SSD2119_REGISTER_H_RAM_END         ((uint32_t)0x46)
                #define SSD2119_REGISTER_1_DRV_POS_1       ((uint32_t)0x48)
                #define SSD2119_REGISTER_1_DRV_POS_2       ((uint32_t)0x49)
                #define SSD2119_REGISTER_2_DRV_POS_1       ((uint32_t)0x4A)
                #define SSD2119_REGISTER_2_DRV_POS_2       ((uint32_t)0x4B)
                #define SSD2119_REGISTER_X_RAM_ADDR        ((uint32_t)0x4E)
                #define SSD2119_REGISTER_Y_RAM_ADDR        ((uint32_t)0x4F)
              #endif

include/GRAPHIC/GUI/Widgets/terminal.h 0 -2

              /*------------------------------------------------------------------------------
              --  This file is a part of the libuc, microcontroler library
              --  Copyright (C) 2012, Alexis Jeandet
              --
              --  This program is free software; you can redistribute it and/or modify
              --  it under the terms of the GNU General Public License as published by
              --  the Free Software Foundation; either version 3 of the License, or
              --  (at your option) any later version.
              --
              --  This program is distributed in the hope that it will be useful,
              --  but WITHOUT ANY WARRANTY; without even the implied warranty of
              --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              --  GNU General Public License for more details.
              --
              --  You should have received a copy of the GNU General Public License
              --  along with this program; if not, write to the Free Software
              --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
              -------------------------------------------------------------------------------
              --                 Author : Alexis Jeandet
              --                   Mail : alexis.jeandet@member.fsf.org
              -------------------------------------------------------------------------------*/
              #ifndef TERMINAL_H
              #define TERMINAL_H
-             #include <stdint.h>
              #include <widget.h>
              #include <streamdevices.h>
              #include <genericLCD_Controler.h>
-             #include <fonts.h>
              typedef struct terminal_t
              {
                  uint16_t line;
                  uint16_t column;
                  uint16_t lineCount;
                  uint16_t columnCount;
                  uint16_t firstLine;
                  uint16_t lastLine;
                  uint16_t Xpos;
                  uint16_t Ypos;
                  uint16_t width;
                  uint16_t height;
                  uint32_t backgroundColor;
                  uint32_t textColor;
                  int8_t verticalSpace;
                  int8_t horizontalSpace;
                  int8_t empty;
                  LCD_t* LCD;
                  sFONT* font;
                  char* buffer;
              }terminal_t;
              int terminal_init(terminal_t* terminal,LCD_t* LCD,sFONT* font,streamdevice* strdev);
              void terminal_setgeometry(terminal_t* terminal,uint16_t Xpos,uint16_t Ypos,uint16_t width,uint16_t height);
              void terminal_clear(terminal_t* terminal);
              void terminal_setbackgroundColor(terminal_t* terminal, uint32_t backgrooundColor);
              void terminal_settextColor(terminal_t* terminal, uint32_t textColor);
              void terminal_movecursor(terminal_t* terminal,int n);
              void terminal_clearCurentLine(terminal_t* terminal);
              int terminal_write(streamdevice* device,void* data,int size, int n);
              int terminal_read(streamdevice* device,void* data,int size, int n);
              int terminal_setpos(streamdevice* device,int pos);
              int terminal_close(streamdevice* device);
              #endif

include/GRAPHIC/TC_CONTROLERS/ADS7843.h 0 -3

              /*------------------------------------------------------------------------------
              --  This file is a part of the libuc, microcontroler library
              --  Copyright (C) 2013, Alexis Jeandet
              --
              --  This program is free software; you can redistribute it and/or modify
              --  it under the terms of the GNU General Public License as published by
              --  the Free Software Foundation; either version 3 of the License, or
              --  (at your option) any later version.
              --
              --  This program is distributed in the hope that it will be useful,
              --  but WITHOUT ANY WARRANTY; without even the implied warranty of
              --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              --  GNU General Public License for more details.
              --
              --  You should have received a copy of the GNU General Public License
              --  along with this program; if not, write to the Free Software
              --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
              -------------------------------------------------------------------------------
              --                 Author : Alexis Jeandet
              --                   Mail : alexis.jeandet@member.fsf.org
              -------------------------------------------------------------------------------*/
              #ifndef STMPE811_H
              #define STMPE811_H
              #include <stdio.h>
-             #include <uhandle.h>
              #include <genericTC_Controler.h>
-             #include <stdint.h>
-             #include <fonts.h>
              #include <spi.h>
              typedef struct ADS7843_t
              {
               spi_t spidev;
               void (*setnCS)(char);
               int (*busy)();
              }ADS7843_t;
              extern int ads7843init(ADS7843_t *dev, spi_t spidev,void (*setnCS)(char),int (*busy)());
              extern int ads7843read(ADS7843_t *dev,int* x,int* y);
              #endif

include/GRAPHIC/TC_CONTROLERS/STMPE811.h 0 -3

              /*------------------------------------------------------------------------------
              --  This file is a part of the libuc, microcontroler library
              --  Copyright (C) 2013, Alexis Jeandet
              --
              --  This program is free software; you can redistribute it and/or modify
              --  it under the terms of the GNU General Public License as published by
              --  the Free Software Foundation; either version 3 of the License, or
              --  (at your option) any later version.
              --
              --  This program is distributed in the hope that it will be useful,
              --  but WITHOUT ANY WARRANTY; without even the implied warranty of
              --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              --  GNU General Public License for more details.
              --
              --  You should have received a copy of the GNU General Public License
              --  along with this program; if not, write to the Free Software
              --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
              -------------------------------------------------------------------------------
              --                 Author : Alexis Jeandet
              --                   Mail : alexis.jeandet@member.fsf.org
              -------------------------------------------------------------------------------*/
              #ifndef STMPE811_H
              #define STMPE811_H
              #include <stdio.h>
-             #include <uhandle.h>
              #include <genericTC_Controler.h>
-             #include <stdint.h>
-             #include <fonts.h>
              #include <i2c.h>
              typedef struct STMPE811_t
              {
               i2c_t i2cdev;
               uint8_t devAddress;
              }STMPE811_t;
              extern int stmpe811init(STMPE811_t *dev, i2c_t i2cdev, uint8_t A0);
              extern int stmpe811getID(STMPE811_t *dev);
              #define	STMPE811_REGISTER_CHIP_ID 	     ((uint32_t)	0x0000	)
              #define	STMPE811_REGISTER_ID_VER  	     ((uint32_t)	0x0002	)
              #define	STMPE811_REGISTER_SYS_CTRL1      ((uint32_t)	0x0003	)
              #define	STMPE811_REGISTER_SYS_CTRL2      ((uint32_t)	0x0004	)
              #define	STMPE811_REGISTER_SPI_CFG        ((uint32_t)	0x0008	)
              #define	STMPE811_REGISTER_INT_CTRL       ((uint32_t)	0x0009	)
              #define	STMPE811_REGISTER_INT_EN         ((uint32_t)	0x000A	)
              #define	STMPE811_REGISTER_INT_STA        ((uint32_t)	0x000B	)
              #define	STMPE811_REGISTER_GPIO_EN        ((uint32_t)	0x000C	)
              #define	STMPE811_REGISTER_GPIO_INT_STA   ((uint32_t)	0x000D	)
              #define	STMPE811_REGISTER_ADC_INT_EN     ((uint32_t)	0x000E	)
              #define	STMPE811_REGISTER_ADC_INT_STA    ((uint32_t)	0x000F	)
              #define	STMPE811_REGISTER_GPIO_SET_PIN   ((uint32_t)	0x0010	)
              #define	STMPE811_REGISTER_GPIO_CLR_PIN   ((uint32_t)	0x0011	)
              #define	STMPE811_REGISTER_GPIO_MP_STA    ((uint32_t)	0x0012	)
              #define	STMPE811_REGISTER_GPIO_DIR       ((uint32_t)	0x0013	)
              #define	STMPE811_REGISTER_GPIO_ED        ((uint32_t)	0x0014	)
              #define	STMPE811_REGISTER_GPIO_RE        ((uint32_t)	0x0015	)
              #define	STMPE811_REGISTER_GPIO_FE        ((uint32_t)	0x0016	)
              #define	STMPE811_REGISTER_GPIO_AF        ((uint32_t)	0x0017	)
              #define	STMPE811_REGISTER_ADC_CTRL1      ((uint32_t)	0x0020	)
              #define	STMPE811_REGISTER_ADC_CTRL2      ((uint32_t)	0x0021	)
              #define	STMPE811_REGISTER_ADC_CAPT       ((uint32_t)	0x0022	)
              #define	STMPE811_REGISTER_ADC_DATA_CH0   ((uint32_t)	0x0030	)
              #define	STMPE811_REGISTER_ADC_DATA_CH1   ((uint32_t)	0x0032	)
              #define	STMPE811_REGISTER_ADC_DATA_CH2   ((uint32_t)	0x0034	)
              #define	STMPE811_REGISTER_ADC_DATA_CH3   ((uint32_t)	0x0036	)
              #define	STMPE811_REGISTER_ADC_DATA_CH4   ((uint32_t)	0x0038	)
              #define	STMPE811_REGISTER_ADC_DATA_CH5   ((uint32_t)	0x003A	)
              #define	STMPE811_REGISTER_ADC_DATA_CH6   ((uint32_t)	0x003C	)
              #define	STMPE811_REGISTER_ADC_DATA_CH7   ((uint32_t)	0x003E	)
              #define	STMPE811_REGISTER_TSC_CTRL       ((uint32_t)	0x0040	)
              #define	STMPE811_REGISTER_TSC_CFG        ((uint32_t)	0x0041	)
              #define	STMPE811_REGISTER_WDW_TR_X       ((uint32_t)	0x0042	)
              #define	STMPE811_REGISTER_WDW_TR_Y       ((uint32_t)	0x0044	)
              #define	STMPE811_REGISTER_WDW_BL_X       ((uint32_t)	0x0046	)
              #define	STMPE811_REGISTER_WDW_BL_Y       ((uint32_t)	0x0048	)
              #define	STMPE811_REGISTER_FIFO_TH        ((uint32_t)	0x004A	)
              #define	STMPE811_REGISTER_FIFO_STA       ((uint32_t)	0x004B	)
              #define	STMPE811_REGISTER_FIFO_SIZE      ((uint32_t)	0x004C	)
              #define	STMPE811_REGISTER_TSC_DATA_X     ((uint32_t)	0x004D	)
              #define	STMPE811_REGISTER_TSC_DATA_Y     ((uint32_t)	0x004F	)
              #define	STMPE811_REGISTER_TSC_DATA_Z     ((uint32_t)	0x0051	)
              #define	STMPE811_REGISTER_TSC_DATA_XYZ   ((uint32_t)	0x0052	)
              #define	STMPE811_REGISTER_TSC_FRACTION_Z ((uint32_t)	0x0056	)
              #define	STMPE811_REGISTER_TSC_DATA       ((uint32_t)	0x0057	)
              #define	STMPE811_REGISTER_TSC_I_DRIVE    ((uint32_t)	0x0058	)
              #define	STMPE811_REGISTER_TSC_SHIELD     ((uint32_t)	0x0059	)
              #define	STMPE811_REGISTER_TEMP_CTRL      ((uint32_t)	0x0060	)
              #define	STMPE811_REGISTER_TEMP_DATA      ((uint32_t)	0x0061	)
              #define	STMPE811_REGISTER_TEMP_TH        ((uint32_t)	0x0062	)
              #endif

include/GRAPHIC/TC_CONTROLERS/genericTC_Controler.h 0 -1

              /*------------------------------------------------------------------------------
              --  This file is a part of the libuc, microcontroler library
              --  Copyright (C) 2013, Alexis Jeandet
              --
              --  This program is free software; you can redistribute it and/or modify
              --  it under the terms of the GNU General Public License as published by
              --  the Free Software Foundation; either version 3 of the License, or
              --  (at your option) any later version.
              --
              --  This program is distributed in the hope that it will be useful,
              --  but WITHOUT ANY WARRANTY; without even the implied warranty of
              --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              --  GNU General Public License for more details.
              --
              --  You should have received a copy of the GNU General Public License
              --  along with this program; if not, write to the Free Software
              --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
              -------------------------------------------------------------------------------
              --                 Author : Alexis Jeandet
              --                   Mail : alexis.jeandet@member.fsf.org
              -------------------------------------------------------------------------------*/
              #ifndef GENERICTC_CONTROLER_H
              #define GENERICTC_CONTROLER_H
              #include <uhandle.h>
-             #include <stdint.h>
              #include <fonts.h>
              #endif              /*GENERICTC_CONTROLER_H*/

include/streamdevices.h 0 -1

              /*------------------------------------------------------------------------------
              --  This file is a part of the libuc, microcontroler library
              --  Copyright (C) 2012, Alexis Jeandet
              --
              --  This program is free software; you can redistribute it and/or modify
              --  it under the terms of the GNU General Public License as published by
              --  the Free Software Foundation; either version 3 of the License, or
              --  (at your option) any later version.
              --
              --  This program is distributed in the hope that it will be useful,
              --  but WITHOUT ANY WARRANTY; without even the implied warranty of
              --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              --  GNU General Public License for more details.
              --
              --  You should have received a copy of the GNU General Public License
              --  along with this program; if not, write to the Free Software
              --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
              -------------------------------------------------------------------------------
              --                 Author : Alexis Jeandet
              --                   Mail : alexis.jeandet@gmail.com
              -------------------------------------------------------------------------------*/
              #ifndef STREAMDEVICES_H
              #define STREAMDEVICES_H
              #include <uhandle.h>
-             #include <stdint.h>
              typedef struct streamdevice* streamdeviceptr;
              struct streamdevice_ops;
              typedef volatile struct streamdevice
              {
                  struct streamdevice_ops* ops;
                  volatile uint32_t streamPt;
                  volatile UHANDLE _stream;
                  volatile uint32_t mode;
              }streamdevice;
              typedef struct streamdevice_ops
              {
                  int (*write)(streamdevice* device,void* data,int size, int n);
                  int (*read)(streamdevice* device,void* data,int size, int n);
                  int (*setpos)(streamdevice* device,int pos);
                  int (*close)(streamdevice* device);
              }streamdevice_ops;
              typedef int (*write_t)(streamdeviceptr device,void* data,int size, int n);
              typedef int (*read_t)(streamdeviceptr device,void* data,int size, int n);
              typedef int (*setpos_t)(streamdeviceptr device,int pos);
              typedef int (*close_t)(streamdeviceptr device);
              #endif

include/thread.h 0 -2

              /*------------------------------------------------------------------------------
              --  This file is a part of the libuc, microcontroler library
              --  Copyright (C) 2013, Alexis Jeandet
              --
              --  This program is free software; you can redistribute it and/or modify
              --  it under the terms of the GNU General Public License as published by
              --  the Free Software Foundation; either version 3 of the License, or
              --  (at your option) any later version.
              --
              --  This program is distributed in the hope that it will be useful,
              --  but WITHOUT ANY WARRANTY; without even the implied warranty of
              --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              --  GNU General Public License for more details.
              --
              --  You should have received a copy of the GNU General Public License
              --  along with this program; if not, write to the Free Software
              --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
              -------------------------------------------------------------------------------
              --                 Author : Alexis Jeandet
              --                   Mail : alexis.jeandet@member.fsf.org
              -------------------------------------------------------------------------------*/
              #ifndef THREAD_H
              #define THREAD_H
              #include <stdint.h>
-             #include <uhandle.h>
-             #include <streamdevices.h>
              #ifdef __cplusplus
              extern "C" {
              #endif
              /*
               This structure holds the thread context. To do so, you need to keep a track of the programm counter,
               to change the stack pointer for each thread and to save all registers needing to be saved. Since the
               number of regiter to be saved vary from one processor to an other, it's easier to save them in the
               owner thread stack;
              */
              typedef struct thread_t
              {
                  int (*func)(void*);
                  void* __stack__;
                  int stackSize;
                  int priority;
                  struct thread_t* prev;
                  struct thread_t* next;
              }thread_t;
              extern int threadcreate(thread_t* thread,void* stack,int stackSize,int (*func)(void*));
              extern int threadstart(thread_t* thread);
              extern int threadstop(thread_t* thread);
              #ifdef __THREAD_PRIVATE__
              extern void __cpusavecontext(void* dataspace);
              extern void __cpurestorecontext(void* dataspace);
              extern void __initThreading();
              extern thread_t mainThread;
              #endif
              #ifdef __cplusplus
              }
              #endif
              #endif //THREAD_H

include/uhandle.h +1 -1

              /*------------------------------------------------------------------------------
              --  This file is a part of the libuc, microcontroler library
              --  Copyright (C) 2012, Alexis Jeandet
              --
              --  This program is free software; you can redistribute it and/or modify
              --  it under the terms of the GNU General Public License as published by
              --  the Free Software Foundation; either version 3 of the License, or
              --  (at your option) any later version.
              --
              --  This program is distributed in the hope that it will be useful,
              --  but WITHOUT ANY WARRANTY; without even the implied warranty of
              --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              --  GNU General Public License for more details.
              --
              --  You should have received a copy of the GNU General Public License
              --  along with this program; if not, write to the Free Software
              --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
              -------------------------------------------------------------------------------
              --                 Author : Alexis Jeandet
              --                   Mail : alexis.jeandet@gmail.com
              -------------------------------------------------------------------------------*/
              #ifndef UHANDLE_H
              #define UHANDLE_H
+             #include <stdint.h>
              typedef volatile void* UHANDLE;
              #define uhandlevalide(HANDLE) ((HANDLE)!=0)
              #endif

mkspecs/features/libuc2.prf +9 -2

              #
              # Libuc2 common rules
              #
              #
              defineTest(copyFiles) {
                  files = $$1
                  DDIR = $$2
                  win32:DDIR ~= s,/,\\,g
                  QMAKE_POST_LINK += $$QMAKE_MKDIR $$quote($$DDIR) $$escape_expand(\\n\\t)
                  for(FILE, files) {
              	message(copying file $$FILE)
                      # Replace slashes in paths with backslashes for Windows
                      win32:FILE ~= s,/,\\,g
                      QMAKE_POST_LINK += $$QMAKE_COPY $$quote($$FILE) $$quote($$DDIR) $$escape_expand(\\n\\t)
                  }
                  export(QMAKE_POST_LINK)
              }
              INCLUDEPATH += $$[QT_INSTALL_HEADERS] \
+                            $$[QT_INSTALL_HEADERS]/FS \
+                            $$[QT_INSTALL_HEADERS]/EEPROMS \
+                            $$[QT_INSTALL_HEADERS]/AUDIO \
+                            $$[QT_INSTALL_HEADERS]/POWER \
+                            $$[QT_INSTALL_HEADERS]/PERIPHERALS \
+                            $$[QT_INSTALL_HEADERS]/FLASH \
+                            $$[QT_INSTALL_HEADERS]/ADC \
                             $$[QT_INSTALL_HEADERS]/GRAPHIC/CONTROLERS \
                             $$[QT_INSTALL_HEADERS]/GRAPHIC/TC_CONTROLERS \
-                         $$[QT_INSTALL_HEADERS]/GRAPHIC/GUI/FONTS \
-                         $$[QT_INSTALL_HEADERS]/GRAPHIC/GUI/Widgets
+                            $$[QT_INSTALL_HEADERS]/GRAPHIC/GUI/FONTS \
+                            $$[QT_INSTALL_HEADERS]/GRAPHIC/GUI/Widgets
              #
              # Microcontroler switch
              #
              #
              contains( TEMPLATE, app ) {
              	!isEmpty( BSP ) {
              	 	include(./boards/$$BSP/bsp.pri)
              	 }
              	INCLUDEPATH+=  $$[QT_INSTALL_PREFIX]/bsp/src/$$BSP
              	CONFIG +=  link_prl
              	OBJECTS_DIR=obj-$$UCMODEL
              	DESTDIR=bin-$$UCMODEL
              }
              !isEmpty( UCMODEL ) {
              	include(./$$UCMODEL/cpu.pri)
               	include(./$$UCMODEL/qmake.conf)
              }
              !isEmpty(FILESTOCOPY.files) {
                      	copyFiles($$FILESTOCOPY.files,$$FILESTOCOPY.path)
              }
              contains( TEMPLATE, lib ) {
              	CONFIG+=staticlib
              	OBJECTS_DIR=obj-$$UCMODEL
              	contains( CONFIG, libuc2lib) {
              		CONFIG +=  create_prl
              		DESTDIR=$$[QT_INSTALL_LIBS]/$$UCMODEL
              	}else{
              		contains( CONFIG, bsp) {
              			DESTDIR=$$[QT_INSTALL_PREFIX]/bsp/lib/$$BSP
              			CONFIG +=  create_prl
              			!isEmpty( BSPFILE ) {
              				#bspFileCopy.target = bspFileCopy
              		    		#bspFileCopy.commands = echo hello
              		 		#QMAKE_EXTRA_TARGETS += bspFileCopy
              				#target.depend += bspFileCopy
              				#PRE_TARGETDEPS += bspFileCopy
              				copyFiles($$BSPFILE,$$[QT_INSTALL_PREFIX]/mkspecs/features/boards/$$BSP)
              			}
              		}else{
              			DESTDIR=bin-$$UCMODEL
              		}
              	}
              }

src/common/AUDIO/VS10XX/VS10XX_SIMULATOR.pro +3 0

              TEMPLATE = lib
              CONFIG += libuc2lib
              TARGET = vs10XX
              SOURCES += VS10XX.c
              UCMODEL=simulator
+             HEADERS += \
+                 ../../../../include/AUDIO/VS10XX.h

src/common/AUDIO/VS10XX/VS10XX_STM32F4.pro +4 0

              TEMPLATE = lib
              CONFIG += libuc2lib
              TARGET = vs10XX
              SOURCES += VS10XX.c
              UCMODEL=stm32f4
+             HEADERS += \
+                 ../../../../include/AUDIO/VS10XX.h

src/common/POWER/ina226/ina226_SIMULATOR.pro +3 0

              TEMPLATE = lib
              CONFIG += libuc2lib
              TARGET = ina226
              SOURCES += ina226.c
              UCMODEL=simulator
+             HEADERS += \
+                 ../../../../include/POWER/ina226.h

src/common/POWER/ina226/ina226_STM32F4.pro +3 0

              TEMPLATE = lib
              CONFIG += libuc2lib
              TARGET = ina226
              SOURCES += ina226.c
              UCMODEL=stm32f4
+             HEADERS += \
+                 ../../../../include/POWER/ina226.h

src/simulator/SDLCD/SDLCD.c +1 -1

              /*------------------------------------------------------------------------------
              --  This file is a part of the libuc, microcontroler library
              --  Copyright (C) 2013, Alexis Jeandet
              --
              --  This program is free software; you can redistribute it and/or modify
              --  it under the terms of the GNU General Public License as published by
              --  the Free Software Foundation; either version 3 of the License, or
              --  (at your option) any later version.
              --
              --  This program is distributed in the hope that it will be useful,
              --  but WITHOUT ANY WARRANTY; without even the implied warranty of
              --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              --  GNU General Public License for more details.
              --
              --  You should have received a copy of the GNU General Public License
              --  along with this program; if not, write to the Free Software
              --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
              -------------------------------------------------------------------------------
              --                 Author : Alexis Jeandet
              --                   Mail : alexis.jeandet@member.fsf.org
              -------------------------------------------------------------------------------*/
              #include <SDL.h>
              #include <malloc.h>
-             #include "SDLCD.h"
+             #include <SDLCD.h>
              SDL_Surface *screen;
              SDL_Overlay     *bmp;
              int SDLCD_Xpos=0;
              int SDLCD_Ypos=0;
              int SDLCD_XWinStrt=0;
              int SDLCD_YWinStrt=0;
              int SDLCD_XWinEnd=0;
              int SDLCD_YWinEnd=0;
              void* SDLCD_buffer;
              int SDLCD_bpp;
              void SDLCD_putpixel(SDL_Surface *surface, int x, int y, Uint32 pixel);
              static Uint32 sdl_refresh_timer(Uint32 interval, void *opaque) {
                  if ( SDL_MUSTLOCK(screen) ) {
                      if ( SDL_LockSurface(screen) < 0 ) {
                          fprintf(stderr, "Can’t lock screen: %s\n", SDL_GetError());
                          return interval;
                      }
                  }
                  //SDL_UpdateRect(screen, 0, 0, screen->w, screen->h);
                  SDL_Flip(screen);
                  if ( SDL_MUSTLOCK(screen) ) {
                      SDL_UnlockSurface(screen);
                  }
                return interval; /* 0 means stop timer */
              }
              void SDLCD_mkscreen(int resx,int resy,int bpp,int lcdtype)
              {
                  int i=0;
                  if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER)) {
                      fprintf(stderr, "Could not initialize SDL - %s\n", SDL_GetError());
                      exit(1);
                  }
                  screen = SDL_SetVideoMode(resx, resy, bpp, SDL_DOUBLEBUF);
                  if(!screen) {
                      fprintf(stderr, "SDL: could not set video mode - exiting\n");
                      exit(1);
                  }
                  if ( SDL_MUSTLOCK(screen) ) {
                      if ( SDL_LockSurface(screen) < 0 ) {
                          fprintf(stderr, "Can’t lock screen: %s\n", SDL_GetError());
                          return;
                      }
                  }
                  SDL_UpdateRect(screen, 0, 0, resx, resy);
                  if ( SDL_MUSTLOCK(screen) ) {
                      SDL_UnlockSurface(screen);
                  }
                  SDLCD_buffer = malloc(resx*resy*bpp/8);
                  SDLCD_bpp = bpp;
                  for(i=0;i<(resx*resy);i++)
                  {
                      SDLCD_putpixel(screen, i%resx, (i/resx), 0xFFFF);
                  }
                  SDL_AddTimer(10, sdl_refresh_timer, NULL);
              }
              int SDLCD_init()
              {
              }
              void SDLCD_writereg(uint32_t reg,uint32_t data)
              {
                  switch (reg) {
                  case ILI9328_REGISTER_HORIZONTALGRAMADDRESSSET:
                      if((data>=screen->w) || (data<0))
                          printf("Warning printing out of bounds HORIZONTALGRAMADDRESSSET=%d",data);
                      SDLCD_Xpos = data;
                      break;
                  case ILI9328_REGISTER_VERTICALGRAMADDRESSSET:
                      if((data>=screen->h) || (data<0))
                          printf("Warning printing out of bounds ILI9328_REGISTER_VERTICALGRAMADDRESSSET=%d",data);
                      SDLCD_Ypos = data;
                      break;
                  case ILI9328_REGISTER_HORIZONTALADDRESSSTARTPOSITION:
                      if((data>=screen->w) || (data<0))
                          printf("Warning printing out of bounds ILI9328_REGISTER_HORIZONTALADDRESSSTARTPOSITION=%d",data);
                      SDLCD_XWinStrt = data;
                      break;
                  case ILI9328_REGISTER_HORIZONTALADDRESSENDPOSITION:
                      if((data>=screen->w) || (data<0))
                          printf("Warning printing out of bounds ILI9328_REGISTER_HORIZONTALADDRESSENDPOSITION=%d",data);
                      SDLCD_XWinEnd = data;
                      break;
                  case ILI9328_REGISTER_VERTICALADDRESSSTARTPOSITION:
                      if((data>=screen->h) || (data<0))
                          printf("Warning printing out of bounds ILI9328_REGISTER_VERTICALADDRESSSTARTPOSITION=%d",data);
                      SDLCD_YWinStrt = data;
                      break;
                  case ILI9328_REGISTER_VERTICALADDRESSENDPOSITION:
                      if((data>=screen->h) || (data<0))
                          printf("Warning printing out of bounds ILI9328_REGISTER_VERTICALADDRESSENDPOSITION=%d",data);
                      SDLCD_YWinEnd = data;
                      break;
                  default:
                      break;
                  }
              }
              uint32_t SDLCD_readreg(uint32_t reg)
              {
                  return 0;
              }
              void SDLCD_putpixel(SDL_Surface *surface, int x, int y, Uint32 pixel)
              {
                  int bpp = surface->format->BytesPerPixel;
                  /* Here p is the address to the pixel we want to set */
                  Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * bpp;
                  switch(bpp) {
                  case 1:
                      *p = pixel;
                      break;
                  case 2:
                      *(Uint16 *)p = pixel;
                      break;
                  case 3:
                      if(SDL_BYTEORDER == SDL_BIG_ENDIAN) {
                          p[0] = (pixel >> 16) & 0xff;
                          p[1] = (pixel >> 8) & 0xff;
                          p[2] = pixel & 0xff;
                      } else {
                          p[0] = pixel & 0xff;
                          p[1] = (pixel >> 8) & 0xff;
                          p[2] = (pixel >> 16) & 0xff;
                      }
                      break;
                  case 4:
                      *(Uint32 *)p = pixel;
                      break;
                  }
              }
              void SDLCD_putpixel_16bpp(SDL_Surface *surface, int x, int y, Uint32 pixel)
              {
                  Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * surface->format->BytesPerPixel;
                  *(Uint16 *)p = pixel;
              }
              Uint32 SDLCD_getpixel_16bpp(SDL_Surface *surface, int x, int y)
              {
                  Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * surface->format->BytesPerPixel;
                  return *(Uint16 *)p;
              }
              Uint32 SDLCD_getpixel(SDL_Surface *surface, int x, int y)
              {
                  int bpp = surface->format->BytesPerPixel;
                  /* Here p is the address to the pixel we want to retrieve */
                  Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * bpp;
                  switch(bpp) {
                  case 1:
                      return *p;
                  case 2:
                      return *(Uint16 *)p;
                  case 3:
                      if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
                          return p[0] << 16 | p[1] << 8 | p[2];
                      else
                          return p[0] | p[1] << 8 | p[2] << 16;
                  case 4:
                      return *(Uint32 *)p;
                  default:
                      return 0;
                  }
                  /* shouldn’t happen, but avoids warnings */
              }
              void SDLCD_writeGRAM(void* buffer,uint32_t count)
              {
                  int i=0;
                  u_int16_t* ptr=(u_int16_t*)SDLCD_buffer;
                  u_int16_t* inptr=(u_int16_t*)buffer;
                  if ( SDL_MUSTLOCK(screen) ) {
                      if ( SDL_LockSurface(screen) < 0 ) {
                          fprintf(stderr, "Can’t lock screen: %s\n", SDL_GetError());
                          return;
                      }
                  }
                  for(i=0;i<count;i++)
                  {
                      SDLCD_putpixel_16bpp(screen,SDLCD_Xpos,SDLCD_Ypos,inptr[i]);
                      SDLCD_Xpos+=1;
                      ptr[i]=inptr[i];
                      if(SDLCD_Xpos>=SDLCD_XWinEnd)
                      {
                          SDLCD_Xpos=SDLCD_XWinStrt;
                          SDLCD_Ypos+=1;
                      }
                      if(SDLCD_Ypos>=SDLCD_YWinEnd)
                      {
                          SDLCD_Ypos=SDLCD_YWinStrt;
                      }
                  }
                  if ( SDL_MUSTLOCK(screen) ) {
                      SDL_UnlockSurface(screen);
                  }
                  //    SDL_UpdateRect(screen, SDLCD_XWinStrt, SDLCD_YWinStrt, SDLCD_XWinEnd-SDLCD_XWinStrt, SDLCD_YWinEnd-SDLCD_YWinStrt);
                  //SDL_UpdateRect(screen, 0, 0, screen->w, screen->h);
              }
              void SDLCD_writeGRAM_16bpp(void* buffer,uint32_t count)
              {
                  int i=0;
                  u_int16_t* inptr=(u_int16_t*)buffer;
                  if ( SDL_MUSTLOCK(screen) ) {
                      if ( SDL_LockSurface(screen) < 0 ) {
                          fprintf(stderr, "Can’t lock screen: %s\n", SDL_GetError());
                          return;
                      }
                  }
                  for(i=0;i<count;i++)
                  {
                      *(( Uint16 * ) screen->pixels + SDLCD_Ypos * screen->pitch / 2 + SDLCD_Xpos)=inptr[i];
                      SDLCD_Xpos+=1;
                      if(SDLCD_Xpos>=SDLCD_XWinEnd)
                      {
                          SDLCD_Xpos=SDLCD_XWinStrt;
                          SDLCD_Ypos+=1;
                      }
                      if(SDLCD_Ypos>=SDLCD_YWinEnd)
                      {
                          SDLCD_Ypos=SDLCD_YWinStrt;
                      }
                  }
                  if ( SDL_MUSTLOCK(screen) ) {
                      SDL_UnlockSurface(screen);
                  }
                  //    SDL_UpdateRect(screen, SDLCD_XWinStrt, SDLCD_YWinStrt, SDLCD_XWinEnd-SDLCD_XWinStrt, SDLCD_YWinEnd-SDLCD_YWinStrt);
                  //SDL_UpdateRect(screen, 0, 0, screen->w, screen->h);
              }
              void SDLCD_readGRAM_16bpp(void* buffer,uint32_t count)
              {
                  int i=0;
                  u_int16_t* ptr=(u_int16_t*)SDLCD_buffer;
                  u_int16_t* inptr=(u_int16_t*)buffer;
                  for(i=0;i<count;i++)
                  {
                      inptr[i]=*(( Uint16 * ) screen->pixels + SDLCD_Ypos * screen->pitch / 2 + SDLCD_Xpos);
                      SDLCD_Xpos+=1;
                      ptr[i]=inptr[i];
                      if(SDLCD_Xpos>=SDLCD_XWinEnd)
                      {
                          SDLCD_Xpos=SDLCD_XWinStrt;
                          SDLCD_Ypos+=1;
                      }
                      if(SDLCD_Ypos>=SDLCD_YWinEnd)
                      {
                          SDLCD_Ypos=SDLCD_YWinStrt;
                      }
                  }
              }
              void SDLCD_readGRAM(void* buffer,uint32_t count)
              {
                  int i=0;
                  u_int16_t* ptr=(u_int16_t*)SDLCD_buffer;
                  u_int16_t* inptr=(u_int16_t*)buffer;
                  for(i=0;i<count;i++)
                  {
                      inptr[i]=SDLCD_getpixel_16bpp(screen,SDLCD_Xpos,SDLCD_Ypos);
                      SDLCD_Xpos+=1;
                      ptr[i]=inptr[i];
                      if(SDLCD_Xpos>=SDLCD_XWinEnd)
                      {
                          SDLCD_Xpos=SDLCD_XWinStrt;
                          SDLCD_Ypos+=1;
                      }
                      if(SDLCD_Ypos>=SDLCD_YWinEnd)
                      {
                          SDLCD_Ypos=SDLCD_YWinStrt;
                      }
                  }
              }

src/stm32f4/CORE/irq_handlers.c +1 -1

              #include <stdio.h>
              #include <stm32f4xx.h>
              void NMI_Handler(void)
              {
                  printf("NMI_Handler\n");
              }
              void HardFault_Handler(void)
              {
                  printf("HardFault_Handler\n");
              }
              void MemManage_Handler(void)
              {
                  printf("MemManage_Handler\n");
              }
              void BusFault_Handler(void)
              {
                  printf("BusFault_Handler\n");
              }
              void UsageFault_Handler(void)
              {
                  printf("UsageFault_Handler\n");
              }
              void SVC_Handler(void)
              {
                 // __set_CONTROL(2);
-                // printf("SVC_Handler\n");
+                 printf("SVC_Handler\n");
              }
              void DebugMon_Handler(void)
              {
                  printf("DebugMon_Handler\n");
              }
              void PendSV_Handler(void)
              {
                  printf("PendSV_Handler\n");
              }
              void WWDG_IRQHandler(void)
              {
                  printf("WWDG_IRQHandler\n");
              }
              void PVD_IRQHandler(void)
              {
                  printf("PVD_IRQHandler\n");
              }
              void TAMP_STAMP_IRQHandler(void)
              {
                  printf("TAMP_STAMP_IRQHandler\n");
              }
              void RTC_WKUP_IRQHandler(void)
              {
                  printf("RTC_WKUP_IRQHandler\n");
              }
              void FLASH_IRQHandler(void)
              {
                  printf("FLASH_IRQHandler\n");
              }
              void RCC_IRQHandler(void)
              {
                  printf("RCC_IRQHandler\n");
              }
              void EXTI0_IRQHandler(void)
              {
                  printf("EXTI0_IRQHandler\n");
              }
              void EXTI1_IRQHandler(void)
              {
                  printf("EXTI1_IRQHandler\n");
              }
              void EXTI2_IRQHandler(void)
              {
                  printf("EXTI2_IRQHandler\n");
              }
              void EXTI3_IRQHandler(void)
              {
                  printf("EXTI3_IRQHandler\n");
              }
              void EXTI4_IRQHandler(void)
              {
                  printf("EXTI4_IRQHandler\n");
              }
              void DMA1_Stream0_IRQHandler(void)
              {
                  printf("DMA1_Stream0_IRQHandler\n");
              }
              void DMA1_Stream1_IRQHandler(void)
              {
                  printf("DMA1_Stream1_IRQHandler\n");
              }
              void DMA1_Stream2_IRQHandler(void)
              {
                  printf("DMA1_Stream2_IRQHandler\n");
              }
              void DMA1_Stream3_IRQHandler(void)
              {
                  printf("DMA1_Stream3_IRQHandler\n");
              }
              void DMA1_Stream4_IRQHandler(void)
              {
                  printf("DMA1_Stream4_IRQHandler\n");
              }
              void DMA1_Stream5_IRQHandler(void)
              {
                  printf("DMA1_Stream5_IRQHandler\n");
              }
              void DMA1_Stream6_IRQHandler(void)
              {
                  printf("DMA1_Stream6_IRQHandler\n");
              }
              void ADC_IRQHandler(void)
              {
                  printf("ADC_IRQHandler\n");
              }
              void CAN1_TX_IRQHandler(void)
              {
                  printf("CAN1_TX_IRQHandler\n");
              }
              void CAN1_RX0_IRQHandler(void)
              {
                  printf("CAN1_RX0_IRQHandler\n");
              }
              void CAN1_RX1_IRQHandler(void)
              {
                  printf("CAN1_RX1_IRQHandler\n");
              }
              void CAN1_SCE_IRQHandler(void)
              {
                  printf("CAN1_SCE_IRQHandler\n");
              }
              void EXTI9_5_IRQHandler(void)
              {
                  printf("EXTI9_5_IRQHandler\n");
              }
              void TIM1_BRK_TIM9_IRQHandler(void)
              {
                  printf("TIM1_BRK_TIM9_IRQHandler\n");
              }
              void TIM1_UP_TIM10_IRQHandler(void)
              {
                  printf("TIM1_UP_TIM10_IRQHandler\n");
              }
              void TIM1_TRG_COM_TIM11_IRQHandlerIM11(void)
              {
                  printf("TIM1_TRG_COM_TIM11_IRQHandlerIM11");
              }
              void TIM1_CC_IRQHandler(void)
              {
                  printf("TIM1_CC_IRQHandler\n");
              }
              void TIM2_IRQHandler(void)
              {
                  printf("TIM2_IRQHandler\n");
              }
              void TIM3_IRQHandler(void)
              {
                  printf("TIM3_IRQHandler\n");
              }
              void TIM4_IRQHandler(void)
              {
                  printf("TIM4_IRQHandler\n");
              }
              void I2C1_EV_IRQHandler(void)
              {
                  printf("I2C1_EV_IRQHandler\n");
              }
              void I2C1_ER_IRQHandler(void)
              {
                  printf("I2C1_ER_IRQHandler\n");
              }
              void I2C2_EV_IRQHandler(void)
              {
                  printf("I2C2_EV_IRQHandler\n");
              }
              void I2C2_ER_IRQHandler(void)
              {
                  printf("I2C2_ER_IRQHandler\n");
              }
              void SPI1_IRQHandler(void)
              {
                  printf("SPI1_IRQHandler\n");
              }
              void SPI2_IRQHandler(void)
              {
                  printf("SPI2_IRQHandler\n");
              }
              void USART1_IRQHandler(void)
              {
                  printf("USART1_IRQHandler\n");
              }
              void USART2_IRQHandler(void)
              {
                  printf("USART2_IRQHandler\n");
              }
              void USART3_IRQHandler(void)
              {
                  printf("USART3_IRQHandler\n");
              }
              void EXTI15_10_IRQHandler(void)
              {
                  printf("EXTI15_10_IRQHandler\n");
              }
              void RTC_Alarm_IRQHandler(void)
              {
                  printf("RTC_Alarm_IRQHandler\n");
              }
              void OTG_FS_WKUP_IRQHandler(void)
              {
                  printf("OTG_FS_WKUP_IRQHandler\n");
              }
              void TIM8_BRK_TIM12_IRQHandler(void)
              {
                  printf("TIM8_BRK_TIM12_IRQHandler\n");
              }
              void TIM8_UP_TIM13_IRQHandler(void)
              {
                  printf("TIM8_UP_TIM13_IRQHandler\n");
              }
              void TIM8_TRG_COM_TIM14_IRQHandlerIM14(void)
              {
                  printf("TIM8_TRG_COM_TIM14_IRQHandlerIM14");
              }
              void TIM8_CC_IRQHandler(void)
              {
                  printf("TIM8_CC_IRQHandler\n");
              }
              void DMA1_Stream7_IRQHandler(void)
              {
                  printf("DMA1_Stream7_IRQHandler\n");
              }
              void FSMC_IRQHandler(void)
              {
                  printf("FSMC_IRQHandler\n");
              }
              void SDIO_IRQHandler(void)
              {
                  printf("SDIO_IRQHandler\n");
              }
              void TIM5_IRQHandler(void)
              {
                  printf("TIM5_IRQHandler\n");
              }
              void SPI3_IRQHandler(void)
              {
                  printf("SPI3_IRQHandler\n");
              }
              void UART4_IRQHandler(void)
              {
                  printf("UART4_IRQHandler\n");
              }
              void UART5_IRQHandler(void)
              {
                  printf("UART5_IRQHandler\n");
              }
              void TIM6_DAC_IRQHandler(void)
              {
                  printf("TIM6_DAC_IRQHandler\n");
              }
              void TIM7_IRQHandler(void)
              {
                  printf("TIM7_IRQHandler\n");
              }
              void DMA2_Stream0_IRQHandler(void)
              {
                  printf("DMA2_Stream0_IRQHandler\n");
              }
              void DMA2_Stream1_IRQHandler(void)
              {
                  printf("DMA2_Stream1_IRQHandler\n");
              }
              void DMA2_Stream2_IRQHandler(void)
              {
                  printf("DMA2_Stream2_IRQHandler\n");
              }
              void DMA2_Stream3_IRQHandler(void)
              {
                  printf("DMA2_Stream3_IRQHandler\n");
              }
              void DMA2_Stream4_IRQHandler(void)
              {
                  printf("DMA2_Stream4_IRQHandler\n");
              }
              void ETH_IRQHandler(void)
              {
                  printf("ETH_IRQHandler\n");
              }
              void ETH_WKUP_IRQHandler(void)
              {
                  printf("ETH_WKUP_IRQHandler\n");
              }
              void CAN2_TX_IRQHandler(void)
              {
                  printf("CAN2_TX_IRQHandler\n");
              }
              void CAN2_RX0_IRQHandler(void)
              {
                  printf("CAN2_RX0_IRQHandler\n");
              }
              void CAN2_RX1_IRQHandler(void)
              {
                  printf("CAN2_RX1_IRQHandler\n");
              }
              void CAN2_SCE_IRQHandler(void)
              {
                  printf("CAN2_SCE_IRQHandler\n");
              }
              void OTG_FS_IRQHandler(void)
              {
                  printf("OTG_FS_IRQHandler\n");
              }
              void DMA2_Stream5_IRQHandler(void)
              {
                  printf("DMA2_Stream5_IRQHandler\n");
              }
              void DMA2_Stream6_IRQHandler(void)
              {
                  printf("DMA2_Stream6_IRQHandler\n");
              }
              void DMA2_Stream7_IRQHandler(void)
              {
                  printf("DMA2_Stream7_IRQHandler\n");
              }
              void USART6_IRQHandler(void)
              {
                  printf("USART6_IRQHandler\n");
              }
              void I2C3_EV_IRQHandler(void)
              {
                  printf("I2C3_EV_IRQHandler\n");
              }
              void I2C3_ER_IRQHandler(void)
              {
                  printf("I2C3_ER_IRQHandler\n");
              }
              void OTG_HS_EP1_OUT_IRQHandler(void)
              {
                  printf("OTG_HS_EP1_OUT_IRQHandler\n");
              }
              void OTG_HS_EP1_IN_IRQHandler(void)
              {
                  printf("OTG_HS_EP1_IN_IRQHandler\n");
              }
              void OTG_HS_WKUP_IRQHandler(void)
              {
                  printf("OTG_HS_WKUP_IRQHandler\n");
              }
              void OTG_HS_IRQHandler(void)
              {
                  printf("OTG_HS_IRQHandler\n");
              }
              void DCMI_IRQHandler(void)
              {
                  printf("DCMI_IRQHandler\n");
              }
              void CRYP_IRQHandler(void)
              {
                  printf("CRYP_IRQHandler\n");
              }
              void HASH_RNG_IRQHandler(void)
              {
                  printf("HASH_RNG_IRQHandler\n");
              }
              void FPU_IRQHandler(void)
              {
                  printf("FPU_IRQHandler\n");
              }

src/stm32f4/GPIO/gpio.pro +3 0

              TEMPLATE = lib
              CONFIG += libuc2lib
              SOURCES += gpio.c
              UCMODEL=stm32f4
+             HEADERS += \
+                 ../../../include/PERIPHERALS/gpio.h

src/stm32f4/I2C/i2c.pro +3 0

              TEMPLATE = lib
              CONFIG += libuc2lib
              SOURCES += i2c.c
              UCMODEL=stm32f4
+             HEADERS += \
+                 ../../../include/PERIPHERALS/i2c.h

src/stm32f4/SDCARD-SDIO/sdcard-sdio.pro +3 0

              TEMPLATE = lib
              CONFIG += libuc2lib
              SOURCES += sdcard-sdio.c
              UCMODEL=stm32f4
+             HEADERS += \
+                 ../../../include/FLASH/sdcard-sdio.h

src/stm32f4/SPI/spi.pro +3 0

              TEMPLATE = lib
              CONFIG += libuc2lib
              SOURCES += spi.c
              UCMODEL=stm32f4
+             HEADERS += \
+                 ../../../include/PERIPHERALS/spi.h

src/stm32f4/UART/uart.pro +4 0

              TEMPLATE = lib
              CONFIG += libuc2lib
              SOURCES += uart.c
              UCMODEL=stm32f4
+             HEADERS += \
+                 ../../../include/PERIPHERALS/uart.h

include/24LC0X.h removed 0 -56

NO CONTENT: file was removed

include/CS43L22.h removed 0 -87

NO CONTENT: file was removed

include/N25Q128.h removed 0 -75

NO CONTENT: file was removed

include/VS10XX.h removed 0 -97

NO CONTENT: file was removed

include/adc.h removed 0 -139

NO CONTENT: file was removed

include/ads1278.h removed 0 -72

NO CONTENT: file was removed

include/blkdevice.h removed 0 -128

NO CONTENT: file was removed

include/fat32.h removed 0 -195

NO CONTENT: file was removed

include/gpio.h removed 0 -557

	1		NO CONTENT: file was removed
This diff has been collapsed as it changes many lines, (557 lines changed) Show them Hide them

include/hexviewer.h removed 0 -52

NO CONTENT: file was removed

include/i2c.h removed 0 -74

NO CONTENT: file was removed

include/ina226.h removed 0 -104

NO CONTENT: file was removed

include/libucfs.h removed 0 -78

NO CONTENT: file was removed

include/libucstrings.h removed 0 -32

NO CONTENT: file was removed

include/mbr.h removed 0 -72

NO CONTENT: file was removed

include/sdcard-sdio.h removed 0 -65

NO CONTENT: file was removed

include/sdcard-spi.h removed 0 -66

NO CONTENT: file was removed

include/sdcard.h removed 0 -106

NO CONTENT: file was removed

include/spi.h removed 0 -151

NO CONTENT: file was removed

include/uart.h removed 0 -118

NO CONTENT: file was removed

include/ucdirent.h removed 0 -134

NO CONTENT: file was removed

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages