HG_REPOSITORIES/LPP/INSTRUMENTATION/libuc2 Commit - r63:68dfbccdd813

Added Simulator target to run code on x86 and debug functions....

jeandet -

r63:68dfbccdd813 dev_alexis

parent child

Context file:

r63:68dfbccdd813

Expand all files

bsp/src/SIMULATOR/SIMULATOR.pro created 644 +19 0

@@ -0,0 +1,19
	1	TEMPLATE = lib
	2
	3	TARGET=bsp
	4
	5
	6
	7	BSP = SIMULATOR
	8
	9	UCMODEL=simulator
	10
	11	SOURCES += bsp.c
	12
	13	HEADERS += bsp.h
	14
	15
	16	BSPFILE = bsp.pri
	17
	18
	19

bsp/src/SIMULATOR/bsp.c created 644 +282 0

@@ -0,0 +1,282
	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	#include "bsp.h"
	23	#include <streamdevices.h>
	24	#include <malloc.h>
	25	#include <stdio.h>
	26
	27
	28	uint32_t OSC0 =8000000;
	29	uint32_t INTOSC =16000000;
	30	uint32_t RTCOSC =32768;
	31	uint32_t currentCpuFreq=0;
	32	extern streamdevice* __opnfiles__[__MAX_OPENED_FILES__];
	33
	34
	35	LCD_IF_t lcdIF0={
	36	.init = &SDLCD_init,
	37	.writereg = &SDLCD_writereg,
	38	.readreg = &SDLCD_readreg,
	39	.writeGRAM = &SDLCD_writeGRAM,
	40	.readGRAM = &SDLCD_readGRAM
	41	};
	42
	43	LCD_t lcd0={
	44	.interface = &lcdIF0,
	45	.init = &ili9328init,
	46	.paint = &ili9328paint,
	47	.paintText = &ili9328paintText,
	48	.paintFilRect = &ili9328paintFilRect,
	49	.refreshenable = &ili9328refreshenable,
	50	.width= 240,
	51	.height = 320
	52	};
	53
	54	terminal_t terminal0;
	55
	56	volatile int8_t* lcd0_CMD=(volatile int8_t*) 0x60000000;
	57	volatile int8_t* lcd0_DATA=(volatile int8_t*)(0x61FFFFF0);
	58
	59	float VREF0 =(float)3.3;
	60	volatile vs10XXDev audioCodec0;
	61
	62	sdcardDev sdcard2;
	63	blkdevice sdcard2blkdev;
	64	dikpartition sdcard2Part1;
	65	FAT32fs sdcard2FAT32part1;
	66	dikpartition sdcard2Part2;
	67	FAT32fs sdcard2FAT32part2;
	68	dikpartition sdcard2Part3;
	69	FAT32fs sdcard2FAT32part3;
	70	dikpartition sdcard2Part4;
	71	FAT32fs sdcard2FAT32part4;
	72
	73	int bsp_init()
	74	{
	75	int i=0;
	76	for(i=0;i<__MAX_OPENED_FILES__;i++)
	77	{
	78	__opnfiles__[i] = NULL;
	79	}
	80	bsp_GPIO_init();
	81	bsp_uart_init();
	82	bsp_iic_init();
	83	bsp_FSMC_init();
	84	bsp_GTerm_init();
	85	bsp_spi_init();
	86	bsp_SD_init();
	87	bsp_Audio_init();
	88	printf("\r=====================\n\r");
	89	printf( "=====================\n\r");
	90	printf(BSP);
	91	printf(" initialised\n\r");
	92	printf( "=====================\n\r");
	93	return 1;
	94	}
	95
	96	void bsp_GPIO_init()
	97	{
	98
	99	}
	100
	101	void bsp_uart_init()
	102	{
	103
	104	}
	105
	106	/*
	107	D0 PD14 D1 PD15 D2 PD0 D3 PD1 D4 PE7
	108	D5 PE8 D6 PE9 D7 PE10
	109	A20 PE4 = RS FSMC_NE1 PD7 CS FSMC_NWE PD5 W/S
	110	FSMC_NOE PD4 RD
	111	*/
	112
	113	int bsp_FSMC_init()
	114	{
	115
	116	return 1;
	117	}
	118
	119	void bsp_spi_init()
	120	{
	121
	122	}
	123
	124
	125	void bsp_iic_init()
	126	{
	127
	128	}
	129
	130
	131	void bsp_Audio_init()
	132	{
	133
	134	}
	135
	136	void bsp_SD_init()
	137	{
	138
	139	}
	140
	141	void vs1052setXCS(char val)
	142	{
	143	}
	144
	145	void vs1052setXDCS(char val)
	146	{
	147	}
	148
	149	void vs1052setRST(char val)
	150	{
	151	}
	152
	153	int vs10XXDREQ()
	154	{
	155	return 1;
	156	}
	157
	158
	159	void bsppowersdcard(char onoff) //always ON
	160	{
	161
	162	}
	163
	164	char bspsdcardpresent()
	165	{
	166	return 1;
	167	}
	168
	169	char bspsdcardwriteprotected()
	170	{
	171	return 0;
	172	}
	173
	174	void bspsdcardselect(char YESNO)
	175	{
	176
	177	}
	178
	179
	180	void bsp_lcd0_write_reg(uint32_t reg,uint32_t data)
	181	{
	182
	183	}
	184
	185	uint32_t bsp_lcd0_read_reg(uint32_t reg)
	186	{
	187	return 0;
	188	}
	189
	190	void bsp_lcd0_writeGRAM(void* buffer,uint32_t count)
	191	{
	192
	193	}
	194
	195	void bsp_lcd0_readGRAM(void* buffer,uint32_t count)
	196	{
	197
	198	}
	199
	200	void bsp_GTerm_init()
	201	{
	202	SDLCD_mkscreen(240,320,16,LCDILI9328);
	203
	204	if(__opnfiles__[1]==NULL)
	205	{
	206	streamdevice* fd1 = (streamdevice*)malloc(sizeof(streamdevice));
	207	terminal_init(&terminal0 ,&lcd0,&ComicSansMS_18,fd1);
	208	__opnfiles__[1] = fd1;
	209	}
	210	else
	211	{
	212
	213	}
	214	}
	215
	216
	217
	218
	219
	220
	221
	222	void putpixel(SDL_Surface *surface, int x, int y, Uint32 pixel)
	223	{
	224	int bpp = surface->format->BytesPerPixel;
	225	/* Here p is the address to the pixel we want to set */
	226	Uint8 p = (Uint8 )surface->pixels + y * surface->pitch + x * bpp;
	227	switch(bpp) {
	228	case 1:
	229	*p = pixel;
	230	break;
	231	case 2:
	232	(Uint16 )p = pixel;
	233	break;
	234	case 3:
	235	if(SDL_BYTEORDER == SDL_BIG_ENDIAN) {
	236	p[0] = (pixel >> 16) & 0xff;
	237	p[1] = (pixel >> 8) & 0xff;
	238	p[2] = pixel & 0xff;
	239	} else {
	240	p[0] = pixel & 0xff;
	241	p[1] = (pixel >> 8) & 0xff;
	242	p[2] = (pixel >> 16) & 0xff;
	243	}
	244	break;
	245	case 4:
	246	(Uint32 )p = pixel;
	247	break;
	248	}
	249	}
	250
	251	Uint32 getpixel(SDL_Surface *surface, int x, int y)
	252	{
	253	int bpp = surface->format->BytesPerPixel;
	254	/* Here p is the address to the pixel we want to retrieve */
	255	Uint8 p = (Uint8 )surface->pixels + y * surface->pitch + x * bpp;
	256	switch(bpp) {
	257	case 1:
	258	return *p;
	259	case 2:
	260	return (Uint16 )p;
	261	case 3:
	262	if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
	263	return p[0] << 16 \| p[1] << 8 \| p[2];
	264	else
	265	return p[0] \| p[1] << 8 \| p[2] << 16;
	266	case 4:
	267	return (Uint32 )p;
	268	default:
	269	return 0;
	270	}
	271	/* shouldn’t happen, but avoids warnings */
	272	}
	273
	274
	275
	276
	277
	278
	279
	280
	281
	282

bsp/src/SIMULATOR/bsp.h created 644 +139 0

@@ -0,0 +1,139
	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 BSP_H
	23	#define BSP_H
	24	#include <gpio.h>
	25	#include <spi.h>
	26	#include <ili9328.h>
	27	#include <genericLCD_Controler.h>
	28	#include <sdcard-spi.h>
	29	#include <terminal.h>
	30	#include <sdcard.h>
	31	#include <mbr.h>
	32	#include <VS10XX.h>
	33	#include <fat32.h>
	34	#include <SDL.h>
	35	#include <stdint.h>
	36	#include <SDLCD.h>
	37
	38
	39	#define __MAX_OPENED_FILES__ 4
	40	#define __FS_ROOT_SIZE__ 4
	41
	42
	43	#define LED1 PC15
	44	#define LED2 PC14
	45
	46	#define BP3 PA0
	47
	48	#define LCD_RESET PD10
	49	#define LCD_BACKL PE11
	50
	51	#define VS1053SPI spi1
	52	#define VS1053xCS PA3
	53	#define VS1053xRESET PA2
	54	#define VS1053xDCS PA4
	55	#define VS1053DREQ PA1
	56	#define VS1053MISO PA6
	57	#define VS1053MOSI PA7
	58	#define VS1053SCK PA5
	59
	60
	61
	62	#define SDCARD2SPI spi3
	63	#define SDCARD2CS PB8
	64	#define SDCARD2CD PB9
	65	#define SDCARD2MISO PB4
	66	#define SDCARD2MOSI PB5
	67	#define SDCARD2SCK PB3
	68
	69	extern float VREF0;
	70
	71	extern uint32_t currentCpuFreq;
	72	extern LCD_t lcd0;
	73
	74	extern volatile vs10XXDev audioCodec0;
	75
	76	extern sdcardDev sdcard2;
	77	extern blkdevice sdcard2blkdev;
	78	extern dikpartition sdcard2Part1;
	79	extern FAT32fs sdcard2FAT32part1;
	80	extern dikpartition sdcard2Part2;
	81	extern FAT32fs sdcard2FAT32part2;
	82	extern dikpartition sdcard2Part3;
	83	extern FAT32fs sdcard2FAT32part3;
	84	extern dikpartition sdcard2Part4;
	85	extern FAT32fs sdcard2FAT32part4;
	86
	87	extern int bsp_init();
	88
	89	extern void bsp_GPIO_init();
	90	extern void bsp_uart_init();
	91	extern void bsp_iic_init();
	92	extern void bsp_spi_init();
	93	extern void bsp_SD_init();
	94	extern void bsp_Audio_init();
	95	extern void bsp_GTerm_init();
	96	extern int bsp_FSMC_init();
	97
	98	/* VS1053 */
	99	extern void vs1052setXCS(char val);
	100	extern void vs1052setXDCS(char val);
	101	extern void vs1052setRST(char val);
	102	extern int vs10XXDREQ();
	103
	104	/* SD CARD */
	105	void bsppowersdcard(char onoff);
	106	char bspsdcardpresent();
	107	void bspsdcardselect(char YESNO);
	108	char bspsdcardwriteprotected();
	109
	110
	111	void bsp_lcd0_write_reg(uint32_t reg,uint32_t data);
	112	uint32_t bsp_lcd0_read_reg(uint32_t reg);
	113	void bsp_lcd0_writeGRAM(void *buffer, uint32_t count);
	114	void bsp_lcd0_readGRAM(void *buffer, uint32_t count);
	115
	116
	117	extern void putpixel(SDL_Surface *surface, int x, int y, Uint32 pixel);
	118	extern Uint32 getpixel(SDL_Surface *surface, int x, int y);
	119
	120	#endif
	121
	122
	123
	124
	125
	126
	127
	128
	129
	130
	131
	132
	133
	134
	135
	136
	137
	138
	139

bsp/src/SIMULATOR/bsp.pri created 644 +6 0

@@ -0,0 +1,6
	1	CPU=simultor
	2	DEFINES+=BSP=\\\"SIMULATOR\\\"
	3
	4	UCMODEL=simulator
	5
	6	LIBS+=-lSDLCD

examples/SOLAR_PSU_HELLO/test_lcd.c created 644 +23 0

@@ -0,0 +1,23
	1	#include <stdio.h>
	2	#include <fat32.h>
	3	#include <gpio.h>
	4	#include <uart.h>
	5	#include <stm32f4xx.h>
	6	#include <bsp.h>
	7	#include <core.h>
	8	#include <VS10XX.h>
	9	#include <bsp.h>
	10	#include <spi.h>
	11	#include <sdcard.h>
	12	#include <sdcard-spi.h>
	13	#include <fat32.h>
	14	#include <ucdirent.h>
	15	#include <string.h>
	16	#include <terminal.h>
	17	#include <ili9328.h>
	18
	19
	20	void test_Block_Move(LCD_t* LCD,int x,int y,int w,int h,int color)
	21	{
	22	LCD->paintFilRect(LCD,x,y,w,h,0,0,color);
	23	}

examples/TEST_SIMULATOR/TEST_SIMULATOR.pro created 644 +13 0

@@ -0,0 +1,13
	1	TEMPLATE = app
	2	CONFIG += cpu
	3
	4
	5	UCMODEL=simulator
	6	BSP = SIMULATOR
	7
	8	DEFINES += CPUFREQ=100000000
	9
	10	SOURCES += \
	11	main.c \
	12	test_lcd.c
	13

examples/TEST_SIMULATOR/main.c created 644 +55 0

@@ -0,0 +1,55
	1	#include <stdio.h>
	2	#include <fat32.h>
	3	#include <gpio.h>
	4	#include <uart.h>
	5	#include <bsp.h>
	6	#include <core.h>
	7	#include <bsp.h>
	8	#include <spi.h>
	9	#include <fat32.h>
	10	#include <ucdirent.h>
	11	#include <string.h>
	12	#include <unistd.h>
	13	#include <terminal.h>
	14	#include <stdarg.h>
	15	#include <malloc.h>
	16
	17	extern streamdevice* __opnfiles__[];
	18	extern void test_Block_Move(LCD_t* LCD,int x,int y,int w,int h,int color);
	19	char buffer[512];
	20
	21	void streamdevicePrint(streamdevice* dev, const char* format,...)
	22	{
	23	char** str_buffer;
	24	int i;
	25	va_list ap;
	26	va_start(ap,format);
	27	vasprintf(str_buffer,format,ap);
	28	va_end(ap);
	29	i=strlen(*str_buffer);
	30	dev->ops->write(dev,(void)str_buffer,1,i);
	31	free(*str_buffer);
	32	}
	33
	34	void lcd_print()
	35	{
	36	lcd0.paintFilRect(&lcd0,10,10,100,100,0,0,0x0F0F);
	37	// __opnfiles__[1]->ops->write(__opnfiles__[1],(void*)"hello",1,5);
	38	}
	39
	40	int libuc2_main_task()
	41	{
	42	char in[255];
	43	lcd_print();
	44	printf("hello world\n");
	45	streamdevicePrint(__opnfiles__[1],"test Hello %d %f \n ",1234567,8.96);
	46	// while (scanf("%c",in))
	47	// {
	48	sleep(3);
	49	// }
	50	}
	51
	52
	53
	54
	55

examples/TEST_SIMULATOR/test_lcd.c created 644 +21 0

@@ -0,0 +1,21
	1	#include <stdio.h>
	2	#include <fat32.h>
	3	#include <gpio.h>
	4	#include <uart.h>
	5	#include <bsp.h>
	6	#include <core.h>
	7	#include <VS10XX.h>
	8	#include <bsp.h>
	9	#include <spi.h>
	10	#include <sdcard.h>
	11	#include <sdcard-spi.h>
	12	#include <fat32.h>
	13	#include <ucdirent.h>
	14	#include <string.h>
	15	#include <ili9328.h>
	16
	17
	18	void test_Block_Move(LCD_t* LCD,int x,int y,int w,int h,int color)
	19	{
	20	// LCD->paintFilRect(LCD,x,y,w,h,0,0,color);
	21	}

lib/src/common/AUDIO/CS43L22/CS43L22_SIMULATOR.pro created 644 +15 0

@@ -0,0 +1,15
	1	TEMPLATE = lib
	2	TARGET = CS43L22
	3
	4	SOURCES += CS43L22.c
	5
	6	INCLUDEPATH += ../../../includes \
	7	../../CPU/CMSIS/Include
	8
	9
	10	UCMODEL=simulator
	11
	12	target.path = $$[QT_INSTALL_LIBS]/$$UCMODEL
	13	INSTALLS += target
	14
	15

lib/src/common/AUDIO/VS10XX/VS10XX_SIMULATOR.pro created 644 +14 0

@@ -0,0 +1,14
	1	TEMPLATE = lib
	2	TARGET = vs10XX
	3
	4	SOURCES += VS10XX.c
	5
	6
	7	HEADERS += ../../../includes/VS10XX.h
	8	INCLUDEPATH += ../../../includes
	9
	10	UCMODEL=simulator
	11
	12	target.path = $$[QT_INSTALL_LIBS]/$$UCMODEL
	13	INSTALLS += target
	14

lib/src/common/AUDIO/VS10XX/VS10XX_STM32F4.pro created 644 +14 0

@@ -0,0 +1,14
	1	TEMPLATE = lib
	2	TARGET = vs10XX
	3
	4	SOURCES += VS10XX.c
	5
	6
	7	HEADERS += ../../../includes/VS10XX.h
	8	INCLUDEPATH += ../../../includes
	9
	10	UCMODEL=stm32f4
	11
	12	target.path = $$[QT_INSTALL_LIBS]/$$UCMODEL
	13	INSTALLS += target
	14

lib/src/common/EEPROMS/24LCXX/24LC0X/24LC0X_SIMULATOR.pro created 644 +14 0

@@ -0,0 +1,14
	1	TEMPLATE = lib
	2
	3	SOURCES += 24LC0X.c
	4	HEADERS += ../../../includes/24LC0X.h \
	5	../../../../includes/24LC0X.h
	6
	7	INCLUDEPATH += ../../../includes \
	8	../../CPU/CMSIS/Include
	9
	10
	11	UCMODEL=simulator
	12
	13	target.path = $$[QT_INSTALL_LIBS]/$$UCMODEL
	14	INSTALLS += target

lib/src/common/EEPROMS/24LCXX/24LC0X/24LC0X_STM32F4.pro created 644 +15 0

@@ -0,0 +1,15
	1	TEMPLATE = lib
	2
	3	SOURCES += 24LC0X.c
	4	HEADERS += ../../../includes/24LC0X.h \
	5	../../../../includes/24LC0X.h
	6
	7	INCLUDEPATH += ../../../includes \
	8	../../CPU/STM32F4xx_StdPeriph_Driver/inc \
	9	../../CPU/CMSIS/Include
	10
	11
	12	UCMODEL=stm32f4
	13
	14	target.path = $$[QT_INSTALL_LIBS]/$$UCMODEL
	15	INSTALLS += target

lib/src/common/EEPROMS/N25Q128/N25Q128_SIMULATOR.pro created 644 +13 0

@@ -0,0 +1,13
	1	TEMPLATE = lib
	2
	3	SOURCES += N25Q128.c
	4	HEADERS += ../../../includes/N25Q128.h
	5
	6	INCLUDEPATH += ../../../includes \
	7	../../CPU/CMSIS/Include
	8
	9
	10	UCMODEL=simulator
	11
	12	target.path = $$[QT_INSTALL_LIBS]/$$UCMODEL
	13	INSTALLS += target

lib/src/common/EEPROMS/N25Q128/N25Q128_STM32F4.pro created 644 +13 0

@@ -0,0 +1,13
	1	TEMPLATE = lib
	2
	3	SOURCES += N25Q128.c
	4	HEADERS += ../../../includes/N25Q128.h
	5
	6	INCLUDEPATH += ../../../includes \
	7	../../CPU/CMSIS/Include
	8
	9
	10	UCMODEL=stm32f4
	11
	12	target.path = $$[QT_INSTALL_LIBS]/$$UCMODEL
	13	INSTALLS += target

lib/src/common/FILE_SYSTEM/DIRENT/dirent_SIMULATOR.pro created 644 +15 0

@@ -0,0 +1,15
	1	TEMPLATE = lib
	2	OBJECTS_DIR = obj
	3	TARGET = ucdirent
	4
	5	SOURCES += \
	6	ucdirent.c
	7
	8	INCLUDEPATH += ../../includes
	9
	10
	11	UCMODEL=simulator
	12
	13	target.path = $$[QT_INSTALL_LIBS]/$$UCMODEL
	14	INSTALLS += target
	15

lib/src/common/FILE_SYSTEM/FAT32/fat32_SIMULATOR.pro created 644 +17 0

@@ -0,0 +1,17
	1	TEMPLATE = lib
	2	OBJECTS_DIR = obj
	3	TARGET = fat32
	4
	5	SOURCES += \
	6	fat32.c
	7
	8	INCLUDEPATH += ../../../includes
	9
	10	UCMODEL=simulator
	11
	12	target.path = $$[QT_INSTALL_LIBS]/$$UCMODEL
	13	INSTALLS += target
	14
	15	HEADERS += \
	16	../../../includes/fat32.h
	17

lib/src/common/FILE_SYSTEM/MBR/mbr_SIMULATOR.pro created 644 +17 0

@@ -0,0 +1,17
	1	TEMPLATE = lib
	2	OBJECTS_DIR = obj
	3	TARGET = mbr
	4
	5	SOURCES += \
	6	mbr.c
	7
	8	INCLUDEPATH += ../../../includes
	9
	10	UCMODEL=simulator
	11
	12	target.path = $$[QT_INSTALL_LIBS]/$$UCMODEL
	13	INSTALLS += target
	14
	15	HEADERS += \
	16	../../../includes/mbr.h
	17

lib/src/common/GRAPHIC/CONTROLERS/ILI9328/ili9328_SIMULATOR.pro created 644 +18 0

@@ -0,0 +1,18
	1	TEMPLATE = lib
	2	TARGET = ili9328
	3
	4	SOURCES += \
	5	ili9328.c
	6
	7
	8	INCLUDEPATH += ../../../../includes \
	9	../../../../includes/GRAPHIC/CONTROLERS \
	10	../../../../includes/GRAPHIC/GUI/FONTS \
	11	../../../../includes/GRAPHIC/GUI/Widgets
	12
	13
	14	UCMODEL=simulator
	15
	16	target.path = $$[QT_INSTALL_LIBS]/$$UCMODEL
	17	INSTALLS += target
	18

lib/src/common/GRAPHIC/CONTROLERS/SSD2119/ssd2119_SIMULATOR.pro created 644 +18 0

@@ -0,0 +1,18
	1	TEMPLATE = lib
	2	TARGET = ssd2119
	3
	4	SOURCES += \
	5	ssd2119.c
	6
	7
	8	INCLUDEPATH += ../../../../includes \
	9	../../../../includes/GRAPHIC/CONTROLERS \
	10	../../../../includes/GRAPHIC/GUI/FONTS \
	11	../../../../includes/GRAPHIC/GUI/Widgets
	12
	13
	14	UCMODEL=simulator
	15
	16	target.path = $$[QT_INSTALL_LIBS]/$$UCMODEL
	17	INSTALLS += target
	18

lib/src/common/GRAPHIC/GUI/FONTS/FONTS_SIMULATOR.pro created 644 +18 0

@@ -0,0 +1,18
	1	TEMPLATE = lib
	2	TARGET = fonts
	3
	4	SOURCES += \
	5	fonts8pts.c
	6
	7
	8	INCLUDEPATH += ../../../../includes \
	9	../../../../includes/GRAPHIC/CONTROLERS \
	10	../../../../includes/GRAPHIC/GUI/FONTS \
	11	../../../../includes/GRAPHIC/GUI/Widgets
	12
	13
	14	UCMODEL=simulator
	15
	16	target.path = $$[QT_INSTALL_LIBS]/$$UCMODEL
	17	INSTALLS += target
	18

lib/src/common/GRAPHIC/GUI/Widgets/Terminal/Terminal_SIMULATOR.pro created 644 +20 0

@@ -0,0 +1,20
	1	TEMPLATE = lib
	2	TARGET = terminal
	3
	4	SOURCES += \
	5	Terminal.c
	6
	7
	8	INCLUDEPATH += ../../../../includes \
	9	../../../../includes/GRAPHIC/CONTROLERS \
	10	../../../../includes/GRAPHIC/GUI/FONTS \
	11	../../../../includes/GRAPHIC/GUI/Widgets
	12
	13	HEADERS += \
	14	../../../../../includes/GRAPHIC/GUI/Widgets/terminal.h
	15
	16	UCMODEL=simulator
	17
	18	target.path = $$[QT_INSTALL_LIBS]/$$UCMODEL
	19	INSTALLS += target
	20

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

@@ -0,0 +1,23
	1	TEMPLATE = lib
	2	TARGET = STMPE811
	3
	4	SOURCES += \
	5	STMPE811.c
	6
	7	INCLUDEPATH += ../../../../includes \
	8	../../../../includes/GRAPHIC/CONTROLERS \
	9	../../../../includes/GRAPHIC/TC_CONTROLERS \
	10	../../../../includes/GRAPHIC/GUI/FONTS \
	11	../../../../includes/GRAPHIC/GUI/Widgets
	12
	13
	14	UCMODEL=simulator
	15
	16	target.path = $$[QT_INSTALL_LIBS]/$$UCMODEL
	17	INSTALLS += target
	18
	19	HEADERS += \
	20	../../../../includes/GRAPHIC/TC_CONTROLERS/STMPE811.h \
	21	../../../../includes/GRAPHIC/TC_CONTROLERS/genericTC_Controler.h
	22
	23

lib/src/common/POWER/ina226/ina226_SIMULATOR.pro created 644 +14 0

@@ -0,0 +1,14
	1	TEMPLATE = lib
	2	TARGET = ina226
	3
	4	SOURCES += ina226.c
	5
	6	INCLUDEPATH += ../../../includes \
	7	../../CPU/CMSIS/Include
	8
	9
	10	UCMODEL=simulator
	11
	12	target.path = $$[QT_INSTALL_LIBS]/$$UCMODEL
	13	INSTALLS += target
	14

lib/src/simulator/CORE/core.c created 644 +126 0

