HG_REPOSITORIES/LPP/INSTRUMENTATION/libuc2 Commit - r65:d4bc0ad7470d

More buid system cleaning....

jeandet -

r65:d4bc0ad7470d dev_alexis

parent child

Context file:

r65:d4bc0ad7470d

Expand all files

mkspecs/features/simulator/optimised_math.h created 644 +37 0

@@ -0,0 +1,37
	1	/*------------------------------------------------------------------------------
	2	-- This file is a part of the libuc, microcontroler library
	3	-- Copyright (C) 2012, Alexis Jeandet
	4	--
	5	-- This program is free software; you can redistribute it and/or modify
	6	-- it under the terms of the GNU General Public License as published by
	7	-- the Free Software Foundation; either version 3 of the License, or
	8	-- (at your option) any later version.
	9	--
	10	-- This program is distributed in the hope that it will be useful,
	11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	-- GNU General Public License for more details.
	14	--
	15	-- You should have received a copy of the GNU General Public License
	16	-- along with this program; if not, write to the Free Software
	17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	18	-------------------------------------------------------------------------------
	19	-- Author : Alexis Jeandet
	20	-- Mail : alexis.jeandet@gmail.com
	21	-------------------------------------------------------------------------------*/
	22	#ifndef OPTIMISED_MATH_H
	23	#define OPTIMISED_MATH_H
	24	#include <arm_math.h>
	25
	26	inline float32_t optimised_sqrt(float32_t value)
	27	{
	28	float32_t out;
	29	arm_sqrt_f32(value,&out);
	30	return out;
	31	}
	32
	33	inline float optimised_sin(float32_t x)
	34	{
	35	return arm_sin_f32(x);
	36	}
	37	#endif

mkspecs/features/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/features/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"

mkspecs/features/stm32f4/optimised_math.h created 644 +37 0

@@ -0,0 +1,37
	1	/*------------------------------------------------------------------------------
	2	-- This file is a part of the libuc, microcontroler library
	3	-- Copyright (C) 2012, Alexis Jeandet
	4	--
	5	-- This program is free software; you can redistribute it and/or modify
	6	-- it under the terms of the GNU General Public License as published by
	7	-- the Free Software Foundation; either version 3 of the License, or
	8	-- (at your option) any later version.
	9	--
	10	-- This program is distributed in the hope that it will be useful,
	11	-- but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	-- GNU General Public License for more details.
	14	--
	15	-- You should have received a copy of the GNU General Public License
	16	-- along with this program; if not, write to the Free Software
	17	-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	18	-------------------------------------------------------------------------------
	19	-- Author : Alexis Jeandet
	20	-- Mail : alexis.jeandet@gmail.com
	21	-------------------------------------------------------------------------------*/
	22	#ifndef OPTIMISED_MATH_H
	23	#define OPTIMISED_MATH_H
	24	#include <arm_math.h>
	25
	26	inline float32_t optimised_sqrt(float32_t value)
	27	{
	28	float32_t out;
	29	arm_sqrt_f32(value,&out);
	30	return out;
	31	}
	32
	33	inline float optimised_sin(float32_t x)
	34	{
	35	return arm_sin_f32(x);
	36	}
	37	#endif

mkspecs/features/stm32f4/qmake.conf created 644 +77 0

