HG_REPOSITORIES/LPP/INSTRUMENTATION/libuc2 Commit - r57:5929eacb0c63

Sync

jeandet -

r57:5929eacb0c63 dev_alexis

parent child

Context file:

r57:5929eacb0c63

Expand all files

lib/src/common/GRAPHIC/TC_CONTROLERS/STMPE811/STMPE811.c created 644 +69 0

@@ -0,0 +1,69
	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@gmail.com
	21	-------------------------------------------------------------------------------*/
	22
	23	#include <STMPE811.h>
	24
	25	int stmpe811init(STMPE811_t *dev, i2c_t i2cdev, uint8_t A0)
	26	{
	27
	28	dev->devAddress = 0x82;
	29	if(A0) dev->devAddress = 0x88;
	30	dev->i2cdev = i2cdev;
	31	return 1;
	32	}
	33
	34	int stmpe811getID(STMPE811_t *dev)
	35	{
	36	if(dev != NULL)
	37	{
	38	char DATA[2];
	39	DATA[0]=STMPE811_REGISTER_CHIP_ID;
	40	i2cwrite(dev->i2cdev,dev->devAddress,DATA,1);
	41	i2cread(dev->i2cdev,dev->devAddress,DATA,2);
	42	uint16_t val=DATA[0];
	43	val=(val<<8)+DATA[1];
	44	return val;
	45	}
	46	return -1;
	47	}
	48
	49
	50
	51
	52
	53
	54
	55
	56
	57
	58
	59
	60
	61
	62
	63
	64
	65
	66
	67
	68
	69

lib/src/common/GRAPHIC/TC_CONTROLERS/STMPE811/STMPE811.pro created 644 +4 0

@@ -0,0 +1,4
	1	TEMPLATE = subdirs
	2	CONFIG += ordered
	3
	4	SUBDIRS += ./STMPE811_STM32F4.pro

lib/src/common/GRAPHIC/TC_CONTROLERS/STMPE811/STMPE811_STM32F4.pro created 644 +28 0

@@ -0,0 +1,28
	1	TEMPLATE = lib
	2	OBJECTS_DIR = obj
	3	TARGET = STMPE811
	4
	5	SOURCES += \
	6	STMPE811.c
	7
	8	DEFINES -= __OPTIMIZED_MATH
	9
	10	INCLUDEPATH += ../../../../includes \
	11	../../../CPU/STM32F4xx_StdPeriph_Driver/inc \
	12	../../../CPU/CMSIS/Include \
	13	../../../../includes/GRAPHIC/CONTROLERS \
	14	../../../../includes/GRAPHIC/TC_CONTROLERS \
	15	../../../../includes/GRAPHIC/GUI/FONTS \
	16	../../../../includes/GRAPHIC/GUI/Widgets
	17
	18
	19	UCMODEL=stm32f4
	20
	21	target.path = $$[QT_INSTALL_LIBS]/$$UCMODEL
	22	INSTALLS += target
	23
	24	HEADERS += \
	25	../../../../includes/GRAPHIC/TC_CONTROLERS/STMPE811.h \
	26	../../../../includes/GRAPHIC/TC_CONTROLERS/genericTC_Controler.h
	27
	28

lib/src/common/GRAPHIC/TC_CONTROLERS/TC_CONTROLERS.pro created 644 +9 0

@@ -0,0 +1,9
	1	TEMPLATE = subdirs
	2	SUBDIRS += STMPE811
	3
	4
	5
	6
	7
	8
	9

lib/src/includes/GRAPHIC/TC_CONTROLERS/STMPE811.h created 644 +115 0

@@ -0,0 +1,115
	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@gmail.com
	21	-------------------------------------------------------------------------------*/
	22	#ifndef STMPE811_H
	23	#define STMPE811_H
	24	#include <stdio.h>
	25	#include <uhandle.h>
	26	#include <genericTC_Controler.h>
	27	#include <stdint.h>
	28	#include <fonts.h>
	29	#include <i2c.h>
	30
	31	typedef struct STMPE811_t
	32	{
	33	i2c_t i2cdev;
	34	uint8_t devAddress;
	35	}STMPE811_t;
	36
	37
	38	extern int stmpe811init(STMPE811_t *dev, i2c_t i2cdev, uint8_t A0);
	39	extern int stmpe811getID(STMPE811_t *dev);
	40
	41
	42
	43	#define STMPE811_REGISTER_CHIP_ID ((uint32_t) 0x0000 )
	44	#define STMPE811_REGISTER_ID_VER ((uint32_t) 0x0002 )
	45	#define STMPE811_REGISTER_SYS_CTRL1 ((uint32_t) 0x0003 )
	46	#define STMPE811_REGISTER_SYS_CTRL2 ((uint32_t) 0x0004 )
	47	#define STMPE811_REGISTER_SPI_CFG ((uint32_t) 0x0008 )
	48	#define STMPE811_REGISTER_INT_CTRL ((uint32_t) 0x0009 )
	49	#define STMPE811_REGISTER_INT_EN ((uint32_t) 0x000A )
	50	#define STMPE811_REGISTER_INT_STA ((uint32_t) 0x000B )
	51	#define STMPE811_REGISTER_GPIO_EN ((uint32_t) 0x000C )
	52	#define STMPE811_REGISTER_GPIO_INT_STA ((uint32_t) 0x000D )
	53	#define STMPE811_REGISTER_ADC_INT_EN ((uint32_t) 0x000E )
	54	#define STMPE811_REGISTER_ADC_INT_STA ((uint32_t) 0x000F )
	55	#define STMPE811_REGISTER_GPIO_SET_PIN ((uint32_t) 0x0010 )
	56	#define STMPE811_REGISTER_GPIO_CLR_PIN ((uint32_t) 0x0011 )
	57	#define STMPE811_REGISTER_GPIO_MP_STA ((uint32_t) 0x0012 )
	58	#define STMPE811_REGISTER_GPIO_DIR ((uint32_t) 0x0013 )
	59	#define STMPE811_REGISTER_GPIO_ED ((uint32_t) 0x0014 )
	60	#define STMPE811_REGISTER_GPIO_RE ((uint32_t) 0x0015 )
	61	#define STMPE811_REGISTER_GPIO_FE ((uint32_t) 0x0016 )
	62	#define STMPE811_REGISTER_GPIO_AF ((uint32_t) 0x0017 )
	63	#define STMPE811_REGISTER_ADC_CTRL1 ((uint32_t) 0x0020 )
	64	#define STMPE811_REGISTER_ADC_CTRL2 ((uint32_t) 0x0021 )
	65	#define STMPE811_REGISTER_ADC_CAPT ((uint32_t) 0x0022 )
	66	#define STMPE811_REGISTER_ADC_DATA_CH0 ((uint32_t) 0x0030 )
	67	#define STMPE811_REGISTER_ADC_DATA_CH1 ((uint32_t) 0x0032 )
	68	#define STMPE811_REGISTER_ADC_DATA_CH2 ((uint32_t) 0x0034 )
	69	#define STMPE811_REGISTER_ADC_DATA_CH3 ((uint32_t) 0x0036 )
	70	#define STMPE811_REGISTER_ADC_DATA_CH4 ((uint32_t) 0x0038 )
	71	#define STMPE811_REGISTER_ADC_DATA_CH5 ((uint32_t) 0x003A )
	72	#define STMPE811_REGISTER_ADC_DATA_CH6 ((uint32_t) 0x003C )
	73	#define STMPE811_REGISTER_ADC_DATA_CH7 ((uint32_t) 0x003E )
	74	#define STMPE811_REGISTER_TSC_CTRL ((uint32_t) 0x0040 )
	75	#define STMPE811_REGISTER_TSC_CFG ((uint32_t) 0x0041 )
	76	#define STMPE811_REGISTER_WDW_TR_X ((uint32_t) 0x0042 )
	77	#define STMPE811_REGISTER_WDW_TR_Y ((uint32_t) 0x0044 )
	78	#define STMPE811_REGISTER_WDW_BL_X ((uint32_t) 0x0046 )
	79	#define STMPE811_REGISTER_WDW_BL_Y ((uint32_t) 0x0048 )
	80	#define STMPE811_REGISTER_FIFO_TH ((uint32_t) 0x004A )
	81	#define STMPE811_REGISTER_FIFO_STA ((uint32_t) 0x004B )
	82	#define STMPE811_REGISTER_FIFO_SIZE ((uint32_t) 0x004C )
	83	#define STMPE811_REGISTER_TSC_DATA_X ((uint32_t) 0x004D )
	84	#define STMPE811_REGISTER_TSC_DATA_Y ((uint32_t) 0x004F )
	85	#define STMPE811_REGISTER_TSC_DATA_Z ((uint32_t) 0x0051 )
	86	#define STMPE811_REGISTER_TSC_DATA_XYZ ((uint32_t) 0x0052 )
	87	#define STMPE811_REGISTER_TSC_FRACTION_Z ((uint32_t) 0x0056 )
	88	#define STMPE811_REGISTER_TSC_DATA ((uint32_t) 0x0057 )
	89	#define STMPE811_REGISTER_TSC_I_DRIVE ((uint32_t) 0x0058 )
	90	#define STMPE811_REGISTER_TSC_SHIELD ((uint32_t) 0x0059 )
	91	#define STMPE811_REGISTER_TEMP_CTRL ((uint32_t) 0x0060 )
	92	#define STMPE811_REGISTER_TEMP_DATA ((uint32_t) 0x0061 )
	93	#define STMPE811_REGISTER_TEMP_TH ((uint32_t) 0x0062 )
	94
	95
	96	#endif
	97
	98
	99
	100
	101
	102
	103
	104
	105
	106
	107
	108
	109
	110
	111
	112
	113
	114
	115

lib/src/includes/GRAPHIC/TC_CONTROLERS/genericTC_Controler.h created 644 +37 0

@@ -0,0 +1,37
	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@gmail.com
	21	-------------------------------------------------------------------------------*/
	22	#ifndef GENERICTC_CONTROLER_H
	23	#define GENERICTC_CONTROLER_H
	24
	25	#include <uhandle.h>
	26	#include <stdint.h>
	27	#include <fonts.h>
	28
	29
	30
	31
	32	#endif /GENERICTC_CONTROLER_H/
	33
	34
	35
	36
	37

lib/src/stm32f4/CORE/threads.c created 644 +81 0