@@ -0,0 +1,126
	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	#include <core.h>
	23	#include <stdint.h>
	24	#include <stdlib.h>
	25	#include <stdio.h>
	26	#include <gpio.h>
	27	#include <unistd.h>
	28
	29	extern uint32_t OSC0;
	30	extern uint32_t INTOSC;
	31	extern uint32_t RTCOSC;
	32
	33	volatile uint32_t tickCounter=0;
	34
	35
	36	void SysTick_Handler(void)
	37	{
	38	tickCounter+=1;
	39	// if((tickCounter&0xFFF)==0x800)
	40	// gpiosetval(PC15,!gpiogetval(PC15));
	41	}
	42
	43	void delay_us(uint32_t value)
	44	{
	45	usleep(value);
	46	}
	47
	48	void delay_100us(uint32_t value)
	49	{
	50	usleep(value*100);
	51	}
	52
	53	uint32_t getAPB1Freq()
	54	{
	55	return 0;
	56	}
	57
	58	uint32_t getAPB2Freq()
	59	{
	60	return 0;
	61	}
	62
	63
	64	uint32_t getCpuFreq()
	65	{
	66	return 0;
	67	}
	68
	69	void reset_AHB1()
	70	{
	71	}
	72
	73	void reset_AHB2()
	74	{
	75
	76	}
	77
	78	void reset_APB1()
	79	{
	80
	81	}
	82
	83	void reset_APB2()
	84	{
	85
	86	}
	87
	88
	89
	90
	91
	92	int optimizePLLcfg(uint32_t freq, uint32_t srcfreq,uint32_t PLLM,uint32_t* PLLP, uint32_t* PLLN,uint8_t* AHBPRindx)
	93	{
	94
	95	return 1;
	96	}
	97
	98
	99	int setPll(uint32_t freq)
	100	{
	101
	102	return freq;
	103	}
	104
	105	void configureSysTick()
	106	{
	107
	108	}
	109
	110	int setCpuFreq(uint32_t freq)
	111	{
	112
	113	return 0;
	114	}
	115
	116
	117	void enable_FPU()
	118	{
	119
	120	}
	121
	122
	123
	124
	125
	126

lib/src/simulator/CORE/core.pro created 644 +13 0

@@ -0,0 +1,13
	1	TEMPLATE = lib
	2	SOURCES += \
	3	core.c \
	4	threads.c \
	5	irq_handlers.c
	6
	7	INCLUDEPATH += ../../includes
	8
	9
	10	UCMODEL=simulator
	11
	12	target.path = $$[QT_INSTALL_LIBS]/$$UCMODEL
	13	INSTALLS += target

lib/src/simulator/CORE/irq_handlers.c created 644 +452 0

@@ -0,0 +1,452
	1	#include <stdio.h>
	2
	3	void NMI_Handler(void)
	4	{
	5	printf("NMI_Handler\n");
	6	}
	7
	8	void HardFault_Handler(void)
	9	{
	10	printf("HardFault_Handler\n");
	11	}
	12
	13	void MemManage_Handler(void)
	14	{
	15	printf("MemManage_Handler\n");
	16	}
	17
	18	void BusFault_Handler(void)
	19	{
	20	printf("BusFault_Handler\n");
	21	}
	22
	23	void UsageFault_Handler(void)
	24	{
	25	printf("UsageFault_Handler\n");
	26	}
	27
	28	void SVC_Handler(void)
	29	{
	30	printf("SVC_Handler\n");
	31	}
	32
	33	void DebugMon_Handler(void)
	34	{
	35	printf("DebugMon_Handler\n");
	36	}
	37
	38	void PendSV_Handler(void)
	39	{
	40	printf("PendSV_Handler\n");
	41	}
	42
	43	void WWDG_IRQHandler(void)
	44	{
	45	printf("WWDG_IRQHandler\n");
	46	}
	47
	48	void PVD_IRQHandler(void)
	49	{
	50	printf("PVD_IRQHandler\n");
	51	}
	52
	53	void TAMP_STAMP_IRQHandler(void)
	54	{
	55	printf("TAMP_STAMP_IRQHandler\n");
	56	}
	57
	58	void RTC_WKUP_IRQHandler(void)
	59	{
	60	printf("RTC_WKUP_IRQHandler\n");
	61	}
	62
	63	void FLASH_IRQHandler(void)
	64	{
	65	printf("FLASH_IRQHandler\n");
	66	}
	67
	68	void RCC_IRQHandler(void)
	69	{
	70	printf("RCC_IRQHandler\n");
	71	}
	72
	73	void EXTI0_IRQHandler(void)
	74	{
	75	printf("EXTI0_IRQHandler\n");
	76	}
	77
	78	void EXTI1_IRQHandler(void)
	79	{
	80	printf("EXTI1_IRQHandler\n");
	81	}
	82
	83	void EXTI2_IRQHandler(void)
	84	{
	85	printf("EXTI2_IRQHandler\n");
	86	}
	87
	88	void EXTI3_IRQHandler(void)
	89	{
	90	printf("EXTI3_IRQHandler\n");
	91	}
	92
	93	void EXTI4_IRQHandler(void)
	94	{
	95	printf("EXTI4_IRQHandler\n");
	96	}
	97
	98	void DMA1_Stream0_IRQHandler(void)
	99	{
	100	printf("DMA1_Stream0_IRQHandler\n");
	101	}
	102
	103	void DMA1_Stream1_IRQHandler(void)
	104	{
	105	printf("DMA1_Stream1_IRQHandler\n");
	106	}
	107
	108	void DMA1_Stream2_IRQHandler(void)
	109	{
	110	printf("DMA1_Stream2_IRQHandler\n");
	111	}
	112
	113	void DMA1_Stream3_IRQHandler(void)
	114	{
	115	printf("DMA1_Stream3_IRQHandler\n");
	116	}
	117
	118	void DMA1_Stream4_IRQHandler(void)
	119	{
	120	printf("DMA1_Stream4_IRQHandler\n");
	121	}
	122
	123	void DMA1_Stream5_IRQHandler(void)
	124	{
	125	printf("DMA1_Stream5_IRQHandler\n");
	126	}
	127
	128	void DMA1_Stream6_IRQHandler(void)
	129	{
	130	printf("DMA1_Stream6_IRQHandler\n");
	131	}
	132
	133	void ADC_IRQHandler(void)
	134	{
	135	printf("ADC_IRQHandler\n");
	136	}
	137
	138	void CAN1_TX_IRQHandler(void)
	139	{
	140	printf("CAN1_TX_IRQHandler\n");
	141	}
	142
	143	void CAN1_RX0_IRQHandler(void)
	144	{
	145	printf("CAN1_RX0_IRQHandler\n");
	146	}
	147
	148	void CAN1_RX1_IRQHandler(void)
	149	{
	150	printf("CAN1_RX1_IRQHandler\n");
	151	}
	152
	153	void CAN1_SCE_IRQHandler(void)
	154	{
	155	printf("CAN1_SCE_IRQHandler\n");
	156	}
	157
	158	void EXTI9_5_IRQHandler(void)
	159	{
	160	printf("EXTI9_5_IRQHandler\n");
	161	}
	162
	163	void TIM1_BRK_TIM9_IRQHandler(void)
	164	{
	165	printf("TIM1_BRK_TIM9_IRQHandler\n");
	166	}
	167
	168	void TIM1_UP_TIM10_IRQHandler(void)
	169	{
	170	printf("TIM1_UP_TIM10_IRQHandler\n");
	171	}
	172
	173	void TIM1_TRG_COM_TIM11_IRQHandlerIM11(void)
	174	{
	175	printf("TIM1_TRG_COM_TIM11_IRQHandlerIM11");
	176	}
	177
	178	void TIM1_CC_IRQHandler(void)
	179	{
	180	printf("TIM1_CC_IRQHandler\n");
	181	}
	182
	183	void TIM2_IRQHandler(void)
	184	{
	185	printf("TIM2_IRQHandler\n");
	186	}
	187
	188	void TIM3_IRQHandler(void)
	189	{
	190	printf("TIM3_IRQHandler\n");
	191	}
	192
	193	void TIM4_IRQHandler(void)
	194	{
	195	printf("TIM4_IRQHandler\n");
	196	}
	197
	198	void I2C1_EV_IRQHandler(void)
	199	{
	200	printf("I2C1_EV_IRQHandler\n");
	201	}
	202
	203	void I2C1_ER_IRQHandler(void)
	204	{
	205	printf("I2C1_ER_IRQHandler\n");
	206	}
	207
	208	void I2C2_EV_IRQHandler(void)
	209	{
	210	printf("I2C2_EV_IRQHandler\n");
	211	}
	212
	213	void I2C2_ER_IRQHandler(void)
	214	{
	215	printf("I2C2_ER_IRQHandler\n");
	216	}
	217
	218	void SPI1_IRQHandler(void)
	219	{
	220	printf("SPI1_IRQHandler\n");
	221	}
	222
	223	void SPI2_IRQHandler(void)
	224	{
	225	printf("SPI2_IRQHandler\n");
	226	}
	227
	228	void USART1_IRQHandler(void)
	229	{
	230	printf("USART1_IRQHandler\n");
	231	}
	232
	233	void USART2_IRQHandler(void)
	234	{
	235	printf("USART2_IRQHandler\n");
	236	}
	237
	238	void USART3_IRQHandler(void)
	239	{
	240	printf("USART3_IRQHandler\n");
	241	}
	242
	243	void EXTI15_10_IRQHandler(void)
	244	{
	245	printf("EXTI15_10_IRQHandler\n");
	246	}
	247
	248	void RTC_Alarm_IRQHandler(void)
	249	{
	250	printf("RTC_Alarm_IRQHandler\n");
	251	}
	252
	253	void OTG_FS_WKUP_IRQHandler(void)
	254	{
	255	printf("OTG_FS_WKUP_IRQHandler\n");
	256	}
	257
	258	void TIM8_BRK_TIM12_IRQHandler(void)
	259	{
	260	printf("TIM8_BRK_TIM12_IRQHandler\n");
	261	}
	262
	263	void TIM8_UP_TIM13_IRQHandler(void)
	264	{
	265	printf("TIM8_UP_TIM13_IRQHandler\n");
	266	}
	267
	268	void TIM8_TRG_COM_TIM14_IRQHandlerIM14(void)
	269	{
	270	printf("TIM8_TRG_COM_TIM14_IRQHandlerIM14");
	271	}
	272
	273	void TIM8_CC_IRQHandler(void)
	274	{
	275	printf("TIM8_CC_IRQHandler\n");
	276	}
	277
	278	void DMA1_Stream7_IRQHandler(void)
	279	{
	280	printf("DMA1_Stream7_IRQHandler\n");
	281	}
	282
	283	void FSMC_IRQHandler(void)
	284	{
	285	printf("FSMC_IRQHandler\n");
	286	}
	287
	288	void SDIO_IRQHandler(void)
	289	{
	290	printf("SDIO_IRQHandler\n");
	291	}
	292
	293	void TIM5_IRQHandler(void)
	294	{
	295	printf("TIM5_IRQHandler\n");
	296	}
	297
	298	void SPI3_IRQHandler(void)
	299	{
	300	printf("SPI3_IRQHandler\n");
	301	}
	302
	303	void UART4_IRQHandler(void)
	304	{
	305	printf("UART4_IRQHandler\n");
	306	}
	307
	308	void UART5_IRQHandler(void)
	309	{
	310	printf("UART5_IRQHandler\n");
	311	}
	312
	313	void TIM6_DAC_IRQHandler(void)
	314	{
	315	printf("TIM6_DAC_IRQHandler\n");
	316	}
	317
	318	void TIM7_IRQHandler(void)
	319	{
	320	printf("TIM7_IRQHandler\n");
	321	}
	322
	323	void DMA2_Stream0_IRQHandler(void)
	324	{
	325	printf("DMA2_Stream0_IRQHandler\n");
	326	}
	327
	328	void DMA2_Stream1_IRQHandler(void)
	329	{
	330	printf("DMA2_Stream1_IRQHandler\n");
	331	}
	332
	333	void DMA2_Stream2_IRQHandler(void)
	334	{
	335	printf("DMA2_Stream2_IRQHandler\n");
	336	}
	337
	338	void DMA2_Stream3_IRQHandler(void)
	339	{
	340	printf("DMA2_Stream3_IRQHandler\n");
	341	}
	342
	343	void DMA2_Stream4_IRQHandler(void)
	344	{
	345	printf("DMA2_Stream4_IRQHandler\n");
	346	}
	347
	348	void ETH_IRQHandler(void)
	349	{
	350	printf("ETH_IRQHandler\n");
	351	}
	352
	353	void ETH_WKUP_IRQHandler(void)
	354	{
	355	printf("ETH_WKUP_IRQHandler\n");
	356	}
	357
	358	void CAN2_TX_IRQHandler(void)
	359	{
	360	printf("CAN2_TX_IRQHandler\n");
	361	}
	362
	363	void CAN2_RX0_IRQHandler(void)
	364	{
	365	printf("CAN2_RX0_IRQHandler\n");
	366	}
	367
	368	void CAN2_RX1_IRQHandler(void)
	369	{
	370	printf("CAN2_RX1_IRQHandler\n");
	371	}
	372
	373	void CAN2_SCE_IRQHandler(void)
	374	{
	375	printf("CAN2_SCE_IRQHandler\n");
	376	}
	377
	378	void OTG_FS_IRQHandler(void)
	379	{
	380	printf("OTG_FS_IRQHandler\n");
	381	}
	382
	383	void DMA2_Stream5_IRQHandler(void)
	384	{
	385	printf("DMA2_Stream5_IRQHandler\n");
	386	}
	387
	388	void DMA2_Stream6_IRQHandler(void)
	389	{
	390	printf("DMA2_Stream6_IRQHandler\n");
	391	}
	392
	393	void DMA2_Stream7_IRQHandler(void)
	394	{
	395	printf("DMA2_Stream7_IRQHandler\n");
	396	}
	397
	398	void USART6_IRQHandler(void)
	399	{
	400	printf("USART6_IRQHandler\n");
	401	}
	402
	403	void I2C3_EV_IRQHandler(void)
	404	{
	405	printf("I2C3_EV_IRQHandler\n");
	406	}
	407
	408	void I2C3_ER_IRQHandler(void)
	409	{
	410	printf("I2C3_ER_IRQHandler\n");
	411	}
	412
	413	void OTG_HS_EP1_OUT_IRQHandler(void)
	414	{
	415	printf("OTG_HS_EP1_OUT_IRQHandler\n");
	416	}
	417
	418	void OTG_HS_EP1_IN_IRQHandler(void)
	419	{
	420	printf("OTG_HS_EP1_IN_IRQHandler\n");
	421	}
	422
	423	void OTG_HS_WKUP_IRQHandler(void)
	424	{
	425	printf("OTG_HS_WKUP_IRQHandler\n");
	426	}
	427
	428	void OTG_HS_IRQHandler(void)
	429	{
	430	printf("OTG_HS_IRQHandler\n");
	431	}
	432
	433	void DCMI_IRQHandler(void)
	434	{
	435	printf("DCMI_IRQHandler\n");
	436	}
	437
	438	void CRYP_IRQHandler(void)
	439	{
	440	printf("CRYP_IRQHandler\n");
	441	}
	442
	443	void HASH_RNG_IRQHandler(void)
	444	{
	445	printf("HASH_RNG_IRQHandler\n");
	446	}
	447
	448	void FPU_IRQHandler(void)
	449	{
	450	printf("FPU_IRQHandler\n");
	451	}
	452

lib/src/simulator/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

lib/src/simulator/CPU/cpu.c created 644 +10 0

	@@ -0,0 +1,10
				1
				2
				3
				4
				5
				6
				7
				8
				9
				10

lib/src/simulator/CPU/cpu.pri created 644 +14 0

@@ -0,0 +1,14
	1
	2
	3	LIBS += -L$$[QT_INSTALL_LIBS]/$$UCMODEL
	4	LIBS += -lcpu
	5
	6
	7
	8
	9
	10
	11
	12
	13
	14

lib/src/simulator/CPU/cpu.pro created 644 +25 0

@@ -0,0 +1,25
	1	TEMPLATE = lib
	2
	3	UCMODEL=simulator
	4
	5	prifile.files = cpu.pri startup.c fs.c
	6	prifile.path = $$[QT_INSTALL_PREFIX]/mkspecs/features/$$UCMODEL
	7
	8	INCLUDEPATH += ../../includes
	9
	10	SOURCES += cpu.c
	11
	12
	13	target.path = $$[QT_INSTALL_LIBS]/$$UCMODEL
	14	INSTALLS += target prifile
	15
	16
	17
	18
	19
	20
	21
	22
	23
	24
	25

lib/src/simulator/CPU/fs.c created 644 +25 0

@@ -0,0 +1,25
	1	#include <stdint.h>
	2	#include <streamdevices.h>
	3	#include <stdio.h>
	4	#include <bsp.h>
	5
	6	const int32_t __max_opened_files__ = __MAX_OPENED_FILES__;
	7	volatile streamdevice* __opnfiles__[__MAX_OPENED_FILES__];
	8	const int32_t __fs_root_size__ = __FS_ROOT_SIZE__;
	9	int32_t __fs_root__[__FS_ROOT_SIZE__];
	10
	11
	12	/*
	13	void __init_fs()
	14	{
	15	int i=0;
	16	for(i=0;i<__fs_root_size__;i++)
	17	{
	18	__fs_root__[i]=(int32_t)NULL;
	19	}
	20	for(i=0;i<__max_opened_files__ ;i++)
	21	{
	22	__opnfiles__[i]._stream=NULL;
	23	}
	24	}
	25	*/

lib/src/simulator/CPU/startup.c created 644 +7 0

@@ -0,0 +1,7
	1
	2
	3	int main(void)
	4	{
	5	bsp_init();
	6	libuc2_main_task();
	7	}

lib/src/simulator/GPIO/gpio.c created 644 +119 0