@@ -0,0 +1,77
	1	#
	2	# qmake configuration for stm32f4
	3	#
	4	#
	5
	6
	7	isEmpty(_stm32f4_conf){
	8	_stm32f4_conf="oneshot"
	9
	10	QMAKE_CFLAGS=-mlittle-endian -mthumb -mcpu=cortex-m4 -mfloat-abi=hard -mfpu=fpv4-sp-d16 -std=c99
	11
	12	include(../../common/arm-none-eabi.conf)
	13
	14	DEFINES += __OPTIMIZED_MATH
	15	DEFINES += \"assert_param(expr)=((void)0)\"
	16	INCLUDEPATH += $$PWD
	17
	18	DEFINES += __FPU_PRESENT=1
	19	DEFINES += ARM_MATH_CM4
	20
	21	DEFINES += BSP="\"\\\"$$BSP"\\\"\"
	22
	23	CONFIG += cpu
	24
	25	contains( TEMPLATE, app ) {
	26	OBJECTS_DIR=obj-$$UCMODEL
	27	DESTDIR=bin-$$UCMODEL
	28	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"
	29	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"
	30
	31	LIBS += -L$$[QT_INSTALL_PREFIX]/bsp/lib/$$BSP
	32	LIBS += -lbsp
	33
	34
	35	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
	36
	37	INCLUDEPATH+= $$[QT_INSTALL_PREFIX]/bsp/includes/$$BSP
	38
	39	SOURCES +=$$[QT_INSTALL_PREFIX]/mkspecs/features/stm32f4/syscalls.c
	40	SOURCES +=$$[QT_INSTALL_PREFIX]/mkspecs/features/stm32f4/fs.c
	41	SOURCES +=$$[QT_INSTALL_PREFIX]/mkspecs/features/stm32f4/startup.s
	42	SOURCES +=$$[QT_INSTALL_PREFIX]/mkspecs/features/stm32f4/cpuinit.c
	43
	44	# OTHER_FILES += $$[QT_INSTALL_PREFIX]/ucfiles/stm32f4/$$CPU/stm32_flash.ld
	45
	46	stflash.target = stflash
	47	stflash.commands = cd $$DESTDIR && sudo st-flash write $(QMAKE_TARGET).bin 0x08000000
	48	dfu.target = dfu
	49	dfu.commands = cd $$DESTDIR && dfu-util d 0483:df11 -c 1 -i 0 -a 0 -s 0x08000000 -D $(QMAKE_TARGET).bin 0x08000000
	50	QMAKE_EXTRA_TARGETS += stflash dfu
	51	}
	52
	53	contains( TEMPLATE, lib ) {
	54	CONFIG+=staticlib
	55	OBJECTS_DIR=obj-$$UCMODEL
	56	DESTDIR=bin-$$UCMODEL
	57	message( "You can only build static library for stm32f4" )
	58	}
	59
	60	include(../../common/libuc2libs.conf)
	61
	62	}
	63
	64
	65
	66
	67
	68
	69
	70
	71
	72
	73
	74
	75
	76
	77

mkspecs/features/stm32f4/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"

bsp/src/OPLAYER/bsp.c +27 -17

             /*------------------------------------------------------------------------------
             --  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@member.fsf.org
             -------------------------------------------------------------------------------*/
             #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 uint8_t* lcd0_CMD=(volatile uint8_t*)  0x60000000;
             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 = 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");
                         }
                         delay_100us(10000);
                         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");
                         }
                         delay_100us(10000);
                         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");
                         }
                         delay_100us(10000);
                         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");
                     }
                 }
                 delay_100us(20000);
             }
             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;
-            //    int8_t* pt8  = (int8_t*)(void*)&reg;
+                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++)
                 {
                     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++)
+                for(int i=0;i<(int)count;i++)
-            //    {
-            //        pt8[(2*i) +1]=*lcd0_DATA;
+                    pt8[(2*i) +1]=*lcd0_DATA;
-            //        __asm__("nop");
+                    __asm__("nop");
-            //        __asm__("nop");
+                    __asm__("nop");
-            //        __asm__("nop");
+                    __asm__("nop");
-            //        __asm__("nop");
+                    __asm__("nop");
-            //        __asm__("nop");
+                    __asm__("nop");
-            //        pt8[2*i]=*lcd0_DATA;
+                    __asm__("nop");
-                    //pt8[(2*i) +1]=(uint8_t)0;
+                    __asm__("nop");
-                    //pt8[(2*i)]=(uint8_t)0;
+                    __asm__("nop");
-            //    }
+                    __asm__("nop");
+                    __asm__("nop");
+                    pt8[2*i]=*lcd0_DATA;
+                    __asm__("nop");
+                    __asm__("nop");
+                    __asm__("nop");
+                    __asm__("nop");
+                    __asm__("nop");
+                    pt8[(2*i) +1]=(uint8_t)0;
+                    pt8[(2*i)]=(uint8_t)0;
+                }
             #endif
             }
             void bsp_GTerm_init()
             {
                 if(__opnfiles__[1]==NULL)
                 {
                     streamdevice* fd1 = (streamdevice*)malloc(sizeof(streamdevice));
                     terminal_init(&terminal0 ,&lcd0,&ComicSansMS_8,fd1);
                     __opnfiles__[1] = fd1;
                 }
                 else
                 {
                 }
             }