@@ -0,0 +1,81
	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@gmail.com
	21	-------------------------------------------------------------------------------*/
	22
	23
	24	#define __THREAD_PRIVATE__
	25	#include <thread.h>
	26
	27	/*
	28	For CM4 cf lazy Stacking and context switching form ARM
	29	List of automatically saved registers:
	30	R0
	31	R1
	32	R2
	33	R3
	34	R4
	35	R5
	36	R6
	37	R7
	38	R8
	39	R9
	40	R10
	41	R11
	42	R12
	43	R13(SP)
	44	R14(LR)
	45	R15(PC)
	46	xPSR
	47	S0 to S15 (if enabled)
	48
	49	List of registers to save:
	50	S16 to S31
	51	*/
	52
	53
	54	void __cpusavecontext(void* dataspace)
	55	{
	56
	57	}
	58
	59	void __cpurestorecontext(void* dataspace)
	60	{
	61
	62	}
	63
	64
	65
	66
	67
	68
	69
	70
	71
	72
	73
	74
	75
	76
	77
	78
	79
	80
	81

bsp/src/STM32F4Eval/bsp.c +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2011, 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
             -------------------------------------------------------------------------------*/
             #include "bsp.h"
             #include <streamdevices.h>
             #include <malloc.h>
             #include <gpio.h>
             #include <uart.h>
             #include <stdio.h>
             #include <stm32f4xx_gpio.h>
             #include <stm32f4xx_fsmc.h>
             #include <i2c.h>
             #include <core.h>
             #include <terminal.h>
             uint32_t OSC0  =8000000;
             uint32_t INTOSC =16000000;
             uint32_t RTCOSC =32768;
             uint32_t currentCpuFreq=0;
             extern streamdevice* __opnfiles__[__MAX_OPENED_FILES__];
             LCD_IF_t lcdIF0={
                 .init = &bsp_FSMC_init,
                 .writereg = &bsp_lcd0_write_reg,
                 .readreg = &bsp_lcd0_read_reg,
                 .writeGRAM = &bsp_lcd0_writeGRAM,
                 .readGRAM = &bsp_lcd0_readGRAM
             };
             LCD_t lcd0={
                 .interface = &lcdIF0,
                 .init = &ili9328init,
                 .paint = &ili9328paint,
                 .paintText = &ili9328paintText,
                 .paintFilRect = &ili9328paintFilRect,
                 .refreshenable = &ili9328refreshenable,
                 .width= 240,
                 .height = 320
             };
             terminal_t terminal0;
             volatile int16_t* lcd0_CMD=(volatile int16_t*)  (0x60000000 | 0x08000000);
             volatile int16_t* lcd0_DATA=((volatile int16_t*)(0x60000000 | 0x08000002));
             float VREF0 =(float)3.3;
             int bsp_init()
             {
                 int i=0;
                 for(i=0;i<32;i++)
                 {
                     __opnfiles__[i] = NULL;
                 }
                 bsp_GPIO_init();
                 bsp_uart_init();
                 bsp_iic_init();
                 bsp_FSMC_init();
                 bsp_GTerm_init();
                 printf("\r=====================\n\r");
                 printf(  "=====================\n\r");
                 printf(BSP);
                 printf(" initialised\n\r");
                 printf(  "=====================\n\r");
                 return 1;
             }
             void bsp_GPIO_init()
             {
                 gpio_t gpio1 = gpioopen(LED1);
                 gpio_t gpio2 = gpioopen(LED2);
                 gpio_t gpio3 = gpioopen(LED3);
                 gpiosetspeed(&gpio1,gpiohighspeed);
                 gpiosetspeed(&gpio2,gpiohighspeed);
                 gpiosetspeed(&gpio3,gpiohighspeed);
                 gpiosetdir(&gpio1,gpiooutdir);
                 gpiosetdir(&gpio2,gpiooutdir);
                 gpiosetdir(&gpio3,gpiooutdir);
             }
             void bsp_uart_init()
             {
                 //if(__opnfiles__[1]==NULL)
                 //{
                 //uart_t* uart1 = (uart_t*)malloc(sizeof(uart_t));
                 //  streamdevice* fd1 = (streamdevice*)malloc(sizeof(streamdevice));
                 // uart_t uart = uartopenandconfig(uart1,uartparitynone | uart8bits | uartonestop,115200,PA9,PA10,-1,-1);
                 //uartmkstreamdev(uart,fd1);
                 //__opnfiles__[1] = fd1;
                 //}
                 //else
                 //{
                 uartopenandconfig(0,uartparitynone | uart8bits | uartonestop,115200,PA9,PA10,-1,-1);
                 //}
             }
             /*
             D0   PD14      D1   PD15      D2   PD0      D3   PD1      D4   PE7
             D5   PE8       D6   PE9       D7   PE10     D8   PE11     D9   PE12
             D10  PE13      D11  PE14      D12  PE15     D13  PD8      D14  PD9
             D15  PD10
             A0   PF0  = RS      FSMC_NE3 PG10 CS      FSMC_NWE PD5  W/S
             FSMC_NOE PD4  RD
             */
             /*-- GPIOs Configuration -----------------------------------------------------*/
             /*
              +-------------------+--------------------+------------------+------------------+
              +                       SRAM pins assignment                                   +
              +-------------------+--------------------+------------------+------------------+
              | PD0  <-> FSMC_D2  | PE0  <-> FSMC_NBL0 | PF0  <-> FSMC_A0 | PG0 <-> FSMC_A10 |
              | PD1  <-> FSMC_D3  | PE1  <-> FSMC_NBL1 | PF1  <-> FSMC_A1 | PG1 <-> FSMC_A11 |
              | PD4  <-> FSMC_NOE | PE3  <-> FSMC_A19  | PF2  <-> FSMC_A2 | PG2 <-> FSMC_A12 |
              | PD5  <-> FSMC_NWE | PE4  <-> FSMC_A20  | PF3  <-> FSMC_A3 | PG3 <-> FSMC_A13 |
              | PD8  <-> FSMC_D13 | PE7  <-> FSMC_D4   | PF4  <-> FSMC_A4 | PG4 <-> FSMC_A14 |
              | PD9  <-> FSMC_D14 | PE8  <-> FSMC_D5   | PF5  <-> FSMC_A5 | PG5 <-> FSMC_A15 |
              | PD10 <-> FSMC_D15 | PE9  <-> FSMC_D6   | PF12 <-> FSMC_A6 | PG9 <-> FSMC_NE2 |
              | PD11 <-> FSMC_A16 | PE10 <-> FSMC_D7   | PF13 <-> FSMC_A7 |------------------+
              | PD12 <-> FSMC_A17 | PE11 <-> FSMC_D8   | PF14 <-> FSMC_A8 |
              | PD13 <-> FSMC_A18 | PE12 <-> FSMC_D9   | PF15 <-> FSMC_A9 |
              | PD14 <-> FSMC_D0  | PE13 <-> FSMC_D10  |------------------+
              | PD15 <-> FSMC_D1  | PE14 <-> FSMC_D11  |
              |                   | PE15 <-> FSMC_D12  |
              +-------------------+--------------------+
             */
             int bsp_FSMC_init()
             {
             #define GPIOGETPORT(gpio)   ((GPIO_TypeDef*)(((((uint32_t)gpio) & (uint32_t)0x0000FF00)*(uint32_t)4) + (uint32_t)GPIOA))
             #define GPIOPORTNUM(gpio)   (((uint32_t)(gpio) & (uint32_t)0x0000FF00)>>(uint32_t)8)
                 gpio_t LCD_DBxList[]={
                     PD0 ,PD1 ,PD4 ,PD5 ,PD8 ,PD9 ,PD10,PD11,PD12,PD13,PD14,PD15,
                     PE0 ,PE1 ,PE3 ,PE4 ,PE7 ,PE8 ,PE9 ,PE10,PE11,PE12,PE13,PE14,
                     PE15,PF0 ,PF1 ,PF2 ,PF3 ,PF4 ,PF5 ,PF12,PF13,PF14,PF15,PG0 ,
                     PG1 ,PG2 ,PG3 ,PG4 ,PG5 ,PG9 ,PG10
                                      };
                 for(int i=0;i<43;i++)
                 {
                     gpio_t LCD_DBx = gpioopen(LCD_DBxList[i]);
                     LCD_DBx |=  gpiohighspeed | gpioaf | gpiopushpulltype | gpionopulltype;
                     gpiosetconfig(&LCD_DBx);
                     GPIO_PinAFConfig(GPIOGETPORT(LCD_DBx), (uint8_t)(LCD_DBx & 0xF), GPIO_AF_FSMC);
                 }
                 FSMC_NORSRAMInitTypeDef  FSMC_NORSRAMInitStructure;
                 FSMC_NORSRAMTimingInitTypeDef  p;
                 /* Enable FSMC clock */
                 RCC_AHB3PeriphClockCmd(RCC_AHB3Periph_FSMC, ENABLE);
                 /*-- FSMC Configuration ------------------------------------------------------*/
                 /*----------------------- SRAM Bank 3 ----------------------------------------*/
                 /* FSMC_Bank1_NORSRAM3 configuration */
                 p.FSMC_AddressSetupTime = 1;
                 p.FSMC_AddressHoldTime = 0;
                 p.FSMC_DataSetupTime = getCpuFreq()/14545450  ;// 11;
                 p.FSMC_BusTurnAroundDuration = 0;
                 p.FSMC_CLKDivision = 0;
                 p.FSMC_DataLatency = 0;
                 p.FSMC_AccessMode = FSMC_AccessMode_A;
                 /* Color LCD configuration ------------------------------------
                    LCD configured as follow:
                       - Data/Address MUX = Disable
                       - Memory Type = SRAM
                       - Data Width = 16bit
                       - Write Operation = Enable
                       - Extended Mode = Enable
                       - Asynchronous Wait = Disable */
                 FSMC_NORSRAMInitStructure.FSMC_Bank = FSMC_Bank1_NORSRAM3;
                 FSMC_NORSRAMInitStructure.FSMC_DataAddressMux = FSMC_DataAddressMux_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_MemoryType = FSMC_MemoryType_SRAM;
                 FSMC_NORSRAMInitStructure.FSMC_MemoryDataWidth = FSMC_MemoryDataWidth_16b;
                 FSMC_NORSRAMInitStructure.FSMC_BurstAccessMode = FSMC_BurstAccessMode_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_AsynchronousWait = FSMC_AsynchronousWait_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_WaitSignalPolarity = FSMC_WaitSignalPolarity_Low;
                 FSMC_NORSRAMInitStructure.FSMC_WrapMode = FSMC_WrapMode_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_WaitSignalActive = FSMC_WaitSignalActive_BeforeWaitState;
                 FSMC_NORSRAMInitStructure.FSMC_WriteOperation = FSMC_WriteOperation_Enable;
                 FSMC_NORSRAMInitStructure.FSMC_WaitSignal = FSMC_WaitSignal_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_ExtendedMode = FSMC_ExtendedMode_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_WriteBurst = FSMC_WriteBurst_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_ReadWriteTimingStruct = &p;
                 FSMC_NORSRAMInitStructure.FSMC_WriteTimingStruct = &p;
                 FSMC_NORSRAMInit(&FSMC_NORSRAMInitStructure);
                 /* Enable FSMC NOR/SRAM Bank1 */
                 FSMC_NORSRAMCmd(FSMC_Bank1_NORSRAM3, ENABLE);
                 p.FSMC_AddressSetupTime = getCpuFreq()/50000000;
                 p.FSMC_AddressHoldTime = 0;
                 p.FSMC_DataSetupTime = getCpuFreq()/25000000;
                 p.FSMC_BusTurnAroundDuration = 1;
                 p.FSMC_CLKDivision = 0;
                 p.FSMC_DataLatency = 0;
                 p.FSMC_AccessMode = FSMC_AccessMode_A;
                 FSMC_NORSRAMInitStructure.FSMC_Bank = FSMC_Bank1_NORSRAM2;
                 FSMC_NORSRAMInitStructure.FSMC_DataAddressMux = FSMC_DataAddressMux_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_MemoryType = FSMC_MemoryType_PSRAM;
                 FSMC_NORSRAMInitStructure.FSMC_MemoryDataWidth = FSMC_MemoryDataWidth_16b;
                 FSMC_NORSRAMInitStructure.FSMC_BurstAccessMode = FSMC_BurstAccessMode_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_AsynchronousWait = FSMC_AsynchronousWait_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_WaitSignalPolarity = FSMC_WaitSignalPolarity_Low;
                 FSMC_NORSRAMInitStructure.FSMC_WrapMode = FSMC_WrapMode_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_WaitSignalActive = FSMC_WaitSignalActive_BeforeWaitState;
                 FSMC_NORSRAMInitStructure.FSMC_WriteOperation = FSMC_WriteOperation_Enable;
                 FSMC_NORSRAMInitStructure.FSMC_WaitSignal = FSMC_WaitSignal_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_ExtendedMode = FSMC_ExtendedMode_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_WriteBurst = FSMC_WriteBurst_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_ReadWriteTimingStruct = &p;
                 FSMC_NORSRAMInitStructure.FSMC_WriteTimingStruct = &p;
                 FSMC_NORSRAMInit(&FSMC_NORSRAMInitStructure);
                 /*!< Enable FSMC Bank1_SRAM2 Bank */
                 FSMC_NORSRAMCmd(FSMC_Bank1_NORSRAM2, ENABLE);
                 lcd0.init(&lcd0);
                 return 1;
             }
             void bsp_spi_init()
             {
             }
             void bsp_iic_init()
             {
-                i2copenandconfig(i2c1,0,100000,PB9,PB6);
+                i2copenandconfig(i2c1,0,10000,PB9,PB6);
             }
             void bsp_SD_init()
             {
                 gpio_t SDIO_DBxList[]={PC8 ,PC9 ,PC10 ,PC11 ,PC12,PD2};
                 for(int i=0;i<6;i++)
                 {
                     gpio_t SDIO_DBx = gpioopen(SDIO_DBxList[i]);
                     SDIO_DBx |=  gpiohighspeed | gpioaf | gpiopushpulltype | gpionopulltype;
                     gpiosetconfig(&SDIO_DBx);
                     GPIO_PinAFConfig(GPIOGETPORT(SDIO_DBx), (uint8_t)(SDIO_DBx & 0xF), GPIO_AF_SDIO);
                 }
             }
             void vs10XXclearXCS(){}
             void vs10XXsetXCS(){}
             int vs10XXDREQ()
             {
                 return 1;
             }
             void bsppowersdcard(char onoff)   //always ON
             {
             }
             char bspsdcardpresent()
             {
                 return 0;
             }
             char bspsdcardwriteprotected()
             {
                 return 0;
             }
             void bspsdcardselect(char YESNO)
             {
             }
             void bsp_lcd0_write_reg(uint32_t reg,uint32_t data)
             {
                 *lcd0_CMD=(uint16_t)reg;
                 *lcd0_DATA=(uint16_t)data;
             }
             uint32_t bsp_lcd0_read_reg(uint32_t reg)
             {
                 *lcd0_CMD=(uint16_t)reg;
                 return (uint16_t)*lcd0_DATA;
             }
             void bsp_lcd0_writeGRAM(void* buffer,uint32_t count)
             {
                 *lcd0_CMD=(uint16_t)ILI9328_REGISTER_WRITEDATATOGRAM;
                 uint16_t* castedBuff=(uint16_t*)buffer;
                 for(int i=0;i<(int)count;i++)
                 {
                     *lcd0_DATA=castedBuff[i];
                 }
             }
             void bsp_lcd0_readGRAM(void* buffer,uint32_t count)
             {
                 *lcd0_CMD=(uint16_t)ILI9328_REGISTER_WRITEDATATOGRAM;
                 uint16_t* castedBuff=(uint16_t*)buffer;
                 castedBuff[0]=*lcd0_DATA;
                 for(int i=0;i<(int)count;i++)
                 {
                     castedBuff[i]=*lcd0_DATA;
                 }
             }
             void bsp_GTerm_init()
             {
                 if(__opnfiles__[1]==NULL)
                 {
                     //uart_t* uart1 = (uart_t*)malloc(sizeof(uart_t));
                     streamdevice* fd1 = (streamdevice*)malloc(sizeof(streamdevice));
                     ili9328paintFilRect(&lcd0,0,0,240,320,0x7FFF,5,0);
                     terminal_init(&terminal0,&lcd0,&ComicSansMS_8,fd1);
                     __opnfiles__[1] = fd1;
                 }
                 else
                 {
                 }
             }