@@ -0,0 +1,119
	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	#include <gpio.h>
	23
	24
	25
	26	gpio_t gpioopen(uint32_t gpio)
	27	{
	28	gpio &= -1^GPIOSPEEDMASK;
	29	gpio \|= gpiolowspeed;
	30	gpio &= -1^GPIODIRMASK;
	31	gpio \|= gpioindir;
	32	gpio &= -1^GPIOOUTTYPEMASK;
	33	gpio \|= gpiopushpulltype;
	34	gpio &= -1^GPIOPULLTYPEMASK;
	35	gpio \|= gpionopulltype;
	36	return gpio;
	37	}
	38
	39
	40	void gpioclose(gpio_t gpio)
	41	{
	42	}
	43
	44	void gpiosetconfig(gpio_t* gpio)
	45	{
	46	gpiosetdir(gpio, (*gpio & GPIODIRMASK));
	47	gpiosetspeed(gpio, (*gpio & GPIOSPEEDMASK));
	48	gpiosetouttype(gpio, (*gpio & GPIOOUTTYPEMASK));
	49	gpiosetpulltype(gpio, (*gpio & GPIOPULLTYPEMASK));
	50	}
	51
	52	extern void gpiosetspeed(gpio_t* gpio,gpiospeed_t speed)
	53	{
	54
	55	}
	56
	57
	58	void gpiosetdir(gpio_t* gpio,gpiodir_t dir)
	59	{
	60
	61
	62	}
	63
	64
	65	void gpiosetouttype(gpio_t* gpio, gpioouttype_t outtype)
	66	{
	67
	68	}
	69
	70
	71	void gpiosetpulltype(gpio_t* gpio,gpiopulltype_t pulltype)
	72	{
	73
	74	}
	75
	76	void gpioset(gpio_t gpio)
	77	{
	78
	79	}
	80
	81
	82	void gpioclr(gpio_t gpio)
	83	{
	84
	85	}
	86
	87	void gpiosetval(gpio_t gpio,int val)
	88	{
	89
	90	}
	91
	92	int gpiogetval(gpio_t gpio)
	93	{
	94	return 0;
	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

lib/src/simulator/GPIO/gpio.pro created 644 +12 0

@@ -0,0 +1,12
	1	TEMPLATE = lib
	2	SOURCES += gpio.c
	3
	4	INCLUDEPATH += ../../includes
	5
	6
	7	UCMODEL=simulator
	8
	9	target.path = $$[QT_INSTALL_LIBS]/$$UCMODEL
	10	INSTALLS += target
	11
	12

lib/src/simulator/I2C/i2c.c created 644 +132 0

@@ -0,0 +1,132
	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	#include <i2c.h>
	24	#include <gpio.h>
	25
	26
	27	int i2ctimeout=1000*1000;
	28
	29
	30	i2c_t i2copen(int count)
	31	{
	32	return -1;
	33	}
	34
	35	i2c_t i2copenandconfig(int count,uint32_t cfg,uint32_t speed,uint32_t SDA,uint32_t SCL)
	36	{
	37	i2c_t dev = i2copen(count);
	38	if(dev!=-1)
	39	{
	40	i2cclose(dev);
	41	i2csetpins(dev,SDA,SCL);
	42	i2copen(count);
	43	i2csetspeed(dev,speed);
	44	i2cenable(count);
	45	}
	46	return dev;
	47	}
	48
	49	int i2cclose(i2c_t dev)
	50	{
	51	return 1;
	52	}
	53
	54	int i2csetpins(i2c_t dev, uint32_t SDA, uint32_t SCL)
	55	{
	56	if((dev<i2c4)&&(dev>=i2c1))
	57	{
	58	return 0;
	59	}
	60	return -1;
	61	}
	62
	63	int i2cenable(i2c_t dev)
	64	{
	65	if((dev<i2c4)&&(dev>=i2c1))
	66	{
	67
	68	return 0;
	69	}
	70	return -1;
	71	}
	72
	73	int i2cdisable(i2c_t dev)
	74	{
	75	if((dev<i2c4)&&(dev>=i2c1))
	76	{
	77
	78	return 0;
	79	}
	80	return -1;
	81	}
	82
	83
	84	int i2csetspeed(i2c_t dev,uint32_t speed)
	85	{
	86	if((dev<i2c4)&&(dev>=i2c1))
	87	{
	88	return 0;
	89	}
	90	return -1;
	91	}
	92
	93	int i2cbusy(i2c_t dev)
	94	{
	95	if((dev<i2c4)&&(dev>=i2c1))
	96	{
	97	return 0; /* Dev isn't busy */
	98	}
	99	return -1; /* Error, dev is out of range */
	100	}
	101
	102	int i2cwrite(i2c_t dev,char address,char* data,int count)
	103	{
	104	if((dev<i2c4)&&(dev>=i2c1))
	105	{
	106
	107	return 0;
	108	}
	109	return -1;
	110	}
	111
	112	int i2cread(i2c_t dev,char address,char* data,int count)
	113	{
	114	if((dev<i2c4)&&(dev>=i2c1))
	115	{
	116	return 0;
	117	}
	118	return -1;
	119	}
	120
	121
	122	int i2cStatusCheck(i2c_t dev,int32_t flagMask)
	123	{
	124	int32_t flag;
	125	if((dev<i2c4)&&(dev>=i2c1))
	126	{
	127	return 0;
	128	}
	129	return -1;
	130	}
	131
	132

lib/src/simulator/I2C/i2c.pro created 644 +12 0

@@ -0,0 +1,12
	1	TEMPLATE = lib
	2	SOURCES += i2c.c
	3
	4	INCLUDEPATH += ../../includes
	5
	6
	7	UCMODEL=simulator
	8
	9	target.path = $$[QT_INSTALL_LIBS]/$$UCMODEL
	10	INSTALLS += target
	11
	12

lib/src/simulator/SDCARD/SDCARD.pro created 644 +15 0

@@ -0,0 +1,15
	1	TEMPLATE = lib
	2	TARGET = sdcard
	3	SOURCES += fakesdcard.c
	4
	5	INCLUDEPATH += ../../includes
	6	HEADERS += \
	7	../../includes/sdcard.h
	8
	9
	10	UCMODEL=simulator
	11
	12	target.path = $$[QT_INSTALL_LIBS]/$$UCMODEL
	13	INSTALLS += target
	14
	15

lib/src/simulator/SDCARD/fakesdcard.c created 644 +115 0

@@ -0,0 +1,115
	1	#include <stdio.h>
	2	#include <sdcard.h>
	3	#include <sdcard-spi.h>
	4
	5	FILE* sdcardimg;
	6
	7
	8	void sdcardmake(sdcardDev* sdcard,UHANDLE phy,void (rcvr_mmc) (UHANDLE,char ,unsigned int ),void (xmit_mmc) (UHANDLE,const char ,unsigned int ),void (setspeed) (UHANDLE phy,unsigned int speed),unsigned int (getspeed) (UHANDLE phy))
	9	{
	10
	11	}
	12
	13
	14	int sdcardselect (blkdevice* _this)
	15	{
	16	return 1;
	17	}
	18
	19
	20	void sdcarddeselect (blkdevice* _this)
	21	{
	22
	23	}
	24
	25	int sdcardwait_ready (sdcardDev* sdcard)
	26	{
	27	return 1;
	28	}
	29
	30	void sdcardpower (blkdevice* _this)
	31	{
	32
	33	}
	34
	35	char sdcarddetect (blkdevice* _this)
	36	{
	37	return 1;
	38	}
	39
	40	char sdcardwriteprotected (blkdevice* _this)
	41	{
	42	return 0;
	43	}
	44
	45
	46
	47	int sdcardxmit_datablock (sdcardDev* sdcard,const char *buff,char token)
	48	{
	49	return 1;
	50	}
	51
	52	int sdcardrcvr_datablock (sdcardDev* sdcard,char *buff,unsigned int btr)
	53	{
	54	return 1;
	55	}
	56
	57	char sdcardsend_cmd (blkdevice* _this,char cmd,unsigned int arg)
	58	{
	59	return 1;
	60	}
	61
	62	DSTATUS sdcarddisk_status (blkdevice* _this)
	63	{}
	64
	65	DSTATUS sdcarddisk_initialize (blkdevice* _this)
	66	{}
	67
	68	DRESULT sdcarddisk_read (blkdevice* _this,char *buff,unsigned long sector,char count)
	69	{
	70	int res = fseek(sdcardimg, sector*(unsigned long)512, SEEK_SET);
	71	if(count512== fread(buff,1,count512,sdcardimg))
	72	return RES_OK;
	73	return RES_ERROR;
	74	}
	75
	76	DRESULT sdcarddisk_write (blkdevice* _this,const char *buff,unsigned long sector,char count)
	77	{
	78	fseek(sdcardimg, sector*(unsigned long)512, SEEK_SET);
	79	fwrite(buff,1,count*512,sdcardimg);
	80	return RES_OK;
	81	}
	82
	83	DRESULT sdcarddisk_ioctl (blkdevice* _this,char ctrl,void *buff)
	84	{}
	85
	86
	87	void sdcardspimakeblkdev(blkdevice* dev,sdcardDev* sdcard, blkdevselect_t select,blkdevpower_t power,blkdevdetect_t detect,blkdevwriteprotected_t writeprotected)
	88	{
	89	sdcardimg=fopen("sdcard.bin","rb");
	90	// sdcardimg=fopen("usbkey.bin","rb");
	91	if(sdcardimg!=NULL)printf("ok sdcard openned\n");
	92	else printf("Nok sdcard not openned\n");
	93	dev->phy=NULL;
	94	dev->select= (blkdevselect_t)select;
	95	dev->power = (blkdevpower_t)power;
	96	dev->detect = (blkdevdetect_t)detect;
	97	dev->writeprotected = (blkdevwriteprotected_t)writeprotected;
	98	dev->write = sdcarddisk_write;
	99	dev->read = sdcarddisk_read;
	100	dev->ioctl = sdcarddisk_ioctl;
	101	dev->initialize = sdcarddisk_initialize;
	102	dev->status = sdcarddisk_status;
	103	printf("sdcard opened\n");
	104	}
	105
	106
	107
	108
	109
	110
	111
	112
	113
	114
	115

lib/src/simulator/SDLCD/SDLCD.c created 644 +237 0

@@ -0,0 +1,237
	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 <SDL.h>
	24	#include <malloc.h>
	25	#include "SDLCD.h"
	26
	27	SDL_Surface *screen;
	28	SDL_Overlay *bmp;
	29
	30	int SDLCD_Xpos=0;
	31	int SDLCD_Ypos=0;
	32	int SDLCD_XWinStrt=0;
	33	int SDLCD_YWinStrt=0;
	34	int SDLCD_XWinEnd=0;
	35	int SDLCD_YWinEnd=0;
	36
	37	void* SDLCD_buffer;
	38	int SDLCD_bpp;
	39	void SDLCD_putpixel(SDL_Surface *surface, int x, int y, Uint32 pixel);
	40
	41	void SDLCD_mkscreen(int resx,int resy,int bpp,int lcdtype)
	42	{
	43	int i=0;
	44	if(SDL_Init(SDL_INIT_VIDEO \| SDL_INIT_TIMER)) {
	45	fprintf(stderr, "Could not initialize SDL - %s\n", SDL_GetError());
	46	exit(1);
	47	}
	48	screen = SDL_SetVideoMode(resx, resy, bpp, 0);
	49	if(!screen) {
	50	fprintf(stderr, "SDL: could not set video mode - exiting\n");
	51	exit(1);
	52	}
	53	if ( SDL_MUSTLOCK(screen) ) {
	54	if ( SDL_LockSurface(screen) < 0 ) {
	55	fprintf(stderr, "Can’t lock screen: %s\n", SDL_GetError());
	56	return;
	57	}
	58	}
	59	if ( SDL_MUSTLOCK(screen) ) {
	60	SDL_UnlockSurface(screen);
	61	}
	62	SDL_UpdateRect(screen, 0, 0, resx, resy);
	63	SDLCD_buffer = malloc(resxresybpp/8);
	64	SDLCD_bpp = bpp;
	65	for(i=0;i<(resx*resy);i++)
	66	{
	67	SDLCD_putpixel(screen, i%resx, (i/resx), 0xFFFF);
	68	}
	69	}
	70
	71
	72
	73	int SDLCD_init()
	74	{
	75
	76	}
	77
	78	void SDLCD_writereg(uint32_t reg,uint32_t data)
	79	{
	80	switch (reg) {
	81	case ILI9328_REGISTER_HORIZONTALGRAMADDRESSSET:
	82	SDLCD_Xpos = data;
	83	break;
	84	case ILI9328_REGISTER_VERTICALGRAMADDRESSSET:
	85	SDLCD_Ypos = data;
	86	break;
	87	case ILI9328_REGISTER_HORIZONTALADDRESSSTARTPOSITION:
	88	SDLCD_XWinStrt = data;
	89	break;
	90	case ILI9328_REGISTER_HORIZONTALADDRESSENDPOSITION:
	91	SDLCD_XWinEnd = data;
	92	break;
	93	case ILI9328_REGISTER_VERTICALADDRESSSTARTPOSITION:
	94	SDLCD_YWinStrt = data;
	95	break;
	96	case ILI9328_REGISTER_VERTICALADDRESSENDPOSITION:
	97	SDLCD_YWinEnd = data;
	98	break;
	99	default:
	100	break;
	101	}
	102	}
	103
	104	uint32_t SDLCD_readreg(uint32_t reg)
	105	{
	106	return 0;
	107	}
	108
	109
	110	void SDLCD_putpixel(SDL_Surface *surface, int x, int y, Uint32 pixel)
	111	{
	112	int bpp = surface->format->BytesPerPixel;
	113	/* Here p is the address to the pixel we want to set */
	114	Uint8 p = (Uint8 )surface->pixels + y * surface->pitch + x * bpp;
	115	switch(bpp) {
	116	case 1:
	117	*p = pixel;
	118	break;
	119	case 2:
	120	(Uint16 )p = pixel;
	121	break;
	122	case 3:
	123	if(SDL_BYTEORDER == SDL_BIG_ENDIAN) {
	124	p[0] = (pixel >> 16) & 0xff;
	125	p[1] = (pixel >> 8) & 0xff;
	126	p[2] = pixel & 0xff;
	127	} else {
	128	p[0] = pixel & 0xff;
	129	p[1] = (pixel >> 8) & 0xff;
	130	p[2] = (pixel >> 16) & 0xff;
	131	}
	132	break;
	133	case 4:
	134	(Uint32 )p = pixel;
	135	break;
	136	}
	137	}
	138
	139	Uint32 SDLCD_getpixel(SDL_Surface *surface, int x, int y)
	140	{
	141	int bpp = surface->format->BytesPerPixel;
	142	/* Here p is the address to the pixel we want to retrieve */
	143	Uint8 p = (Uint8 )surface->pixels + y * surface->pitch + x * bpp;
	144	switch(bpp) {
	145	case 1:
	146	return *p;
	147	case 2:
	148	return (Uint16 )p;
	149	case 3:
	150	if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
	151	return p[0] << 16 \| p[1] << 8 \| p[2];
	152	else
	153	return p[0] \| p[1] << 8 \| p[2] << 16;
	154	case 4:
	155	return (Uint32 )p;
	156	default:
	157	return 0;
	158	}
	159	/* shouldn’t happen, but avoids warnings */
	160	}
	161
	162	void SDLCD_writeGRAM(void* buffer,uint32_t count)
	163	{
	164	int i=0;
	165	u_int16_t* ptr=(u_int16_t*)SDLCD_buffer;
	166	u_int16_t* inptr=(u_int16_t*)buffer;
	167	if ( SDL_MUSTLOCK(screen) ) {
	168	if ( SDL_LockSurface(screen) < 0 ) {
	169	fprintf(stderr, "Can’t lock screen: %s\n", SDL_GetError());
	170	return;
	171	}
	172	}
	173	for(i=0;i<count;i++)
	174	{
	175	SDLCD_putpixel(screen,SDLCD_Xpos,SDLCD_Ypos,inptr[i]);
	176	SDLCD_Xpos+=1;
	177	ptr[i]=inptr[i];
	178	if(SDLCD_Xpos>=SDLCD_XWinEnd)
	179	{
	180	SDLCD_Xpos=SDLCD_XWinStrt;
	181	SDLCD_Ypos+=1;
	182	}
	183	if(SDLCD_Ypos>=SDLCD_YWinEnd)
	184	{
	185	SDLCD_Ypos=SDLCD_YWinStrt;
	186	}
	187	}
	188	if ( SDL_MUSTLOCK(screen) ) {
	189	SDL_UnlockSurface(screen);
	190	}
	191	SDL_UpdateRect(screen, 0, 0, screen->w, screen->h);
	192	}
	193
	194	void SDLCD_readGRAM(void* buffer,uint32_t count)
	195	{
	196	int i=0;
	197	u_int16_t* ptr=(u_int16_t*)SDLCD_buffer;
	198	u_int16_t* inptr=(u_int16_t*)buffer;
	199	for(i=0;i<count;i++)
	200	{
	201	inptr[i]=SDLCD_getpixel(screen,SDLCD_Xpos,SDLCD_Ypos);
	202	SDLCD_Xpos+=1;
	203	ptr[i]=inptr[i];
	204	if(SDLCD_Xpos>=SDLCD_XWinEnd)
	205	{
	206	SDLCD_Xpos=SDLCD_XWinStrt;
	207	SDLCD_Ypos+=1;
	208	}
	209	if(SDLCD_Ypos>=SDLCD_YWinEnd)
	210	{
	211	SDLCD_Ypos=SDLCD_YWinStrt;
	212	}
	213	}
	214
	215	}
	216
	217
	218
	219
	220
	221
	222
	223
	224
	225
	226
	227
	228
	229
	230
	231
	232
	233
	234
	235
	236
	237

lib/src/simulator/SDLCD/SDLCD.h created 644 +46 0

@@ -0,0 +1,46
	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 <SDL.h>
	24	#include <ili9328.h>
	25	#include <stdint.h>
	26
	27	#define LCDILI9328 9328
	28
	29	extern SDL_Surface *screen;
	30	extern SDL_Overlay *bmp;
	31
	32	extern void SDLCD_mkscreen(int resx,int resy,int bbp,int lcdtype);
	33	extern int SDLCD_init();
	34	extern void SDLCD_writereg(uint32_t reg,uint32_t data);
	35	extern uint32_t SDLCD_readreg(uint32_t reg);
	36	extern void SDLCD_writeGRAM(void* buffer,uint32_t count);
	37	extern void SDLCD_readGRAM(void* buffer,uint32_t count);
	38
	39
	40
	41
	42
	43
	44
	45
	46

lib/src/simulator/SDLCD/SDLCD.pro created 644 +18 0

@@ -0,0 +1,18
	1	TEMPLATE = lib
	2	SOURCES += SDLCD.c
	3
	4	HEADERS += ./SDLCD.h
	5
	6	INCLUDEPATH += ../../includes
	7
	8	SDLCDHEADERS.files += \
	9	./SDLCD.h
	10
	11	SDLCDHEADERS.path = $$[QT_INSTALL_HEADERS]/simulator
	12
	13	UCMODEL=simulator
	14
	15	target.path = $$[QT_INSTALL_LIBS]/$$UCMODEL
	16	INSTALLS += target SDLCDHEADERS
	17
	18

lib/src/simulator/SPI/spi.c created 644 +255 0

@@ -0,0 +1,255
	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
	23	#include <spi.h>
	24	#include <gpio.h>
	25
	26
	27
	28	spi_t spiopen(int count)
	29	{
	30
	31	return -1;
	32	}
	33
	34	spi_t spiopenandconfig(int count, uint32_t cfg, uint32_t speed, uint32_t MOSIpin, uint32_t MISOpin, uint32_t SCKpin, uint32_t SCSpin)
	35	{
	36	spi_t dev = spiopen(count);
	37	if(dev!=-1)
	38	{
	39	spidisable(dev);
	40	spisetpins(dev,MOSIpin, MISOpin, SCKpin, SCSpin);
	41	spienable(dev);
	42	spisetconfig(dev,cfg,speed);
	43	}
	44	return dev;
	45	}
	46
	47
	48	int spiclose(spi_t spidev)
	49	{
	50	if((spidev<3)&&(spidev>=0))
	51	{
	52
	53	return 1;
	54	}
	55	return -1;
	56	}
	57
	58	int spisetpins(spi_t spidev,uint32_t MOSIpin,uint32_t MISOpin,uint32_t SCKpin,uint32_t SCSpin)
	59	{
	60	if((spidev<3)&&(spidev>=0))
	61	{
	62
	63	return 1;
	64	}
	65	return -1;
	66	}
	67
	68
	69	int spienable(spi_t spidev)
	70	{
	71	if((spidev<3)&&(spidev>=0))
	72	{
	73	return 1;
	74	}
	75	return -1;
	76	}
	77
	78
	79	int spidisable(spi_t spidev)
	80	{
	81	if((spidev<3)&&(spidev>=0))
	82	{
	83	return 1;
	84	}
	85	return -1;
	86	}
	87
	88	int spisetconfig(spi_t spidev, uint32_t config, uint32_t speed)
	89	{
	90	if((spidev<3)&&(spidev>=0))
	91	{
	92	return 0;
	93	}
	94	return 1;
	95	}
	96
	97	int spisetspeed(spi_t spidev, uint32_t speed)
	98	{
	99	if((spidev<3)&&(spidev>=0))
	100	{
	101	return 1;
	102	}
	103	return -1;
	104	}
	105
	106	uint32_t spigetspeed(spi_t spidev)
	107	{
	108	if((spidev<3)&&(spidev>=0))
	109	{
	110
	111	return 0;
	112	}
	113	return -1;
	114	}
	115
	116	int spisetdatabits(spi_t spidev,spibits_t bitscnt)
	117	{
	118	if((spidev<3)&&(spidev>=0))
	119	{
	120	return 0;
	121	}
	122	return -1;
	123	}
	124
	125	int spisetbitorder(spi_t spidev,spibitorder_t order)
	126	{
	127	if((spidev<3)&&(spidev>=0))
	128	{
	129	return 1;
	130	}
	131	return -1;
	132	}
	133
	134	int spisetclkinhlevel(spi_t spidev,spiclkinhlvl_t level)
	135	{
	136	if((spidev<3)&&(spidev>=0))
	137	{
	138	return 1;
	139	}
	140	return -1;
	141	}
	142
	143	int spisetclkphase(spi_t spidev,spiclkphase_t phase)
	144	{
	145	if((spidev<3)&&(spidev>=0))
	146	{
	147	return 1;
	148	}
	149	return -1;
	150	}
	151
	152	int spiputw(spi_t spidev,uint16_t data)
	153	{
	154	if((spidev<3)&&(spidev>=0))
	155	{
	156	return 0;
	157	}
	158	return -1;
	159	}
	160	uint16_t spigetw(spi_t spidev)
	161	{
	162	if((spidev<3)&&(spidev>=0))
	163	{
	164	return 0;
	165	}
	166	return -1;
	167	}
	168
	169	int spiputs(spi_t spidev,char* s)
	170	{
	171	while (s) spiputw(spidev,s++);
	172	return 1;
	173	}
	174
	175	int spigets(spi_t spidev,char* s)
	176	{
	177	do
	178	{
	179	(*s) = spigetw(spidev);
	180	}
	181	while(*s++);
	182	return 1;
	183	}
	184
	185	int spiputnw(spi_t spidev,uint16_t* w,int n)
	186	{
	187	while(n!=0)
	188	{
	189	spiputw(spidev,*w++);
	190	n--;
	191	}
	192	return 1;
	193	}
	194
	195	int spigetnw(spi_t spidev,uint16_t* w,int n)
	196	{
	197	while(n!=0)
	198	{
	199	*w++=spigetw(spidev);
	200	n--;
	201	}
	202	return 1;
	203	}
	204
	205	int spiputnc(spi_t spidev,char* c,int n)
	206	{
	207	while(n!=0)
	208	{
	209	spiputw(spidev,*c++);
	210	n--;
	211	}
	212	return 1;
	213	}
	214
	215	int spigetnc(spi_t spidev,char* c,int n)
	216	{
	217	while(n!=0)
	218	{
	219	*c++=spigetw(spidev);
	220	n--;
	221	}
	222	return 1;
	223	}
	224
	225	int spiavailiabledata(spi_t spidev)
	226	{
	227	return 0;
	228	}
	229
	230
	231	int spitransactionfinished(spi_t spidev)
	232	{
	233	if((spidev<3)&&(spidev>=0))
	234	{
	235	return 1;
	236	}
	237	return 0;
	238	}
	239
	240
	241
	242
	243
	244
	245
	246
	247
	248
	249
	250
	251
	252
	253
	254
	255

lib/src/simulator/SPI/spi.pro created 644 +14 0

@@ -0,0 +1,14
	1	TEMPLATE = lib
	2	SOURCES += spi.c
	3
	4	HEADERS += ../../includes/spi.h
	5
	6	INCLUDEPATH += ../../includes
	7
	8
	9	UCMODEL=simulator
	10
	11	target.path = $$[QT_INSTALL_LIBS]/$$UCMODEL
	12	INSTALLS += target
	13
	14

lib/src/simulator/UART/uart.c created 644 +226 0

@@ -0,0 +1,226
	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 <uart.h>
	24	#include <gpio.h>
	25	#include <stdio.h>
	26
	27
	28
	29	int _uartstrsetpos(streamdevice* device,int pos);
	30	int _uartstrread(streamdevice* device,void* data,int size, int n);
	31	int _uartstrwrite(streamdevice* device,void* data,int size, int n);
	32
	33	streamdevice_ops UART_OPS=
	34	{
	35	.write = &_uartstrwrite,
	36	.read = &_uartstrread,
	37	.setpos= &_uartstrsetpos,
	38	.close = NULL
	39	};
	40
	41	uart_t uartopen(int count)
	42	{
	43	return -1;
	44	}
	45
	46	uart_t uartopenandconfig(int count, uint32_t cfg, uint32_t speed, uint32_t TXpin, uint32_t RXpin, uint32_t RTSpin, uint32_t CTSpin)
	47	{
	48	uart_t dev= uartopen(count);
	49	uartsetconfig(dev,cfg,speed);
	50	uartsetpins(dev,TXpin,RXpin,RTSpin,CTSpin);
	51	return dev;
	52	}
	53
	54
	55	int uartclose(uart_t uart)
	56	{
	57	return 1;
	58	}
	59
	60	int uartsetpins(uart_t uart,uint32_t TXpin,uint32_t RXpin,uint32_t RTSpin,uint32_t CTSpin)
	61	{
	62	if(uart >5)return -1;
	63	if(uart <0)return -1;
	64	return 1;
	65	}
	66
	67	int uartsetconfig(uart_t uart, uint32_t cfg, uint32_t speed)
	68	{
	69	int res=1;
	70	uartdisable(uart);
	71	uartsetspeed(uart,speed);
	72	uartsetparity(uart,cfg & UARTPARITYMASK);
	73	uartsetdatabits(uart,cfg & UARTBITSMASK);
	74	uartsetstopbits(uart,cfg & UARTSTOPBITSMASK);
	75	uartenable(uart);
	76	return res;
	77	}
	78
	79	int uartenable(uart_t uart)
	80	{
	81	if((uart<6)&&(uart>=0))
	82	{
	83	return 1;
	84	}
	85	return -1;
	86	}
	87
	88	int uartdisable(uart_t uart)
	89	{
	90	if((uart<6)&&(uart>=0))
	91	{
	92	return 1;
	93	}
	94	return -1;
	95	}
	96
	97	int uartsetspeed(uart_t uart,uint32_t speed)
	98	{
	99	if((uart<6)&&(uart>=0))
	100	{
	101	return 1;
	102	}
	103	return -1;
	104	}
	105
	106	int uartsetparity(uart_t uart,uartparity_t parity)
	107	{
	108	if((uart<6)&&(uart>=0))
	109	{
	110	return 1;
	111	}
	112	return -1;
	113	}
	114
	115	int uartsetdatabits(uart_t uart,uartbits_t databits)
	116	{
	117	if((uart<6)&&(uart>=0))
	118	{
	119	return 1;
	120	}
	121	return -1;
	122	}
	123
	124	int uartsetstopbits(uart_t uart,uartstopbits_t stopbits)
	125	{
	126	if((uart<6)&&(uart>=0))
	127	{
	128	return 1;
	129	}
	130	return -1;
	131	}
	132
	133	int uartputc(uart_t uart,char c)
	134	{
	135	if((uart<6)&&(uart>=0))
	136	{
	137	return 1;
	138	}
	139	return -1;
	140	}
	141
	142	char uartgetc(uart_t uart)
	143	{
	144	if((uart<6)&&(uart>=0))
	145	{
	146	return 0;
	147	}
	148	return -1;
	149	}
	150
	151	int uartputs(uart_t uart,char* s)
	152	{
	153	while (s) uartputc(uart,s++);
	154	return 1;
	155	}
	156
	157	int uartgets(uart_t uart,char* s)
	158	{
	159	do
	160	{
	161	(*s) = uartgetc(uart);
	162	}
	163	while(*s++);
	164	return 1;
	165	}
	166
	167	int uartputnc(uart_t uart,char* c,int n)
	168	{
	169	int l=0;
	170	while(l<n)
	171	{
	172	uartputc(uart,*c++);
	173	l++;
	174	}
	175	return n;
	176	}
	177
	178	int uartgetnc(uart_t uart,char* c,int n)
	179	{
	180	int l=0;
	181	while(l<n)
	182	{
	183	*c++=uartgetc(uart);
	184	l++;
	185	}
	186	return n;
	187	}
	188
	189	int uartavailiabledata(uart_t uart)
	190	{
	191	if((uart<6)&&(uart>=0))
	192	{
	193	return 1;
	194	}
	195	return -1;
	196	}
	197
	198
	199	int _uartstrwrite(streamdevice* device,void* data,int size, int n)
	200	{
	201	return uartputnc((uart_t) device->_stream,(char) data,sizen);
	202	}
	203
	204	int _uartstrread(streamdevice* device,void* data,int size, int n)
	205	{
	206	return uartgetnc((uart_t) device->_stream,(char) data,sizen);
	207	}
	208
	209	int _uartstrsetpos(streamdevice* device,int pos)
	210	{
	211	return 1;
	212	}
	213
	214	int uartmkstreamdev(uart_t uart,streamdevice* strdev)
	215	{
	216	strdev->_stream = (UHANDLE)uart;
	217	strdev->ops = &UART_OPS;
	218	strdev->streamPt = 0;
	219	return 1;
	220	}
	221
	222
	223
	224
	225
	226

lib/src/simulator/UART/uart.pro created 644 +12 0

@@ -0,0 +1,12
	1	TEMPLATE = lib
	2	SOURCES += uart.c
	3
	4	INCLUDEPATH += ../../includes
	5
	6
	7	UCMODEL=simulator
	8
	9	target.path = $$[QT_INSTALL_LIBS]/$$UCMODEL
	10	INSTALLS += target
	11
	12

lib/src/simulator/simulator.pro created 644 +14 0

@@ -0,0 +1,14
	1	TEMPLATE = subdirs
	2	CONFIG += ordered
	3	SUBDIRS = CORE/core.pro \
	4	CPU/cpu.pro \
	5	GPIO/gpio.pro \
	6	UART/uart.pro \
	7	SPI/spi.pro \
	8	I2C/i2c.pro \
	9	SDCARD \
	10	SDLCD
	11
	12
	13
	14

lib/src/stm32f4/CORE/irq_handlers.c created 644 +452 0

@@ -0,0 +1,452
	1	#include <stdio.h>
	2
	3	void NMI_Handler(void)
	4	{
	5	printf("NMI_Handler\n");
	6	}
	7
	8	void HardFault_Handler(void)
	9	{
	10	printf("HardFault_Handler\n");
	11	}
	12
	13	void MemManage_Handler(void)
	14	{
	15	printf("MemManage_Handler\n");
	16	}
	17
	18	void BusFault_Handler(void)
	19	{
	20	printf("BusFault_Handler\n");
	21	}
	22
	23	void UsageFault_Handler(void)
	24	{
	25	printf("UsageFault_Handler\n");
	26	}
	27
	28	void SVC_Handler(void)
	29	{
	30	printf("SVC_Handler\n");
	31	}
	32
	33	void DebugMon_Handler(void)
	34	{
	35	printf("DebugMon_Handler\n");
	36	}
	37
	38	void PendSV_Handler(void)
	39	{
	40	printf("PendSV_Handler\n");
	41	}
	42
	43	void WWDG_IRQHandler(void)
	44	{
	45	printf("WWDG_IRQHandler\n");
	46	}
	47
	48	void PVD_IRQHandler(void)
	49	{
	50	printf("PVD_IRQHandler\n");
	51	}
	52
	53	void TAMP_STAMP_IRQHandler(void)
	54	{
	55	printf("TAMP_STAMP_IRQHandler\n");
	56	}
	57
	58	void RTC_WKUP_IRQHandler(void)
	59	{
	60	printf("RTC_WKUP_IRQHandler\n");
	61	}
	62
	63	void FLASH_IRQHandler(void)
	64	{
	65	printf("FLASH_IRQHandler\n");
	66	}
	67
	68	void RCC_IRQHandler(void)
	69	{
	70	printf("RCC_IRQHandler\n");
	71	}
	72
	73	void EXTI0_IRQHandler(void)
	74	{
	75	printf("EXTI0_IRQHandler\n");
	76	}
	77
	78	void EXTI1_IRQHandler(void)
	79	{
	80	printf("EXTI1_IRQHandler\n");
	81	}
	82
	83	void EXTI2_IRQHandler(void)
	84	{
	85	printf("EXTI2_IRQHandler\n");
	86	}
	87
	88	void EXTI3_IRQHandler(void)
	89	{
	90	printf("EXTI3_IRQHandler\n");
	91	}
	92
	93	void EXTI4_IRQHandler(void)
	94	{
	95	printf("EXTI4_IRQHandler\n");
	96	}
	97
	98	void DMA1_Stream0_IRQHandler(void)
	99	{
	100	printf("DMA1_Stream0_IRQHandler\n");
	101	}
	102
	103	void DMA1_Stream1_IRQHandler(void)
	104	{
	105	printf("DMA1_Stream1_IRQHandler\n");
	106	}
	107
	108	void DMA1_Stream2_IRQHandler(void)
	109	{
	110	printf("DMA1_Stream2_IRQHandler\n");
	111	}
	112
	113	void DMA1_Stream3_IRQHandler(void)
	114	{
	115	printf("DMA1_Stream3_IRQHandler\n");
	116	}
	117
	118	void DMA1_Stream4_IRQHandler(void)
	119	{
	120	printf("DMA1_Stream4_IRQHandler\n");
	121	}
	122
	123	void DMA1_Stream5_IRQHandler(void)
	124	{
	125	printf("DMA1_Stream5_IRQHandler\n");
	126	}
	127
	128	void DMA1_Stream6_IRQHandler(void)
	129	{
	130	printf("DMA1_Stream6_IRQHandler\n");
	131	}
	132
	133	void ADC_IRQHandler(void)
	134	{
	135	printf("ADC_IRQHandler\n");
	136	}
	137
	138	void CAN1_TX_IRQHandler(void)
	139	{
	140	printf("CAN1_TX_IRQHandler\n");
	141	}
	142
	143	void CAN1_RX0_IRQHandler(void)
	144	{
	145	printf("CAN1_RX0_IRQHandler\n");
	146	}
	147
	148	void CAN1_RX1_IRQHandler(void)
	149	{
	150	printf("CAN1_RX1_IRQHandler\n");
	151	}
	152
	153	void CAN1_SCE_IRQHandler(void)
	154	{
	155	printf("CAN1_SCE_IRQHandler\n");
	156	}
	157
	158	void EXTI9_5_IRQHandler(void)
	159	{
	160	printf("EXTI9_5_IRQHandler\n");
	161	}
	162
	163	void TIM1_BRK_TIM9_IRQHandler(void)
	164	{
	165	printf("TIM1_BRK_TIM9_IRQHandler\n");
	166	}
	167
	168	void TIM1_UP_TIM10_IRQHandler(void)
	169	{
	170	printf("TIM1_UP_TIM10_IRQHandler\n");
	171	}
	172
	173	void TIM1_TRG_COM_TIM11_IRQHandlerIM11(void)
	174	{
	175	printf("TIM1_TRG_COM_TIM11_IRQHandlerIM11");
	176	}
	177
	178	void TIM1_CC_IRQHandler(void)
	179	{
	180	printf("TIM1_CC_IRQHandler\n");
	181	}
	182
	183	void TIM2_IRQHandler(void)
	184	{
	185	printf("TIM2_IRQHandler\n");
	186	}
	187
	188	void TIM3_IRQHandler(void)
	189	{
	190	printf("TIM3_IRQHandler\n");
	191	}
	192
	193	void TIM4_IRQHandler(void)
	194	{
	195	printf("TIM4_IRQHandler\n");
	196	}
	197
	198	void I2C1_EV_IRQHandler(void)
	199	{
	200	printf("I2C1_EV_IRQHandler\n");
	201	}
	202
	203	void I2C1_ER_IRQHandler(void)
	204	{
	205	printf("I2C1_ER_IRQHandler\n");
	206	}
	207
	208	void I2C2_EV_IRQHandler(void)
	209	{
	210	printf("I2C2_EV_IRQHandler\n");
	211	}
	212
	213	void I2C2_ER_IRQHandler(void)
	214	{
	215	printf("I2C2_ER_IRQHandler\n");
	216	}
	217
	218	void SPI1_IRQHandler(void)
	219	{
	220	printf("SPI1_IRQHandler\n");
	221	}
	222
	223	void SPI2_IRQHandler(void)
	224	{
	225	printf("SPI2_IRQHandler\n");
	226	}
	227
	228	void USART1_IRQHandler(void)
	229	{
	230	printf("USART1_IRQHandler\n");
	231	}
	232
	233	void USART2_IRQHandler(void)
	234	{
	235	printf("USART2_IRQHandler\n");
	236	}
	237
	238	void USART3_IRQHandler(void)
	239	{
	240	printf("USART3_IRQHandler\n");
	241	}
	242
	243	void EXTI15_10_IRQHandler(void)
	244	{
	245	printf("EXTI15_10_IRQHandler\n");
	246	}
	247
	248	void RTC_Alarm_IRQHandler(void)
	249	{
	250	printf("RTC_Alarm_IRQHandler\n");
	251	}
	252
	253	void OTG_FS_WKUP_IRQHandler(void)
	254	{
	255	printf("OTG_FS_WKUP_IRQHandler\n");
	256	}
	257
	258	void TIM8_BRK_TIM12_IRQHandler(void)
	259	{
	260	printf("TIM8_BRK_TIM12_IRQHandler\n");
	261	}
	262
	263	void TIM8_UP_TIM13_IRQHandler(void)
	264	{
	265	printf("TIM8_UP_TIM13_IRQHandler\n");
	266	}
	267
	268	void TIM8_TRG_COM_TIM14_IRQHandlerIM14(void)
	269	{
	270	printf("TIM8_TRG_COM_TIM14_IRQHandlerIM14");
	271	}
	272
	273	void TIM8_CC_IRQHandler(void)
	274	{
	275	printf("TIM8_CC_IRQHandler\n");
	276	}
	277
	278	void DMA1_Stream7_IRQHandler(void)
	279	{
	280	printf("DMA1_Stream7_IRQHandler\n");
	281	}
	282
	283	void FSMC_IRQHandler(void)
	284	{
	285	printf("FSMC_IRQHandler\n");
	286	}
	287
	288	void SDIO_IRQHandler(void)
	289	{
	290	printf("SDIO_IRQHandler\n");
	291	}
	292
	293	void TIM5_IRQHandler(void)
	294	{
	295	printf("TIM5_IRQHandler\n");
	296	}
	297
	298	void SPI3_IRQHandler(void)
	299	{
	300	printf("SPI3_IRQHandler\n");
	301	}
	302
	303	void UART4_IRQHandler(void)
	304	{
	305	printf("UART4_IRQHandler\n");
	306	}
	307
	308	void UART5_IRQHandler(void)
	309	{
	310	printf("UART5_IRQHandler\n");
	311	}
	312
	313	void TIM6_DAC_IRQHandler(void)
	314	{
	315	printf("TIM6_DAC_IRQHandler\n");
	316	}
	317
	318	void TIM7_IRQHandler(void)
	319	{
	320	printf("TIM7_IRQHandler\n");
	321	}
	322
	323	void DMA2_Stream0_IRQHandler(void)
	324	{
	325	printf("DMA2_Stream0_IRQHandler\n");
	326	}
	327
	328	void DMA2_Stream1_IRQHandler(void)
	329	{
	330	printf("DMA2_Stream1_IRQHandler\n");
	331	}
	332
	333	void DMA2_Stream2_IRQHandler(void)
	334	{
	335	printf("DMA2_Stream2_IRQHandler\n");
	336	}
	337
	338	void DMA2_Stream3_IRQHandler(void)
	339	{
	340	printf("DMA2_Stream3_IRQHandler\n");
	341	}
	342
	343	void DMA2_Stream4_IRQHandler(void)
	344	{
	345	printf("DMA2_Stream4_IRQHandler\n");
	346	}
	347
	348	void ETH_IRQHandler(void)
	349	{
	350	printf("ETH_IRQHandler\n");
	351	}
	352
	353	void ETH_WKUP_IRQHandler(void)
	354	{
	355	printf("ETH_WKUP_IRQHandler\n");
	356	}
	357
	358	void CAN2_TX_IRQHandler(void)
	359	{
	360	printf("CAN2_TX_IRQHandler\n");
	361	}
	362
	363	void CAN2_RX0_IRQHandler(void)
	364	{
	365	printf("CAN2_RX0_IRQHandler\n");
	366	}
	367
	368	void CAN2_RX1_IRQHandler(void)
	369	{
	370	printf("CAN2_RX1_IRQHandler\n");
	371	}
	372
	373	void CAN2_SCE_IRQHandler(void)
	374	{
	375	printf("CAN2_SCE_IRQHandler\n");
	376	}
	377
	378	void OTG_FS_IRQHandler(void)
	379	{
	380	printf("OTG_FS_IRQHandler\n");
	381	}
	382
	383	void DMA2_Stream5_IRQHandler(void)
	384	{
	385	printf("DMA2_Stream5_IRQHandler\n");
	386	}
	387
	388	void DMA2_Stream6_IRQHandler(void)
	389	{
	390	printf("DMA2_Stream6_IRQHandler\n");
	391	}
	392
	393	void DMA2_Stream7_IRQHandler(void)
	394	{
	395	printf("DMA2_Stream7_IRQHandler\n");
	396	}
	397
	398	void USART6_IRQHandler(void)
	399	{
	400	printf("USART6_IRQHandler\n");
	401	}
	402
	403	void I2C3_EV_IRQHandler(void)
	404	{
	405	printf("I2C3_EV_IRQHandler\n");
	406	}
	407
	408	void I2C3_ER_IRQHandler(void)
	409	{
	410	printf("I2C3_ER_IRQHandler\n");
	411	}
	412
	413	void OTG_HS_EP1_OUT_IRQHandler(void)
	414	{
	415	printf("OTG_HS_EP1_OUT_IRQHandler\n");
	416	}
	417
	418	void OTG_HS_EP1_IN_IRQHandler(void)
	419	{
	420	printf("OTG_HS_EP1_IN_IRQHandler\n");
	421	}
	422
	423	void OTG_HS_WKUP_IRQHandler(void)
	424	{
	425	printf("OTG_HS_WKUP_IRQHandler\n");
	426	}
	427
	428	void OTG_HS_IRQHandler(void)
	429	{
	430	printf("OTG_HS_IRQHandler\n");
	431	}
	432
	433	void DCMI_IRQHandler(void)
	434	{
	435	printf("DCMI_IRQHandler\n");
	436	}
	437
	438	void CRYP_IRQHandler(void)
	439	{
	440	printf("CRYP_IRQHandler\n");
	441	}
	442
	443	void HASH_RNG_IRQHandler(void)
	444	{
	445	printf("HASH_RNG_IRQHandler\n");
	446	}
	447
	448	void FPU_IRQHandler(void)
	449	{
	450	printf("FPU_IRQHandler\n");
	451	}
	452

mkspecs/common/simulator.conf created 644 +41 0

@@ -0,0 +1,41
	1	#
	2	# qmake configuration for simulator
	3	#
	4
	5	CONFIG +=
	6	QMAKE_CC = gcc
	7	QMAKE_CFLAGS += -g -O0
	8	QMAKE_CFLAGS_DEPS += -M
	9	QMAKE_CFLAGS_WARN_ON += -Wall
	10	QMAKE_CFLAGS_WARN_OFF += -w
	11	QMAKE_CFLAGS_RELEASE += -O2
	12	QMAKE_CFLAGS_DEBUG +=
	13
	14	QMAKE_CXX = g++
	15	QMAKE_CXXFLAGS += $$QMAKE_CFLAGS s
	16	QMAKE_CXXFLAGS_DEPS += $$QMAKE_CFLAGS_DEPS
	17	QMAKE_CXXFLAGS_WARN_ON += $$QMAKE_CFLAGS_WARN_ON
	18	QMAKE_CXXFLAGS_WARN_OFF += $$QMAKE_CFLAGS_WARN_OFF
	19	QMAKE_CXXFLAGS_RELEASE += $$QMAKE_CFLAGS_RELEASE
	20	QMAKE_CXXFLAGS_DEBUG += $$QMAKE_CFLAGS_DEBUG
	21	QMAKE_CXXFLAGS_SHLIB += $$QMAKE_CFLAGS_SHLIB
	22	QMAKE_CXXFLAGS_STATIC_LIB += $$QMAKE_CFLAGS_STATIC_LIB
	23	QMAKE_CXXFLAGS_YACC += $$QMAKE_CFLAGS_YACC
	24	QMAKE_CXXFLAGS_HIDESYMS += $$QMAKE_CFLAGS_HIDESYMS
	25
	26	QMAKE_LINK = gcc
	27	QMAKE_LINK_SHLIB = gcc
	28	QMAKE_LINK_C = gcc
	29	QMAKE_LINK_C_SHLIB = gcc
	30	QMAKE_LFLAGS += -g -O0
	31	QMAKE_LFLAGS_RELEASE +=
	32	QMAKE_LFLAGS_DEBUG +=
	33	QMAKE_LFLAGS_APP +=
	34	QMAKE_LFLAGS_SHLIB +=
	35	QMAKE_LFLAGS_PLUGIN += $$QMAKE_LFLAGS_SHLIB
	36	QMAKE_LFLAGS_THREAD +=
	37
	38	QMAKE_AR = ar -ru
	39	QMAKE_LIB = ar -ru
	40	QMAKE_RANLIB =
	41

mkspecs/features/simulator/cpu.pri created 644 +16 0

@@ -0,0 +1,16
	1
	2
	3	LIBS += -L$$[QT_INSTALL_LIBS]/$$UCMODEL
	4	LIBS += -lcpu
	5
	6
	7
	8
	9
	10
	11
	12
	13
	14
	15
	16

mkspecs/features/simulator/startup.c created 644 +7 0

@@ -0,0 +1,7
	1
	2
	3	int main(void)
	4	{
	5	bsp_init();
	6	libuc2_main_task();
	7	}

mkspecs/simulator/qmake.conf created 644 +57 0

@@ -0,0 +1,57
	1	#
	2	# qmake configuration for stm32f4
	3	#
	4	#
	5
	6
	7	isEmpty(_simulator_conf){
	8	_simulator_conf="oneshot"
	9
	10	QMAKE_CFLAGS= -std=c99
	11
	12	include(../common/simulator.conf)
	13
	14	DEFINES += \"assert_param(expr)=((void)0)\"
	15	INCLUDEPATH += $$PWD /usr/include/SDL
	16
	17	DEFINES += BSP="\"\\\"$$BSP"\\\"\"
	18
	19	CONFIG += cpu
	20
	21	contains( TEMPLATE, app ) {
	22	OBJECTS_DIR=obj-$$UCMODEL
	23	DESTDIR=bin-$$UCMODEL
	24	LIBS += -L$$[QT_INSTALL_PREFIX]/bsp/lib/$$BSP
	25	LIBS += -lbsp -lSDLCD -lSDL -lz -lm
	26	SOURCES +=$$[QT_INSTALL_PREFIX]/mkspecs/features/simulator/startup.c
	27	SOURCES +=$$[QT_INSTALL_PREFIX]/mkspecs/features/simulator/fs.c
	28
	29
	30	INCLUDEPATH+= $$[QT_INSTALL_PREFIX]/bsp/includes/$$BSP
	31
	32	}
	33
	34	contains( TEMPLATE, lib ) {
	35	OBJECTS_DIR=obj-$$UCMODEL
	36	DESTDIR=bin-$$UCMODEL
	37	CONFIG+=staticlib
	38	}
	39
	40	include(../common/libuc2libs.conf)
	41
	42	}
	43
	44
	45
	46
	47
	48
	49
	50
	51
	52
	53
	54
	55
	56
	57

mkspecs/simulator/qplatformdefs.h created 644 +42 0

@@ -0,0 +1,42
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2012 Digia Plc and/or its subsidiary(-ies).
	4	** Contact: http://www.qt-project.org/legal
	5	**
	6	** This file is part of the qmake spec of the Qt Toolkit.
	7	**
	8	** $QT_BEGIN_LICENSE:LGPL$
	9	** Commercial License Usage
	10	** Licensees holding valid commercial Qt licenses may use this file in
	11	** accordance with the commercial license agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia. For licensing terms and
	14	** conditions see http://qt.digia.com/licensing. For further information
	15	** use the contact form at http://qt.digia.com/contact-us.
	16	**
	17	** GNU Lesser General Public License Usage
	18	** Alternatively, this file may be used under the terms of the GNU Lesser
	19	** General Public License version 2.1 as published by the Free Software
	20	** Foundation and appearing in the file LICENSE.LGPL included in the
	21	** packaging of this file. Please review the following information to
	22	** ensure the GNU Lesser General Public License version 2.1 requirements
	23	** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
	24	**
	25	** In addition, as a special exception, Digia gives you certain additional
	26	** rights. These rights are described in the Digia Qt LGPL Exception
	27	** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
	28	**
	29	** GNU General Public License Usage
	30	** Alternatively, this file may be used under the terms of the GNU
	31	** General Public License version 3.0 as published by the Free Software
	32	** Foundation and appearing in the file LICENSE.GPL included in the
	33	** packaging of this file. Please review the following information to
	34	** ensure the GNU General Public License version 3.0 requirements will be
	35	** met: http://www.gnu.org/copyleft/gpl.html.
	36	**
	37	**
	38	** $QT_END_LICENSE$
	39	**
	40	****************************************************************************/
	41
	42	//#include "../linux-g++/qplatformdefs.h"

README +2 -5

             #------------------------------------------------------------------------------
             #--  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
+            #--                   Mail : alexis.jeandet@member.fsf.org
             #-------------------------------------------------------------------------------
             ________
             licence:
             ~~~~~~~~
             	Please note that all the files included inside the libuc2 are not written by me and for the libuc2. They are covered by their
             own licence. If you reconize any of your code and you whant it to be removed from this library tell me.
             ____________
             Intallation:
             ~~~~~~~~~~~~
             	To install the libuc2 you just need to copy the libuc2 folder where you whant then you need to:
-            		-add the libuc2 binary folder to the PATH, with linux you can append this to the end of your /etc/bashrc file:
-            			PATH=$PATH:/opt/libuc2/bin
-            			replace /opt/ by the path where is installed the libuc2.
             		-set the libuc2 environement varriable, with linux you can append this to the end of your /etc/bashrc file:
             			libuc2=/opt/libuc2
             			replace /opt/ by the path where is installed the libuc2.
             ______________
             Contributions:
             ~~~~~~~~~~~~~~
             	Feel free to modify everything in the libuc2, if you think that some of your improvement should be integrated in the
-            libuc2 you can send them to me at alexis.jeandet@lpp.polytechnique.fr or alexis.jeandet@gmail.fr.
+            libuc2 you can send them to me at alexis.jeandet@member.fsf.org or alexis.jeandet@gmail.fr.
             ______________
             Documentation:
             ~~~~~~~~~~~~~~
             	You can find some documentation in the Doc folder. But as the libuc, the documentation is not already finished.

bsp/src/OPLAYER/bsp.c +38 -21

             /*------------------------------------------------------------------------------
             --  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 int8_t* lcd0_CMD=(volatile int8_t*)  0x60000000;
+            volatile uint8_t* lcd0_CMD=(volatile uint8_t*)  0x60000000;
-            volatile int8_t* lcd0_DATA=(volatile int8_t*)(0x61FFFFF0);
+            volatile uint8_t* lcd0_DATA=(volatile uint8_t*)(0x61FFFFF0);
             float VREF0 =(float)3.3;
             volatile vs10XXDev audioCodec0;
             sdcardDev sdcard2;
             blkdevice sdcard2blkdev;
             dikpartition sdcard2Part1;
             FAT32fs sdcard2FAT32part1;
             dikpartition sdcard2Part2;
             FAT32fs sdcard2FAT32part2;
             dikpartition sdcard2Part3;
             FAT32fs sdcard2FAT32part3;
             dikpartition sdcard2Part4;
             FAT32fs sdcard2FAT32part4;
             int bsp_init()
             {
                 int i=0;
                 for(i=0;i<__MAX_OPENED_FILES__;i++)
                 {
                     __opnfiles__[i] = NULL;
                 }
                 bsp_GPIO_init();
                 bsp_uart_init();
                 bsp_iic_init();
                 bsp_FSMC_init();
                 bsp_GTerm_init();
                 bsp_spi_init();
                 bsp_SD_init();
                 bsp_Audio_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 GPIO_Out_init_List[]={LED1,LED2,LCD_RESET,LCD_BACKL,VS1053xCS,VS1053xDCS,VS1053xRESET,SDCARD2CS};
                 for(int i=0;i<8;i++)
                 {
                     gpio_t GPIO_init = gpioopen(GPIO_Out_init_List[i]);
                     GPIO_init |=  gpiohighspeed | gpiooutdir | gpiopushpulltype;
                     gpiosetconfig(&GPIO_init);
                 }
                 gpio_t GPIO_In_init_List[]={VS1053DREQ,SDCARD2CD,BP3};
                 for(int i=0;i<3;i++)
                 {
                     gpio_t GPIO_init = gpioopen(GPIO_In_init_List[i]);
                     GPIO_init |=  gpiohighspeed | gpioindir;
                     gpiosetconfig(&GPIO_init);
                 }
                 gpioclr(VS1053xRESET);
                 gpioset(VS1053xCS);
                 gpioset(VS1053xDCS);
                 gpioset(SDCARD2CS);
                 gpioclr(LCD_RESET);
                 gpioclr(LCD_BACKL);
             }
             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(uart3,uartparitynone | uart8bits | uartonestop,115200,PD8,PD9,-1,-1);
+            //        uartmkstreamdev(uart,fd1);
+            //        __opnfiles__[1] = fd1;
+            //    }
+            //    else
+            //    {
+            //        uartopenandconfig(uart3,uartparitynone | uart8bits | uartonestop,115200,PD8,PD9,-1,-1);
+            //    }
             }
             /*
             D0   PD14      D1   PD15      D2   PD0      D3   PD1      D4   PE7
             D5   PE8       D6   PE9       D7   PE10
             A20   PE4  = RS      FSMC_NE1 PD7 CS      FSMC_NWE PD5  W/S
             FSMC_NOE PD4  RD
             */
             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[]={PD14,PD15,PD0,PD1,PE7,PE8,PE9,PE10\
                                       ,PD4,PD5,PD7,PE4};
                 for(int i=0;i<12;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_NORSRAM4 configuration */
                 //p.FSMC_AddressSetupTime = 5;
                 //p.FSMC_AddressSetupTime = 1;
                 p.FSMC_AddressSetupTime = 3;
                 p.FSMC_AddressHoldTime = 3;
                 //p.FSMC_DataSetupTime = 9;
                 //ili9328 -> data setup time > 10ns
                 p.FSMC_DataSetupTime = 1;
                 if(getCpuFreq()>100*1000*1000)
                     p.FSMC_DataSetupTime = 2;// 11;
                 p.FSMC_BusTurnAroundDuration = 0;
                 p.FSMC_CLKDivision = 0;
                 p.FSMC_DataLatency = 0;
                 //ili9328 -> data hold time > 15ns
                 if(getCpuFreq()>66*1000*1000)
-                    p.FSMC_DataLatency = 0;
+                    p.FSMC_DataLatency = 1;
                 p.FSMC_AccessMode = FSMC_AccessMode_A;
                 FSMC_NORSRAMInitStructure.FSMC_Bank = FSMC_Bank1_NORSRAM1;
                 FSMC_NORSRAMInitStructure.FSMC_DataAddressMux = FSMC_DataAddressMux_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_MemoryType = FSMC_MemoryType_SRAM;
                 FSMC_NORSRAMInitStructure.FSMC_MemoryDataWidth = FSMC_MemoryDataWidth_8b;
                 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);
                 FSMC_NORSRAMCmd(FSMC_Bank1_NORSRAM1, ENABLE);
                 gpioset(LCD_RESET);
                 gpioclr(LCD_RESET);
                 delay_100us(500);
                 gpioset(LCD_RESET);
                 delay_100us(500);
                 lcd0.init(&lcd0);
                 gpioset(LCD_BACKL);
                 return 1;
             }
             void bsp_spi_init()
             {
                 gpio_t VSSPI_DBxList[]={VS1053SCK,VS1053MOSI,VS1053MISO};
                 for(int i=0;i<3;i++)
                 {
                     gpio_t SPI_DBx = gpioopen(VSSPI_DBxList[i]);
                     SPI_DBx |=  gpiohighspeed | gpioaf | gpiopushpulltype | gpionopulltype;
                     gpiosetconfig(&SPI_DBx);
                     GPIO_PinAFConfig(GPIOGETPORT(SPI_DBx), (uint8_t)(SPI_DBx & 0xF), GPIO_AF_SPI1);
                 }
                 spiopenandconfig(VS1053SPI,spi8bits|spimaster|spimsbfirst,2*1000*1000,VS1053MOSI,VS1053MISO,VS1053SCK,-1);
                 gpio_t SDSPI_DBxList[]={SDCARD2SCK,SDCARD2MOSI,SDCARD2MISO};
                 for(int i=0;i<3;i++)
                 {
                     gpio_t SPI_DBx = gpioopen(SDSPI_DBxList[i]);
                     SPI_DBx |=  gpiohighspeed | gpioaf | gpiopushpulltype | gpionopulltype;
                     gpiosetconfig(&SPI_DBx);
                     GPIO_PinAFConfig(GPIOGETPORT(SPI_DBx), (uint8_t)(SPI_DBx & 0xF), GPIO_AF_SPI3);
                 }
                 spiopenandconfig(SDCARD2SPI,spi8bits|spimaster|spimsbfirst,400*1000,SDCARD2MOSI,SDCARD2MISO,SDCARD2SCK,-1);
             }
             void bsp_iic_init()
             {
                 // i2copenandconfig(i2c2,0,10000,PF0,PF1);
             }
             void bsp_Audio_init()
             {
                 vs10XXopen(&audioCodec0,VS1053SPI,vs1052setXCS,vs1052setRST,vs1052setXDCS,vs10XXDREQ);
                 if(audioCodec0.VERSION!=UNKNOWN)
                 {
                     printf("detected Audio codec ");
                     switch (audioCodec0.VERSION) {
                     case VS1001:
                         printf("VS1001\n");
                         break;
                     case VS1011:
                         printf("VS1011\n");
                         break;
                     case VS1002:
                         printf("VS1002\n");
                         break;
                     case VS1003:
                         printf("VS1003\n");
                         break;
                     case VS1053:
                         printf("VS1053\n");
                         break;
                     case VS1033:
                         printf("VS1033\n");
                         break;
                     case VS1103:
                         printf("VS1103\n");
                         break;
                     default:
                         printf("Unknown device\n");
                         break;
                     }
                 }
             }
             void bsp_SD_init()
             {
                 if(bspsdcardpresent())
                 {
                     sdcardspimake(&sdcard2,(UHANDLE)SDCARD2SPI,spigetnc,spiputnc,spisetspeed,spigetspeed);
                     sdcardspimakeblkdev(&sdcard2blkdev,&sdcard2,bspsdcardselect,bsppowersdcard,bspsdcardpresent,bspsdcardwriteprotected);
                     if(sdcard2blkdev.initialize(&sdcard2blkdev)!=STA_NOINIT)
                     {
                         if(mbropen(&sdcard2blkdev,&sdcard2Part1,1)==MBRnoErr)
                         {
                             if(FATnoErr!=fat32open(&sdcard2FAT32part1,&sdcard2Part1))
                                 printf("Can't open fat32 partition 1\n");
                         }
                         else
                         {
                             printf("Can't open or read MBR\n");
                         }
                         if(mbropen(&sdcard2blkdev,&sdcard2Part2,2)==MBRnoErr)
                         {
                             if(FATnoErr!=fat32open(&sdcard2FAT32part2,&sdcard2Part2))
                                 printf("Can't open fat32 partition 2\n");
                         }
                         else
                         {
                             printf("Can't open or read MBR\n");
                         }
                         if(mbropen(&sdcard2blkdev,&sdcard2Part3,3)==MBRnoErr)
                         {
                             if(FATnoErr!=fat32open(&sdcard2FAT32part3,&sdcard2Part3))
                                 printf("Can't open fat32 partition 3\n");
                         }
                         else
                         {
                             printf("Can't open or read MBR\n");
                         }
                         if(mbropen(&sdcard2blkdev,&sdcard2Part4,4)==MBRnoErr)
                         {
                             if(FATnoErr!=fat32open(&sdcard2FAT32part4,&sdcard2Part4))
                                 printf("Can't open fat32 partition 4\n");
                         }
                         else
                         {
                             printf("Can't open or read MBR\n");
                         }
                     }
                     else
                     {
                         printf("Can't initialize SDCARD\n");
                     }
                 }
             }
             void vs1052setXCS(char val)
             {
                 gpiosetval(VS1053xCS,(int)val);
             }
             void vs1052setXDCS(char val)
             {
                 //gpiosetval(LED1,(int)val);
                 gpiosetval(VS1053xDCS,(int)val);
             }
             void vs1052setRST(char val)
             {
                 if(val)
                     gpioset(VS1053xRESET);
                 else
                     gpioclr(VS1053xRESET);
             }
             int vs10XXDREQ()
             {
                 return gpiogetval(VS1053DREQ);
             }
             void bsppowersdcard(char onoff)   //always ON
             {
             }
             char bspsdcardpresent()
             {
                 return gpiogetval(SDCARD2CD);
             }
             char bspsdcardwriteprotected()
             {
                 return 0;
             }
             void bspsdcardselect(char YESNO)
             {
              //   gpiosetval(LED1,(int)YESNO);
                 if(YESNO)
                     gpioclr(SDCARD2CS);
                 else
                     gpioset(SDCARD2CS);
             }
             void bsp_lcd0_write_reg(uint32_t reg,uint32_t data)
             {
                 uint8_t* pt8  = (uint8_t*)(void*)&reg;
             #if __BYTE_ORDER__==__ORDER_BIG_ENDIAN__
                 *lcd0_CMD=pt8[3];
                 *lcd0_CMD=pt8[2];
                 pt8  = (uint8_t*)(void*)&data;
                 *lcd0_DATA=pt8[3];
                 *lcd0_DATA=pt8[2];
             #else
                 *lcd0_CMD=pt8[1];
                 *lcd0_CMD=pt8[0];
                 pt8  = (uint8_t*)(void*)&data;
                 *lcd0_DATA=pt8[1];
                 *lcd0_DATA=pt8[0];
             #endif
             }
             uint32_t bsp_lcd0_read_reg(uint32_t reg)
             {
                 uint8_t* pt8  = (uint8_t*)(void*)&reg;
                 uint32_t DATA=0;
             #if __BYTE_ORDER__==__ORDER_BIG_ENDIAN__
                 *lcd0_CMD=pt8[3];
                 *lcd0_CMD=pt8[2];
                 pt8  = (uint8_t*)(void*)&DATA;
                 pt8[3]=*lcd0_DATA;
                 pt8[2]=*lcd0_DATA;
             #else
                 *lcd0_CMD=pt8[1];
                 *lcd0_CMD=pt8[0];
                 pt8  = (uint8_t*)(void*)&DATA;
                 pt8[1]=*lcd0_DATA;
                 pt8[0]=*lcd0_DATA;
             #endif
                 return DATA;
             }
             void bsp_lcd0_writeGRAM(void* buffer,uint32_t count)
             {
                 uint32_t reg =ILI9328_REGISTER_WRITEDATATOGRAM;
                 uint8_t* pt8  = (uint8_t*)(void*)&reg;
             #if __BYTE_ORDER__==__ORDER_BIG_ENDIAN__
                 *lcd0_CMD=pt8[3];
                 *lcd0_CMD=pt8[2];
                 pt8  = (uint8_t*)(void*)buffer;
                 for(int i=0;i<(int)count;i++)
                 {
                     *lcd0_DATA=pt8[(2*i) +1];
                     *lcd0_DATA=pt8[2*i];
                 }
             #else
                 *lcd0_CMD=pt8[1];
                 *lcd0_CMD=pt8[0];
                 pt8  = (uint8_t*)(void*)buffer;
                 for(int i=0;i<(int)count;i++)
                 {
                     *lcd0_DATA=pt8[(2*i) +1];
                     *lcd0_DATA=pt8[2*i];
                 }
             #endif
             }
             void bsp_lcd0_readGRAM(void* buffer,uint32_t count)
             {
-                uint32_t reg =ILI9328_REGISTER_WRITEDATATOGRAM;
+            //    uint32_t reg =ILI9328_REGISTER_WRITEDATATOGRAM;
-                uint8_t* pt8  = (uint8_t*)(void*)&reg;
+            //    int8_t* pt8  = (int8_t*)(void*)&reg;
             #if __BYTE_ORDER__==__ORDER_BIG_ENDIAN__
                 *lcd0_CMD=pt8[3];
                 *lcd0_CMD=pt8[2];
                 pt8  = (uint8_t*)(void*)buffer;
-                pt8[0] = *lcd0_DATA;
-                pt8[0] = *lcd0_DATA;
                 for(int i=0;i<(int)count;i++)
                 {
                     pt8[(2*i) +1]=*lcd0_DATA;
+                    __asm__("nop");
+                    __asm__("nop");
+                    __asm__("nop");
+                    __asm__("nop");
+                    __asm__("nop");
                     pt8[2*i]=*lcd0_DATA;
                 }
             #else
+            //    lcd0_CMD=pt8[1];
-                *lcd0_CMD=pt8[1];
+            //    lcd0_CMD=pt8[0];
-                *lcd0_CMD=pt8[0];
+            //     pt8  = (int8_t*)(void*)buffer;
-                pt8  = (uint8_t*)(void*)buffer;
+            //    for(int i=0;i<(int)count;i++)
-                pt8[0] = *lcd0_DATA;
+            //    {
-                pt8[0] = *lcd0_DATA;
+            //        pt8[(2*i) +1]=*lcd0_DATA;
-                for(int i=0;i<(int)count;i++)
+            //        __asm__("nop");
+            //        __asm__("nop");
-                    pt8[(2*i) +1]=*lcd0_DATA;
+            //        __asm__("nop");
-                    pt8[2*i]=*lcd0_DATA;
+            //        __asm__("nop");
+            //        __asm__("nop");
+            //        pt8[2*i]=*lcd0_DATA;
+                    //pt8[(2*i) +1]=(uint8_t)0;
+                    //pt8[(2*i)]=(uint8_t)0;
+            //    }
             #endif
             }
             void bsp_GTerm_init()
             {
                 if(__opnfiles__[1]==NULL)
                 {
-                    //uart_t* uart1 = (uart_t*)malloc(sizeof(uart_t));
                     streamdevice* fd1 = (streamdevice*)malloc(sizeof(streamdevice));
-                    terminal_init(&terminal0 ,&lcd0,&ComicSansMS_8,fd1);
+                    terminal_init(&terminal0 ,&lcd0,&ComicSansMS_18,fd1);
                     __opnfiles__[1] = fd1;
                 }
                 else
                 {
                 }
             }