examples/SOLAR_PSU_HELLO/hello.pro +1 -1

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

examples/SOLAR_PSU_HELLO/main.c +6 -9

             #include <stdio.h>
             #include <fat32.h>
             #include <gpio.h>
             #include <uart.h>
             #include <stm32f4xx.h>
             #include <bsp.h>
             #include <core.h>
             #include <VS10XX.h>
             #include <bsp.h>
             #include <spi.h>
             #include <sdcard.h>
             #include <sdcard-spi.h>
             #include <fat32.h>
             #include <ucdirent.h>
             #include <string.h>
             #include <terminal.h>
             #include <ili9328.h>
             extern streamdevice* __opnfiles__[];
             extern void test_Block_Move(LCD_t* LCD,int x,int y,int w,int h,int color);
             char buffer[512];
             void randBoxesDemo()
             {
                 int16_t x,y,w,h,t,r;
                 x=rand()%240;
                 y=rand()%320;
                 w=rand()%(240-x);
                 if(x>y)
                     r=(rand()%(y))%(320-y);
                 else
                     r=(rand()%(x))%(240-x);
                 h=rand()%(320-y);
                 t=rand()%(10);
                 ili9328paintFilRect(&lcd0,x,y,w,h,rand(),t,rand());
                 //ili9328paintFilCirc(&lcd0,x,y,r,rand(),t,rand());
                 //delay_100us(10);
                 //for(volatile int i=0;i<(1024*2);i++);
             }
             void randTextDemo()
             {
                 int16_t x,y,w,h,t,r;
                 char buf[2];
                 buf[1]='\0';
                 x=rand()%240;
                 y=rand()%320;
                 if(x>y)
                     r=(rand()%(y))%(320-y);
                 else
                     r=(rand()%(x))%(240-x);
                 h=rand()%(320-y);
                 buf[0]=rand()%(255);
                 //ili9328paintFilRect(&lcd0,x,y,w,h,rand(),t,rand());
                 ili9328paintText(&lcd0,buf,x,y,&ComicSansMS_18,rand());
                 //ili9328paintFilCirc(&lcd0,x,y,r,rand(),t,rand());
                 delay_100us(5000);
                 //for(volatile int i=0;i<(1024*2);i++);
             }
             void tryToplay2()
             {
                 extern blkdevice sdcard2blkdev;
                 int i=0,l=0;
                 spisetspeed(audioCodec0.SPIdev,4000000);
                 printf("Streaming File\n");
                 //printf("New LBA=0x%X\n",nextLba);
                 while(sdcard2blkdev.read(&sdcard2blkdev,buffer,l++,1)==RES_OK)
                 {
                     for(i=0;i<512;i+=32)
                     {
                         vs10XXstream32bytes(&audioCodec0,buffer+i);
                     }
                 }
             }
             void playFile(ucdirent* file,FAT32fs* part)
             {
                 extern volatile vs10XXDev audioCodec0;
                 char direntName[]="                                 \n";
                 uint32_t fileLba,nextLba;
                 int i=0;
                 fat32getdirentname(file,direntName);
-                gpioset(LCD_BACKL);
+                //gpioset(LCD_BACKL);
-                //printf("%s\n",direntName);
+                printf("%s\n",direntName);
                 nextLba=fat32getdirentlba(file);
                 //printf("Streaming File\n");
-                gpioclr(LCD_BACKL);
+                //gpioclr(LCD_BACKL);
                 do
                 {
                     fileLba = nextLba;
                     if(sdcard2FAT32part1.part->phy->read(part->part->phy,buffer,fileLba,1)==RES_OK)
                     {
                         for(i=0;i<512;i+=32)
                         {
                             vs10XXstream32bytes(&audioCodec0,buffer+i);
                         }
                     }
                 }while ((fat32nextsectorlba(part,fileLba,&nextLba)==DIRENT_noErr) && (!gpiogetval(BP3)));
                 vs10XXsoftReset(&audioCodec0);
                 while (gpiogetval(BP3))delay_100us(1000);
             }
             void playAllparts()
             {
                 extern FAT32fs sdcard2FAT32part1,sdcard2FAT32part2,sdcard2FAT32part3,sdcard2FAT32part4;
                 ucdirent root;
                 if(DIRENT_noErr==fat32mkdirent(&sdcard2FAT32part1,&root))
                 {
                     printf("Reading on SDCARD2 part1\n");
                     if(DIRENT_noErr==fat32getrootfirstent(&root))
                     {
                         do{
                             playFile(&root,&sdcard2FAT32part1);
                         }while (DIRENT_noErr==fat32nextdirent(&root));
                     }
                 }
                 gpioset(LED2);
                 if(DIRENT_noErr==fat32mkdirent(&sdcard2FAT32part2,&root))
                 {
                     printf("Reading on SDCARD2 part2\n");
                     if(DIRENT_noErr==fat32getrootfirstent(&root))
                     {
                         do{
                             playFile(&root,&sdcard2FAT32part2);
                         }while (DIRENT_noErr==fat32nextdirent(&root));
                     }
                 }
             }