examples/BeagleSynthHelloSupMon/BeagleSynthHelloSupMon.pro +1 -1

             TEMPLATE = app
             CONFIG += cpu
             UCMODEL=stm32f4
-            DEFINES += CPUFREQ=40000000
+            DEFINES += CPUFREQ=80000000
             BSP = BEAGLESYNTH
             #BSP = SOLAR_LFR_PSU
             #BSP = STM32F4Eval
             SOURCES += \
                 main.c
             #beagleCp.target = beagleCp
             #beagleCp.commands = cd bin && scp $(QMAKE_TARGET).bin root@192.168.7.2://opt/stm32flashAje/hello.bin
             #beagleCp131.target = beagleCp131
             #beagleCp131.commands = cd bin && scp $(QMAKE_TARGET).bin root@129.104.27.131://opt/stm32flashAje/hello.bin
             #QMAKE_EXTRA_TARGETS += beagleCp beagleCp131

examples/BeagleSynthHelloSupMon/main.c +46 -6

             #include <stdio.h>
             #include <fat32.h>
             #include <gpio.h>
             #include <uart.h>
             #include <stm32f4xx.h>
             #include <math.h>
             #include <bsp.h>
             #include <i2c.h>
             #include <CS43L22.h>
             #include <ina226.h>
             #include <fonts.h>
             #include <stdlib.h>
             #include <core.h>
             #include <malloc.h>
             extern streamdevice* __opnfiles__[];
             #define LCD_COLOR_WHITE          0xFFFF
             #define LCD_COLOR_BLACK          0x0000
             #define LCD_COLOR_GREY           0xF7DE
             #define LCD_COLOR_BLUE           0x001F
             #define LCD_COLOR_BLUE2          0x051F
             #define LCD_COLOR_RED            0xF800
             #define LCD_COLOR_MAGENTA        0xF81F
             #define LCD_COLOR_GREEN          0x07E0
             #define LCD_COLOR_CYAN           0x7FFF
             #define LCD_COLOR_YELLOW         0xFFE0
             #ifndef PSU_DISABLE
             #define PSU_DISABLE LED1
             #endif
             void setUartAsStdout()
             {
                 streamdevice* fd1 = (streamdevice*)malloc(sizeof(streamdevice));
                 uart_t uart = uartopenandconfig(uart1,uartparitynone | uart8bits | uartonestop,115200,PA9,PA10,-1,-1);
                 uartmkstreamdev(uart,fd1);
                 __opnfiles__[1] = fd1;
             }