bsp/src/STM32F4Discovery/bsp.pri +1 -1

             CPU=stm32f4xxxG
-            DEFINES+=BSP=\\\"SOLAR_LFR_PSU\\\"
+            DEFINES+=BSP=\\\"STM32F4Discovery\\\"
             UCMODEL=stm32f4

bsp/src/bsp.pro +2 -1

             TEMPLATE = subdirs
             CONFIG   += ordered
             SUBDIRS += STM32F4Discovery \
                        M4Stick \
                        M4StickV2 \
                        SOLAR_LFR_PSU \
                        BEAGLESYNTH \
                        STM32F4Eval \
             	   STM32F4Discovery-EXT \
-            	   OPLAYER
+            	   OPLAYER \
+                       SIMULATOR

examples/SOLAR_PSU_HELLO/hello.pro +4 -2

             TEMPLATE = app
             CONFIG += cpu
             UCMODEL=stm32f4
             BSP = OPLAYER
-            DEFINES += CPUFREQ=160000000
+            DEFINES += CPUFREQ=180000000
             SOURCES += \
-                main.c
+                main.c \
+                test_lcd.c

examples/SOLAR_PSU_HELLO/main.c +129 -105

@@ -1,182 +1,206
1	#include <stdio.h>	1	#include <stdio.h>
2	#include <fat32.h>	2	#include <fat32.h>
3	#include <gpio.h>	3	#include <gpio.h>
4	#include <uart.h>	4	#include <uart.h>
5	#include <stm32f4xx.h>	5	#include <stm32f4xx.h>
6	#include <bsp.h>	6	#include <bsp.h>
7	#include <core.h>	7	#include <core.h>
8	#include <VS10XX.h>	8	#include <VS10XX.h>
9	#include <bsp.h>	9	#include <bsp.h>
10	#include <spi.h>	10	#include <spi.h>
11	#include <sdcard.h>	11	#include <sdcard.h>
12	#include <sdcard-spi.h>	12	#include <sdcard-spi.h>
13	#include <fat32.h>	13	#include <fat32.h>
14	#include <ucdirent.h>	14	#include <ucdirent.h>
15	#include <string.h>	15	#include <string.h>
16	#include <terminal.h>	16	#include <terminal.h>
		17	#include <ili9328.h>