-            int main()
+            int main2()
             {
                 delay_100us(30000);
                 int i=0;
                 int color=0;
                 for(i=0;i<240;i++)
                 {
                     if(i>(240/3))
                     {
                         color= (i<<5) + 0x1F;
                     }
                     else
                     {
                         color = i;
                     }
                     if(i>(2*240/3))
                     {
                         color= (i<<10) + 0x3FF;
                     }
                     lcd0.paintFilRect(&lcd0,i,0,1,100,0,0,color);
                 }
                 while(1)printf("test ");
             //    for(i=0;i<240;i++)
             //    {
             //        if(i>(240/3))
             //        {
             //            color= (i<<5) + 0x1F;
             //        }
             //        else
             //        {
             //            color = i;
             //        }
             //        if(i>(2*240/3))
             //        {
             //            color= (i<<10) + 0x3FF;
             //        }
             //        lcd0.paintFilRect(&lcd0,i,220,1,100,0,0,color);
             //    }
                 for(i=0;i<240;i++)
                 {
                     ili9328setFrame(&lcd0,i,0,1,100);
                     lcd0.interface->readGRAM(buffer,100);
                     lcd0.paint(&lcd0,buffer,i,200,1,100);
                 }
                 while(1);
             }
-            int main2()
+            int main()
             {
                 extern terminal_t terminal0;
                 extern volatile vs10XXDev audioCodec0;
-                lcd0.paintText(&lcd0,"hello",20,50,&ComicSansMS_18 ,0xF0F0);
-                while (1)
-                    randTextDemo();
                 printf("Volume=0x%x\n",vs10XXcmdread(&audioCodec0,VSVOL));
                 vs10XXcmdwrite(&audioCodec0,VSCLOCKF,0x2000);
                 delay_100us(1000);
                 vs10XXcmdwrite(&audioCodec0,VSVOL,0x2020);
                 printf("VSCLOCKF=0x%x\n",vs10XXcmdread(&audioCodec0,VSCLOCKF));
                 printf("VSMODE=0x%x\n",vs10XXcmdread(&audioCodec0,VSMODE));
                 //terminal_clear(&terminal0);
-                gpioclr(LCD_BACKL);
+               // gpioclr(LCD_BACKL);
                 playAllparts();
                 return 0;
             }

examples/TEST_SIMULATOR/main.c +1 -1

             #include <stdio.h>
             #include <fat32.h>
             #include <gpio.h>
             #include <uart.h>
             #include <bsp.h>
             #include <core.h>
             #include <bsp.h>
             #include <spi.h>
             #include <fat32.h>
             #include <ucdirent.h>
             #include <string.h>
             #include <unistd.h>
             #include <terminal.h>
             #include <stdarg.h>
             #include <malloc.h>
             extern streamdevice* __opnfiles__[];
             extern void test_Block_Move(LCD_t* LCD,int x,int y,int w,int h,int color);
             char buffer[512];
             void streamdevicePrint(streamdevice* dev, const char* format,...)
             {
                 char** str_buffer;
                 int i;
                 va_list ap;
                 va_start(ap,format);
                 vasprintf(str_buffer,format,ap);
                 va_end(ap);
                 i=strlen(*str_buffer);
                 dev->ops->write(dev,(void*)*str_buffer,1,i);
                 free(*str_buffer);
             }
             void lcd_print()
             {
                 lcd0.paintFilRect(&lcd0,10,10,100,100,0,0,0x0F0F);
                // __opnfiles__[1]->ops->write(__opnfiles__[1],(void*)"hello",1,5);
             }