+            void printSupplyStatus(int cur5v,int cur33v,int cur15v, int volt5v, int volt33v, int volt15v)
+            {
+                char buffer[64];
+                int i=0;
+                int power5V=(cur5v*(volt5v/1000))/1000,power33V=(cur33v*(volt33v/1000))/1000,power15V=(cur15v*(volt15v/1000))/1000;
+            #define clearBuff for(i=0;i<64;i++)buffer[i]='\0'
+                ili9328paintFilRect(&lcd0,5,5,230,7*(ComicSansMS_18.Height+10)+50,LCD_COLOR_BLACK,4,LCD_COLOR_WHITE);
+                ili9328paintFilRect(&lcd0,5,7*(ComicSansMS_18.Height+10)+50,230,320 - (7*(ComicSansMS_18.Height+10)+50),LCD_COLOR_BLACK,4,LCD_COLOR_WHITE);
+                clearBuff;
+                sprintf(buffer,"%.3fV  %dmA",volt5v/1000000.0,cur5v);
+                ili9328paintText(&lcd0,buffer,10,0*(ComicSansMS_18.Height+10)+50,&ComicSansMS_18,LCD_COLOR_BLACK);
+                clearBuff;
+                sprintf(buffer,"%dmW",power5V);
+                ili9328paintText(&lcd0,buffer,10,1*(ComicSansMS_18.Height+10)+50,&ComicSansMS_18,LCD_COLOR_BLACK);
+                clearBuff;
+                sprintf(buffer,"%.3fV  %dmA",volt33v/1000000.0,cur33v);
+                ili9328paintText(&lcd0,buffer,10,2*(ComicSansMS_18.Height+10)+50,&ComicSansMS_18,LCD_COLOR_BLACK);
+                clearBuff;
+                sprintf(buffer,"%dmW",power33V);
+                ili9328paintText(&lcd0,buffer,10,3*(ComicSansMS_18.Height+10)+50,&ComicSansMS_18,LCD_COLOR_BLACK);
+                clearBuff;
+                sprintf(buffer,"%.3fV  %dmA",volt15v/1000000.0,cur15v);
+                ili9328paintText(&lcd0,buffer,10,4*(ComicSansMS_18.Height+10)+50,&ComicSansMS_18,LCD_COLOR_BLACK);
+                clearBuff;
+                sprintf(buffer,"%dmW",power15V);
+                ili9328paintText(&lcd0,buffer,10,5*(ComicSansMS_18.Height+10)+50,&ComicSansMS_18,LCD_COLOR_BLACK);
+                clearBuff;
+                sprintf(buffer,"Total = %dmW",power5V+power33V+power15V);
+                ili9328paintText(&lcd0,buffer,10,320-10-20,&ComicSansMS_18,LCD_COLOR_BLACK);
+            }
             int main()
             {
                 delay_100us(20000);
                 INA226_t ina5VSens,ina33VSens,ina15VSens;
                 gpioset(PSU_DISABLE);//enable psu!
                 setUartAsStdout();
                 //ili9328paintFilRect(&lcd0,0,0,240,320,LCD_COLOR_BLACK,1,LCD_COLOR_BLACK);
-                if(-1==ina226open(&ina33VSens,i2c2,INA226_MODE_SHUNT_VOLTAGE_CONTINUOUS|INA226_AVERAGES_16|INA226_BUS_CONV_8244us|INA226_SHUNT_CONV_8244us,0,0,15,1000000))
+                ili9328paintFilRect(&lcd0,5,5,230,310,LCD_COLOR_BLACK,4,LCD_COLOR_WHITE);
+                if(-1==ina226open(&ina33VSens,i2c2,INA226_MODE_SHUNT_VOLTAGE_CONTINUOUS|INA226_AVERAGES_16|INA226_BUS_CONV_8244us|INA226_SHUNT_CONV_8244us,0,1,15,1000000))
                 {
                     printf("Can't open 3.3V monitor\n\r");
                 }
-                if(-1==ina226open(&ina5VSens,i2c2,INA226_MODE_SHUNT_VOLTAGE_CONTINUOUS|INA226_AVERAGES_16|INA226_BUS_CONV_8244us|INA226_SHUNT_CONV_8244us,0,1,15,1000000))
+                if(-1==ina226open(&ina5VSens,i2c2,INA226_MODE_SHUNT_VOLTAGE_CONTINUOUS|INA226_AVERAGES_16|INA226_BUS_CONV_8244us|INA226_SHUNT_CONV_8244us,0,0,15,1000000))
                 {
                     printf("Can't open 5V monitor\n\r");
                 }
                 if(-1==ina226open(&ina15VSens,i2c2,INA226_MODE_SHUNT_VOLTAGE_CONTINUOUS|INA226_AVERAGES_16|INA226_BUS_CONV_8244us|INA226_SHUNT_CONV_8244us,1,0,15,1000000))
                 {
                     printf("Can't open 1.5V monitor\n\r");
                 }
-                int current5V,current33V,current15V;
+                int current5V,current33V,current15V,volt5v, volt33v, volt15v;
                 while(1)
                 {
                     current5V = ina226getCurrent(&ina5VSens);
                     current33V = ina226getCurrent(&ina33VSens);
                     current15V = ina226getCurrent(&ina15VSens);
-                    printf("%dmA\n\r",current15V/1000);
+                    volt5v  = ina226getBusVoltage(&ina5VSens);
-                    printf("%dmA\n\r",current33V/1000);
+                    volt33v = ina226getBusVoltage(&ina33VSens);
-                    printf("%dmA\n\r",current5V/1000);
+                    volt15v = ina226getBusVoltage(&ina15VSens);
+                    printf("%fV\t%dmA\n\r",volt15v/1000000.0,current15V/1000);
+                    printf("%fV\t%dmA\n\r",volt33v/1000000.0,current33V/1000);
+                    printf("%fV\t%dmA\n\r",volt5v/1000000.0,current5V/1000);
+                    printSupplyStatus(current5V/1000,current33V/1000,current15V/1000,volt5v, volt33v, volt15v);
                     delay_100us(10000);
                 }
                 printf("Exit\n\r");
                 return 0;
             }

examples/lcdTerminal/main.c +19 -6

             #include <stdio.h>
             #include <fat32.h>
             #include <gpio.h>
             #include <uart.h>
             #include <stm32f4xx.h>
             #include <math.h>
             #include <bsp.h>
             #include <i2c.h>
             #include <CS43L22.h>
+            #include <STMPE811.h>
             #include <ina226.h>
             #include <fonts.h>
             #include <stdlib.h>
             #include <core.h>
             #include <terminal.h>
             extern streamdevice* __opnfiles__[__MAX_OPENED_FILES__];
             #define LCD_COLOR_WHITE          0xFFFF
             #define LCD_COLOR_BLACK          0x0000
             #define LCD_COLOR_GREY           0xF7DE
             #define LCD_COLOR_BLUE           0x001F
             #define LCD_COLOR_BLUE2          0x051F
             #define LCD_COLOR_RED            0xF800
             #define LCD_COLOR_MAGENTA        0xF81F
             #define LCD_COLOR_GREEN          0x07E0
             #define LCD_COLOR_CYAN           0x7FFF
             #define LCD_COLOR_YELLOW         0xFFE0
             void testAudioDAC()
             {
                 CS43L22_t dac;
                 cs43l22open(&dac,i2c1,0);
                 uint8_t ID= cs43l22getID(&dac);
                 printf("dac ID = %d\n\r",ID);
             }
+            void testIOEXPender()
+            {
+                STMPE811_t ioexp1,ioexp2;
+                char data[2]={0,0};
+                i2cwrite(i2c1,0x50,data,1);
+                //i2cread(i2c1,0x88,data,2);
+            //    stmpe811init(&ioexp1,i2c1,0);
+            //    stmpe811init(&ioexp2,i2c1,1);
+            //    printf("Scan for IOEXPANDER:\n\r ID1=%d\n\rID2=%d",stmpe811getID(&ioexp1),stmpe811getID(&ioexp2));
+            }
             int main()
             {
                 delay_100us(10000);
                 uint16_t innerbuffer[16];
                 uint16_t outterbuffer[16];
                 for(int i=0;i<16;i++)innerbuffer[i]=LCD_COLOR_BLUE;
                 for(int i=0;i<16;i++)outterbuffer[i]=LCD_COLOR_RED;
                 ili9328paintFilRect(&lcd0,0,0,240,320,LCD_COLOR_CYAN,5,LCD_COLOR_BLACK);
                 streamdevice* fd1=__opnfiles__[1];
                 streamdevice fd2;
                 int i=0;
                 terminal_t terminal0,terminal1;
                 terminal_init(&terminal0,&lcd0,&ComicSansMS_18,fd1);
-                terminal_init(&terminal1,&lcd0,&ComicSansMS_18,&fd2);
+                //terminal_init(&terminal1,&lcd0,&ComicSansMS_18,&fd2);
-                terminal_setgeometry(&terminal0,5,5,terminal0.LCD->width-10,(terminal0.LCD->height/2)-10);
+                terminal_setgeometry(&terminal0,5,5,terminal0.LCD->width-10,(terminal0.LCD->height)-10);
-                terminal_setbackgroundColor(&terminal1,0xFFFF);
+                //terminal_setbackgroundColor(&terminal1,0xFFFF);
-                terminal_settextColor(&terminal1,0x0000);
+                //terminal_settextColor(&terminal1,0x0000);
-                terminal_setgeometry(&terminal1,5,(terminal0.LCD->height/2)+5,terminal0.LCD->width-10,(terminal0.LCD->height/2)-10);
+                //terminal_setgeometry(&terminal1,5,(terminal0.LCD->height/2)+5,terminal0.LCD->width-10,(terminal0.LCD->height/2)-10);
                 printf("Line cnt :\n \t%d\n",terminal0.lineCount);
                 printf("Column cnt :\n \t%d\n",terminal0.columnCount);
                 printf("CPU Freq :\n \t%dMHz\n",getCpuFreq()/1000000);
                 //testAudioDAC();
-                i2cwrite(i2c1,0x4a," ",1);
+                testIOEXPender();
                 while(1)
                 {
                     i%=1000;
                     //terminal->write(&terminal," Hi",1, 2);
                     //delay_100us(1000);
                     gpioset(LED1);
                     //delay_100us(1000);
                     gpioclr(LED1);
                 }
                 printf("hello world\n\r");
                 return 0;
             }

lib/src/common/EEPROMS/24LCXX/24LC0X/24LC0X.c +6 -6

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2011, 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
             -------------------------------------------------------------------------------*/
             #include <24LC0X.h>
             #include <i2c.h>
             #include <core.h>
             /*
             struct 24LC0X_str
             {
              i2cDev iicdev;
              unsigned char devAddress;
              unsigned char size;
             };
             */
             void eeprom24lc0xopen(eeprom24lc0xDev* dev, i2c_t iicdev, unsigned char A0_A1_A2_val, unsigned int size)
             {
             	dev->iicdev = iicdev;
             	dev->devAddress = 0x50 | (A0_A1_A2_val & 0x7);
             	if(size == 2048) dev->size = 2;
             	if(size == 1024) dev->size = 1;
             }
-            void eeprom24lc0xpagewrite(eeprom24lc0xDev dev,unsigned char address,unsigned char* page)
+            void eeprom24lc0xpagewrite(eeprom24lc0xDev* dev,unsigned char address,unsigned char* page)
             {
             	int cmdcnt=1,datacnt=8;
                 //i2cwrite(dev.iicdev,address,page)
                 //i2cwrite2(dev.iicdev,dev.devAddress,&address,&cmdcnt,page,&datacnt);
             }
-            void eeprom24lc0xpageread(eeprom24lc0xDev dev,unsigned char address,unsigned char* page)
+            void eeprom24lc0xpageread(eeprom24lc0xDev* dev,unsigned char address,unsigned char* page)
             {
             	int cmdcnt=1,datacnt=8;
                 /*i2cwrite(dev.iicdev,dev.devAddress,&address,&cmdcnt);
                 i2cread(dev.iicdev,dev.devAddress,page,&datacnt);*/
             }