17		18
18		19
19	extern streamdevice* __opnfiles__[];	20	extern streamdevice* __opnfiles__[];
		21	extern void test_Block_Move(LCD_t* LCD,int x,int y,int w,int h,int color);
20	char buffer[512];	22	char buffer[512];
21		23
22	void randBoxesDemo()	24	void randBoxesDemo()
23	{	25	{
24	int16_t x,y,w,h,t,r;	26	int16_t x,y,w,h,t,r;
25	x=rand()%240;	27	x=rand()%240;
26	y=rand()%320;	28	y=rand()%320;
27	w=rand()%(240-x);	29	w=rand()%(240-x);
28	if(x>y)	30	if(x>y)
29	r=(rand()%(y))%(320-y);	31	r=(rand()%(y))%(320-y);
30	else	32	else
31	r=(rand()%(x))%(240-x);	33	r=(rand()%(x))%(240-x);
32	h=rand()%(320-y);	34	h=rand()%(320-y);
33	t=rand()%(10);	35	t=rand()%(10);
34	ili9328paintFilRect(&lcd0,x,y,w,h,rand(),t,rand());	36	ili9328paintFilRect(&lcd0,x,y,w,h,rand(),t,rand());
35	//ili9328paintFilCirc(&lcd0,x,y,r,rand(),t,rand());	37	//ili9328paintFilCirc(&lcd0,x,y,r,rand(),t,rand());
36	//delay_100us(10);	38	//delay_100us(10);
37	//for(volatile int i=0;i<(1024*2);i++);	39	//for(volatile int i=0;i<(1024*2);i++);
38	}	40	}
39	void tryToplay1()
40	{
41		41
42	extern FAT32fs sdcard2FAT32part1;	42	void randTextDemo()
43	extern volatile vs10XXDev audioCodec0;	43	{
44	ucdirent root;	44	int16_t x,y,w,h,t,r;
45	char direntName[]=" \n";	45	char buf[2];
46	uint32_t fileLba,nextLba;	46	buf[1]='\0';
47	int i=0;	47	x=rand()%240;
48	spisetspeed(audioCodec0.SPIdev,2000000);	48	y=rand()%320;
49	if(DIRENT_noErr==fat32mkdirent(&sdcard2FAT32part1,&root))	49	if(x>y)
50	{	50	r=(rand()%(y))%(320-y);
51	if(DIRENT_noErr==fat32getrootfirstent(&root))	51	else
52	{	52	r=(rand()%(x))%(240-x);
53	do{	53	h=rand()%(320-y);
54	fat32getdirentname(&root,direntName);	54	buf[0]=rand()%(255);
55	printf("%s\n",direntName);	55	//ili9328paintFilRect(&lcd0,x,y,w,h,rand(),t,rand());
56	nextLba=fat32getdirentlba(&root);	56	ili9328paintText(&lcd0,buf,x,y,&ComicSansMS_18,rand());
57	printf("Streaming File\n");	57	//ili9328paintFilCirc(&lcd0,x,y,r,rand(),t,rand());
58	do	58	delay_100us(5000);
59	{	59	//for(volatile int i=0;i<(1024*2);i++);
60	fileLba = nextLba;
61	if(sdcard2FAT32part1.part->phy->read(sdcard2FAT32part1.part->phy,buffer,fileLba,1)==RES_OK)
62	{
63	for(i=0;i<512;i+=32)
64	{
65	vs10XXstream32bytes(&audioCodec0,buffer+i);
66	}
67	}
68	}while ((fat32nextsectorlba(&sdcard2FAT32part1,fileLba,&nextLba)==DIRENT_noErr) && (!gpiogetval(BP3)));
69	//vs10XXsoftReset(&audioCodec0);
70	while (gpiogetval(BP3))delay_100us(1000);
71	printf("looking for next file\n");
72	}while (DIRENT_noErr==fat32nextdirent(&root));
73	}
74	}
75	if(DIRENT_noErr==fat32mkdirent(&sdcard2FAT32part2,&root))
76	{
77	if(DIRENT_noErr==fat32getrootfirstent(&root))
78	{
79	fat32getdirentname(&root,direntName);
80	printf("%s\n",direntName);
81	nextLba=fat32getdirentlba(&root);
82	printf("Streaming File\n");
83	do
84	{
85	fileLba = nextLba;
86	if(sdcard2FAT32part2.part->phy->read(sdcard2FAT32part2.part->phy,buffer,fileLba,1)==RES_OK)
87	{
88	for(i=0;i<512;i+=32)
89	{
90	vs10XXstream32bytes(&audioCodec0,buffer+i);
91	}
92	}
93	}while ((fat32nextsectorlba(&sdcard2FAT32part2,fileLba,&nextLba)==DIRENT_noErr) && (!gpiogetval(BP3)));
94	while (gpiogetval(BP3))delay_100us(1000);
95	}
96	}
97	if(DIRENT_noErr==fat32mkdirent(&sdcard2FAT32part3,&root))
98	{
99	if(DIRENT_noErr==fat32getrootfirstent(&root))
100	{
101	fat32getdirentname(&root,direntName);
102	printf("%s\n",direntName);
103	nextLba=fat32getdirentlba(&root);
104	printf("Streaming File\n");
105	do
106	{
107	fileLba = nextLba;
108	if(sdcard2FAT32part3.part->phy->read(sdcard2FAT32part3.part->phy,buffer,fileLba,1)==RES_OK)
109	{
110	for(i=0;i<512;i+=32)
111	{
112	vs10XXstream32bytes(&audioCodec0,buffer+i);
113	}
114	}
115	}while ((fat32nextsectorlba(&sdcard2FAT32part3,fileLba,&nextLba)==DIRENT_noErr) && (!gpiogetval(BP3)));
116	while (gpiogetval(BP3))delay_100us(1000);
117	}
118	}
119	if(DIRENT_noErr==fat32mkdirent(&sdcard2FAT32part4,&root))
120	{
121	if(DIRENT_noErr==fat32getrootfirstent(&root))
122	{
123	fat32getdirentname(&root,direntName);
124	printf("%s\n",direntName);
125	nextLba=fat32getdirentlba(&root);
126	printf("Streaming File\n");
127	do
128	{
129	fileLba = nextLba;
130	if(sdcard2FAT32part4.part->phy->read(sdcard2FAT32part4.part->phy,buffer,fileLba,1)==RES_OK)
131	{
132	for(i=0;i<512;i+=32)
133	{
134	vs10XXstream32bytes(&audioCodec0,buffer+i);
135	}
136	}
137	}while ((fat32nextsectorlba(&sdcard2FAT32part4,fileLba,&nextLba)==DIRENT_noErr) && (!gpiogetval(BP3)));
138	while (gpiogetval(BP3))delay_100us(1000);
139	}
140	}
141	}	60	}
		61
142	void tryToplay2()	62	void tryToplay2()
143	{	63	{
144		64
145	extern blkdevice sdcard2blkdev;	65	extern blkdevice sdcard2blkdev;
146	int i=0,l=0;	66	int i=0,l=0;
147		67
148	spisetspeed(audioCodec0.SPIdev,4000000);	68	spisetspeed(audioCodec0.SPIdev,4000000);
149	printf("Streaming File\n");	69	printf("Streaming File\n");
150		70
151	//printf("New LBA=0x%X\n",nextLba);	71	//printf("New LBA=0x%X\n",nextLba);
152		72
153	while(sdcard2blkdev.read(&sdcard2blkdev,buffer,l++,1)==RES_OK)	73	while(sdcard2blkdev.read(&sdcard2blkdev,buffer,l++,1)==RES_OK)
154	{	74	{
155		75
156	for(i=0;i<512;i+=32)	76	for(i=0;i<512;i+=32)
157	{	77	{
158	vs10XXstream32bytes(&audioCodec0,buffer+i);	78	vs10XXstream32bytes(&audioCodec0,buffer+i);
159	}	79	}
160	}	80	}
161	}	81	}
162		82
		83	void playFile(ucdirent* file,FAT32fs* part)
		84	{
		85	extern volatile vs10XXDev audioCodec0;
		86	char direntName[]=" \n";
		87	uint32_t fileLba,nextLba;
		88	int i=0;
		89	fat32getdirentname(file,direntName);
		90	gpioset(LCD_BACKL);
		91	//printf("%s\n",direntName);
		92	nextLba=fat32getdirentlba(file);
		93	//printf("Streaming File\n");
		94	gpioclr(LCD_BACKL);
		95	do
		96	{
		97	fileLba = nextLba;
		98	if(sdcard2FAT32part1.part->phy->read(part->part->phy,buffer,fileLba,1)==RES_OK)
		99	{
		100	for(i=0;i<512;i+=32)
		101	{
		102	vs10XXstream32bytes(&audioCodec0,buffer+i);
		103	}
		104	}
		105	}while ((fat32nextsectorlba(part,fileLba,&nextLba)==DIRENT_noErr) && (!gpiogetval(BP3)));
		106	vs10XXsoftReset(&audioCodec0);
		107	while (gpiogetval(BP3))delay_100us(1000);
		108	}
		109
		110	void playAllparts()
		111	{
		112	extern FAT32fs sdcard2FAT32part1,sdcard2FAT32part2,sdcard2FAT32part3,sdcard2FAT32part4;
		113	ucdirent root;
		114	if(DIRENT_noErr==fat32mkdirent(&sdcard2FAT32part1,&root))
		115	{
		116	printf("Reading on SDCARD2 part1\n");
		117	if(DIRENT_noErr==fat32getrootfirstent(&root))
		118	{
		119	do{
		120	playFile(&root,&sdcard2FAT32part1);
		121	}while (DIRENT_noErr==fat32nextdirent(&root));
		122	}
		123	}
		124	gpioset(LED2);
		125	if(DIRENT_noErr==fat32mkdirent(&sdcard2FAT32part2,&root))
		126	{
		127	printf("Reading on SDCARD2 part2\n");
		128	if(DIRENT_noErr==fat32getrootfirstent(&root))
		129	{
		130	do{
		131	playFile(&root,&sdcard2FAT32part2);
		132	}while (DIRENT_noErr==fat32nextdirent(&root));
		133	}
		134	}
		135	}
		136
163	int main()	137	int main()
164	{	138	{
		139	int i=0;
		140	int color=0;
		141	for(i=0;i<240;i++)
		142	{
		143	if(i>(240/3))
		144	{
		145	color= (i<<5) + 0x1F;
		146	}
		147	else
		148	{
		149	color = i;
		150	}
		151	if(i>(2*240/3))
		152	{
		153	color= (i<<10) + 0x3FF;
		154	}
		155	lcd0.paintFilRect(&lcd0,i,0,1,100,0,0,color);
		156	}
		157	while(1)printf("test ");
		158	// for(i=0;i<240;i++)
		159	// {
		160	// if(i>(240/3))
		161	// {
		162	// color= (i<<5) + 0x1F;
		163	// }
		164	// else
		165	// {
		166	// color = i;
		167	// }
		168	// if(i>(2*240/3))
		169	// {
		170	// color= (i<<10) + 0x3FF;
		171	// }
		172	// lcd0.paintFilRect(&lcd0,i,220,1,100,0,0,color);
		173	// }
		174	for(i=0;i<240;i++)
		175	{
		176	ili9328setFrame(&lcd0,i,0,1,100);
		177	lcd0.interface->readGRAM(buffer,100);
		178	lcd0.paint(&lcd0,buffer,i,200,1,100);
		179	}
		180	while(1);
		181	}
		182
		183	int main2()
		184	{
165	extern terminal_t terminal0;	185	extern terminal_t terminal0;
166	extern volatile vs10XXDev audioCodec0;	186	extern volatile vs10XXDev audioCodec0;
		187	lcd0.paintText(&lcd0,"hello",20,50,&ComicSansMS_18 ,0xF0F0);
		188	while (1)
		189	randTextDemo();
167	printf("Volume=0x%x\n",vs10XXcmdread(&audioCodec0,VSVOL));	190	printf("Volume=0x%x\n",vs10XXcmdread(&audioCodec0,VSVOL));
168	vs10XXcmdwrite(&audioCodec0,VSCLOCKF,0x2000);	191	vs10XXcmdwrite(&audioCodec0,VSCLOCKF,0x2000);
169	vs10XXcmdwrite(&audioCodec0,VSVOL,0x2222);	192	delay_100us(1000);
		193	vs10XXcmdwrite(&audioCodec0,VSVOL,0x2020);
170	printf("VSCLOCKF=0x%x\n",vs10XXcmdread(&audioCodec0,VSCLOCKF));	194	printf("VSCLOCKF=0x%x\n",vs10XXcmdread(&audioCodec0,VSCLOCKF));
171	printf("VSMODE=0x%x\n",vs10XXcmdread(&audioCodec0,VSMODE));	195	printf("VSMODE=0x%x\n",vs10XXcmdread(&audioCodec0,VSMODE));
172	terminal_clear(&terminal0);	196	//terminal_clear(&terminal0);
173	// tryToplay2();	197	gpioclr(LCD_BACKL);
174	~~tryToplay1~~();	198	playAllparts();
175	return 0;	199	return 0;
176	}	200	}
177		201
178		202
179		203
180		204
181		205
182		206

examples/examples.pro +2 -1

             TEMPLATE = subdirs
             CONFIG   += ordered
             SUBDIRS += 	QtTest/test.pro \
                             SOLAR_PSU_HELLO/hello.pro \
                             SDCARD \
                             STM32F4IT \
                             M4StickV2 \
                             lcdHello \
                             BeagleSynthHello \
             		lcdTerminal \
                             BeagleSynthHelloSupMon \
                             TEST_CMSIS_FFT \
                             N25Q128_test \
-                ssd2119Tests
+                            ssd2119Tests \
+                            TEST_SIMULATOR

lib/src/common/AUDIO/CS43L22/CS43L22.pro +2 -1

             TEMPLATE = subdirs
             CONFIG   += ordered
-            SUBDIRS += ./CS43L22_STM32F4.pro
+            SUBDIRS += ./CS43L22_STM32F4.pro \
+                       ./CS43L22_SIMULATOR.pro

lib/src/common/AUDIO/CS43L22/CS43L22_STM32F4.pro 0 -1

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

lib/src/common/AUDIO/VS10XX/VS10XX.pro +3 -15

@@ -1,15 +1,3
1	TEMPLATE = ~~lib~~	1	TEMPLATE = subdirs
2	OBJECTS_DIR = obj	2	SUBDIRS += ./VS10XX_STM32F4.pro \
3	TARGET = vs10XX	3	./VS10XX_SIMULATOR.pro
4
5	SOURCES += VS10XX.c
6
7
8	HEADERS += ../../../includes/VS10XX.h
9	INCLUDEPATH += ../../../includes
10
11	UCMODEL=stm32f4
12
13	target.path = $$[QT_INSTALL_LIBS]/$$UCMODEL
14	INSTALLS += target
15

lib/src/common/EEPROMS/24LCXX/24LC0X/24LC0X.pro +3 -16

@@ -1,16 +1,3
1	TEMPLATE = ~~lib~~	1	TEMPLATE = subdirs
2	OBJECTS_DIR = obj	2	SUBDIRS += ./24LC0X_STM32F4.pro \
3		3	./24LC0X_SIMULATOR.pro
4	SOURCES += 24LC0X.c
5	HEADERS += ../../../includes/24LC0X.h \
6	../../../../includes/24LC0X.h
7
8	INCLUDEPATH += ../../../includes \
9	../../CPU/STM32F4xx_StdPeriph_Driver/inc \
10	../../CPU/CMSIS/Include
11
12
13	UCMODEL=stm32f4
14
15	target.path = $$[QT_INSTALL_LIBS]/$$UCMODEL
16	INSTALLS += target

lib/src/common/EEPROMS/N25Q128/N25Q128.pro +3 -13

@@ -1,15 +1,5
1	TEMPLATE = ~~lib~~	1	TEMPLATE = subdirs
2	OBJECTS_DIR = obj
3
4	SOURCES += N25Q128.c
5	HEADERS += ../../../includes/N25Q128.h
6
7	INCLUDEPATH += ../../../includes \
8	../../CPU/STM32F4xx_StdPeriph_Driver/inc \
9	../../CPU/CMSIS/Include
10		2
11		3
12	UCMODEL=stm32f4	4	SUBDIRS += ./N25Q128_SIMULATOR.pro \
13		5	./N25Q128_STM32F4.pro
14	target.path = $$[QT_INSTALL_LIBS]/$$UCMODEL
15	INSTALLS += target

lib/src/common/FILE_SYSTEM/DIRENT/DIRENT.pro +2 -1

             TEMPLATE = subdirs
             CONFIG   += ordered
-            SUBDIRS += ./dirent_STM32F4.pro
+            SUBDIRS += ./dirent_STM32F4.pro \
+            		./dirent_SIMULATOR.pro

lib/src/common/FILE_SYSTEM/FAT32/FAT32.pro +2 -1

             TEMPLATE = subdirs
             CONFIG   += ordered
-            SUBDIRS += ./fat32_STM32F4.pro
+            SUBDIRS += ./fat32_STM32F4.pro \
+            	   ./fat32_SIMULATOR.pro

lib/src/common/FILE_SYSTEM/FAT32/fat32.c +136 -89

             /*------------------------------------------------------------------------------
             --  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
             -------------------------------------------------------------------------------*/
             #define FAT32_PRIVATE
             #include <fat32.h>
             #include <stdio.h>
             #include <stdint.h>
             #include <hexviewer.h>