-            int libuc2_main_task()
+            int libuc_main()
             {
                 char in[255];
                 lcd_print();
                 printf("hello world\n");
                 streamdevicePrint(__opnfiles__[1],"test Hello %d %f \n",1234567,8.96);
                 lcd0.paintText(&lcd0,"A",10,100,&ComicSansMS_18,0x0);
             //    while (scanf("%c",in))
             //    {
                     sleep(5);
             //    }
             }

lib/src/common/FILE_SYSTEM/SDCARD/sdcard_STM32F4.pro +2 -1

             TEMPLATE = lib
             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
+                ../../../includes/sdcard.h \
+                ../../../includes/sdcard-spi.h

lib/src/common/GRAPHIC/CONTROLERS/ILI9328/ili9328.c +1 -1

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

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2013, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
             --                   Mail : alexis.jeandet@member.fsf.org
             -------------------------------------------------------------------------------*/
             #include <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->verticalSpace = 0;
                     int charw=terminal->font->Width + terminal->horizontalSpace;
                     int charh=terminal->font->Height + terminal->verticalSpace;
                     terminal->textColor=0xFFFF;
-                    terminal->backgroundColor=0x0000;
+                    terminal->backgroundColor=0xF00F;
                     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))
                 {
                     terminal->line += (terminal->column)/terminal->columnCount;
                     terminal->line = terminal->line % terminal->lineCount;
                     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);
+                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;
                         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'){
                        //     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->verticalSpace/2),terminal->font,terminal->textColor);
                             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/includes/sdcard-spi.h +2 -2

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2012, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
             --                   Mail : alexis.jeandet@gmail.com
             -------------------------------------------------------------------------------*/
-            #ifndef SDCARD-SPI_H
+            #ifndef SDCARD_SPI_H
-            #define SDCARD-SPI_H
+            #define SDCARD_SPI_H
             #include <blkdevice.h>
             #include <libucstrings.h>
             #include <uhandle.h>
             #include <sdcard.h>
             extern void sdcardspimake(sdcardDev* sdcard,UHANDLE phy,void (*rcvr_mmc) (UHANDLE,char *,uint32_t ),void (*xmit_mmc) (UHANDLE,const char *,uint32_t ),void (*setspeed) (UHANDLE phy,uint32_t speed),uint32_t (*getspeed) (UHANDLE phy));
             extern void sdcardspimakeblkdev(blkdevice* dev,sdcardDev* sdcard, blkdevselect_t select,blkdevpower_t power,blkdevdetect_t detect,blkdevwriteprotected_t writeprotected);
             #endif

lib/src/simulator/CPU/startup.c +1 -1

             int main(void)
             {
             	bsp_init();
-            	libuc2_main_task();
+            	libuc_main();
             }

mkspecs/features/ucswitch.prf +2 -4

             #
             # Microcontroler switch
             #
             #
             contains( TEMPLATE, app ) {
             	!isEmpty( BSP ) {
             	 	include(./boards/$$BSP/bsp.pri)
             	 }
             }
-            #contains( TEMPLATE, lib ) {
             !isEmpty( UCMODEL ) {
-            	 	include(../$$UCMODEL/qmake.conf)
+            	include(./$$UCMODEL/cpu.pri)
+             	include(./$$UCMODEL/qmake.conf)
             }
-            #}

examples/SOLAR_PSU_HELLO/bin/dfu.py removed 0 -121

NO CONTENT: file was removed

examples/SOLAR_PSU_HELLO/bin/test.dfu removed binary 0 0

NO CONTENT: file was removed, binary diff hidden

mkspecs/features/cpu.prf removed 0 -14

NO CONTENT: file was removed

mkspecs/simulator/qmake.conf removed 0 -57

NO CONTENT: file was removed

mkspecs/simulator/qplatformdefs.h removed 0 -42

NO CONTENT: file was removed

mkspecs/stm32f4/optimised_math.h removed 0 -37

NO CONTENT: file was removed

mkspecs/stm32f4/qmake.conf removed 0 -77

NO CONTENT: file was removed

mkspecs/stm32f4/qplatformdefs.h removed 0 -42

NO CONTENT: file was removed

General Comments 0

Write
Preview

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

No TODOs yet

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

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