-            void eeprom24lc0xbytewrite(eeprom24lc0xDev dev,unsigned char address,unsigned char data)
+            void eeprom24lc0xbytewrite(eeprom24lc0xDev* dev,unsigned char address,unsigned char data)
             {
             	int cmdcnt=1,datacnt=1;
                 //i2cwrite2(dev.iicdev,dev.devAddress,&address,&cmdcnt,&data,&datacnt);
             }
-            unsigned char eeprom24lc0xbyteread(eeprom24lc0xDev dev,unsigned char address)
+            unsigned char eeprom24lc0xbyteread(eeprom24lc0xDev* dev,unsigned char address)
             {
             	int cmdcnt=1,datacnt=1;
             	unsigned char data = 0;
             /*	i2cwrite(dev.iicdev,dev.devAddress,&address,&cmdcnt);
                 i2cread(dev.iicdev,dev.devAddress,&data,&datacnt);*/
             	return data;
             }
-            void eeprom24lc0xreadn(eeprom24lc0xDev dev,unsigned char address,unsigned char* data, unsigned int count)
+            void eeprom24lc0xreadn(eeprom24lc0xDev* dev,unsigned char address,unsigned char* data, unsigned int count)
             {
             	int cmdcnt=1,datacnt=count;
             /*	i2cwrite(dev.iicdev,dev.devAddress,&address,&cmdcnt);
                 i2cread(dev.iicdev,dev.devAddress,data,&datacnt);*/
             }
-            void eeprom24lc0xwriten(eeprom24lc0xDev dev,unsigned char address,unsigned char* data, unsigned int count)
+            void eeprom24lc0xwriten(eeprom24lc0xDev* dev,unsigned char address,unsigned char* data, unsigned int count)
             {
             	int cmdcnt=1,datacnt=8;
             	while(count >8)
             	{
             		cmdcnt=1;datacnt=8;
             //		while(i2noerr!=i2cwrite2(dev.iicdev,dev.devAddress,&address,&cmdcnt,data,&datacnt)){cmdcnt=1;datacnt=8;}
             		count-=8;
             		address+=8;
             		data+=8;
             	}
             	cmdcnt=1;datacnt=count;
             //	while(i2noerr!=i2cwrite2(dev.iicdev,dev.devAddress,&address,&cmdcnt,data,&datacnt)){cmdcnt=1;datacnt=count;}
             }

lib/src/common/EEPROMS/24LCXX/24LC0X/24LC0X.pro +2 -1

             TEMPLATE = lib
             OBJECTS_DIR = obj
             SOURCES += 24LC0X.c
-            HEADERS += ../../../includes/24LC0X.h
+            HEADERS += ../../../includes/24LC0X.h \
+                ../../../../includes/24LC0X.h
             INCLUDEPATH += ../../../includes \
                     ../../CPU/STM32F4xx_StdPeriph_Driver/inc \
                     ../../CPU/CMSIS/Include
             UCMODEL=stm32f4
             target.path = $$[QT_INSTALL_LIBS]/$$UCMODEL
             INSTALLS += target