-            char fat32buff[512];
+            char fat32buff[512]__attribute__ ((aligned (4)));
             uint32_t lastSecAddrs=-1;
             FAT32fs* lastFATFS=0;
             int fat32open(FAT32fs* fs,dikpartition* part)
             {
-            	char sector[512];
+                fs->valide = 0;
-            	fs->part = part;
+                if(part->valide==0)return FATBadpart;
-            	if(!isFat32(fs->part->TypeCode))return FATBadpart;
+                char sector[512];
-            	if(fs->part->phy->read(fs->part->phy,sector,fs->part->LBABegin,1)!=RES_OK)return FATReadErr;
+                fs->part = part;
+                if(!isFat32(fs->part->TypeCode))return FATBadpart;
+                if(fs->part->phy->read(fs->part->phy,sector,fs->part->LBABegin,1)!=RES_OK)return FATReadErr;
                 fs->BPB_BytsPerSec = fat32Ui8_2_Ui16(sector,BPB_BytsPerSecoff);
                 fs->BPB_RsvdSecCnt = fat32Ui8_2_Ui16(sector,BPB_RsvdSecCntoff);
                 fs->BPB_FATSz32    = fat32Ui8_2_Ui32(sector,BPB_FATSz32off);
                 fs->BPB_RootClus   = fat32Ui8_2_Ui32(sector,BPB_RootClusoff);
-            	fs->BPB_SecPerClus = sector[BPB_SecPerClusoff];
+                fs->BPB_SecPerClus = sector[BPB_SecPerClusoff];
-            	fs->BPB_NumFATs    = sector[BPB_NumFATsoff];
+                fs->BPB_NumFATs    = sector[BPB_NumFATsoff];
-            	fs->fat_begin_lba  = (unsigned int)fs->part->LBABegin + (unsigned int)(unsigned short)fs->BPB_RsvdSecCnt;
+                fs->fat_begin_lba  = (unsigned int)fs->part->LBABegin + (unsigned int)(unsigned short)fs->BPB_RsvdSecCnt;
-            	fs->cluster_begin_lba = (unsigned int)fs->fat_begin_lba + ((unsigned int)fs->BPB_NumFATs * (unsigned int)fs->BPB_FATSz32 );
+                fs->cluster_begin_lba = (unsigned int)fs->fat_begin_lba + ((unsigned int)fs->BPB_NumFATs * (unsigned int)fs->BPB_FATSz32 );
-            	return FATnoErr;
+                fs->valide=1;
+                return FATnoErr;
             }
             int fat32mkdirent(FAT32fs* fs,ucdirent* dirent)
             {
-            	if(fs==0) return DIRENT_BabArg;
+                if((fs==0) || (fs->valide==0)) return DIRENT_BabArg;
-            	if(dirent==0) return DIRENT_BabArg;
+                if(dirent==0) return DIRENT_BabArg;
-            	dirent->fs = (UHANDLE)fs;
+                dirent->fs = (UHANDLE)fs;
-            	dirent->getrootfirstent = &fat32getrootfirstent;
+                dirent->getrootfirstent = &fat32getrootfirstent;
-            	dirent->nextdirent = &fat32nextdirent;
+                dirent->nextdirent = &fat32nextdirent;
-            	return DIRENT_noErr;
+                return DIRENT_noErr;
             }
             int fat32getrootfirstent(ucdirent* entry)
             {
-            	if(entry==0) return DIRENT_BabArg;
+                if(entry==0) return DIRENT_BabArg;
-            	entry->CurrentSec = ((FAT32fs*)entry->fs)->cluster_begin_lba;
+                entry->CurrentSec = ((FAT32fs*)entry->fs)->cluster_begin_lba;
-            	entry->Currententry = 0;
+                entry->Currententry = 0;
-            	return fat32nextdirent(entry);
+                return fat32nextdirent(entry);
             }
             int fat32getVolName(FAT32fs* fs,char* Name)
             {
-            	if(fs==0) return DIRENT_BabArg;
+                if((fs==0) || (fs->valide==0)) return DIRENT_BabArg;
-            	if(Name==0) return DIRENT_BabArg;
+                if(Name==0) return DIRENT_BabArg;
-            	int i=0;
+                int i=0;
-            	ucdirent entry;
+                ucdirent entry;
-            	if(DIRENT_noErr==fat32mkdirent(fs,&entry))
+                if(DIRENT_noErr==fat32mkdirent(fs,&entry))
+                {
-            		entry.CurrentSec = ((FAT32fs*)entry.fs)->cluster_begin_lba;
+                    entry.CurrentSec = ((FAT32fs*)entry.fs)->cluster_begin_lba;
-            		entry.Currententry = -1;
+                    entry.Currententry = -1;
-            		if(DIRENT_noErr!=fat32nextdirent(&entry))return DIRENT_ReadErr;
+                    if(DIRENT_noErr!=fat32nextdirent(&entry))return DIRENT_ReadErr;
-            		for(i=0;i<16;i++)
+                    for(i=0;i<16;i++)
+                    {
-            			Name[i] = entry.DIR_Name[i];
+                        Name[i] = entry.DIR_Name[i];
+                    }
-            		return DIRENT_noErr;
+                    return DIRENT_noErr;
+                }
-            	return DIRENT_ReadErr;
+                return DIRENT_ReadErr;
             }
             int fat32enterdirent(ucdirent* currententry,ucdirent* firstentry)
             {
-            	if(firstentry==0) return DIRENT_BabArg;
+                if(firstentry==0) return DIRENT_BabArg;
-            	if(currententry==0) return DIRENT_BabArg;
+                if(currententry==0) return DIRENT_BabArg;
                 fat32mkdirent(((FAT32fs*)currententry->fs),firstentry);
-            	firstentry->CurrentSec = fat32getdirentlba(currententry);
+                firstentry->CurrentSec = fat32getdirentlba(currententry);
-            	firstentry->Currententry = -1;
+                firstentry->Currententry = -1;
-            	return fat32nextdirent(firstentry);
+                return fat32nextdirent(firstentry);
             }
             int fat32nextdirent(ucdirent* entry)
             {
                 uint32_t n=0,res=DIRENT_noErr,k,j;
                 k=(0xFF&((signed char)entry->Currententry)+1)*32; /*Restart at last dir entry*/
                 j=entry->CurrentSec;//  /*Restart at last sector*/
-            	do
+                do
+                {
+                    //printf("reading new secotr\n",k);
                     fat32sectorreadout(((FAT32fs*)entry->fs),j);
-            		for(k=k;k<(512);k+=32)     /*512 Bytes per sector and 32 bytes per entry*/
+                    //printf("done\n",k);
+                    /*512 Bytes per sector and 32 bytes per entry*/
+                    for(k=k;k<(512);k+=32)
+                    {
                         if((fat32buff[DIR_Nameoff+k]!=(char)0xE5))   /*0xE5 = free entry*/
+                        {
+                            //printf("Fount dir entry = %d, 0x%X\n",0xff & ((int)fat32buff[DIR_Nameoff+k]),0xff & ((int)fat32buff[DIR_Attroff+k]));
                             if(fat32buff[DIR_Nameoff+k]==(char)0)
+                            {
+                                //printf("end of directory reached\n",k);
                                 return DIRENT_EndOfDir;   /*0x00 = end of dir*/
-            				else
-                                if((fat32buff[DIR_Attroff + k]==(char)ATTR_DIRECTORY)||(fat32buff[DIR_Attroff + k]==(char)ATTR_ARCHIVE)||(fat32buff[DIR_Attroff + k]==(char)(ATTR_READ_ONLY)))
+                            else
+                            {
-            						for(n=0;n<16;n++)entry->DIR_Name[n] = '\0';
+                                uint8_t attribute=fat32buff[DIR_Attroff + k];
-            						for(n=0;n<11;n++)entry->DIR_Name[n] = fat32buff[n+DIR_Nameoff + k];
+                                if(       (attribute==ATTR_DIRECTORY)
-                                    entry->DIR_Attr         = (uint8_t)fat32buff[DIR_Attroff + k];
+                                          ||(attribute==ATTR_ARCHIVE)
+                                          ||(attribute==ATTR_READ_ONLY)
+                                          ||(attribute==ATTR_READ_ONLY))
+                                {
+                                    for(n=0;n<16;n++)entry->DIR_Name[n] = '\0';
+                                    for(n=0;n<11;n++)entry->DIR_Name[n] = fat32buff[n+DIR_Nameoff + k];
+                                    entry->DIR_Attr         = attribute;
                                     entry->DIR_CrtTimeTenth = (uint8_t)fat32buff[DIR_CrtTimeTenthoff + k];
                                     entry->DIR_CrtTime      = fat32extract16b(fat32buff,(DIR_CrtTimeoff + k));
                                     entry->DIR_CrtDate      = fat32extract16b(fat32buff,(DIR_CrtDateoff + k));
                                     entry->DIR_LstAccDate   = fat32extract16b(fat32buff,(DIR_LstAccDateoff + k));
                                     entry->DIR_FstClusHI    = fat32extract16b(fat32buff, (DIR_FstClusHIoff + k));
                                     entry->DIR_WrtTime      = fat32extract16b(fat32buff,(DIR_WrtTimeoff + k));
                                     entry->DIR_FstClustLO   = fat32extract16b(fat32buff, (DIR_FstClusLOoff + k));
                                     entry->DIR_FileSize     = fat32extract32b(fat32buff,(DIR_FileSizeoff + k));
-            						entry->CurrentSec = j;
+                                    entry->CurrentSec = j;
-            						entry->Currententry = (unsigned char)(k/32);
+                                    entry->Currententry = (uint8_t)(0xFF&(k>>5));
-            						return DIRENT_noErr;
+                                    return DIRENT_noErr;
+                                }
+                            }
+                        }
+                    }
-            		j=fat32nextsectorlba(((FAT32fs*)entry->fs),j,&k);
+                    //printf("asking for next sector\n");
-            		if(j!=DIRENT_noErr)
+                    //printf("current = 0x%X\n",j);
+                    j=fat32nextsectorlba(((FAT32fs*)entry->fs),j,&k);
-            			if(j==DIRENT_LastSect) return DIRENT_EndOfDir;   /*Not clean but can avoid some bugs*/
+                    //printf("got it 0x%x\n",k);
-            			return j;
+                    if(j!=DIRENT_noErr)
+                    {
-            		j=k;
+                        if(j==DIRENT_LastSect) return DIRENT_EndOfDir;   /*Not clean but can avoid some bugs*/
-            		k=0;
+                        return j;
-            	}while(res==DIRENT_noErr);
-            	return res;
+                    j=k;
+                    k=0;
+                }while(res==DIRENT_noErr);
+                return res;
             }
             int fat32getdirentname(ucdirent* entry,char* nameBuffer)
             {
                 uint32_t j;
                 int k,n,i;
                 int res=DIRENT_noErr;
                 char longName=0;
                 k=(((signed char)entry->Currententry))*32;
                 j=entry->CurrentSec;
                 fat32sectorreadout(((FAT32fs*)entry->fs),j);
                 longName |= fat32buff[DIR_Nameoff + 6 + k]=='~';
                 if(k>=32)
                 {
                     longName |= ((fat32buff[DIR_Nameoff + k-32]&0x40)==0x40)&((fat32buff[DIR_Nameoff + k-32 +11])==ATTR_LONGNAME);
                 }
                 else
                 {
                     uint32_t j_old=j;
                     if(fat32prevsectorlba((FAT32fs*)entry->fs, j,&j)!=DIRENT_noErr)return DIRENT_ReadErr;
                     fat32sectorreadout(((FAT32fs*)entry->fs),j);
                     k=512;
                     longName |= ((fat32buff[DIR_Nameoff + k-32]&0x40)==0x40)&((fat32buff[DIR_Nameoff + k-32 +11])==ATTR_LONGNAME);
                     if(!longName)
                     {
                         k=0;
                         j=j_old;
                         fat32sectorreadout(((FAT32fs*)entry->fs),j);
                         k=0;
                     }
                 }
                 if(longName) //long Name? or lower case name
                 {
                     i=0;
                     do{
                         if(k==0)
                         {
                             //get previous sector
-                            if(fat32prevsectorlba((FAT32fs*)entry->fs, j,&j)!=DIRENT_noErr)return DIRENT_ReadErr;
+                            if(fat32prevsectorlba2((FAT32fs*)entry->fs,entry, j,&j)!=DIRENT_noErr)return DIRENT_ReadErr;
                             fat32sectorreadout(((FAT32fs*)entry->fs),j);
                             k=512-32;
                             for(n=0;n<5;n++)nameBuffer[i++] = fat32buff[((n<<1)|1) + k];
                             for(n=14;n<26;n+=2)nameBuffer[i++] = fat32buff[n + k];
                             for(n=28;n<32;n+=2)nameBuffer[i++] = fat32buff[n + k];
                         }
                         else
                         {
                             k-=32;
                             for(n=0;n<5;n++)nameBuffer[i++] = fat32buff[((n<<1)|1) + k];
                             for(n=14;n<26;n+=2)nameBuffer[i++] = fat32buff[n + k];
                             for(n=28;n<32;n+=2)nameBuffer[i++] = fat32buff[n + k];
                         }
                     }while((fat32buff[k]&0x40)!=0x40);
                     nameBuffer[i]='\0';
                 }
                 else
                 {
                     i=0;
                     for(n=0;n<8;n++)
                     {
                         nameBuffer[i] = 0x20 | fat32buff[n+DIR_Nameoff + k];
                         if(nameBuffer[i]!=0x20)i++;
                     }
                     if((((fat32buff[DIR_Nameoff + k +11])&ATTR_DIRECTORY)!=ATTR_DIRECTORY)&&(fat32buff[8+DIR_Nameoff + k]!=0x20))
                         nameBuffer[i++]='.';
                     for(n=8;n<11;n++)
                     {
                         nameBuffer[i] = 0x20 | fat32buff[n+DIR_Nameoff + k];
                         if(nameBuffer[i]!=0x20)i++;
                     }
                     nameBuffer[i]='\0';
                 }
                 return res;
             }
             uint32_t fat32getdirentlba(ucdirent* entry)
             {
                 uint32_t clusterNum = (uint32_t)((uint16_t)entry->DIR_FstClustLO) + ((uint32_t)((uint16_t)entry->DIR_FstClusHI) <<16);
                 uint32_t lba=clusterlba(((FAT32fs*)entry->fs),clusterNum);
-            	return lba;
+                return lba;
             }
             int fat32nextsectorlba(FAT32fs* fs,uint32_t lastsector_lba,uint32_t *nextsector_lba)
             {
                 if(((lastsector_lba + 1 - fs->cluster_begin_lba) & ((uint32_t)(fs->BPB_SecPerClus)-1))!=0)  /*Is it the last sector of the cluster?*/
+                {
                     *nextsector_lba = lastsector_lba+1;                                       /*if not just increment lba*/
-            		return DIRENT_noErr;
+                    return DIRENT_noErr;
                 }
                 uint32_t clusternum=fat32sectorlbatoclusternum(fs,lastsector_lba); /*Get cluster Number from sector number*/
                 uint32_t fatsec=fat32clusterinfatsect(fs,clusternum);              /*Get FAT sector number*/
                 fat32sectorreadout(fs,fatsec);
                 int i= fat32clusterinfatoff(clusternum);
                 *nextsector_lba=fat32Ui8_2_Ui32(fat32buff,i);
                 if(*nextsector_lba==0xFFFFFFF7)
                 {
-                    printf("DIRENT_BadSect\n");
                     return DIRENT_BadSect;
                 }
                 if((uint32_t)(*nextsector_lba)>=(uint32_t)0xFFFFFFF6)
                 {
-                    printf("DIRENT_LastSect\n");
                     return DIRENT_LastSect;
                 }
-            	*nextsector_lba = clusterlba(fs,*nextsector_lba);
+                *nextsector_lba = clusterlba(fs,*nextsector_lba);
-            	return DIRENT_noErr;
+                return DIRENT_noErr;
             }
             int fat32prevsectorlba(FAT32fs* fs,uint32_t lastsector_lba,uint32_t *nextsector_lba)
             {
                 uint32_t i=0,fatsec=0;
                 if(((lastsector_lba - 1 - fs->cluster_begin_lba) & (fs->BPB_SecPerClus-1))!=0)  /*Is it the first sector of the cluster?*/
                 {
                     *nextsector_lba = lastsector_lba-1;                                       /*if not just decrement lba*/
                     return DIRENT_noErr;
                 }
-                uint32_t clusternum=fat32sectorlbatoclusternum(fs,lastsector_lba); /*Get cluster Number from sector number*/
+                uint32_t clusternum = fat32sectorlbatoclusternum(fs,lastsector_lba); /*Get cluster Number from sector number*/
                 fatsec=fat32clusterinfatsect(fs,clusternum);              /*Get FAT sector number*/
-                do
+                while(fatsec>=fs->fat_begin_lba)
                 {
                     fat32sectorreadout(fs,fatsec);
                     fatsec--;
-                    for(i=511;i>3;i-=4)
+                    for(i=508;i>2;i-=4)
                     {
-                        *nextsector_lba = fat32Ui8_2_Ui32(fat32buff,i-3);
+                        *nextsector_lba = fat32Ui8_2_Ui32(fat32buff,i);
                         if (*nextsector_lba ==clusternum)
                         {
                             *nextsector_lba = clusterlba(fs,*nextsector_lba);
                             return DIRENT_noErr;
                         }
                     }
+                }
-                }while(fatsec>=fs->fat_begin_lba);
                 clusternum=fat32sectorlbatoclusternum(fs,lastsector_lba); /*Get cluster Number from sector number*/
                 fatsec=fat32clusterinfatsect(fs,clusternum);              /*Get FAT sector number*/
                 do
                 {
                     fat32sectorreadout(fs,fatsec);
                     fatsec++;
                     for(i=0;i<512;i+=4)
                     {
                         *nextsector_lba = fat32Ui8_2_Ui32(fat32buff,i);
                         if (*nextsector_lba ==clusternum)
                         {
                             *nextsector_lba = clusterlba(fs,*nextsector_lba);
                             return DIRENT_noErr;
                         }
                     }
+                }while(fatsec<=(fs->fat_begin_lba+fs->BPB_FATSz32));
+                return DIRENT_ReadErr;
+            }
-                }while(fatsec<=(fs->fat_begin_lba+fs->BPB_FATSz32));
+            int fat32prevsectorlba2(FAT32fs* fs,ucdirent* entry,uint32_t lastsector_lba,uint32_t *nextsector_lba)
+            {
+                uint32_t i=0,fatsec=0;
+                if(((lastsector_lba - 1 - fs->cluster_begin_lba) & (fs->BPB_SecPerClus-1))!=0)  /*Is it the first sector of the cluster?*/
+                {
+                    *nextsector_lba = lastsector_lba-1;                                       /*if not just decrement lba*/
+                    return DIRENT_noErr;
+                }
+                uint32_t clusternum = fat32sectorlbatoclusternum(fs,lastsector_lba); /*Get cluster Number from sector number*/
+                uint32_t currentClusternum = fat32sectorlbatoclusternum(fs,(fat32getdirentlba(entry)));
+                fatsec=fat32clusterinfatsect(fs,currentClusternum);              /*Get FAT sector number*/
+                *nextsector_lba = fat32getdirentlba(entry);
+                while(fatsec<=(fs->fat_begin_lba+fs->BPB_FATSz32))
+                {
+                    uint32_t currentClusternum = fat32sectorlbatoclusternum(fs,(*nextsector_lba));
+                    fatsec=fat32clusterinfatsect(fs,currentClusternum);              /*Get FAT sector number*/
+                    fat32sectorreadout(fs,fatsec);
+                    i= fat32clusterinfatoff(currentClusternum);
+                    if(i==clusternum)
+                    {
+                        return DIRENT_noErr;
+                    }
+                    *nextsector_lba=fat32Ui8_2_Ui32(fat32buff,i);
+                    if(*nextsector_lba==0xFFFFFFF7)
+                    {
+                        return DIRENT_BadSect;
+                    }
+                    if((uint32_t)(*nextsector_lba)>=(uint32_t)0xFFFFFFF6)
+                    {
+                        return DIRENT_LastSect;
+                    }
+                }
                 return DIRENT_ReadErr;
             }

lib/src/common/FILE_SYSTEM/MBR/MBR.pro +2 -1

             TEMPLATE = subdirs
             CONFIG   += ordered
-            SUBDIRS += ./mbr_STM32F4.pro
+            SUBDIRS += ./mbr_STM32F4.pro \
+            		./mbr_SIMULATOR.pro

lib/src/common/FILE_SYSTEM/MBR/mbr.c +4 -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 "mbr.h"
+            #include <mbr.h>
             #include <stdio.h>
             int mbropen(blkdevice* phy,dikpartition* part,char partNum)
             {
             	printf("enter MBR open function\n");
             	char mbr[512];
             	if((part==0) || (phy ==0) || (partNum>4) || (partNum==0)  ) return MBRBabArg;
             	part->phy = phy;
             	if(phy->read(phy,mbr,0,1)!=RES_OK)
             	{
             		printf("can't read MBR!\n");
                     printf("%x %x %x %x %x %x %x %x\n",mbr[0],mbr[1],mbr[2],mbr[3],mbr[4],mbr[5],mbr[6],mbr[7]);
+                    part->valide = 0;
             		return MBRReadErr;
             	}
             	if(((mbr[510]) == (char)0x55) && ((mbr[511]) == (char)0xAA))
             	{
             		part->TypeCode = mbr[(512-82+TypeCodeoffset)+partNum*16];
             		part->LBABegin = (unsigned int)mbr[(512-82+LBABeginoffset)+partNum*16] + ((unsigned int)mbr[(512-82+LBABeginoffset+1)+partNum*16]<<8)+ ((unsigned int)mbr[(512-82+LBABeginoffset+2)+partNum*16]<<16)+ ((unsigned int)mbr[(512-82+LBABeginoffset+3)+partNum*16]<<24);
             		part->NumOfSec = (unsigned int)mbr[(512-82+NumOfSecoffset)+partNum*16] + ((unsigned int)mbr[(512-82+NumOfSecoffset+1)+partNum*16]<<8)+ ((unsigned int)mbr[(512-82+NumOfSecoffset+2)+partNum*16]<<16)+ ((unsigned int)mbr[(512-82+NumOfSecoffset+3)+partNum*16]<<24);
             		printf("MBR Ok\n");
+                    part->valide = 1;
             		return MBRnoErr;
             	}
             	printf("Bad MBR MBR[510]=0x%.2X MBR[511]=0x%.2X!\n",0xff&mbr[510],0xff&mbr[511]);
+                part->valide = 0;
             	return MBRBadMbr;
             }

lib/src/common/FILE_SYSTEM/MBR/mbr_STM32F4.pro +3 0

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

lib/src/common/FILE_SYSTEM/SDCARD/sdcard_STM32F4.pro 0 -1

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

lib/src/common/GRAPHIC/CONTROLERS/ILI9328/ILI9328.pro +2 -1

             TEMPLATE = subdirs
             CONFIG   += ordered
-            SUBDIRS += ./ili9328_STM32F4.pro
+            SUBDIRS += ./ili9328_STM32F4.pro \
+                       ./ili9328_SIMULATOR.pro

lib/src/common/GRAPHIC/CONTROLERS/ILI9328/ili9328.c +3 -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!='\0')
                 {
+                    if(*buffer<32)*buffer=32;
+                    if(*buffer>127)*buffer=32;
                     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++];
                         }
+                        tmp[pix]=0;
                         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, 0x0302);
                     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(1000);
                     LCD->interface->writereg(ILI9328_REGISTER_POWERCONTROL1, 0x14B0);         // Power Control 1 (R10h)
                     delay_100us(500);
                     LCD->interface->writereg(ILI9328_REGISTER_POWERCONTROL2, 0x0007);         // Power Control 2 (R11h)
                     delay_100us(500);
                     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, LCD->width - 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, LCD->height - 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->paintFilRect(LCD,0,0,LCD->width,LCD->height,0,0,0xFFFF);
                 }
                 return 0;
             }

lib/src/common/GRAPHIC/CONTROLERS/SSD2119/SSD2119.pro +2 -1

             TEMPLATE = subdirs
             CONFIG   += ordered
-            SUBDIRS += ./ssd2119_STM32F4.pro
+            SUBDIRS += ./ssd2119_STM32F4.pro \
+                       ./ssd2119_SIMULATOR.pro

lib/src/common/GRAPHIC/CONTROLERS/SSD2119/ssd2119_STM32F4.pro 0 -1

             TEMPLATE = lib
-            OBJECTS_DIR = obj
             TARGET = ssd2119
             SOURCES +=  \
                 ssd2119.c
             DEFINES -= __OPTIMIZED_MATH
             INCLUDEPATH += ../../../../includes \
             	../../../CPU/STM32F4xx_StdPeriph_Driver/inc \
             	../../../CPU/CMSIS/Include \
             	../../../../includes/GRAPHIC/CONTROLERS \
             	../../../../includes/GRAPHIC/GUI/FONTS \
             	../../../../includes/GRAPHIC/GUI/Widgets
             UCMODEL=stm32f4
             target.path = $$[QT_INSTALL_LIBS]/$$UCMODEL
             INSTALLS += target

lib/src/common/GRAPHIC/GUI/FONTS/FONTS.pro +2 -1

             TEMPLATE = subdirs
-            SUBDIRS += 	./FONTS_STM32F4.pro
+            SUBDIRS += 	./FONTS_STM32F4.pro \
+                            ./FONTS_SIMULATOR.pro

lib/src/common/GRAPHIC/GUI/Widgets/Terminal/Terminal.c +71 -13

             /*------------------------------------------------------------------------------
             --  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
             -------------------------------------------------------------------------------*/
             #include <widget.h>
             #include <terminal.h>
             #include <stdint.h>
             #include <stdio.h>
             #include <gpio.h>
             #include <core.h>