lib/src/common/GRAPHIC/CONTROLERS/ILI9328/ili9328.c +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
             -------------------------------------------------------------------------------*/
             #include <ili9328.h>
             #include <stdio.h>
             #include <stddef.h>
             #include <core.h>
             #include <math.h>
             #ifdef __OPTIMIZED_MATH
             #include <optimised_math.h>
             #endif
             #define _delay_(del) for(volatile int _d_e_l_=0;_d_e_l_<(del);_d_e_l_++);
             #define ilipaintLine(LCD,X,Y,W,buffer,buffsize) \
                 for(int l=0;l<1;l++)\
                 {\
                  ili9328setFrame(LCD,X,Y,W,1);\
                  int rem=(W)%buffsize;\
                  if(rem)LCD->interface->writeGRAM(buffer,rem);\
                  for(int i=rem;i<(W);i+=buffsize)\
                  {\
                   LCD->interface->writeGRAM(buffer,buffsize);\
                  }\
                 }
             #define ilipaintHLineWithCont(LCD,X,Y,W,ContSz,bufferInt,buffIntsize,bufferCont,buffContsize) \
                 for(int l=0;l<1;l++)\
                 {\
                  ili9328setFrame(LCD,X,Y,W,1);\
                  int rem=(ContSz)%buffContsize;\
                  if(rem)LCD->interface->writeGRAM(bufferCont,rem);\
                  for(int i=rem;i<(ContSz);i+=buffContsize)\
                  {\
                   LCD->interface->writeGRAM(bufferCont,buffContsize);\
                  }\
                 if((2*ContSz)<W) \
                 {\
                  rem=(W-(2*ContSz))%buffIntsize;\
                  if(rem)LCD->interface->writeGRAM(bufferInt,rem);\
                  for(int i=rem;i<(W-(2*ContSz));i+=buffIntsize)\
                  {\
                   LCD->interface->writeGRAM(bufferInt,buffIntsize);\
                  }\
                 }\
                 rem=(ContSz)%buffContsize;\
                 if(rem)LCD->interface->writeGRAM(bufferCont,rem);\
                 for(int i=rem;i<(ContSz);i+=buffContsize)\
                 {\
                  LCD->interface->writeGRAM(bufferCont,buffContsize);\
                 }\
                }\
             #define ilipaintVLineWithCont(LCD,X,Y,H,ContSz,bufferInt,buffIntsize,bufferCont,buffContsize) \
                 for(int l=0;l<1;l++)\
                 {\
                  ili9328setFrame(LCD,X,Y,1,H);\
                  int rem=(ContSz)%buffContsize;\
                  if(rem)LCD->interface->writeGRAM(bufferCont,rem);\
                  for(int i=rem;i<(ContSz);i+=buffContsize)\
                  {\
                   LCD->interface->writeGRAM(bufferCont,buffContsize);\
                  }\
                 if((2*ContSz)<H) \
                 {\
                  rem=(H-(2*ContSz))%buffIntsize;\
                  if(rem)LCD->interface->writeGRAM(bufferInt,rem);\
                  for(int i=rem;i<(H-(2*ContSz));i+=buffIntsize)\
                  {\
                   LCD->interface->writeGRAM(bufferInt,buffIntsize);\
                  }\
                 }\
                 rem=(ContSz)%buffContsize;\
                 if(rem)LCD->interface->writeGRAM(bufferCont,rem);\
                 for(int i=rem;i<(ContSz);i+=buffContsize)\
                 {\
                  LCD->interface->writeGRAM(bufferCont,buffContsize);\
                 }\
                }\
             #define ilipaintHalfTopVLineWithCont(LCD,X,Y,H,ContSz,bufferInt,buffIntsize,bufferCont,buffContsize) \
                 for(int l=0;l<1;l++)\
                 {\
                  ili9328setFrame(LCD,X,Y,1,H);\
                  int rem=(ContSz)%buffContsize;\
                  if(rem)LCD->interface->writeGRAM(bufferCont,rem);\
                  for(int i=rem;i<(ContSz);i+=buffContsize)\
                  {\
                   LCD->interface->writeGRAM(bufferCont,buffContsize);\
                  }\
                 if(ContSz<H) \
                 {\
                  rem=(H-ContSz)%buffIntsize;\
                  if(rem)LCD->interface->writeGRAM(bufferInt,rem);\
                  for(int i=rem;i<(H-ContSz);i+=buffIntsize)\
                  {\
                   LCD->interface->writeGRAM(bufferInt,buffIntsize);\
                  }\
                 }\
                }\
             #define ilipaintHalfBottomVLineWithCont(LCD,X,Y,H,ContSz,bufferInt,buffIntsize,bufferCont,buffContsize) \
                 for(int l=0;l<1;l++)\
                 {\
                  ili9328setFrame(LCD,X,Y,1,H);\
                 int rem;\
                 if(ContSz<H) \
                 {\
                  rem=(H-ContSz)%buffIntsize;\
                  if(rem)LCD->interface->writeGRAM(bufferInt,rem);\
                  for(int i=rem;i<(H-ContSz);i+=buffIntsize)\
                  {\
                   LCD->interface->writeGRAM(bufferInt,buffIntsize);\
                  }\
                 }\
                 rem=(ContSz)%buffContsize;\
                 if(rem)LCD->interface->writeGRAM(bufferCont,rem);\
                 for(int i=rem;i<(ContSz);i+=buffContsize)\
                 {\
                  LCD->interface->writeGRAM(bufferCont,buffContsize);\
                 }\
                }\
             void ili9328setGRAMaddress(LCD_t* LCD,uint16_t Haddress,uint16_t Vaddress)
             {
                 LCD->interface->writereg(ILI9328_REGISTER_HORIZONTALGRAMADDRESSSET,Haddress);
                 LCD->interface->writereg(ILI9328_REGISTER_VERTICALGRAMADDRESSSET,Vaddress);
             }
             void ili9328refreshenable(struct LCD_t* LCD,int enable)
             {
                 if(enable)
                 {
                     //LCD->interface->writereg(ILI9328_REGISTER_ENTRYMODE,0x1018);
                 }
                 else
                 {
                     //LCD->interface->writereg(ILI9328_REGISTER_ENTRYMODE,0x1008);
                 }
             }
             void ili9328setFrame(LCD_t* LCD,uint16_t X,uint16_t Y,uint16_t W,uint16_t H)
             {
                 LCD->interface->writereg(ILI9328_REGISTER_HORIZONTALGRAMADDRESSSET,(uint32_t)X);
                 LCD->interface->writereg(ILI9328_REGISTER_VERTICALGRAMADDRESSSET,(uint32_t)Y);
                 LCD->interface->writereg(ILI9328_REGISTER_HORIZONTALADDRESSSTARTPOSITION,(uint32_t)X);
                 LCD->interface->writereg(ILI9328_REGISTER_HORIZONTALADDRESSENDPOSITION,(uint32_t)(W+X-1));
                 LCD->interface->writereg(ILI9328_REGISTER_VERTICALADDRESSSTARTPOSITION,(uint32_t)Y);
                 LCD->interface->writereg(ILI9328_REGISTER_VERTICALADDRESSENDPOSITION,(uint32_t)(Y+H-1));
             }
             void ili9328paint(LCD_t* LCD,void* buffer,uint16_t Xpos,uint16_t Ypos,uint16_t Width,uint16_t Height)
             {
                 if((LCD!=NULL) && (LCD->interface!=NULL) && (LCD->interface->writeGRAM!=NULL) &&  (LCD->width>(Xpos+Width)) && (LCD->height>(Ypos+Height)))
                 {
                     ili9328setFrame(LCD,Xpos,Ypos,Width,Height);
                     LCD->interface->writeGRAM(buffer,Width*Height);
                 }
             }
             void ili9328paintFilCirc(LCD_t* LCD,uint16_t Xpos,uint16_t Ypos,uint16_t r,uint32_t contColor,uint16_t contSz,uint32_t fillColor)
             {
                 //Based on the mid point circle algorithm from Wikipedia
                 //http://en.wikipedia.org/wiki/Midpoint_circle_algorithm
                 uint16_t innerbuffer[16];
                 uint16_t outterbuffer[16];
                 for(int i=0;i<16;i++)innerbuffer[i]=fillColor;
                 for(int i=0;i<16;i++)outterbuffer[i]=contColor;
                 if(contSz<r)
                 {
                     int error = -r,error_int = -r+contSz;
                     int x = r,x_int=r-contSz;
                     int y = 0,y_int=0;
                     while (x >= y)
                     {
                         ilipaintHLineWithCont(LCD,(Xpos-x),(Ypos+y),(2*x),(x-x_int),innerbuffer,16,outterbuffer,16);
                         ilipaintHLineWithCont(LCD,(Xpos-x),(Ypos-y),(2*x),(x-x_int),innerbuffer,16,outterbuffer,16);
                         ilipaintHalfTopVLineWithCont(LCD,(Xpos+y),(Ypos-x),(x),(x-x_int),innerbuffer,16,outterbuffer,16);
                         ilipaintHalfTopVLineWithCont(LCD,(Xpos-y),(Ypos-x),(x),(x-x_int),innerbuffer,16,outterbuffer,16);
                         ilipaintHalfBottomVLineWithCont(LCD,(Xpos-y),(Ypos),(x),(x-x_int),innerbuffer,16,outterbuffer,16);
                         ilipaintHalfBottomVLineWithCont(LCD,(Xpos+y),(Ypos),(x),(x-x_int),innerbuffer,16,outterbuffer,16);
                         error += y;
                         ++y;
                         error += y;
                         error_int += y_int;
                         ++y_int;
                         error_int += y_int;
                         if(error >= 0)
                         {
                             error -= x;
                             --x;
                             error -= x;
                         }
                         if(error_int >= 0)
                         {
                             error_int -= x_int;
                             --x_int;
                             error_int -= x_int;
                         }
                     }
                 }
             }
             void ili9328paintFilCirc_old(LCD_t* LCD,uint16_t Xpos,uint16_t Ypos,uint16_t r,uint32_t contColor,uint16_t contSz,uint32_t fillColor)
             {
                 if(contSz<r)
                 {
                     uint16_t innerbuffer[16];
                     uint16_t outterbuffer[16];
                     int32_t rr=(r*r),rr2=((r-contSz)*(r-contSz)),contSz2,Val1,Val2,X1,W,rem;
                     for(int i=0;i<16;i++)innerbuffer[i]=fillColor;
                     for(int i=0;i<16;i++)outterbuffer[i]=contColor;
                     /* Y = b +/- sqrt[r^2 - (x - a)^2] */
                     for(int32_t line=-r;line<r;line++)
                     {
             #ifdef __OPTIMIZED_MATH
                         Val1 = (uint32_t)optimised_sqrt((float32_t)(rr - (line*line)) );
                         Val2 = (uint32_t)optimised_sqrt((float32_t)(rr2 - (line*line)) );
             #else
                         Val1 = sqrt(  (double)(rr - ((line)*(line))) );
                         Val2 = sqrt(  (double)(rr2 - ((line)*(line))) );
             #endif
                         X1=Xpos - Val1;
                         contSz2= Val1-Val2;
                         ili9328setFrame(LCD,X1,line+Ypos,2*Val1,1);
                         rem=(contSz2)%16;
                         if(rem)LCD->interface->writeGRAM(outterbuffer,rem);
                         for(int i=rem;i<(contSz2);i+=16)
                         {
                             LCD->interface->writeGRAM(outterbuffer,16);
                         }
                         W=2*Val1;
                         if(W>(2*contSz2))
                         {
                             W-=2*contSz2;
                             rem=(W)%16;
                             if(rem)LCD->interface->writeGRAM(innerbuffer,rem);
                             for(int i=rem;i<(W);i+=16)
                             {
                                 LCD->interface->writeGRAM(innerbuffer,16);
                             }
                         }
                         rem=(contSz2)%16;
                         if(rem)LCD->interface->writeGRAM(outterbuffer,rem);
                         for(int i=rem;i<(contSz2);i+=16)
                         {
                             LCD->interface->writeGRAM(outterbuffer,16);
                         }
                     }
                 }
             }
             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)
             {
                 ili9328setFrame(LCD,Xpos,Ypos,w,h);
                 uint16_t tmp[32];
                 for(int i=0;i<32;i++)tmp[i]=fillColor;
                 for(int i=0;i<(h*w);i+=32)
                 {
                     LCD->interface->writeGRAM(tmp,32);
                 }
                 int rem=(w*h)%32;
                 if(rem)LCD->interface->writeGRAM(tmp,rem);
                 if(contSz)
                 {
                     ili9328setFrame(LCD,Xpos,Ypos,w,contSz);
                     for(int i=0;i<32;i++)tmp[i]=contColor;
                     rem=(w*contSz)%32;
                     if(rem)LCD->interface->writeGRAM(tmp,rem);
                     for(int i=rem;i<(w*contSz);i+=32)
                     {
                         LCD->interface->writeGRAM(tmp,32);
                     }
                     ili9328setFrame(LCD,Xpos,Ypos+h-contSz,w,contSz);
                     rem=(w*contSz)%32;
                     if(rem)LCD->interface->writeGRAM(tmp,rem);
                     for(int i=rem;i<(w*contSz);i+=32)
                     {
                         LCD->interface->writeGRAM(tmp,32);
                     }
                     ili9328setFrame(LCD,Xpos,Ypos,contSz,h);
                     rem=(h*contSz)%32;
                     if(rem)LCD->interface->writeGRAM(tmp,rem);
                     for(int i=rem;i<(h*contSz);i+=32)
                     {
                         LCD->interface->writeGRAM(tmp,32);
                     }
                     ili9328setFrame(LCD,Xpos+w-contSz,Ypos,contSz,h);
                     rem=(h*contSz)%32;
                     if(rem)LCD->interface->writeGRAM(tmp,rem);
                     for(int i=rem;i<(h*contSz);i+=32)
                     {
                         LCD->interface->writeGRAM(tmp,32);
                     }
                 }
             }
             void ili9328paintText(LCD_t* LCD,char* buffer,uint16_t Xpos,uint16_t Ypos,sFONT* font,uint32_t color)
             {
                 int w=font->Width,h=font->Height,bpl=font->bytesPerLine,pix=0,tableoffset=0;
                 uint16_t tmp[w];
                 uint16_t linenum=0,charnum=0;
                 uint8_t line=0;
-                while(*buffer)
+                while(*buffer!='\0')
                 {
                     ili9328setFrame(LCD,Xpos+(charnum*w),Ypos-h,w,1);
                     LCD->interface->readGRAM(tmp,w);
                     for(int i=0;i<(h*w);i++)
                     {
                         if( ((i%w)==0) ) //read current line to apply text pixmap
                         {
                             if(linenum++>0)
                             {
                                 ili9328setFrame(LCD,Xpos+(charnum*w),Ypos + linenum -h,w,1);
                                 LCD->interface->writeGRAM(tmp,w);
                                 ili9328setFrame(LCD,Xpos+(charnum*w),Ypos + linenum + 1-h,w,1);
                                 LCD->interface->readGRAM(tmp,w);
                                 pix=0;
                             }
                         }
                         if((pix%8) == 0)
                         {
                             line=font->table[(((*buffer)-32)*h*bpl)+tableoffset++];
                         }
                         if((line & (uint8_t)0x01)==(uint8_t)1)tmp[pix]=(uint16_t)color;
                         pix++;
                         line>>=1;
                     }
                     linenum=0;
                     tableoffset=0;
                     charnum++;
                     buffer++;
                 }
             }
             int ili9328init(struct LCD_t* LCD)
             {
                 if((LCD!=NULL) && (LCD->interface!=NULL) && (LCD->interface->writereg!=NULL))
                 {
                     LCD->interface->writereg(ILI9328_REGISTER_DRIVEROUTPUTCONTROL1, 0x0100);  // Driver Output Control Register (R01h)
                     LCD->interface->writereg(ILI9328_REGISTER_LCDDRIVINGCONTROL, 0x0700);     // LCD Driving Waveform Control (R02h)
                     LCD->interface->writereg(ILI9328_REGISTER_ENTRYMODE, 0x1030);             // Entry Mode (R03h)
                     LCD->interface->writereg(ILI9328_REGISTER_DISPLAYCONTROL2, 0x0202);
                     LCD->interface->writereg(ILI9328_REGISTER_DISPLAYCONTROL3, 0x0000);
                     LCD->interface->writereg(ILI9328_REGISTER_DISPLAYCONTROL4, 0x0000);       // Fmark On
                     LCD->interface->writereg(ILI9328_REGISTER_POWERCONTROL1, 0x0000);         // Power Control 1 (R10h)
                     LCD->interface->writereg(ILI9328_REGISTER_POWERCONTROL2, 0x0007);         // Power Control 2 (R11h)
                     LCD->interface->writereg(ILI9328_REGISTER_POWERCONTROL3, 0x0000);         // Power Control 3 (R12h)
                     LCD->interface->writereg(ILI9328_REGISTER_POWERCONTROL4, 0x0000);         // Power Control 4 (R13h)
                     delay_100us(10);
                     LCD->interface->writereg(ILI9328_REGISTER_POWERCONTROL1, 0x14B0);         // Power Control 1 (R10h)
                     delay_100us(10);
                     LCD->interface->writereg(ILI9328_REGISTER_POWERCONTROL2, 0x0007);         // Power Control 2 (R11h)
                     delay_100us(10);
                     LCD->interface->writereg(ILI9328_REGISTER_POWERCONTROL3, 0x008E);         // Power Control 3 (R12h)
                     LCD->interface->writereg(ILI9328_REGISTER_POWERCONTROL4, 0x0C00);         // Power Control 4 (R13h)
                     LCD->interface->writereg(ILI9328_REGISTER_POWERCONTROL7, 0x0015);         // NVM read data 2 (R29h)
                     delay_100us(500);
                     LCD->interface->writereg(ILI9328_REGISTER_GAMMACONTROL1, 0x0000);         // Gamma Control 1
                     LCD->interface->writereg(ILI9328_REGISTER_GAMMACONTROL2, 0x0107);         // Gamma Control 2
                     LCD->interface->writereg(ILI9328_REGISTER_GAMMACONTROL3, 0x0000);         // Gamma Control 3
                     LCD->interface->writereg(ILI9328_REGISTER_GAMMACONTROL4, 0x0203);         // Gamma Control 4
                     LCD->interface->writereg(ILI9328_REGISTER_GAMMACONTROL5, 0x0402);         // Gamma Control 5
                     LCD->interface->writereg(ILI9328_REGISTER_GAMMACONTROL6, 0x0000);         // Gamma Control 6
                     LCD->interface->writereg(ILI9328_REGISTER_GAMMACONTROL7, 0x0207);         // Gamma Control 7
                     LCD->interface->writereg(ILI9328_REGISTER_GAMMACONTROL8, 0x0000);         // Gamma Control 8
                     LCD->interface->writereg(ILI9328_REGISTER_GAMMACONTROL9, 0x0203);         // Gamma Control 9
                     LCD->interface->writereg(ILI9328_REGISTER_GAMMACONTROL10, 0x0403);        // Gamma Control 10
                     LCD->interface->writereg(ILI9328_REGISTER_HORIZONTALADDRESSSTARTPOSITION, 0x0000);                      // Window Horizontal RAM Address Start (R50h)
                     LCD->interface->writereg(ILI9328_REGISTER_HORIZONTALADDRESSENDPOSITION, 240 - 1);   // Window Horizontal RAM Address End (R51h)
                     LCD->interface->writereg(ILI9328_REGISTER_VERTICALADDRESSSTARTPOSITION, 0X0000);                        // Window Vertical RAM Address Start (R52h)
                     LCD->interface->writereg(ILI9328_REGISTER_VERTICALADDRESSENDPOSITION, 320 - 1);    // Window Vertical RAM Address End (R53h)
                     LCD->interface->writereg(ILI9328_REGISTER_DRIVEROUTPUTCONTROL2, 0xa700);    // Driver Output Control (R60h)
                     LCD->interface->writereg(ILI9328_REGISTER_BASEIMAGEDISPLAYCONTROL, 0x0003); // Driver Output Control (R61h) - enable VLE
                     LCD->interface->writereg(ILI9328_REGISTER_PANELINTERFACECONTROL1, 0X0010);  // Panel Interface Control 1 (R90h)
                     // Display On
                     LCD->interface->writereg(ILI9328_REGISTER_DISPLAYCONTROL1, 0x0133);     // Display Control (R07h)
                     delay_100us(500);
                     LCD->interface->writereg(ILI9328_REGISTER_ENTRYMODE, 0x0038);
                 }
                 return 0;
             }

lib/src/common/GRAPHIC/GRAPHIC.pro +1 0

             TEMPLATE = subdirs
             SUBDIRS += 	CONTROLERS \
+            		TC_CONTROLERS \
                             GUI

lib/src/common/Threading/Threading.pro +7 0

             TEMPLATE = lib
             OBJECTS_DIR = obj
             SOURCES += thread.c
             INCLUDEPATH += ../../includes \
             	../CPU/STM32F4xx_StdPeriph_Driver/inc \
             	../CPU/CMSIS/Include
             UCMODEL=stm32f4
             target.path = $$[QT_INSTALL_LIBS]/$$UCMODEL
             INSTALLS += target
+            HEADERS += \
+                ../../includes/thread.h

lib/src/includes/24LC0X.h +6 -6

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2011, 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 B24LC0X_H
             #define B24LC0X_H
             #include <i2c.h>
             #include <uhandle.h>
             typedef struct eeprom24lc0xDev
             {
              i2c_t iicdev;
              unsigned char devAddress;
              unsigned char size;
             }eeprom24lc0xDev;
             extern void eeprom24lc0xopen(eeprom24lc0xDev* dev,i2c_t iicdev,unsigned char A0_A1_A2_val,unsigned int size);
-            extern void eeprom24lc0xpagewrite(eeprom24lc0xDev dev,unsigned char address,unsigned char* page);
+            extern void eeprom24lc0xpagewrite(eeprom24lc0xDev* dev,unsigned char address,unsigned char* page);
-            extern void eeprom24lc0xpageread(eeprom24lc0xDev dev,unsigned char address,unsigned char* page);
+            extern void eeprom24lc0xpageread(eeprom24lc0xDev* dev,unsigned char address,unsigned char* page);
-            extern void eeprom24lc0xbytewrite(eeprom24lc0xDev dev,unsigned char address,unsigned char data);
+            extern void eeprom24lc0xbytewrite(eeprom24lc0xDev* dev,unsigned char address,unsigned char data);
-            extern unsigned char eeprom24lc0xbyteread(eeprom24lc0xDev dev,unsigned char address);
+            extern unsigned char eeprom24lc0xbyteread(eeprom24lc0xDev* dev,unsigned char address);
-            extern void eeprom24lc0xreadn(eeprom24lc0xDev dev,unsigned char address,unsigned char* data, unsigned int count);
+            extern void eeprom24lc0xreadn(eeprom24lc0xDev* dev,unsigned char address,unsigned char* data, unsigned int count);
-            extern void eeprom24lc0xwriten(eeprom24lc0xDev dev,unsigned char address,unsigned char* data, unsigned int count);
+            extern void eeprom24lc0xwriten(eeprom24lc0xDev* dev,unsigned char address,unsigned char* data, unsigned int count);
             #endif