+            #include <malloc.h>
             #define CHARXPOS(terminal,charwidth) (((terminal)->column * charwidth) + (terminal)->Xpos)
             #define CHARYPOS(terminal,charheight) ((terminal)->line * charheight + (terminal)->Ypos+charheight)
             streamdevice_ops TERMINAL_OPS=
             {
                 .write = &terminal_write,
                 .read  = &terminal_read,
                 .setpos= &terminal_setpos,
                 .close = NULL
             };
             int terminal_init(terminal_t* terminal,LCD_t* LCD,sFONT* font,streamdevice* strdev)
             {
                 if((LCD!=NULL) && (font!=NULL) && (strdev!=NULL) && (terminal!=NULL))
                 {
                     terminal->LCD=LCD;
                     terminal->font=font;
                     terminal->line = 0;
                     terminal->column = 0;
-                    terminal->horizontalSpace=0;
+                    terminal->horizontalSpace = 0;
-                    terminal->verticalSpace=0;
+                    terminal->verticalSpace = 0;
                     int charw=terminal->font->Width + terminal->horizontalSpace;
                     int charh=terminal->font->Height + terminal->verticalSpace;
                     terminal->textColor=0xFFFF;
                     terminal->backgroundColor=0x0000;
                     terminal_setgeometry(terminal,5,5,terminal->LCD->width-(10),terminal->LCD->height-(10));
                     strdev->_stream = (UHANDLE)terminal;
                     strdev->ops = &TERMINAL_OPS;
                     strdev->streamPt = 0;
                     terminal_clear(terminal);
                     terminal->LCD->paintFilRect(terminal->LCD,CHARXPOS(terminal, charw),CHARYPOS(terminal, charh)-charh,charw,charh,terminal->backgroundColor,0,terminal->backgroundColor);
+                    terminal->buffer = (char*)malloc(terminal->lineCount*(terminal->columnCount + 1));
+                    terminal->firstLine = 0;
+                    terminal->lastLine = 0;
+                    terminal->empty = 1;
+                    for(int i=1;i<=terminal->lineCount;i++)
+                    {
+                        terminal->buffer[i * terminal->columnCount]='\n';
+                    }
                     return 1;
                 }
                 return 0;
             }
             void terminal_setgeometry(terminal_t* terminal,uint16_t Xpos,uint16_t Ypos,uint16_t width,uint16_t height)
             {
                 int charw=terminal->font->Width + terminal->horizontalSpace;
                 int charh=terminal->font->Height + terminal->verticalSpace;
                 if(terminal->LCD->height<(Ypos+height))
                     return;
                 if(terminal->LCD->width<(Xpos+width))
                     return;
                 terminal->Xpos = Xpos;
                 terminal->Ypos = Ypos;
                 terminal->height = height;
                 terminal->width = width;
                 terminal->lineCount = terminal->height/charh;
                 terminal->columnCount = (terminal->width/charw)-1;
                 terminal_clear(terminal);
             }
             void terminal_clear(terminal_t* terminal)
             {
+                terminal->firstLine = 0;
+                terminal->lastLine = 0;
+                terminal->empty = 1;
+                terminal->line =0;
+                terminal->column=0;
                 terminal->LCD->paintFilRect(terminal->LCD,terminal->Xpos,terminal->Ypos,terminal->width,terminal->height,terminal->backgroundColor,0,terminal->backgroundColor);
             }
             void terminal_setbackgroundColor(terminal_t* terminal, uint32_t backgrooundColor)
             {
                 terminal->backgroundColor = backgrooundColor;
             }
             void terminal_settextColor(terminal_t* terminal, uint32_t textColor)
             {
                 terminal->textColor = textColor;
             }
             void terminal_movecursor(terminal_t* terminal,int n)
             {
                 int charw=terminal->font->Width + terminal->horizontalSpace;
                 int charh=terminal->font->Height + terminal->verticalSpace;
                 terminal->column += n;
-                if(terminal->column>terminal->columnCount)
+                if(terminal->column>(terminal->columnCount))
                 {
                     terminal->line += (terminal->column)/terminal->columnCount;
-                    terminal->LCD->paintFilRect(terminal->LCD,CHARXPOS(terminal, charw),CHARYPOS(terminal,charh)-charh,charw*(terminal->columnCount-terminal->column),charh,terminal->backgroundColor,0,terminal->backgroundColor);
                     terminal->line = terminal->line % terminal->lineCount;
-                    terminal->column = terminal->column % terminal->columnCount;
+                    terminal->column = (terminal->column % terminal->columnCount)-1;
+                    int x=CHARXPOS(terminal, charw);
+                    int y=CHARYPOS(terminal,charh)-charh;
+                    int w=charw*(terminal->columnCount-terminal->column);
+                    int h=charh;
+                    terminal->LCD->paintFilRect(terminal->LCD,CHARXPOS(terminal, charw),CHARYPOS(terminal,charh)-charh,charw*(terminal->columnCount-terminal->column-1),charh,terminal->backgroundColor,0,terminal->backgroundColor);
                 }
                 terminal->LCD->paintFilRect(terminal->LCD,CHARXPOS(terminal,charw),CHARYPOS(terminal,charh)-charh,charw,charh,terminal->backgroundColor,0,terminal->backgroundColor);
             }
             void terminal_clearCurentLine(terminal_t* terminal)
             {
                 int charw=terminal->font->Width + terminal->horizontalSpace;
                 int charh=terminal->font->Height + terminal->verticalSpace;
                 terminal->LCD->paintFilRect(terminal->LCD,terminal->Xpos,CHARYPOS(terminal, charh)-charh,terminal->width,charh,terminal->backgroundColor,0,terminal->backgroundColor);
             }
             int terminal_writenc(terminal_t* terminal,char* data, int n)
             {
                 int charw=terminal->font->Width + terminal->horizontalSpace;
                 int charh=terminal->font->Height + terminal->verticalSpace;
                 int l=0;
                 char buffer[2]=" ";
                 while(l<n)
                 {
                     buffer[0]=data[l];
                     if(buffer[0]=='\n')
                     {
                         terminal->line= (terminal->line+1) % terminal->lineCount;
                         terminal->column = 0;
-                        terminal_clearCurentLine(terminal);
+                        if(terminal->line==0)
+                            terminal_clear(terminal);
+                        else
+                            terminal_clearCurentLine(terminal);
                     }else {
                         if(buffer[0]=='\t')
                         {
                             for(int i=0;i<1;i++)terminal_movecursor(terminal,1);
                         }else
                             if(terminal->column==0)terminal_clearCurentLine(terminal);
-                            if(buffer[0]!='\r'){
+                        if(buffer[0]!='\r'){
-                                terminal->LCD->paintFilRect(terminal->LCD,CHARXPOS(terminal,charw),CHARYPOS(terminal, charh)-charh,charw,charh,terminal->backgroundColor,0,terminal->backgroundColor);
+                            terminal->LCD->paintFilRect(terminal->LCD,CHARXPOS(terminal,charw),CHARYPOS(terminal, charh)-charh,charw,charh,terminal->backgroundColor,0,terminal->backgroundColor);
-                                terminal->LCD->paintText(terminal->LCD,buffer,CHARXPOS(terminal,charw),CHARYPOS(terminal, charh),terminal->font,terminal->textColor);
+                            terminal->LCD->paintText(terminal->LCD,buffer,CHARXPOS(terminal,charw),CHARYPOS(terminal, charh),terminal->font,terminal->textColor);
-                                terminal_movecursor(terminal,1);
+                            terminal_movecursor(terminal,1);
+                        }
                     }
                     l++;
                 }
                 return n;
             }
+            void terminal_print_line(terminal_t* terminal,int line)
+            {
+                int charw=terminal->font->Width + terminal->horizontalSpace;
+                int charh=terminal->font->Height + terminal->verticalSpace;
+                terminal_clearCurentLine(terminal);
+                terminal->LCD->paintText(terminal->LCD,terminal->buffer+(line*(terminal->columnCount + 1)),CHARXPOS(terminal,charw),CHARYPOS(terminal, charh),terminal->font,terminal->textColor);
+            }
+            int terminal_writenc2(terminal_t* terminal,char* data, int n)
+            {
+                int charw=terminal->font->Width + terminal->horizontalSpace;
+                int charh=terminal->font->Height + terminal->verticalSpace;
+                /* First copy to buffer*/
+                int offset = (terminal->lastLine*(terminal->columnCount + 1)) + terminal->column;
+                for(int i=0;i<n;i++)
+                {
+                    terminal->empty=0;
+                    terminal->buffer[offset] = data[i];
+                    if(data[i]=='\n')
+                    {
+                        offset = ((offset/(terminal->columnCount + 1) + 1) * (terminal->columnCount + 1));
+                    }
+                    else
+                    {
+                        offset++;
+                    }
+                }
+                if(!terminal->empty)
+                {
+                    for(int i=terminal->firstLine;i<=terminal->lastLine;i++)
+                    {
+                        terminal_print_line(terminal,i);
+                    }
+                }
+                return n;
+            }
             int terminal_write(streamdevice* device,void* data,int size, int n)
             {
                 return terminal_writenc((terminal_t*)device->_stream,(char*) data,size*n);
             }
             int terminal_read(streamdevice* device,void* data,int size, int n)
             {
                 return n*size;
             }
             int terminal_setpos(streamdevice* device,int pos)
             {
                 return 1;
             }
             int terminal_close( streamdevice* device)
             {
                 return 1;
             }

lib/src/common/GRAPHIC/GUI/Widgets/Terminal/Terminal.pro +3 -1

@@ -1,3 +1,5
1	TEMPLATE = subdirs	1	TEMPLATE = subdirs
2	SUBDIRS += ./Terminal_STM32F4.pro	2	SUBDIRS += ./Terminal_STM32F4.pro \
		3	./Terminal_SIMULATOR.pro
3		4
		5

lib/src/common/GRAPHIC/TC_CONTROLERS/STMPE811/STMPE811.pro +2 -1

             TEMPLATE = subdirs
             CONFIG   += ordered
-            SUBDIRS += ./STMPE811_STM32F4.pro
+            SUBDIRS += ./STMPE811_STM32F4.pro \
+                       ./STMPE811_SIMULATOR.pro

lib/src/common/GRAPHIC/TC_CONTROLERS/STMPE811/STMPE811_STM32F4.pro 0 -1

             TEMPLATE = lib
-            OBJECTS_DIR = obj
             TARGET = STMPE811
             SOURCES +=  \
                 STMPE811.c
             DEFINES -= __OPTIMIZED_MATH
             INCLUDEPATH += ../../../../includes \
             	../../../CPU/STM32F4xx_StdPeriph_Driver/inc \
             	../../../CPU/CMSIS/Include \
             	../../../../includes/GRAPHIC/CONTROLERS \
             	../../../../includes/GRAPHIC/TC_CONTROLERS \
             	../../../../includes/GRAPHIC/GUI/FONTS \
             	../../../../includes/GRAPHIC/GUI/Widgets
             UCMODEL=stm32f4
             target.path = $$[QT_INSTALL_LIBS]/$$UCMODEL
             INSTALLS += target
             HEADERS += \
                 ../../../../includes/GRAPHIC/TC_CONTROLERS/STMPE811.h \
                 ../../../../includes/GRAPHIC/TC_CONTROLERS/genericTC_Controler.h

lib/src/common/POWER/ina226/ina226.pro +2 -1

             TEMPLATE = subdirs
             CONFIG   += ordered
-            SUBDIRS += ./ina226_STM32F4.pro
+            SUBDIRS += ./ina226_STM32F4.pro \
+                       ./ina226_SIMULATOR.pro

lib/src/common/POWER/ina226/ina226_STM32F4.pro 0 -1

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

lib/src/includes/GRAPHIC/GUI/Widgets/terminal.h +4 0

             /*------------------------------------------------------------------------------
             --  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 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

lib/src/includes/fat32.h +60 -40

             /*------------------------------------------------------------------------------
             --  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 FAT32_H
             #define FAT32_H
             #include <mbr.h>
             #include <libucfs.h>
             #include <ucdirent.h>
             #include <stdint.h>
             #include <stdint-gcc.h>
             /*BPB (Boot Sector) Offsets  */
-            #define BS_jmpBootoff 		0
+            #define BS_jmpBootoff 		    0
-            #define BS_OEMNameoff 		3
+            #define BS_OEMNameoff 		    3
-            #define BPB_BytsPerSecoff 	11
+            #define BPB_BytsPerSecoff 	    11
-            #define BPB_SecPerClusoff	13
+            #define BPB_SecPerClusoff	    13
-            #define BPB_RsvdSecCntoff	14
+            #define BPB_RsvdSecCntoff	    14
-            #define BPB_NumFATsoff 		16
+            #define BPB_NumFATsoff 		    16
-            #define BPB_RootEntCntoff	17
+            #define BPB_RootEntCntoff	    17
-            #define BPB_TotSec16off		19
+            #define BPB_TotSec16off		    19
-            #define BPB_Mediaoff 		21
+            #define BPB_Mediaoff 		    21
-            #define BPB_FATSz16off 		22
+            #define BPB_FATSz16off 		    22
-            #define BPB_SecPerTrkoff	24
+            #define BPB_SecPerTrkoff	    24
-            #define BPB_NumHeadsoff		26
+            #define BPB_NumHeadsoff		    26
-            #define BPB_HiddSecoff 		28
+            #define BPB_HiddSecoff 		    28
-            #define BPB_TotSec32off		32
+            #define BPB_TotSec32off		    32
             /*FAT16*/
-            #define BS_DrvNumFAT16off	36
+            #define BS_DrvNumFAT16off	    36
             #define BS_Reserved1FAT16off	37
-            #define BS_BootSigFAT16off 	38
+            #define BS_BootSigFAT16off 	    38
-            #define BS_VolIDFAT16off	39
+            #define BS_VolIDFAT16off	    39
-            #define BS_VolLabFAT16off	43
+            #define BS_VolLabFAT16off	    43
             #define BS_FilSysTypeFAT16off 	54
             /*FAT32*/
-            #define BPB_FATSz32off 		36
+            #define BPB_FATSz32off 		    36
-            #define BPB_ExtFlagsoff		40
+            #define BPB_ExtFlagsoff		    40
-            #define BPB_FSVeroff 		42
+            #define BPB_FSVeroff 		    42
-            #define BPB_RootClusoff		44
+            #define BPB_RootClusoff	  	    44
-            #define BPB_FSInfooff 		48
+            #define BPB_FSInfooff 		    48
-            #define BPB_BkBootSecoff	50
+            #define BPB_BkBootSecoff	    50
-            #define BPB_Reservedoff		52
+            #define BPB_Reservedoff		    52
-            #define BS_DrvNumFAT32off	64
+            #define BS_DrvNumFAT32off	    64
-            #define BS_Reserved1FAT32off	65
+            #define BS_Reserved1FAT32off    65
-            #define BS_BootSigFAT32off 	66
+            #define BS_BootSigFAT32off 	    66
-            #define BS_VolIDFAT32off	67
+            #define BS_VolIDFAT32off	    67
-            #define BS_VolLabFAT32off	71
+            #define BS_VolLabFAT32off	    71
-            #define BS_FilSysTypeFAT32off 	82
+            #define BS_FilSysTypeFAT32off   82
             #define DIR_Nameoff             0
             #define DIR_Attroff             0xb
             #define DIR_FstClusHIoff        0x14
             #define DIR_FstClusLOoff        0x1A
             #define DIR_FileSizeoff         0x1c
             #define DIR_CrtTimeTenthoff     13
             #define DIR_CrtTimeoff          14
             #define DIR_CrtDateoff          16
             #define DIR_LstAccDateoff       18
             #define DIR_WrtTimeoff          22
             #define DIR_WrtDateoff          24
-            #define FATBadpart 1
+            #define FATBadpart   1
-            #define FATBabArg 2
+            #define FATBabArg    2
-            #define FATReadErr 3
+            #define FATReadErr   3
-            #define FATnoErr 0
+            #define FATnoErr     0
+            /*
+                TODO :
+                intergrate a per BLKDEV or per partition buffer.
+            */
             typedef struct FAT32fs
             {
                 uint16_t BPB_BytsPerSec;
                 uint16_t BPB_RsvdSecCnt;
                 uint32_t   BPB_FATSz32;
                 uint32_t   BPB_RootClus;
                 uint32_t   fat_begin_lba;
                 uint32_t   cluster_begin_lba;
                 uint8_t  BPB_SecPerClus;
                 uint8_t  BPB_NumFATs;
+                char     valide;
             	dikpartition*  part;
             }FAT32fs;
             #define castUI64(val) ((uint64_t)(val))
             #define castUI32(val) ((uint32_t)(val))
             #define castUI16(val) ((uint16_t)(val))
             #define castUI8(val) ((uint8_t)(val))
             #define castI64(val) ((int64_t)(val))
             #define castI32(val) ((int32_t)(val))
             #define castI16(val) ((int16_t)(val))
             #define castI8(val) ((int8_t)(val))
-            #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))))
+            /*
-            #define fat32Ui8_2_Ui16(table,lsBindex) ((uint16_t)((0xFF&(table[lsBindex]))+(0xFF00&(((uint16_t)table[lsBindex+1])<<8))))
+                TODO :
+                Should add global function for casting with endianness care.
+                have a look at REV, REV16, REVSH, and RBIT ARMV7m asm
+            */
+            #if __BYTE_ORDER__==__ORDER_BIG_ENDIAN__
+                #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))))
+                #define fat32Ui8_2_Ui16(table,lsBindex) ((uint16_t)((0xFF&(table[lsBindex]))+(0xFF00&(((uint16_t)table[lsBindex+1])<<8))))
+                #define fat32extract16b(table, LSBOffset) (uint16_t)(( (uint16_t) ((uint8_t)table[(LSBOffset)]) ) + (uint16_t)( ((uint8_t)table[(LSBOffset)+1]) << 8 ))
+                #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 ))
+            #else
+                #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))))
+                #define fat32Ui8_2_Ui16(table,lsBindex) ((uint16_t)((0xFF&(table[lsBindex]))+(0xFF00&(((uint16_t)table[lsBindex+1])<<8))))
+                #define fat32extract16b(table, LSBOffset) (uint16_t)(( (uint16_t) ((uint8_t)table[(LSBOffset)]) ) + (uint16_t)( ((uint8_t)table[(LSBOffset)+1]) << 8 ))
+                #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 ))
+            #endif
             /* Get the first sector lba of given cluster number*/
             #define clusterlba(fs,cluster_number) ((uint32_t)fs->cluster_begin_lba + (((uint32_t)cluster_number) - (2)) * (uint32_t)fs->BPB_SecPerClus)
             //#define fat32clusterinfatsect(fs,cluster_number) ((((uint32_t)(cluster_number))>>6) + fs->fat_begin_lba)
             #define fat32clusterinfatsect(fs,cluster_number) ((((uint32_t)(cluster_number))>>7) + fs->fat_begin_lba)
             #define fat32clusterinfatoff(cluster_number) (((cluster_number)&0x7F)*4)
             /*Get cluster index in FAT Table from sector address*/
-            #define fat32masksectorlba(sectorlba,fs) (sectorlba & (castUI32(-1)^castUI32(fs->BPB_SecPerClus-1)))
+            #define fat32masksectorlba(sectorlba,fs)  (sectorlba)//(sectorlba & (castUI32(-1)^castUI32(fs->BPB_SecPerClus-1)))
             #define fat32sectorlbatoclusternum(fs,sectorlba)  (((fat32masksectorlba(castUI32(sectorlba),fs) -(castUI32(fs->cluster_begin_lba)))/castUI32(fs->BPB_SecPerClus))+castUI32(2))
-            #define fat32extract16b(table, LSBOffset) (uint16_t)(( (uint16_t) ((uint8_t)table[(LSBOffset)]) ) + (uint16_t)( ((uint8_t)table[(LSBOffset)+1]) << 8 ))
-            #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 ))
             #ifdef FAT32_PRIVATE
             #define fat32sectorreadout(fs,fatsec) \
                 if((lastSecAddrs!=(fatsec)) || (lastFATFS!=(fs)))                 /*Check if sector already buffered*/ \
                 {\
                     if((fs)->part->phy->read((fs)->part->phy,fat32buff,(fatsec),1)!=RES_OK) \
                     {\
                         return DIRENT_ReadErr;\
                     }\
                 }\
                 lastSecAddrs=(fatsec);\
                 lastFATFS=(fs);
             #endif
             extern int fat32open(FAT32fs* fs,dikpartition* part);
             extern int fat32mkdirent(FAT32fs* fs,ucdirent* dirent);
             extern int fat32getVolName(FAT32fs* fs,char* Name);
             extern int fat32getrootfirstent(ucdirent* entry);
             extern int fat32nextdirent(ucdirent* entry);
             extern int fat32nextsectorlba(FAT32fs* fs,uint32_t lastsector_lba,uint32_t* nextsector_lba);
             extern int fat32prevsectorlba(FAT32fs* fs,uint32_t lastsector_lba,uint32_t *nextsector_lba);
+            extern int fat32prevsectorlba2(FAT32fs* fs,ucdirent* entry,uint32_t lastsector_lba,uint32_t *nextsector_lba);
             extern uint32_t fat32getdirentlba(ucdirent* entry);
             extern int fat32getdirentname(ucdirent* entry,char* nameBuffer);
             #endif

lib/src/includes/mbr.h +1 0

             /*------------------------------------------------------------------------------
             --  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 MBR_H
             #define MBR_H
             #include <uhandle.h>
             #include <blkdevice.h>
             #define BootFlagoffset 0
             #define TypeCodeoffset 4
             #define LBABeginoffset 8
             #define NumOfSecoffset 12
             #define MBRBadMbr 1
             #define MBRBabArg 2
             #define MBRReadErr 3
             #define MBRnoErr 0
             #define isFat32(TypeCode) (((TypeCode)==0x0b)||((TypeCode)==0x0c))
             typedef struct dikpartition
             {
             	char TypeCode;
+                char valide;
             	unsigned int LBABegin;
             	unsigned int NumOfSec;
             	blkdevice* phy;
             }dikpartition;
             int mbropen(blkdevice* phy,dikpartition* part,char partNum);
             #endif

lib/src/lib.pro +1 0

             TEMPLATE = subdirs
             CONFIG   += ordered
             SUBDIRS +=  stm32f4
             SUBDIRS += common
+            SUBDIRS += simulator
             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.c +3 0

             /*------------------------------------------------------------------------------
             --  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 <core.h>
             #include <stm32f4xx_rcc.h>
             #include <stdint.h>
             #include <stdlib.h>
             #include <stdio.h>
             #include <core_cm4.h>
+            #include <gpio.h>
             extern uint32_t OSC0;
             extern uint32_t INTOSC;
             extern uint32_t RTCOSC;
             volatile uint32_t tickCounter=0;
             void SysTick_Handler(void)
             {
                 tickCounter+=1;
+                if((tickCounter&0xFFF)==0x800)
+                    gpiosetval(PC15,!gpiogetval(PC15));
             }
             void delay_us(uint32_t value)
             {
                 extern uint32_t currentCpuFreq;
                 if(value)
                 {
                     uint32_t tickperus=currentCpuFreq/(1000*10);
                     uint32_t tickCounterSnap = SysTick->VAL+((value%100)*tickperus);
                     uint32_t targetVal=tickCounterSnap +(value/100);
                     if(targetVal < tickCounterSnap)
                     {
                         while(tickCounter > targetVal);
                     }
                     while((tickCounter < targetVal) | (SysTick->VAL<tickCounterSnap));
                 }
             }
             void delay_100us(uint32_t value)
             {
                 if(value)
                 {
                     uint32_t tickCounterSnap = tickCounter;
                     uint32_t SysTickSnap = SysTick->VAL;
                     uint32_t targetVal=tickCounterSnap +(value);
                     if(targetVal < tickCounterSnap)
                     {
                         while(tickCounter > targetVal);
                     }
                     while((tickCounter < targetVal) | (SysTick->VAL<SysTickSnap));
                 }
             }
             uint32_t getAPB1Freq()
             {
                 RCC_ClocksTypeDef RCC_ClocksStatus;
                 RCC_GetClocksFreq(&RCC_ClocksStatus);
                 return RCC_ClocksStatus.PCLK1_Frequency;
             }
             uint32_t getAPB2Freq()
             {
                 RCC_ClocksTypeDef RCC_ClocksStatus;
                 RCC_GetClocksFreq(&RCC_ClocksStatus);
                 return RCC_ClocksStatus.PCLK2_Frequency;
             }
             uint32_t getCpuFreq()
             {
                 uint32_t cpufreq = OSC0;
                 uint32_t PLLN,PLLM,PLLP;
                 if((RCC->CFGR & 0xC) == 8) //PLL used as sys clk
                 {
                     uint32_t pllinput=INTOSC;
                     if((RCC->PLLCFGR & (1<<22)) == (1<<22))
                     {
                         pllinput=OSC0;
                     }
                     PLLN = (RCC->PLLCFGR>>6) & 0x1FF;
                     PLLM = RCC->PLLCFGR & 0x3F;
                     PLLP = 1<<(((RCC->PLLCFGR>>16) & 3 )+1);
                     cpufreq = (pllinput * PLLN )/(PLLM*PLLP);
                 }
                 else if((RCC->CFGR & 0xC) == 0) //HSI used as sys clk
                 {
                     cpufreq=INTOSC;
                 }
                 if((RCC->CFGR & (1<<7))==1<<7)
                 {
                     return cpufreq>>((RCC->CFGR & (7<<4))>>4);
                 }
                 return cpufreq;
             }
             void reset_AHB1()
             {
                 RCC->AHB1RSTR = -1;
                 RCC->AHB1RSTR = 0;
             }
             void reset_AHB2()
             {
                 RCC->AHB2RSTR = -1;
                 RCC->AHB2RSTR = 0;
             }
             void reset_APB1()
             {
                 RCC->APB1RSTR = -1;
                 RCC->APB1RSTR = 0;
             }
             void reset_APB2()
             {
                 RCC->APB2RSTR = -1;
                 RCC->APB2RSTR = 0;
             }
             /*
                    | 2.7->3.6V
             -------------------------
 WS  | 0<HCLK<=30
 WS  | 30<HCLK<=60
 WS  | 60<HCLK<=90
 WS  | 90<HCLK<=120
 WS  | 120<HCLK<=150
 WS  | 150<HCLK<=168
             f(VCO clock) = f(PLL clock input) × (PLLN / PLLM) [1]
 MHz <= f(VCO clock) <= 432MHz [2]
             f(VCO clock input) must be between 1MHz and 2MHz and as close to 2MHz as possible!! [3]
             f(PLL general clock output) = f(VCO clock) / PLLP  [4]
             CPU<168MHz  AHB1<168MHz AHB2<168MHz  APB1<42MHz APB2<84MHz  [5]
             ! 63<=PLLN<=432  [6]
             !  2<=PLLM<=63   [7]
             !  PLLP=2,4,6,8  [8]
 <=PLLM*PLLP<=504
             F= f(PLL clock input) * A/B with
 <=A<=432
 <=B<=504
             */
             int optimizePLLcfg(uint32_t freq, uint32_t srcfreq,uint32_t PLLM,uint32_t* PLLP, uint32_t* PLLN,uint8_t* AHBPRindx)
             {
                 uint32_t AHBPRtbl[9]={1,2,4,8,16,64,128,256,512};
                 uint32_t AHBPR=0,AHBPR_r=0,PLLN_r=0,PLLP_r=0;
                 uint32_t Fplli=0;
                 int32_t f_error=100000000;
                 int32_t f_errornw=100000000;
                 Fplli = srcfreq / PLLM;
                 //not efficient but should find the best parameters
                 for((*AHBPRindx)=0;(*AHBPRindx)<9;(*AHBPRindx)++) //lowest priority
                 {
                     AHBPR = AHBPRtbl[(*AHBPRindx)];
                     for(*PLLP=2;*PLLP<9;*PLLP+=2)
                     {
                         *PLLN = (freq*(*PLLP)*AHBPR)/Fplli;
                         if(((*PLLN)>62) && ((*PLLN)<433) && ((Fplli * (*PLLN)) < 433000000))
                         {
                             f_errornw = abs((int32_t)((int32_t)((Fplli*(*PLLN))/((*PLLP)*AHBPR))-freq));
                             if( ( (f_error)>(f_errornw) ) || ( (*AHBPRindx==0)&&(*PLLP==2)&&(*PLLN==63) ) )
                             {
                                 f_error=f_errornw;
                                 PLLN_r = *PLLN;
                                 PLLP_r = *PLLP;
                                 AHBPR_r=*AHBPRindx;
                                 if(f_error==0)
                                 {
                                     *PLLN = PLLN_r;
                                     *PLLP = PLLP_r;
                                     *AHBPRindx = AHBPR_r;
                                     return 1;
                                 }
                             }
                         }
                     }
                 }
                 *PLLN = PLLN_r;
                 *PLLP = PLLP_r;
                 *AHBPRindx = AHBPR_r;
                 return 1;
             }
             int setPll(uint32_t freq)
             {
                 extern uint32_t OSC0;
                 extern uint32_t INTOSC;
                 uint32_t srcfreq = INTOSC;
                 uint8_t AHBPRindx;
                 uint32_t AHBPRtbl[9]={1,2,4,8,16,64,128,256,512};
                 uint32_t PLLN=0,PLLM=0,PLLP=0,AHBPR=0;
                 uint32_t Fplli=0;
                 if((RCC->PLLCFGR & (1<<22))==(1<<22))
                 {
                     srcfreq = OSC0;
                 }
                 PLLM = srcfreq / 1500000;   // [3]
                 Fplli = srcfreq / PLLM;
                 optimizePLLcfg(freq,srcfreq,PLLM,&PLLP,&PLLN,&AHBPRindx);
                 srcfreq = (Fplli*PLLN)/(PLLP*AHBPRtbl[AHBPRindx]);   //Put real clk freq in srcfreq for return value
                 //now switch to HSIs
                 if((RCC->CR & 1)==0)RCC->CR |= 1;                      //turn ON HSI
                 while((RCC->CR & 2)!=2);                               //wait for HSI Ready
                 RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_SW));
                 RCC->CFGR |= RCC_CFGR_SW_HSI;                          //set HSI as main clk
                 while ((RCC->CFGR & (uint32_t)RCC_CFGR_SWS ) != RCC_CFGR_SWS_HSI);
                 RCC->CR &= ~(1<<24);                                   //Turn OFF PLL
                 RCC->PLLCFGR &= ~0x37FFF;                              //clear PLLP PLLM PLLN
                 RCC->PLLCFGR |= PLLM + (PLLN<<6) + (((PLLP>>1) -1)<<16);
                 RCC->CR |= RCC_CR_PLLON;                                      //Turn ON PLL
                 while((RCC->CR & (1<<25))!=(1<<25));                   //wait for PLL Ready
                 if(AHBPRindx!=0)AHBPRindx|=0x8;
                 RCC->CFGR &= ~(0xF<<4);
                 RCC->CFGR |= (uint32_t)(AHBPRindx<<4);
                 AHBPR=0;
                 while((srcfreq>>AHBPR)>42000000)AHBPR++; //[5]             //Thune APB1 prescaler to keep APB1 CLK below 42MHz
                 if(AHBPR!=0)
                 {
                     AHBPR-=1;
                     AHBPR|=0x4;
                 }
                 RCC->CFGR &= ~(0x7<<10);
                 RCC->CFGR |= (uint32_t)(AHBPR<<10);
                 AHBPR=0;
                 while((srcfreq>>AHBPR)>84000000)AHBPR++; //[5]             //Thune APB2 prescaler to keep APB2 CLK below 42MHz
                 if(AHBPR!=0)
                 {
                     AHBPR-=1;
                     AHBPR|=0x4;
                 }
                 RCC->CFGR &= ~(0x7<<13);
                 RCC->CFGR |= (uint32_t)(AHBPR<<13);
                 FLASH->ACR |= FLASH_ACR_LATENCY_7WS;
                 RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_SW));//Switch to PLL as main clk source
                 RCC->CFGR |= RCC_CFGR_SW_PLL;
                 /* Wait untill the main PLL is used as system clock source */
                 while ((RCC->CFGR & (uint32_t)RCC_CFGR_SWS ) != RCC_CFGR_SWS_PLL);
                 if(srcfreq>150000000)
                 {
                     FLASH->ACR &= (~7)|FLASH_ACR_LATENCY_5WS;
                 }
                 if((srcfreq<150000000) && (srcfreq>=120000000))
                 {
                     FLASH->ACR &= (~7)|FLASH_ACR_LATENCY_4WS;
                 }
                 if((srcfreq<120000000) && (srcfreq>=90000000))
                 {
                     FLASH->ACR &= (~7)|FLASH_ACR_LATENCY_3WS;
                 }
                 if((srcfreq<90000000) && (srcfreq>=60000000))
                 {
                     FLASH->ACR &= (~7)|FLASH_ACR_LATENCY_2WS;
                 }
                 if((srcfreq<60000000) && (srcfreq>=30000000))
                 {
                     FLASH->ACR &= (~7)|FLASH_ACR_LATENCY_1WS;
                 }
                 if(srcfreq<30000000)
                 {
                     FLASH->ACR &= (~7)|FLASH_ACR_LATENCY_0WS;
                 }
                 return srcfreq;
             }
             void configureSysTick()
             {
                 extern uint32_t currentCpuFreq;
                 uint32_t us=currentCpuFreq/(1000*10);
                 SysTick_Config(us);
             }
             int setCpuFreq(uint32_t freq)
             {
                 extern uint32_t OSC0;
                 extern uint32_t INTOSC;
                 uint8_t i=0;
                 uint32_t curentFeq = getCpuFreq();
                 if(curentFeq==freq)return curentFeq;
                 if((freq>2000000) && (freq<=250000000)) //be carefull with 250MHz!!!
                 {
                     if((RCC->CFGR & 0xC) == 8) //PLL used as sys clk
                     {
                         return setPll(freq);
                     }
                     else if((RCC->CFGR & 0xC) == 0) //HSI used as sys clk
                     {
                         if((INTOSC%freq)==0) //now check if we can directly divide HSI
                         {
                             if(freq==INTOSC)
                             {
                                 RCC->CFGR &= ~(0xF<<4);
                                 return freq;
                             }
                             for(i=1;i<8;i++)
                             {
                                 if((freq<<i)==INTOSC)
                                 {
                                     RCC->CFGR &= ~(0xF<<4);
                                     RCC->CFGR |= ((0x8|i)<<4);
                                     return freq;
                                 }
                             }
                         }
                         else
                             return setPll(freq);
                     }
                     else //HSE used as sys clk
                     {
                         if((OSC0%freq)==0) //now check if we can directly divide HSI
                         {
                             if(freq==OSC0)
                             {
                                 RCC->CFGR &= ~(0xF<<4);
                                 return freq;
                             }
                             for(i=1;i<8;i++)
                             {
                                 if((freq<<i)==OSC0)
                                 {
                                     RCC->CFGR &= ~(0xF<<4);
                                     RCC->CFGR |= ((0x8|i)<<4);
                                     return freq;
                                 }
                             }
                         }
                         else
                             return setPll(freq);
                     }
                 }
                 return 0;
             }
             void enable_FPU()
             {
                 SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2));  /* set CP10 and CP11 Full Access */
                 __asm__("dsb");
                 __asm__("isb");
             }

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

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