lib/src/includes/thread.h +15 -6

             /*------------------------------------------------------------------------------
             --  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 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__;
+                void* __programmCounter__;
-                int __stackPointer__;
+                void* __registers__;
-                int __programcounter__;
             }thread_t;
-            int threadcreate(thread_t* thread,void* stack,int stackSize);
+            extern int threadcreate(thread_t* thread,void* stack,int stackSize);
-            int threadstart(thread_t* thread);
+            extern int threadstart(thread_t* thread);
-            int threadstop(thread_t* thread);
+            extern int threadstop(thread_t* thread);
+            #ifdef __THREAD_PRIVATE__
+            extern void __cpusavecontext(void* dataspace);
+            extern void __cpurestorecontext(void* dataspace);
+            #endif
             #ifdef __cplusplus
             }
             #endif
             #endif //THREAD_H

lib/src/lib.pro +1 0

             TEMPLATE = subdirs
             CONFIG   += ordered
             SUBDIRS +=  stm32f4
             SUBDIRS += common
             headers.files = includes/*.h \
             		includes/GRAPHIC/CONTROLERS/*.h \
+            		includes/GRAPHIC/TC_CONTROLERS/*.h \
             		includes/GRAPHIC/GUI/FONTS/*.h \
             		includes/GRAPHIC/GUI/Widgets/*.h
             headers.path = $$[QT_INSTALL_HEADERS]
             INSTALLS += headers

lib/src/stm32f4/CORE/core.pro +2 -1

             TEMPLATE = lib
             OBJECTS_DIR = obj
             SOURCES += \
-                core.c
+                core.c \
+                threads.c
             INCLUDEPATH += ../../includes \
             	../CPU/STM32F4xx_StdPeriph_Driver/inc \
             	../CPU/CMSIS/Include
             UCMODEL=stm32f4
             target.path = $$[QT_INSTALL_LIBS]/$$UCMODEL
             INSTALLS += target

lib/src/stm32f4/I2C/i2c.c 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@gmail.com
             -------------------------------------------------------------------------------*/
             #include <i2c.h>
             #include <stm32f4xx_usart.h>
             #include <stm32f4xx_rcc.h>
             #include <stm32f4xx_gpio.h>
             #include <gpio.h>
             #include <core.h>
             #define GPIOGETPORT(gpio)   ((GPIO_TypeDef*)(((((uint32_t)gpio) & (uint32_t)0x0000FF00)*(uint32_t)4) + (uint32_t)GPIOA))
             #define GPIOPORTNUM(gpio)   (((uint32_t)(gpio) & (uint32_t)0x0000FF00)>>(uint32_t)8)
             int i2ctimeout=1000*1000;
             I2C_TypeDef* _i2c_dev_table[3]={I2C1,I2C2,I2C3};
             i2c_t i2copen(int count)
             {
             #define _INIT_DEV(_RCC_) \
                 RCC_APB1PeriphClockCmd(_RCC_, ENABLE); \
                 RCC_APB1PeriphResetCmd(_RCC_, ENABLE); \
                 RCC_APB1PeriphResetCmd(_RCC_, DISABLE);
                 switch(count)
                 {
                 case i2c1:
                     _INIT_DEV(RCC_APB1Periph_I2C1);
                     return i2c1;
                     break;
                 case i2c2:
                     _INIT_DEV(RCC_APB1Periph_I2C2);
                     return i2c2;
                     break;
                 case i2c3:
                     _INIT_DEV(RCC_APB1Periph_I2C3);
                     return i2c3;
                     break;
                 default:
                     break;
                 }
                 return -1;
             }
             i2c_t i2copenandconfig(int count,uint32_t cfg,uint32_t speed,uint32_t SDA,uint32_t SCL)
             {
                 i2c_t dev = i2copen(count);
                 if(dev!=-1)
                 {
                     i2cclose(dev);
                     i2csetpins(dev,SDA,SCL);
                     i2copen(count);
-                    //i2cenable(count);
-                    //I2C_TypeDef* _dev_ = _i2c_dev_table[(int)dev];
                     i2csetspeed(dev,speed);
                     i2cenable(count);
                 }
                 return dev;
             }
             int i2cclose(i2c_t dev)
             {
                 switch(dev)
                 {
                 case i2c1:
                     RCC_APB1PeriphResetCmd(RCC_APB1Periph_I2C1, ENABLE);
                     break;
                 case i2c2:
                     RCC_APB1PeriphResetCmd(RCC_APB1Periph_I2C2, ENABLE);
                     break;
                 case i2c3:
                     RCC_APB1PeriphResetCmd(RCC_APB1Periph_I2C3, ENABLE);
                     break;
                 default:
                     break;
                 }
                 return 1;
             }
             int i2csetpins(i2c_t dev, uint32_t SDA, uint32_t SCL)
             {
                 if((dev<i2c4)&&(dev>=i2c1))
                 {
                     gpio_t SDApin,SCLpin;
                     SDApin = gpioopen(SDA);
                     SCLpin = gpioopen(SCL);
                     SDApin |= gpiolowspeed | gpioaf | gpioopendraintype | gpionopulltype;
                     SCLpin |= gpiolowspeed | gpiooutdir | gpioopendraintype | gpionopulltype;
                     gpiosetconfig(&SCLpin);
                     for(int i=0;i<32;i++)
                     {
                         gpioclr(SCLpin);
                         for(int l=0;l<200;l++)
                         {__asm__("nop");}
                         gpioset(SCLpin);
                         for(int l=0;l<200;l++)
                         {__asm__("nop");}
                     }
                     SCLpin = gpioopen(SCL);
                     SCLpin |= gpiolowspeed | gpioaf | gpioopendraintype | gpionopulltype;
                     gpiosetconfig(&SDApin);
                     gpiosetconfig(&SCLpin);
                     uint8_t gpioAFi2cx = GPIO_AF_I2C1;
                     switch(dev)
                     {
                     case i2c1:
                         gpioAFi2cx = GPIO_AF_I2C1;
                         break;
                     case i2c2:
                         gpioAFi2cx = GPIO_AF_I2C2;
                         break;
                     case i2c3:
                         gpioAFi2cx = GPIO_AF_I2C3;
                         break;
                     default:
                         break;
                     }
                     GPIO_PinAFConfig(GPIOGETPORT(SDApin), (uint8_t)(SDApin & 0xF), gpioAFi2cx);
                     GPIO_PinAFConfig(GPIOGETPORT(SCLpin), (uint8_t)(SCLpin & 0xF), gpioAFi2cx);
                     return 0;
                 }
                 return -1;
             }
             int i2cenable(i2c_t dev)
             {
                 if((dev<i2c4)&&(dev>=i2c1))
                 {
                     I2C_TypeDef* _dev_ = _i2c_dev_table[(int)dev];
                     _dev_->CR1 |=1 ;
                     return 0;
                 }
                 return -1;
             }
             int i2cdisable(i2c_t dev)
             {
                 if((dev<i2c4)&&(dev>=i2c1))
                 {
                     I2C_TypeDef* _dev_ = _i2c_dev_table[(int)dev];
                     _dev_->CR1 &= ~1;
                     return 0;
                 }
                 return -1;
             }
             int i2csetspeed(i2c_t dev,uint32_t speed)
             {
                 if((dev<i2c4)&&(dev>=i2c1))
                 {
                     I2C_TypeDef* _dev_ = _i2c_dev_table[(int)dev];
                     int32_t APB1Freq=getAPB1Freq()/1000000;
                     if((APB1Freq>1)&&(APB1Freq<43))
                     {
                         uint16_t tmpreg=_dev_->CR2;
                         tmpreg &= ~(0x1f);
                         tmpreg |= APB1Freq;
                         _dev_->CR2=tmpreg;
                         i2cdisable(dev);
                         tmpreg=_dev_->CCR;
                         APB1Freq=getAPB1Freq();
                         if(speed>100000) //100kHz= standard mode, 400kHz= fast mode
                         {
                             if(speed<=400000)
                             {
                                 tmpreg |= 1<<15;
                                 tmpreg &= ~(1<<14);
                                 tmpreg &= ~(0xfff);
                                 tmpreg |= 0xfff & (APB1Freq/(3*speed));
                             }
                         }
                         else
                         {
                             tmpreg &= ~(1<<15);
                             tmpreg &= ~(0xfff);
                             tmpreg |= 0xfff & (APB1Freq/(2*speed));
                         }
                         _dev_->CCR=tmpreg;
                         tmpreg=_dev_->TRISE;
                         tmpreg &= ~(0x3f);
                         tmpreg |= (APB1Freq/1000000)+1;
                         _dev_->TRISE = tmpreg;
                         i2cenable(dev);
                         return 0;
                     }
                 }
                 return -1;
             }
             int i2cbusy(i2c_t dev)
             {
                 if((dev<i2c4)&&(dev>=i2c1))
                 {
                     I2C_TypeDef* _dev_ = _i2c_dev_table[(int)dev];
                     if((_dev_->SR2 & 2) ==2) return 1;  /* Dev is busy */
                     return 0;                           /* Dev isn't busy */
                 }
                 return -1;                              /* Error, dev is out of range */
             }
             int i2cwrite(i2c_t dev,char address,char* data,int count)
             {
                 if((dev<i2c4)&&(dev>=i2c1))
                 {
                     int timeout=i2ctimeout;
                     I2C_TypeDef* _dev_ = _i2c_dev_table[(int)dev];
                     while(i2cbusy(dev))
                     {
                         if(0==(timeout--))
                         {
                             printf("Exited on timeout @ line %d\n\r",__LINE__);
                             return -1;
                         }
                     }
                     _dev_->CR1 |= 1<<8;
                     timeout=i2ctimeout;
                     while(!i2cStatusCheck(dev,((uint32_t)0x00030001)))
                     {
                         if(0==(timeout--))
                         {
                             printf("Exited on timeout @ line %d\n\r",__LINE__);
                             return -1;
                         }
                     }
                     _dev_->DR= address<<1;
                     timeout=i2ctimeout;
                     while(!i2cStatusCheck(dev, ((uint32_t)0x00070082)))
                     {
                         if(0==(timeout--))
                         {
                             printf("Exited on timeout @ line %d\n\r",__LINE__);
                             return -1;
                         }
                     }
                     address=_dev_->SR2;
                     for(int i=0;i<count;i++)
                     {
                         timeout=i2ctimeout;
                         while(!i2cStatusCheck(dev,((uint32_t)0x00070080)))
                         {
                             if(0==(timeout--))
                             {
                                 printf("Exited on timeout @ line %d\n\r",__LINE__);
                                 return -1;
                             }
                         }
                         _dev_->DR= data[i];
                     }
                     timeout=i2ctimeout;
                     while(!i2cStatusCheck(dev,1<<7))
                     {
                         if(0==(timeout--))
                         {
                             printf("Exited on timeout @ line %d\n\r",__LINE__);
                             return -1;
                         }
                     }
                     timeout=i2ctimeout;
                     while(!i2cStatusCheck(dev,1<<2))
                     {
                         if(0==(timeout--))
                         {
                             printf("Exited on timeout @ line %d\n\r",__LINE__);
                             return -1;
                         }
                     }
                     _dev_->CR1 |= 1<<9;
                     return count;
                 }
                 return -1;
             }
             int i2cread(i2c_t dev,char address,char* data,int count)
             {
                 if((dev<i2c4)&&(dev>=i2c1))
                 {
                     int i=0;
                     int timeout=i2ctimeout;
                     while(i2cbusy(dev))
                     {
                         if(0==(timeout--))
                         {
                             printf("Exited on timeout @ line %d\n\r",__LINE__);
                             return -1;
                         }
                     }
                     I2C_TypeDef* _dev_ = _i2c_dev_table[(int)dev];
                     _dev_->CR1 |= (1<<8) + (1<<10);
                     timeout=i2ctimeout;
                     while(!i2cStatusCheck(dev,0x00030001))
                     {
                         if(0==(timeout--))
                         {
                             printf("Exited on timeout @ line %d\n\r",__LINE__);
                             return -1;
                         }
                     }
                     _dev_->DR= (address<<1) + 1;
                     while(!i2cStatusCheck(dev,0x000002))
                     {
                         if(0==(timeout--))
                         {
                             printf("Exited on timeout @ line %d\n\r",__LINE__);
                             return -1;
                         }
                     }
                     if(count==1)
                     {
                         _dev_->CR1 &= ~(1<<10);
                     }
                     address=_dev_->SR2;
                     for(i=0;i<(count-1);i++)
                     {
                         timeout=i2ctimeout;
                         while(!i2cStatusCheck(dev,0x0000040))
                         {
                             if(0==(timeout--))
                             {
                                 printf("Exited on timeout @ line %d\n\r",__LINE__);
                                 return -1;
                             }
                         }
                         data[i]=_dev_->DR;
                     }
                     _dev_->CR1 &= ~(1<<10);
                     _dev_->CR1 |= 1<<9;
                     timeout=i2ctimeout;
                     while(!i2cStatusCheck(dev,0x0000040))
                     {
                         if(0==(timeout--))
                         {
                             printf("Exited on timeout @ line %d\n\r",__LINE__);
                             return -1;
                         }
                     }
                     data[i]=_dev_->DR;
                     timeout=i2ctimeout;
                     while(_dev_->CR1 & ((uint16_t)0x0200))
                     {
                         if(0==(timeout--))
                         {
                             printf("Exited on timeout @ line %d\n\r",__LINE__);
                             return -1;
                         }
                     }
                     _dev_->CR1 |= 1<<10;
                     return count;
                 }
                 return -1;
             }
             int i2cStatusCheck(i2c_t dev,int32_t flagMask)
             {
                 int32_t flag;
                 if((dev<i2c4)&&(dev>=i2c1))
                 {
                     I2C_TypeDef* _dev_ = _i2c_dev_table[(int)dev];
                     flag= _dev_->SR1 + (_dev_->SR2<<16);
                     if(flagMask==(flag & flagMask))
                         return 1;
                     return 0;
                 }
                 return -1;
             }

mkspecs/common/libuc2libs.conf +2 -1

             INCLUDEPATH += $$[QT_INSTALL_HEADERS] \
                            $$[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]/$$ARCH
-            LIBS += -L$$[QT_INSTALL_LIBS]/$$ARCH  -lterminal -lCS43L22 -lina226 -lili9328 -lfonts -lsdcard -lfat32 -lmbr -luart -li2c -lgpio -lspi -lcpu -lcore -lm
+            LIBS += -L$$[QT_INSTALL_LIBS]/$$ARCH  -lterminal -lCS43L22 -lina226 -lili9328 -lSTMPE811 -lfonts -lsdcard -lfat32 -lmbr -luart -li2c -lgpio -lspi -lcpu -lcore -lm

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