lib/src/stm32f4/CPU/cpuinit.c +2 -2

             #include "stm32f4xx.h"
             #include <stdint.h>
             #include <stdlib.h>
             #include <stdio.h>
             #include <bsp.h>
             #include <stm32f4xx_rcc.h>
             #include <core.h>
             extern int main();
             void cpu_init()
             {
                 extern uint32_t currentCpuFreq;
             #ifndef CPUFREQ
               #define CPUFREQ (16*1000*1000)
             #endif
                 currentCpuFreq = CPUFREQ;
                 enable_FPU();
                 RCC->CR |= (uint32_t)0x00000001;
                 FLASH->ACR = FLASH_ACR_ICEN |FLASH_ACR_DCEN |FLASH_ACR_LATENCY_5WS;
                 reset_AHB1();
                 reset_AHB2();
                 reset_APB1();
                 reset_APB2();
                 RCC->CR |= (uint32_t)0x00000001;
                 FLASH->ACR = FLASH_ACR_ICEN |FLASH_ACR_DCEN |FLASH_ACR_LATENCY_5WS;
                 RCC->CFGR = 0x00000000;
                 RCC->CIR = 0x00000000;
                 SCB->VTOR = FLASH_BASE;
                 RCC->APB1ENR |= RCC_APB1ENR_PWREN;
                 PWR->CR |= PWR_CR_PMODE;
                 currentCpuFreq=setCpuFreq(currentCpuFreq);
                 currentCpuFreq=getCpuFreq();
                 configureSysTick();
                 bsp_init();
                 printf("SysTick Configured to reach 100us period\n\r");
                 RCC_ClocksTypeDef RCC_ClocksStatus;
                 RCC_GetClocksFreq(&RCC_ClocksStatus);
                 printf("PLL Configured got:\n\r SYS=%uHz\n\r CPU=%uHz\n\r APB1=%uHz\n\r APB2=%uHz\n\r",(unsigned int)RCC_ClocksStatus.SYSCLK_Frequency,(unsigned int)RCC_ClocksStatus.HCLK_Frequency,(unsigned int)RCC_ClocksStatus.PCLK1_Frequency,(unsigned int)RCC_ClocksStatus.PCLK2_Frequency);
                 printf("Enter Main\n\r");
                 int res=main();
                 printf("\n\rprogram exited with code ");
                 printf("%u",res);
                 printf("\n\r");
                 while(1)
                 {
                     delay_100us(10000);
-                    gpioset(LED1);
+                    gpioset(LED2);
                     delay_100us(10000);
-                    gpioclr(LED1);
+                    gpioclr(LED2);
                 }
             }

lib/src/stm32f4/CPU/stm32_flash.ld +2 -2

             /*
             *****************************************************************************
             **
             **  File        : stm32_flash.ld
             **
             **  Abstract    : Linker script for STM32F407VG Device with
             **                1024KByte FLASH, 192KByte RAM
             **
             **                Set heap size, stack size and stack location according
             **                to application requirements.
             **
             **                Set memory bank area and size if external memory is used.
             **
             **  Target      : STMicroelectronics STM32
             **
             **  Environment : Atollic TrueSTUDIO(R)
             **
             **  Distribution: The file is distributed �as is,� without any warranty
             **                of any kind.
             **
             **  (c)Copyright Atollic AB.
             **  You may use this file as-is or modify it according to the needs of your
             **  project. Distribution of this file (unmodified or modified) is not
             **  permitted. Atollic AB permit registered Atollic TrueSTUDIO(R) users the
             **  rights to distribute the assembled, compiled & linked contents of this
             **  file as part of an application binary file, provided that it is built
             **  using the Atollic TrueSTUDIO(R) toolchain.
             **
             *****************************************************************************
             */
             /* Entry Point */
             ENTRY(Reset_Handler)
             /* Highest address of the user mode stack */
             _estack = 0x20020000;    /* end of 128K RAM on AHB bus*/
             /* Generate a link error if heap and stack don't fit into RAM */
-            _Min_Heap_Size = 0;      /* required amount of heap  */
+            _Min_Heap_Size = 0x2000;      /* required amount of heap  */
-            _Min_Stack_Size = 0x1000; /* required amount of stack */
+            _Min_Stack_Size = 0x2000; /* required amount of stack */
             /* Specify the memory areas */
             MEMORY
             {
               FLASH (rx)      : ORIGIN = 0x08000000, LENGTH = 1024k
               RAM (xrw)       : ORIGIN = 0x20000000, LENGTH = 112k
               CCMRAM (xrw)    : ORIGIN = 0x10000000, LENGTH = 64k
               MEMORY_B1 (rx)  : ORIGIN = 0x60000000, LENGTH = 0K
             }
             /* Define output sections */
             SECTIONS
             {
               /* The startup code goes first into FLASH */
               .isr_vector :
               {
                 . = ALIGN(4);
                 KEEP(*(.isr_vector)) /* Startup code */
                 . = ALIGN(4);
               } >FLASH
               /* The program code and other data goes into FLASH */
               .text :
               {
                 . = ALIGN(4);
                 *(.text)           /* .text sections (code) */
                 *(.text*)          /* .text* sections (code) */
                 *(.rodata)         /* .rodata sections (constants, strings, etc.) */
                 *(.rodata*)        /* .rodata* sections (constants, strings, etc.) */
                 *(.glue_7)         /* glue arm to thumb code */
                 *(.glue_7t)        /* glue thumb to arm code */
                     *(.eh_frame)
                 KEEP (*(.init))
                 KEEP (*(.fini))
                 . = ALIGN(4);
                 _etext = .;        /* define a global symbols at end of code */
               } >FLASH
                .ARM.extab   : { *(.ARM.extab* .gnu.linkonce.armextab.*) } >FLASH
                 .ARM : {
                 __exidx_start = .;
                   *(.ARM.exidx*)
                   __exidx_end = .;
                 } >FLASH
               .preinit_array     :
               {
                 PROVIDE_HIDDEN (__preinit_array_start = .);
                 KEEP (*(.preinit_array*))
                 PROVIDE_HIDDEN (__preinit_array_end = .);
               } >FLASH
               .init_array :
               {
                 PROVIDE_HIDDEN (__init_array_start = .);
                 KEEP (*(SORT(.init_array.*)))
                 KEEP (*(.init_array*))
                 PROVIDE_HIDDEN (__init_array_end = .);
               } >FLASH
               .fini_array :
               {
                 PROVIDE_HIDDEN (__fini_array_start = .);
                 KEEP (*(.fini_array*))
                 KEEP (*(SORT(.fini_array.*)))
                 PROVIDE_HIDDEN (__fini_array_end = .);
               } >FLASH
               /* used by the startup to initialize data */
               _sidata = .;
               /* Initialized data sections goes into RAM, load LMA copy after code */
               .data : AT ( _sidata )
               {
                 . = ALIGN(4);
                 _sdata = .;        /* create a global symbol at data start */
                 *(.data)           /* .data sections */
                 *(.data*)          /* .data* sections */
                 . = ALIGN(4);
                 _edata = .;        /* define a global symbol at data end */
               } >RAM
               /* Uninitialized data section */
               . = ALIGN(4);
               .bss :
               {
                 /* This is used by the startup in order to initialize the .bss secion */
                 _sbss = .;         /* define a global symbol at bss start */
                 __bss_start__ = _sbss;
                 *(.bss)
                 *(.bss*)
                 *(COMMON)
                 . = ALIGN(4);
                 _ebss = .;         /* define a global symbol at bss end */
                 __bss_end__ = _ebss;
               } >RAM
               /* User_heap_stack section, used to check that there is enough RAM left */
               ._user_heap_stack :
               {
                 . = ALIGN(4);
                 PROVIDE ( end = . );
                 PROVIDE ( _end = . );
                 . = . + _Min_Heap_Size;
                 . = . + _Min_Stack_Size;
                 . = ALIGN(4);
               } >RAM
               /* MEMORY_bank1 section, code must be located here explicitly            */
               /* Example: extern int foo(void) __attribute__ ((section (".mb1text"))); */
               .memory_b1_text :
               {
                 *(.mb1text)        /* .mb1text sections (code) */
                 *(.mb1text*)       /* .mb1text* sections (code)  */
                 *(.mb1rodata)      /* read-only data (constants) */
                 *(.mb1rodata*)
               } >MEMORY_B1
               /* Remove information from the standard libraries */
               /DISCARD/ :
               {
                 libc.a ( * )
                 libm.a ( * )
                 libgcc.a ( * )
               }
               .ARM.attributes 0 : { *(.ARM.attributes) }
             }

lib/src/stm32f4/CPU/syscalls.c +27 -6

             #include <stdlib.h>
             #include <errno.h>
             #include <string.h>
             #include <sys/stat.h>
             #include <sys/types.h>
             #include <sys/times.h>
             #include <streamdevices.h>
             #include <string.h>
             #include <stdio.h>
             #include <gpio.h>
             #include <uart.h>
             #include <stdint.h>
+            #include <bsp.h>
             #undef errno
             #ifdef __cplusplus
             extern "C" {
             #endif
             extern int errno;
             extern int32_t __max_opened_files__;
             extern streamdevice* __opnfiles__[];
             extern int32_t* __fs_root__;
             extern int32_t __fs_root_size__;
             char *__env[1] = { 0 };
             char **environ = __env;
             int _exit()
             {
-                while(1);
+                while(1)
+                {
+                    delay_100us(10000);
+                    gpioset(LED2);
+                    delay_100us(10000);
+                    gpioclr(LED2);
+                }
             }
             int _close(int file)
             {
                 if(file<__max_opened_files__ && __opnfiles__[file]!=NULL)
                 {
                     return __opnfiles__[file]->ops->close( __opnfiles__[file]);
                 }
                 return 0;
             }
             int _write(int file, char *ptr, int len)
             {
                 if(file<__max_opened_files__ && __opnfiles__[file]!=NULL)
                 {
                     if(__opnfiles__[file]->ops->write(__opnfiles__[file],ptr,1,len)) return len;
                 }
-                return 0;
+                return len;
             }
             int _execve(char *name, char **argv, char **env) {
                 errno = ENOMEM;
                 return -1;
             }
             int _fork(void) {
                 errno = EAGAIN;
                 return -1;
             }
             int _fstat(int file, struct stat *st) {
                 st->st_mode = S_IFCHR;
                 return 0;
             }
             int _getpid(void) {
                 return 1;
             }
             int _isatty(int file) {
                 return 1;
             }
             int _kill(int pid, int sig) {
                 errno = EINVAL;
                 return -1;
             }
             int _link(char *old, char *_new) {
                 errno = EMLINK;
                 return -1;
             }
             int _lseek(int file, int ptr, int dir) {
                 return 0;
             }
             #include <gpio.h>
             int _open(const char *name, int flags, int mode)
             {
                 if(!strncmp("UART", name, 4) && ((name[4] & 0x30)==0x30))
                 {
                     //uart_t* uart1 = malloc(sizeof(uart_t));
                     streamdevice* fd1 = malloc(sizeof(streamdevice));
                     uart_t uart=uartopen((name[4] & 0xF)-1);
                     if(uart!=-1);
                     {
                         uartmkstreamdev(uart,fd1);
                         int i=2;
                         while((i<__max_opened_files__) && (__opnfiles__[i]!=NULL))i++;
                         if(i!=__max_opened_files__)
                         {
                             __opnfiles__[i] = fd1;
                             return i;
                         }
                         else printf("Too much files opened\n\r");
                     }
                 }
                 return -1;
             }
             int _read(int file, char *ptr, int len) {
                 if(file<__max_opened_files__ && __opnfiles__[file]!=NULL)
                 {
                     if(__opnfiles__[file]->ops->read(__opnfiles__[file],ptr,1,len)) return len;
                 }
                 return 0;
             }
             caddr_t _sbrk(int incr) {
                 register char * stack_ptr __asm__ ("sp");
                 extern char _end; /* Defined by the linker */
                 static char *heap_end;
                 char *prev_heap_end;
                 if (heap_end == 0) {
                     heap_end = &_end;
                 }
                 prev_heap_end = heap_end;
                 if (heap_end + incr > stack_ptr) {
-                    _write (1, "Heap and stack collision\n", 25);
+                    printf("Heap and stack collision\n");
-                    abort ();
+                    //abort ();
+                    while(1)
+                    {
+                        delay_100us(10000);
+                        gpioset(LED2);
+                        delay_100us(10000);
+                        gpioclr(LED2);
+                    }
                 }
                 heap_end += incr;
                 return (caddr_t) prev_heap_end;
             }
             int _stat(char *file, struct stat *st) {
                 st->st_mode = S_IFCHR;
                 return 0;
             }
             int _times(struct tms *buf) {
                 return -1;
             }
             int _unlink(char *name) {
                 errno = ENOENT;
                 return -1;
             }
             int _wait(int *status) {
                 errno = ECHILD;
                 return -1;
             }
             int _read_r (struct _reent *r, int file, char * ptr, int len)
             {
                 r = r;
                 file = file;
                 ptr = ptr;
                 len = len;
                 _read(file,ptr,len);
                 errno = EINVAL;
                 return -1;
             }
             /***************************************************************************/
             int _lseek_r (struct _reent *r, int file, int ptr, int dir)
             {
                 r = r;
                 file = file;
                 ptr = ptr;
                 dir = dir;
                 return 0;
             }
             /***************************************************************************/
             int _write_r (struct _reent *r, int file, char * ptr, int len)
             {
                 return _write(file, ptr, len);
             }
             /***************************************************************************/
             int _close_r (struct _reent *r, int file)
             {
                 return 0;
             }
             /***************************************************************************/
             caddr_t _sbrk_r (struct _reent *r, int incr)
             {
                 register char * stack_ptr __asm__ ("sp");
                 extern char _end; /* Defined by the linker */
                 static char *heap_end;
                 char *prev_heap_end;
                 if (heap_end == 0) {
                     heap_end = &_end;
                 }
                 prev_heap_end = heap_end;
                 if (heap_end + incr > stack_ptr) {
-                    _write (1, "Heap and stack collision\n", 25);
+                    printf( "Heap and stack collision\n");
-                    abort ();
+                    //abort ();
+                    while(1)
+                    {
+                        delay_100us(10000);
+                        gpioset(LED2);
+                        delay_100us(10000);
+                        gpioclr(LED2);
+                    }
                 }
                 heap_end += incr;
                 return (caddr_t) prev_heap_end;
             }
             /***************************************************************************/
             int _fstat_r (struct _reent *r, int file, struct stat * st)
             {
                 r = r;
                 file = file;
                 memset (st, 0, sizeof (* st));
                 st->st_mode = S_IFCHR;
                 return 0;
             }
             /***************************************************************************/
             int _open_r(struct _reent *r,const char *name, int flags, int mode)
             {
                 return _open(name, flags, mode);
             }
             int _isatty_r(struct _reent *r, int fd)
             {
                 r = r;
                 fd = fd;
                 return 1;
             }
             #ifdef __cplusplus
             }
             #endif

mkspecs/common/arm-none-eabi.conf +3 -3

             #
             # qmake configuration for arm-none-eabi
             #
             CONFIG			+=
             QMAKE_CC		= arm-none-eabi-gcc
             QMAKE_CFLAGS		+=
             QMAKE_CFLAGS_DEPS	+= -M
             QMAKE_CFLAGS_WARN_ON	+= -Wall
             QMAKE_CFLAGS_WARN_OFF	+= -w
-            QMAKE_CFLAGS_RELEASE	+= -O2
+            QMAKE_CFLAGS_RELEASE	+= -O3
             QMAKE_CFLAGS_DEBUG	+= -g -O0
             QMAKE_CXX		= arm-none-eabi-g++
             QMAKE_CXXFLAGS		+= $$QMAKE_CFLAGS s
             QMAKE_CXXFLAGS_DEPS	+= $$QMAKE_CFLAGS_DEPS
             QMAKE_CXXFLAGS_WARN_ON	+= $$QMAKE_CFLAGS_WARN_ON
             QMAKE_CXXFLAGS_WARN_OFF	+= $$QMAKE_CFLAGS_WARN_OFF
             QMAKE_CXXFLAGS_RELEASE	+= $$QMAKE_CFLAGS_RELEASE
             QMAKE_CXXFLAGS_DEBUG	+= $$QMAKE_CFLAGS_DEBUG
             QMAKE_CXXFLAGS_SHLIB	+= $$QMAKE_CFLAGS_SHLIB
             QMAKE_CXXFLAGS_STATIC_LIB += $$QMAKE_CFLAGS_STATIC_LIB
             QMAKE_CXXFLAGS_YACC	+= $$QMAKE_CFLAGS_YACC
             QMAKE_CXXFLAGS_HIDESYMS += $$QMAKE_CFLAGS_HIDESYMS
             QMAKE_LINK		= arm-none-eabi-gcc
             QMAKE_LINK_SHLIB	= arm-none-eabi-gcc
             QMAKE_LINK_C		= arm-none-eabi-gcc
             QMAKE_LINK_C_SHLIB	= arm-none-eabi-gcc
             QMAKE_LFLAGS		+=
-            QMAKE_LFLAGS_RELEASE	+=
+            QMAKE_LFLAGS_RELEASE	+= -O3
             QMAKE_LFLAGS_DEBUG	+=
             QMAKE_LFLAGS_APP	+=
             QMAKE_LFLAGS_SHLIB	+=
             QMAKE_LFLAGS_PLUGIN	+= $$QMAKE_LFLAGS_SHLIB
             QMAKE_LFLAGS_THREAD	+=
             QMAKE_AR                = arm-none-eabi-ar -ru
             QMAKE_LIB               = arm-none-eabi-ar -ru
             QMAKE_RANLIB            =

mkspecs/stm32f4/qmake.conf +5 -3

             #
             # qmake configuration for stm32f4
             #
             #
             isEmpty(_stm32f4_conf){
             _stm32f4_conf="oneshot"
             QMAKE_CFLAGS=-mlittle-endian -mthumb -mcpu=cortex-m4 -mfloat-abi=hard -mfpu=fpv4-sp-d16 -std=c99
             include(../common/arm-none-eabi.conf)
             DEFINES += __OPTIMIZED_MATH
             DEFINES += \"assert_param(expr)=((void)0)\"
             INCLUDEPATH += $$PWD
             DEFINES += __FPU_PRESENT=1
             DEFINES += ARM_MATH_CM4
             DEFINES += BSP="\"\\\"$$BSP"\\\"\"
             CONFIG += cpu
             contains( TEMPLATE, app ) {
-                OBJECTS_DIR=obj
+                OBJECTS_DIR=obj-$$UCMODEL
-                DESTDIR=bin
+                DESTDIR=bin-$$UCMODEL
                 unix:QMAKE_POST_LINK += arm-none-eabi-objcopy -O ihex "$(TARGET)" $$DESTDIR/"$(QMAKE_TARGET).hex" && arm-none-eabi-objcopy -O binary "$(TARGET)" $$DESTDIR/"$(QMAKE_TARGET).bin && python $$[QT_INSTALL_BINS]/dfu.py -b 0x08000000:"$$DESTDIR/"$(QMAKE_TARGET).bin " $$DESTDIR/"$(QMAKE_TARGET).dfu"
                 win32:QMAKE_POST_LINK += arm-none-eabi-objcopy -O ihex "$(DESTDIR_TARGET)" $$DESTDIR/"$(QMAKE_TARGET).hex" && arm-none-eabi-objcopy -O binary "$(DESTDIR_TARGET)" $$DESTDIR/"$(QMAKE_TARGET).bin"
                 LIBS += -L$$[QT_INSTALL_PREFIX]/bsp/lib/$$BSP
                 LIBS += -lbsp
                 QMAKE_LFLAGS= -mlittle-endian -mthumb -mcpu=cortex-m4 -mfloat-abi=hard -mfpu=fpv4-sp-d16 -std=c99 -T $$[QT_INSTALL_PREFIX]/mkspecs/features/stm32f4/stm32_flash.ld
                 INCLUDEPATH+=  $$[QT_INSTALL_PREFIX]/bsp/includes/$$BSP
                 SOURCES +=$$[QT_INSTALL_PREFIX]/mkspecs/features/stm32f4/syscalls.c
                 SOURCES +=$$[QT_INSTALL_PREFIX]/mkspecs/features/stm32f4/fs.c
                 SOURCES +=$$[QT_INSTALL_PREFIX]/mkspecs/features/stm32f4/startup.s
                 SOURCES +=$$[QT_INSTALL_PREFIX]/mkspecs/features/stm32f4/cpuinit.c
             #    OTHER_FILES += $$[QT_INSTALL_PREFIX]/ucfiles/stm32f4/$$CPU/stm32_flash.ld
                 stflash.target = stflash
                 stflash.commands = cd $$DESTDIR && sudo st-flash write $(QMAKE_TARGET).bin 0x08000000
                 dfu.target = dfu
-                dfu.commands = cd $$DESTDIR && sudo  dfu-util d 0483:df11 -c 1 -i 0 -a 0 -s 0x08000000 -D $(QMAKE_TARGET).bin 0x08000000
+                dfu.commands = cd $$DESTDIR && dfu-util d 0483:df11 -c 1 -i 0 -a 0 -s 0x08000000 -D $(QMAKE_TARGET).bin 0x08000000
                 QMAKE_EXTRA_TARGETS += stflash dfu
             }
             contains( TEMPLATE, lib ) {
                 CONFIG+=staticlib
+                OBJECTS_DIR=obj-$$UCMODEL
+                DESTDIR=bin-$$UCMODEL
                 message( "You can only build static library for stm32f4" )
             }
             include(../common/libuc2libs.conf)
             }

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