HG_REPOSITORIES/LPP/INSTRUMENTATION/libuc2 Commit - r64:b702edc52366

sync

Jeandet Alexis -

r64:b702edc52366 dev_alexis

parent child

Context file:

r64:b702edc52366

Expand all files

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

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2011, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
-            --                   Mail : alexis.jeandet@gmail.com
+            --                   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 int16_t* lcd0_CMD=(volatile int16_t*)  0x60000000;
             volatile int16_t* lcd0_DATA=(volatile int16_t*)(0x61FFFFF0);
             float VREF0 =(float)3.3;
             int bsp_init()
             {
                 int i=0;
                 for(i=0;i<32;i++)
                 {
                     __opnfiles__[i] = NULL;
                 }
                 bsp_GPIO_init();
                 bsp_uart_init();
                 bsp_iic_init();
                 bsp_FSMC_init();
                 bsp_GTerm_init();
                 printf("\r=====================\n\r");
                 printf(  "=====================\n\r");
                 printf(BSP);
                 printf(" initialised\n\r");
                 printf(  "=====================\n\r");
                 return 1;
             }
             void bsp_GPIO_init()
             {
                 gpio_t gpio1 = gpioopen(LED1);
                 gpio_t gpio2 = gpioopen(LED2);
                 gpio_t gpio3 = gpioopen(LED3);
                 gpio_t gpio4 = gpioopen(PSU_DISABLE);
                 gpio_t gpio5 = gpioopen(PSU_ALERT_5V);
                 gpio_t gpio6 = gpioopen(PSU_ALERT_1_5V);
                 gpio_t gpio7 = gpioopen(PSU_ALERT_3_3V);
                 gpiosetspeed(&gpio1,gpiohighspeed);
                 gpiosetspeed(&gpio2,gpiohighspeed);
                 gpiosetspeed(&gpio3,gpiohighspeed);
                 gpiosetspeed(&gpio4,gpiohighspeed);
                 gpiosetspeed(&gpio5,gpiohighspeed);
                 gpiosetspeed(&gpio6,gpiohighspeed);
                 gpiosetspeed(&gpio7,gpiohighspeed);
                 gpioclr(PSU_DISABLE);
                 gpiosetdir(&gpio1,gpiooutdir);
                 gpiosetdir(&gpio3,gpiooutdir);
                 gpiosetdir(&gpio2,gpiooutdir);
                 gpiosetdir(&gpio4,gpiooutdir);
                 gpiosetdir(&gpio5,gpioindir);
                 gpiosetdir(&gpio6,gpioindir);
                 gpiosetdir(&gpio7,gpioindir);
                 gpioclr(PSU_DISABLE);
             }
             void bsp_uart_init()
             {
                 //if(__opnfiles__[1]==NULL)
                 //{
                 //uart_t* uart1 = (uart_t*)malloc(sizeof(uart_t));
                 //  streamdevice* fd1 = (streamdevice*)malloc(sizeof(streamdevice));
                 // uart_t uart = uartopenandconfig(uart1,uartparitynone | uart8bits | uartonestop,115200,PA9,PA10,-1,-1);
                 //uartmkstreamdev(uart,fd1);
                 //__opnfiles__[1] = fd1;
                 //}
                 //else
                 //{
                 uartopenandconfig(0,uartparitynone | uart8bits | uartonestop,115200,PA9,PA10,-1,-1);
                 //}
             }
             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 gpio1 = gpioopen(LCD_RESET);
                 gpiosetspeed(&gpio1,gpiohighspeed);
                 gpiosetdir(&gpio1,gpiooutdir);
                 gpioclr(LCD_RESET);
                 gpio_t LCD_DBxList[]={PD14,PD15,PD0,PD1,PE7,PE8,PE9,PE10,PE11,PE12,PE13,PE14,PE15\
                                       ,PD8,PD9,PD10,PD4,PD5,PD7,PE4};
                 for(int i=0;i<20;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_AddressHoldTime = 0;
                 //p.FSMC_DataSetupTime = 9;
                 p.FSMC_DataSetupTime = getCpuFreq()/14545450  ;// 11;
                 p.FSMC_BusTurnAroundDuration = 0;
                 p.FSMC_CLKDivision = 0;
                 p.FSMC_DataLatency = 0;
                 p.FSMC_AccessMode = FSMC_AccessMode_A;
                 /* Color LCD configuration ------------------------------------
                    LCD configured as follow:
                       - Data/Address MUX = Disable
                       - Memory Type = SRAM
                       - Data Width = 16bit
                       - Write Operation = Enable
                       - Extended Mode = Enable
                       - Asynchronous Wait = Disable */
                 FSMC_NORSRAMInitStructure.FSMC_Bank = FSMC_Bank1_NORSRAM1;
                 FSMC_NORSRAMInitStructure.FSMC_DataAddressMux = FSMC_DataAddressMux_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_MemoryType = FSMC_MemoryType_SRAM;
                 FSMC_NORSRAMInitStructure.FSMC_MemoryDataWidth = FSMC_MemoryDataWidth_16b;
                 FSMC_NORSRAMInitStructure.FSMC_BurstAccessMode = FSMC_BurstAccessMode_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_AsynchronousWait = FSMC_AsynchronousWait_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_WaitSignalPolarity = FSMC_WaitSignalPolarity_Low;
                 FSMC_NORSRAMInitStructure.FSMC_WrapMode = FSMC_WrapMode_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_WaitSignalActive = FSMC_WaitSignalActive_BeforeWaitState;
                 FSMC_NORSRAMInitStructure.FSMC_WriteOperation = FSMC_WriteOperation_Enable;
                 FSMC_NORSRAMInitStructure.FSMC_WaitSignal = FSMC_WaitSignal_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_ExtendedMode = FSMC_ExtendedMode_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_WriteBurst = FSMC_WriteBurst_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_ReadWriteTimingStruct = &p;
                 FSMC_NORSRAMInitStructure.FSMC_WriteTimingStruct = &p;
                 FSMC_NORSRAMInit(&FSMC_NORSRAMInitStructure);
                 /* Enable FSMC NOR/SRAM Bank1 */
                 FSMC_NORSRAMCmd(FSMC_Bank1_NORSRAM1, ENABLE);
                 gpioset(LCD_RESET);
                 lcd0.init(&lcd0);
                 return 1;
             }
             void bsp_spi_init()
             {
             }
             void bsp_iic_init()
             {
                 i2copenandconfig(i2c2,0,10000,PF0,PF1);
             }
             void bsp_SD_init()
             {
             }
             void vs10XXclearXCS(){}
             void vs10XXsetXCS(){}
             int vs10XXDREQ()
             {
                 return 1;
             }
             void bsppowersdcard(char onoff)   //always ON
             {
             }
             char bspsdcardpresent()
             {
                 return 0;
             }
             char bspsdcardwriteprotected()
             {
                 return 0;
             }
             void bspsdcardselect(char YESNO)
             {
             }
             void bsp_lcd0_write_reg(uint32_t reg,uint32_t data)
             {
                 *lcd0_CMD=(uint16_t)reg;
                 *lcd0_DATA=(uint16_t)data;
             }
             uint32_t bsp_lcd0_read_reg(uint32_t reg)
             {
                 *lcd0_CMD=(uint16_t)reg;
                 return (uint16_t)*lcd0_DATA;
             }
             void bsp_lcd0_writeGRAM(void* buffer,uint32_t count)
             {
                 *lcd0_CMD=(uint16_t)ILI9328_REGISTER_WRITEDATATOGRAM;
                 uint16_t* castedBuff=(uint16_t*)buffer;
                 for(int i=0;i<(int)count;i++)
                 {
                     *lcd0_DATA=castedBuff[i];
                 }
             }
             void bsp_lcd0_readGRAM(void* buffer,uint32_t count)
             {
                 *lcd0_CMD=(uint16_t)ILI9328_REGISTER_WRITEDATATOGRAM;
                 uint16_t* castedBuff=(uint16_t*)buffer;
                 castedBuff[0]=*lcd0_DATA;
                 for(int i=0;i<(int)count;i++)
                 {
                     castedBuff[i]=*lcd0_DATA;
                 }
             }
             void bsp_GTerm_init()
             {
                 if(__opnfiles__[1]==NULL)
                 {
                     //uart_t* uart1 = (uart_t*)malloc(sizeof(uart_t));
                     streamdevice* fd1 = (streamdevice*)malloc(sizeof(streamdevice));
                     terminal_init(&terminal0 ,&lcd0,&ComicSansMS_8,fd1);
                     __opnfiles__[1] = fd1;
                 }
                 else
                 {
                 }
             }

bsp/src/BEAGLESYNTH/bsp.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2011, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
-            --                   Mail : alexis.jeandet@gmail.com
+            --                   Mail : alexis.jeandet@member.fsf.org
             -------------------------------------------------------------------------------*/
             #ifndef BSP_H
             #define BSP_H
             #include <stm32f4xx.h>
             #include <stm32f4xx_gpio.h>
             #include <stm32f4xx_rcc.h>
             #include <gpio.h>
             #include <ili9328.h>
             #include <genericLCD_Controler.h>
             #define __MAX_OPENED_FILES__ 4
             #define __FS_ROOT_SIZE__ 4
             /*
             #ifndef PD8
               #define PD8
             #endif
             #ifndef PD9
               #define PD9
             #endif
             */
             #define LED1 PF6
             #define LED2 PF7
             #define LED3 PF8
             #define PSU_DISABLE PH2
             #define PSU_ALERT_5V PF2
             #define PSU_ALERT_1_5V PF3
             #define PSU_ALERT_3_3V PF4
             #define LCD_RESET PE2
             extern float VREF0;
             extern uint32_t currentCpuFreq;
             extern LCD_t lcd0;
             extern int bsp_init();
             extern void bsp_GPIO_init();
             extern void bsp_uart_init();
             extern void bsp_iic_init();
             extern void bsp_spi_init();
             extern void bsp_SD_init();
             extern void bsp_GTerm_init();
             extern int bsp_FSMC_init();
             /*  VS1053  */
             extern void clearXCS();
             extern void setXCS();
             extern int vs10XXDREQ();
             /*   SD CARD */
             void bsppowersdcard(char onoff);
             char bspsdcardpresent();
             void bspsdcardselect(char YESNO);
             char bspsdcardwriteprotected();
             void bsp_lcd0_write_reg(uint32_t reg,uint32_t data);
             uint32_t bsp_lcd0_read_reg(uint32_t reg);
             void bsp_lcd0_writeGRAM(void *buffer, uint32_t count);
             void bsp_lcd0_readGRAM(void *buffer, uint32_t count);
             #endif

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

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2011, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
-            --                   Mail : alexis.jeandet@gmail.com
+            --                   Mail : alexis.jeandet@member.fsf.org
             -------------------------------------------------------------------------------*/
             #include "bsp.h"
             #include <streamdevices.h>
             #include <malloc.h>
             #include <gpio.h>
             #include <uart.h>
             #include <stdio.h>
             uint32_t OSC0  =8000000;
             uint32_t INTOSC =16000000;
             uint32_t RTCOSC =32768;
             uint32_t currentCpuFreq=0;
             extern streamdevice* __opnfiles__[__MAX_OPENED_FILES__];
             float VREF0 =(float)3.3;
             int bsp_init()
             {
                 int i=0;
                 for(i=0;i<32;i++)
                 {
                     __opnfiles__[i] = NULL;
                 }
                 bsp_GPIO_init();
                 bsp_uart_init();
                 printf("\r================================================================\n\r");
                 printf("================================================================\n\r");
                 printf(BSP);
                 printf(" initialised\n\r");
                 printf("================================================================\n\r");
                 return 1;
             }
             void bsp_GPIO_init()
             {
                 gpio_t gpio1 = gpioopen(PC6);//gpioopen(LED1);  //PD9 D=> 0x0300 9 => 0x0009
                 gpio_t gpio2 = gpioopen(PC7);//gpioopen(LED2);
                 gpiosetspeed(&gpio1,gpiohighspeed);
                 gpiosetspeed(&gpio2,gpiohighspeed);
                 gpiosetdir(&gpio1,gpiooutdir);
                 gpiosetdir(&gpio2,gpiooutdir);
             }
             void bsp_uart_init()
             {
                 if(__opnfiles__[1]==NULL)
                 {
                     //uart_t* uart1 = (uart_t*)malloc(sizeof(uart_t));
                     streamdevice* fd1 = (streamdevice*)malloc(sizeof(streamdevice));
                     uart_t uart = uartopenandconfig(uart3,uartparitynone | uart8bits | uartonestop,115200,LED2,LED1,-1,-1);
                     uartmkstreamdev(uart,fd1);
                     __opnfiles__[1] = fd1;
                 }
                 else
                 {
                     uartopenandconfig(uart3,uartparitynone | uart8bits | uartonestop,115200,LED2,LED1,-1,-1);
                 }
             }
             void bsp_spi_init()
             {
             }
             void bsp_iic_init()
             {
             }
             void bsp_SD_init()
             {
             }
             void vs10XXclearXCS(){}
             void vs10XXsetXCS(){}
             int vs10XXDREQ()
             {
                 return 1;
             }
             void bsppowersdcard(char onoff)   //always ON
             {
             }
             char bspsdcardpresent()
             {
                 return 0;
             }
             char bspsdcardwriteprotected()
             {
                 return 0;
             }
             void bspsdcardselect(char YESNO)
             {
             }

bsp/src/M4Stick/bsp.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2011, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
-            --                   Mail : alexis.jeandet@gmail.com
+            --                   Mail : alexis.jeandet@member.fsf.org
             -------------------------------------------------------------------------------*/
             #ifndef BSP_H
             #define BSP_H
             #include <stm32f4xx.h>
             #include <stm32f4xx_gpio.h>
             #include <stm32f4xx_rcc.h>
             #include <gpio.h>
             #define __MAX_OPENED_FILES__ 32
             #define __FS_ROOT_SIZE__ 32
             #define LED1 PD8
             #define LED2 PD9
             #define LED3ON GPIOB->BSRRH = GPIO_Pin_15
             #define LED2ON GPIOD->BSRRH = GPIO_Pin_8
             #define LED1ON GPIOD->BSRRH = GPIO_Pin_9
             #define LED3OFF GPIOB->BSRRL = GPIO_Pin_15
             #define LED2OFF GPIOD->BSRRL = GPIO_Pin_8
             #define LED1OFF GPIOD->BSRRL = GPIO_Pin_9
             extern float VREF0;
             extern uint32_t currentCpuFreq;
             extern int bsp_init();
             extern void bsp_GPIO_init();
             extern void bsp_uart_init();
             extern void bsp_iic_init();
             extern void bsp_spi_init();
             extern void bsp_SD_init();
             /*  VS1053  */
             extern void clearXCS();
             extern void setXCS();
             extern int vs10XXDREQ();
             /*   SD CARD */
             void bsppowersdcard(char onoff);
             char bspsdcardpresent();
             void bspsdcardselect(char YESNO);
             char bspsdcardwriteprotected();
             #endif

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

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2011, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
-            --                   Mail : alexis.jeandet@gmail.com
+            --                   Mail : alexis.jeandet@member.fsf.org
             -------------------------------------------------------------------------------*/
             #include "bsp.h"
             #include <streamdevices.h>
             #include <malloc.h>
             #include <gpio.h>
             #include <uart.h>
             #include <spi.h>
             #include <stdio.h>
             #include <core.h>
             uint32_t OSC0  =8000000;
             uint32_t INTOSC =16000000;
             uint32_t RTCOSC =32768;
             uint32_t currentCpuFreq=0;
             extern streamdevice* __opnfiles__[__MAX_OPENED_FILES__];
             float VREF0 =(float)3.3;
             int bsp_init()
             {
                 int i=0;
                 for(i=0;i<32;i++)
                 {
                     __opnfiles__[i] = NULL;
                 }
                 bsp_GPIO_init();
                 bsp_uart_init();
                 bsp_spi_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 GPIOList[]={LED1,LED2,LED3,ADC_MODE0,ADC_MODE1,ADC_FSYNC
                                    ,ADC_SYNC,ADC_CLKDIV};
                 gpio_t GPIOx;
                 for(int i=0;i<8;i++)
                 {
                     GPIOx = gpioopen(GPIOList[i]);
                     gpiosetspeed(&GPIOx,gpiohighspeed);
                     gpiosetdir(&GPIOx,gpiooutdir);
                     gpiosetouttype(&GPIOx,gpiopushpulltype);
                 }
                 gpioset(ADC_CLKDIV);
                 gpioset(ADC_MODE0);
                 gpioset(ADC_MODE1);
                 gpioclr(ADC_SYNC);
                 gpioclr(ADC_FSYNC);
                 delay_100us(10);
                 gpioset(ADC_SYNC);
             }
             void bsp_uart_init()
             {
                 if(__opnfiles__[1]==NULL)
                 {
                     //uart_t* uart1 = (uart_t*)malloc(sizeof(uart_t));
                     streamdevice* fd1 = (streamdevice*)malloc(sizeof(streamdevice));
                     //uart_t uart = uartopenandconfig(uart1,uartparitynone | uart8bits | uartonestop,230400,PA9,PA10,-1,-1);
                     uart_t uart = uartopenandconfig(uart1,uartparitynone | uart8bits | uartonestop,115200,PA9,PA10,-1,-1);
                     uartmkstreamdev(uart,fd1);
                     __opnfiles__[1] = fd1;
                 }
                 else
                 {
                    // uartopenandconfig(uart1,uartparitynone | uart8bits | uartonestop,230400,PA9,PA10,-1,-1);
                     uartopenandconfig(uart1,uartparitynone | uart8bits | uartonestop,115200,PA9,PA10,-1,-1);
                 }
             }
             void bsp_spi_init()
             {
                 spiopenandconfig(spi1,spi8bits | spimaster |spiclkinhlow | spiclkfirstedge | spimsbfirst,4000000,DAC_DIN,ADC_DOUT1,ADC_SCLK,-1);
             }
             void bsp_iic_init()
             {
             }
             void bsp_SD_init()
             {
             }
             void vs10XXclearXCS(){}
             void vs10XXsetXCS(){}
             int vs10XXDREQ()
             {
                 return 1;
             }
             void bsppowersdcard(char onoff)   //always ON
             {
             }
             char bspsdcardpresent()
             {
                 return 0;
             }
             char bspsdcardwriteprotected()
             {
                 return 0;
             }
             void bspsdcardselect(char YESNO)
             {
             }

bsp/src/M4StickV2/bsp.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2011, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
-            --                   Mail : alexis.jeandet@gmail.com
+            --                   Mail : alexis.jeandet@member.fsf.org
             -------------------------------------------------------------------------------*/
             #ifndef BSP_H
             #define BSP_H
             #include <stm32f4xx.h>
             #include <stm32f4xx_gpio.h>
             #include <stm32f4xx_rcc.h>
             #include <gpio.h>
             #define __MAX_OPENED_FILES__ 32
             #define __FS_ROOT_SIZE__ 32
             #define LED1 PD9
             #define LED2 PD8
             #define LED3 PB15
             #define DAC_CS     PA1
             #define DAC_DIN    PA7
             #define ADC_MODE0  PA2
             #define ADC_MODE1  PA3
             #define ADC_FSYNC  PA4
             #define ADC_SCLK   PA5
             #define ADC_DOUT1  PA6
             #define ADC_SYNC   PB10
             #define ADC_CLKDIV PB11
             extern float VREF0;
             extern uint32_t currentCpuFreq;
             extern int bsp_init();
             extern void bsp_GPIO_init();
             extern void bsp_uart_init();
             extern void bsp_iic_init();
             extern void bsp_spi_init();
             extern void bsp_SD_init();
             /*  VS1053  */
             extern void clearXCS();
             extern void setXCS();
             extern int vs10XXDREQ();
             /*   SD CARD */
             void bsppowersdcard(char onoff);
             char bspsdcardpresent();
             void bspsdcardselect(char YESNO);
             char bspsdcardwriteprotected();
             #endif

bsp/src/OPLAYER/bsp.c +6 -5

             /*------------------------------------------------------------------------------
             --  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
+            --                   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;
             //    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;
                 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[0];
             //     pt8  = (int8_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;
                     //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_18,fd1);
+                    terminal_init(&terminal0 ,&lcd0,&ComicSansMS_8,fd1);
                     __opnfiles__[1] = fd1;
                 }
                 else
                 {
                 }
             }

bsp/src/OPLAYER/bsp.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2011, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
-            --                   Mail : alexis.jeandet@gmail.com
+            --                   Mail : alexis.jeandet@member.fsf.org
             -------------------------------------------------------------------------------*/
             #ifndef BSP_H
             #define BSP_H
             #include <stm32f4xx.h>
             #include <stm32f4xx_gpio.h>
             #include <stm32f4xx_rcc.h>
             #include <gpio.h>
             #include <spi.h>
             #include <ili9328.h>
             #include <genericLCD_Controler.h>
             #include <sdcard-spi.h>
             #include <sdcard.h>
             #include <mbr.h>
             #include <VS10XX.h>
             #include <fat32.h>
             #define __MAX_OPENED_FILES__ 4
             #define __FS_ROOT_SIZE__ 4
             #define LED1 PC15
             #define LED2 PC14
             #define BP3   PA0
             #define LCD_RESET PD10
             #define LCD_BACKL PE11
             #define VS1053SPI    spi1
             #define VS1053xCS    PA3
             #define VS1053xRESET PA2
             #define VS1053xDCS   PA4
             #define VS1053DREQ   PA1
             #define VS1053MISO   PA6
             #define VS1053MOSI   PA7
             #define VS1053SCK    PA5
             #define SDCARD2SPI   spi3
             #define SDCARD2CS    PB8
             #define SDCARD2CD    PB9
             #define SDCARD2MISO  PB4
             #define SDCARD2MOSI  PB5
             #define SDCARD2SCK   PB3
             extern float VREF0;
             extern uint32_t currentCpuFreq;
             extern LCD_t lcd0;
             extern volatile vs10XXDev audioCodec0;
             extern sdcardDev sdcard2;
             extern blkdevice sdcard2blkdev;
             extern dikpartition sdcard2Part1;
             extern FAT32fs sdcard2FAT32part1;
             extern dikpartition sdcard2Part2;
             extern FAT32fs sdcard2FAT32part2;
             extern dikpartition sdcard2Part3;
             extern FAT32fs sdcard2FAT32part3;
             extern dikpartition sdcard2Part4;
             extern FAT32fs sdcard2FAT32part4;
             extern int bsp_init();
             extern void bsp_GPIO_init();
             extern void bsp_uart_init();
             extern void bsp_iic_init();
             extern void bsp_spi_init();
             extern void bsp_SD_init();
             extern void bsp_Audio_init();
             extern void bsp_GTerm_init();
             extern int bsp_FSMC_init();
             /*  VS1053  */
             extern void vs1052setXCS(char val);
             extern void vs1052setXDCS(char val);
             extern void vs1052setRST(char val);
             extern int vs10XXDREQ();
             /*   SD CARD */
             void bsppowersdcard(char onoff);
             char bspsdcardpresent();
             void bspsdcardselect(char YESNO);
             char bspsdcardwriteprotected();
             void bsp_lcd0_write_reg(uint32_t reg,uint32_t data);
             uint32_t bsp_lcd0_read_reg(uint32_t reg);
             void bsp_lcd0_writeGRAM(void *buffer, uint32_t count);
             void bsp_lcd0_readGRAM(void *buffer, uint32_t count);
             #endif

bsp/src/SIMULATOR/bsp.c +4 -3

             /*------------------------------------------------------------------------------
             --  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
+            --                   Mail : alexis.jeandet@member.fsf.org
             -------------------------------------------------------------------------------*/
             #include "bsp.h"
             #include <streamdevices.h>
             #include <malloc.h>
             #include <stdio.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 = &SDLCD_init,
                 .writereg = &SDLCD_writereg,
                 .readreg = &SDLCD_readreg,
-                .writeGRAM = &SDLCD_writeGRAM,
+                .writeGRAM = &SDLCD_writeGRAM_16bpp,
-                .readGRAM = &SDLCD_readGRAM
+                .readGRAM = &SDLCD_readGRAM_16bpp
             };
             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 int8_t* lcd0_DATA=(volatile int8_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()
             {
             }
             void bsp_uart_init()
             {
             }
             /*
             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()
             {
                 return 1;
             }
             void bsp_spi_init()
             {
             }
             void bsp_iic_init()
             {
             }
             void bsp_Audio_init()
             {
             }
             void bsp_SD_init()
             {
             }
             void vs1052setXCS(char val)
             {
             }
             void vs1052setXDCS(char val)
             {
             }
             void vs1052setRST(char val)
             {
             }
             int vs10XXDREQ()
             {
                 return 1;
             }
             void bsppowersdcard(char onoff)   //always ON
             {
             }
             char bspsdcardpresent()
             {
                 return 1;
             }
             char bspsdcardwriteprotected()
             {
                 return 0;
             }
             void bspsdcardselect(char YESNO)
             {
             }
             void bsp_lcd0_write_reg(uint32_t reg,uint32_t data)
             {
             }
             uint32_t bsp_lcd0_read_reg(uint32_t reg)
             {
                 return 0;
             }
             void bsp_lcd0_writeGRAM(void* buffer,uint32_t count)
             {
             }
             void bsp_lcd0_readGRAM(void* buffer,uint32_t count)
             {
             }
             void bsp_GTerm_init()
             {
                 SDLCD_mkscreen(240,320,16,LCDILI9328);
                 if(__opnfiles__[1]==NULL)
                 {
                     streamdevice* fd1 = (streamdevice*)malloc(sizeof(streamdevice));
                     terminal_init(&terminal0 ,&lcd0,&ComicSansMS_18,fd1);
+                    lcd0.paintFilRect(&lcd0,0,0,240,320,0,0,0x0f0f);
                     __opnfiles__[1] = fd1;
                 }
                 else
                 {
                 }
             }
             void putpixel(SDL_Surface *surface, int x, int y, Uint32 pixel)
             {
                 int bpp = surface->format->BytesPerPixel;
                 /* Here p is the address to the pixel we want to set */
                 Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * bpp;
                 switch(bpp) {
                 case 1:
                     *p = pixel;
                     break;
                 case 2:
                     *(Uint16 *)p = pixel;
                     break;
                 case 3:
                     if(SDL_BYTEORDER == SDL_BIG_ENDIAN) {
                         p[0] = (pixel >> 16) & 0xff;
                         p[1] = (pixel >> 8) & 0xff;
                         p[2] = pixel & 0xff;
                     } else {
                         p[0] = pixel & 0xff;
                         p[1] = (pixel >> 8) & 0xff;
                         p[2] = (pixel >> 16) & 0xff;
                     }
                     break;
                 case 4:
                     *(Uint32 *)p = pixel;
                     break;
                 }
             }
             Uint32 getpixel(SDL_Surface *surface, int x, int y)
             {
                 int bpp = surface->format->BytesPerPixel;
                 /* Here p is the address to the pixel we want to retrieve */
                 Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * bpp;
                 switch(bpp) {
                 case 1:
                     return *p;
                 case 2:
                     return *(Uint16 *)p;
                 case 3:
                     if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
                         return p[0] << 16 | p[1] << 8 | p[2];
                     else
                         return p[0] | p[1] << 8 | p[2] << 16;
                 case 4:
                     return *(Uint32 *)p;
                 default:
                     return 0;
                 }
                 /* shouldn’t happen, but avoids warnings */
             }

bsp/src/SIMULATOR/bsp.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2011, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
-            --                   Mail : alexis.jeandet@gmail.com
+            --                   Mail : alexis.jeandet@member.fsf.org
             -------------------------------------------------------------------------------*/
             #ifndef BSP_H
             #define BSP_H
             #include <gpio.h>
             #include <spi.h>
             #include <ili9328.h>
             #include <genericLCD_Controler.h>
             #include <sdcard-spi.h>
             #include <terminal.h>
             #include <sdcard.h>
             #include <mbr.h>
             #include <VS10XX.h>
             #include <fat32.h>
             #include <SDL.h>
             #include <stdint.h>
             #include <SDLCD.h>
             #define __MAX_OPENED_FILES__ 4
             #define __FS_ROOT_SIZE__ 4
             #define LED1 PC15
             #define LED2 PC14
             #define BP3   PA0
             #define LCD_RESET PD10
             #define LCD_BACKL PE11
             #define VS1053SPI    spi1
             #define VS1053xCS    PA3
             #define VS1053xRESET PA2
             #define VS1053xDCS   PA4
             #define VS1053DREQ   PA1
             #define VS1053MISO   PA6
             #define VS1053MOSI   PA7
             #define VS1053SCK    PA5
             #define SDCARD2SPI   spi3
             #define SDCARD2CS    PB8
             #define SDCARD2CD    PB9
             #define SDCARD2MISO  PB4
             #define SDCARD2MOSI  PB5
             #define SDCARD2SCK   PB3
             extern float VREF0;
             extern uint32_t currentCpuFreq;
             extern LCD_t lcd0;
             extern volatile vs10XXDev audioCodec0;
             extern sdcardDev sdcard2;
             extern blkdevice sdcard2blkdev;
             extern dikpartition sdcard2Part1;
             extern FAT32fs sdcard2FAT32part1;
             extern dikpartition sdcard2Part2;
             extern FAT32fs sdcard2FAT32part2;
             extern dikpartition sdcard2Part3;
             extern FAT32fs sdcard2FAT32part3;
             extern dikpartition sdcard2Part4;
             extern FAT32fs sdcard2FAT32part4;
             extern int bsp_init();
             extern void bsp_GPIO_init();
             extern void bsp_uart_init();
             extern void bsp_iic_init();
             extern void bsp_spi_init();
             extern void bsp_SD_init();
             extern void bsp_Audio_init();
             extern void bsp_GTerm_init();
             extern int bsp_FSMC_init();
             /*  VS1053  */
             extern void vs1052setXCS(char val);
             extern void vs1052setXDCS(char val);
             extern void vs1052setRST(char val);
             extern int vs10XXDREQ();
             /*   SD CARD */
             void bsppowersdcard(char onoff);
             char bspsdcardpresent();
             void bspsdcardselect(char YESNO);
             char bspsdcardwriteprotected();
             void bsp_lcd0_write_reg(uint32_t reg,uint32_t data);
             uint32_t bsp_lcd0_read_reg(uint32_t reg);
             void bsp_lcd0_writeGRAM(void *buffer, uint32_t count);
             void bsp_lcd0_readGRAM(void *buffer, uint32_t count);
             extern void putpixel(SDL_Surface *surface, int x, int y, Uint32 pixel);
             extern Uint32 getpixel(SDL_Surface *surface, int x, int y);
             #endif

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

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2011, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
-            --                   Mail : alexis.jeandet@gmail.com
+            --                   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 <i2c.h>
             uint32_t OSC0  =8000000;
             uint32_t INTOSC =16000000;
             uint32_t RTCOSC =32768;
             uint32_t currentCpuFreq=0;
             extern streamdevice* __opnfiles__[__MAX_OPENED_FILES__];
             float VREF0 =(float)3.3;
             int bsp_init()
             {
                 int i=0;
                 for(i=0;i<32;i++)
             	{
                     __opnfiles__[i] = NULL;
                 }
                 bsp_GPIO_init();
                 bsp_uart_init();
                 bsp_iic_init();
                 printf("\r================================================================\n\r");
                 printf("================================================================\n\r");
                 printf(BSP);
                 printf(" initialised\n\r");
                 printf("================================================================\n\r");
                 return 1;
             }
             void bsp_GPIO_init()
             {
                 gpio_t gpio1 = gpioopen(PD12);//gpioopen(LED1);  //PD9 D=> 0x0300 9 => 0x0009
                 gpio_t gpio2 = gpioopen(PD13);//gpioopen(LED2);
                 gpio_t gpio3 = gpioopen(PD14);//gpioopen(LED2);
                 gpio_t gpio4 = gpioopen(PD15);//gpioopen(LED2);
                 gpio_t dacRst=gpioopen(PD4);
                 gpiosetspeed(&gpio1,gpiohighspeed);
                 gpiosetspeed(&gpio2,gpiohighspeed);
                 gpiosetspeed(&gpio3,gpiohighspeed);
                 gpiosetspeed(&gpio4,gpiohighspeed);
                 gpiosetspeed(&dacRst,gpiohighspeed);
                 gpiosetdir(&gpio1,gpiooutdir);
                 gpiosetdir(&gpio3,gpiooutdir);
                 gpiosetdir(&gpio2,gpiooutdir);
                 gpiosetdir(&gpio4,gpiooutdir);
                 gpiosetdir(&dacRst,gpiooutdir);
                 gpioset(dacRst);
             }
             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,PB10,PB11,-1,-1);
                     uartmkstreamdev(uart,fd1);
                     __opnfiles__[1] = fd1;
                 }
                 else
                 {
                     uartopenandconfig(uart3,uartparitynone | uart8bits | uartonestop,115200,PB10,PB11,-1,-1);
                 }
             }
             void bsp_spi_init()
             {
             }
             void bsp_iic_init()
             {
                 i2copenandconfig(i2c1,0,400000,PB9,PB6);
                 i2copenandconfig(i2c3,0,400000,PC9,PA8);
             }
             void bsp_SD_init()
             {
             }
             void vs10XXclearXCS(){}
             void vs10XXsetXCS(){}
             int vs10XXDREQ()
             {
             	return 1;
             }
             void bsppowersdcard(char onoff)   //always ON
             {
             }
             char bspsdcardpresent()
             {
             	return 0;
             }
             char bspsdcardwriteprotected()
             {
             	return 0;
             }
             void bspsdcardselect(char YESNO)
             {
             }

bsp/src/SOLAR_LFR_PSU/bsp.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2011, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
-            --                   Mail : alexis.jeandet@gmail.com
+            --                   Mail : alexis.jeandet@member.fsf.org
             -------------------------------------------------------------------------------*/
             #ifndef BSP_H
             #define BSP_H
             #include <stm32f4xx.h>
             #include <stm32f4xx_gpio.h>
             #include <stm32f4xx_rcc.h>
             #include <gpio.h>
             #define __MAX_OPENED_FILES__ 32
             #define __FS_ROOT_SIZE__ 32
             /*
             #ifndef PD8
               #define PD8
             #endif
             #ifndef PD9
               #define PD9
             #endif
             */
             #define LED1 PD12
             #define LED2 PD13
             #define LED3 PD14
             #define LED4 PD15
             extern float VREF0;
             extern uint32_t currentCpuFreq;
             extern int bsp_init();
             extern void bsp_GPIO_init();
             extern void bsp_uart_init();
             extern void bsp_iic_init();
             extern void bsp_spi_init();
             extern void bsp_SD_init();
             /*  VS1053  */
             extern void clearXCS();
             extern void setXCS();
             extern int vs10XXDREQ();
             /*   SD CARD */
             void bsppowersdcard(char onoff);
             char bspsdcardpresent();
             void bspsdcardselect(char YESNO);
             char bspsdcardwriteprotected();
             #endif

bsp/src/STM32F4Discovery-EXT/bsp.c +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2011, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
-            --                   Mail : alexis.jeandet@gmail.com
+            --                   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 <stm32f4xx_gpio.h>
             #include <stm32f4xx_rcc.h>
             #include <core.h>
             uint32_t OSC0  =8000000;
             uint32_t INTOSC =16000000;
             uint32_t RTCOSC =32768;
             uint32_t currentCpuFreq=0;
             extern streamdevice* __opnfiles__[__MAX_OPENED_FILES__];
             float VREF0 =(float)3.3;
             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 = &ssd2119init,
                 .paint = &ssd2119paint,
                 .paintText = &ssd2119paintText,
                 .paintFilRect = &ssd2119paintFilRect,
                 .refreshenable = &ssd2119refreshenable,
                 .width= 320,
                 .height = 240
             };
             volatile int16_t* lcd0_CMD=(volatile int16_t*)  0x60000000;
             volatile int16_t* lcd0_DATA=(volatile int16_t*)(0x60FFFFF0);
             int bsp_init()
             {
                 int i=0;
                 for(i=0;i<32;i++)
                 {
                     __opnfiles__[i] = NULL;
                 }
                 bsp_GPIO_init();
                 bsp_uart_init();
                 bsp_FSMC_init();
                 printf("\r================================================================\n\r");
                 printf("================================================================\n\r");
                 printf(BSP);
                 printf(" initialised\n\r");
                 printf("================================================================\n\r");
                 return 1;
             }
             void bsp_GPIO_init()
             {
                 gpio_t gpio1 = gpioopen(PD12);//gpioopen(LED1);  //PD9 D=> 0x0300 9 => 0x0009
                // gpio_t gpio2 = gpioopen(PD13);//gpioopen(LED2);
                 gpio_t gpio3 = gpioopen(PD14);//gpioopen(LED2);
                // gpio_t gpio4 = gpioopen(PD15);//gpioopen(LED2);
                 gpiosetspeed(&gpio1,gpiohighspeed);
                 //gpiosetspeed(&gpio2,gpiohighspeed);
                 gpiosetspeed(&gpio3,gpiohighspeed);
                 //gpiosetspeed(&gpio4,gpiohighspeed);
                 gpiosetdir(&gpio1,gpiooutdir);
                 gpiosetdir(&gpio3,gpiooutdir);
                // gpiosetdir(&gpio2,gpiooutdir);
                 //gpiosetdir(&gpio4,gpiooutdir);
             }
             void bsp_uart_init()
             {
                 if(__opnfiles__[1]==NULL)
                 {
                     //uart_t* uart1 = (uart_t*)malloc(sizeof(uart_t));
                     streamdevice* fd1 = (streamdevice*)malloc(sizeof(streamdevice));
                     uart_t uart = uartopenandconfig(uart6,uartparitynone | uart8bits | uartonestop,9600,PC6,PC7,-1,-1);
                     uartmkstreamdev(uart,fd1);
                     __opnfiles__[1] = fd1; //stdo
                     __opnfiles__[0] = fd1; //stdi
                 }
                 else
                 {
                     uartopenandconfig(uart6,uartparitynone | uart8bits | uartonestop,9600,PC6,PC7,-1,-1);
                 }
             }
             /*
             D0   PD14      D1   PD15      D2   PD0      D3   PD1      D4   PE7
             D5   PE8       D6   PE9       D7   PE10     D8   PE11     D9   PE12
             D10  PE13      D11  PE14      D12  PE15     D13  PD8      D14  PD9
             D15  PD10
             A0   PF0  = RS      FSMC_NE3 PG10 CS      FSMC_NWE PD5  W/S
             FSMC_NOE PD4  RD
             */
             /*-- GPIOs Configuration -----------------------------------------------------*/
             /*
              +-------------------+--------------------+------------------+------------------+
              +                       SRAM pins assignment                                   +
              +-------------------+--------------------+------------------+------------------+
              | PD0  <-> FSMC_D2  | PE0  <-> FSMC_NBL0 | PF0  <-> FSMC_A0 | PG0 <-> FSMC_A10 |
              | PD1  <-> FSMC_D3  | PE1  <-> FSMC_NBL1 | PF1  <-> FSMC_A1 | PG1 <-> FSMC_A11 |
              | PD4  <-> FSMC_NOE | PE3  <-> FSMC_A19  | PF2  <-> FSMC_A2 | PG2 <-> FSMC_A12 |
              | PD5  <-> FSMC_NWE | PE4  <-> FSMC_A20  | PF3  <-> FSMC_A3 | PG3 <-> FSMC_A13 |
              | PD8  <-> FSMC_D13 | PE7  <-> FSMC_D4   | PF4  <-> FSMC_A4 | PG4 <-> FSMC_A14 |
              | PD9  <-> FSMC_D14 | PE8  <-> FSMC_D5   | PF5  <-> FSMC_A5 | PG5 <-> FSMC_A15 |
              | PD10 <-> FSMC_D15 | PE9  <-> FSMC_D6   | PF12 <-> FSMC_A6 | PG9 <-> FSMC_NE2 |
              | PD11 <-> FSMC_A16 | PE10 <-> FSMC_D7   | PF13 <-> FSMC_A7 |------------------+
              | PD12 <-> FSMC_A17 | PE11 <-> FSMC_D8   | PF14 <-> FSMC_A8 |
              | PD13 <-> FSMC_A18 | PE12 <-> FSMC_D9   | PF15 <-> FSMC_A9 |
              | PD14 <-> FSMC_D0  | PE13 <-> FSMC_D10  |------------------+
              | PD15 <-> FSMC_D1  | PE14 <-> FSMC_D11  |
              |                   | PE15 <-> FSMC_D12  |
              +-------------------+--------------------+
             */
             int bsp_FSMC_init()
             {
             #define GPIOGETPORT(gpio)   ((GPIO_TypeDef*)(((((uint32_t)gpio) & (uint32_t)0x0000FF00)*(uint32_t)4) + (uint32_t)GPIOA))
             #define GPIOPORTNUM(gpio)   (((uint32_t)(gpio) & (uint32_t)0x0000FF00)>>(uint32_t)8)
                 gpio_t gpio1 = gpioopen(LCD_RESET);
                 gpiosetspeed(&gpio1,gpiohighspeed);
                 gpiosetdir(&gpio1,gpiooutdir);
                 gpioclr(LCD_RESET);
                 gpio1 = gpioopen(LCD_CS);
                 gpiosetspeed(&gpio1,gpiohighspeed);
                 gpiosetdir(&gpio1,gpiooutdir);
                 gpioset(LCD_CS);
                 gpio_t LCD_DBxList[]={
                     PD0 ,PD1 ,PD4 ,PD5 ,PD8 ,PD9 ,PD10,PD14,PD15,
                     PE3 ,PE7 ,PE8 ,PE9 ,PE10,PE11,PE12,PE13,PE14,
                     PE15 };
                 for(int i=0;i<19;i++)
                 {
                     gpio_t LCD_DBx = gpioopen(LCD_DBxList[i]);
                     LCD_DBx |=  gpiohighspeed | gpioaf | gpiopushpulltype | gpionopulltype;
                     gpiosetconfig(&LCD_DBx);
                     GPIO_PinAFConfig(GPIOGETPORT(LCD_DBx), (uint8_t)(LCD_DBx & 0xF), GPIO_AF_FSMC);
                 }
                 FSMC_NORSRAMInitTypeDef  FSMC_NORSRAMInitStructure;
                 FSMC_NORSRAMTimingInitTypeDef  p;
                 /* Enable FSMC clock */
                 RCC_AHB3PeriphClockCmd(RCC_AHB3Periph_FSMC, ENABLE);
                 /*-- FSMC Configuration ------------------------------------------------------*/
                 /*----------------------- SRAM Bank 3 ----------------------------------------*/
                 /* FSMC_Bank1_NORSRAM3 configuration */
                 p.FSMC_AddressSetupTime = 1;
                 p.FSMC_AddressHoldTime = 0;
                 p.FSMC_DataSetupTime = getCpuFreq()/14545450  ;// 11;
                 p.FSMC_BusTurnAroundDuration = 0;
                 p.FSMC_CLKDivision = 0;
                 p.FSMC_DataLatency = 0;
                 p.FSMC_AccessMode = FSMC_AccessMode_A;
                 /* Color LCD configuration ------------------------------------
                    LCD configured as follow:
                       - Data/Address MUX = Disable
                       - Memory Type = SRAM
                       - Data Width = 16bit
                       - Write Operation = Enable
                       - Extended Mode = Enable
                       - Asynchronous Wait = Disable */
                 FSMC_NORSRAMInitStructure.FSMC_Bank = FSMC_Bank1_NORSRAM3;
                 FSMC_NORSRAMInitStructure.FSMC_DataAddressMux = FSMC_DataAddressMux_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_MemoryType = FSMC_MemoryType_SRAM;
                 FSMC_NORSRAMInitStructure.FSMC_MemoryDataWidth = FSMC_MemoryDataWidth_16b;
                 FSMC_NORSRAMInitStructure.FSMC_BurstAccessMode = FSMC_BurstAccessMode_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_AsynchronousWait = FSMC_AsynchronousWait_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_WaitSignalPolarity = FSMC_WaitSignalPolarity_Low;
                 FSMC_NORSRAMInitStructure.FSMC_WrapMode = FSMC_WrapMode_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_WaitSignalActive = FSMC_WaitSignalActive_BeforeWaitState;
                 FSMC_NORSRAMInitStructure.FSMC_WriteOperation = FSMC_WriteOperation_Enable;
                 FSMC_NORSRAMInitStructure.FSMC_WaitSignal = FSMC_WaitSignal_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_ExtendedMode = FSMC_ExtendedMode_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_WriteBurst = FSMC_WriteBurst_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_ReadWriteTimingStruct = &p;
                 FSMC_NORSRAMInitStructure.FSMC_WriteTimingStruct = &p;
                 FSMC_NORSRAMInit(&FSMC_NORSRAMInitStructure);
                 /* Enable FSMC NOR/SRAM Bank1 */
                 FSMC_NORSRAMCmd(FSMC_Bank1_NORSRAM3, ENABLE);
                 gpioset(LCD_RESET);
                 gpioclr(LCD_CS);
                 lcd0.init(&lcd0);
                 return 1;
             }
             void bsp_spi_init()
             {
             }
             void bsp_iic_init()
             {
             }
             void bsp_SD_init()
             {
             }
             void vs10XXclearXCS(){}
             void vs10XXsetXCS(){}
             int vs10XXDREQ()
             {
                 return 1;
             }
             void bsppowersdcard(char onoff)   //always ON
             {
             }
             char bspsdcardpresent()
             {
                 return 0;
             }
             char bspsdcardwriteprotected()
             {
                 return 0;
             }
             void bspsdcardselect(char YESNO)
             {
             }
             void bsp_lcd0_write_reg(uint32_t reg,uint32_t data)
             {
                 gpioclr(LCD_CS);
                 *lcd0_CMD=(uint16_t)reg;
                 *lcd0_DATA=(uint16_t)data;
                 gpioset(LCD_CS);
             }
             uint32_t bsp_lcd0_read_reg(uint32_t reg)
             {
                 gpioclr(LCD_CS);
                 *lcd0_CMD=(uint16_t)reg;
                 uint32_t data=(uint16_t)*lcd0_DATA;
                 gpioset(LCD_CS);
                 return data;
             }
             void bsp_lcd0_writeGRAM(void* buffer,uint32_t count)
             {
                 gpioclr(LCD_CS);
                 *lcd0_CMD=(uint16_t)ILI9328_REGISTER_WRITEDATATOGRAM;
                 uint16_t* castedBuff=(uint16_t*)buffer;
                 for(int i=0;i<(int)count;i++)
                 {
                     *lcd0_DATA=castedBuff[i];
                 }
                 gpioset(LCD_CS);
             }
             void bsp_lcd0_readGRAM(void* buffer,uint32_t count)
             {
                 gpioclr(LCD_CS);
                 *lcd0_CMD=(uint16_t)ILI9328_REGISTER_WRITEDATATOGRAM;
                 uint16_t* castedBuff=(uint16_t*)buffer;
                 castedBuff[0]=*lcd0_DATA;
                 for(int i=0;i<(int)count;i++)
                 {
                     castedBuff[i]=*lcd0_DATA;
                 }
                 gpioset(LCD_CS);
             }

bsp/src/STM32F4Discovery-EXT/bsp.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2011, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
-            --                   Mail : alexis.jeandet@gmail.com
+            --                   Mail : alexis.jeandet@member.fsf.org
             -------------------------------------------------------------------------------*/
             #ifndef BSP_H
             #define BSP_H
             #include <stm32f4xx.h>
             #include <gpio.h>
             #include <ili9328.h>
             #include <ssd2119.h>
             #include <genericLCD_Controler.h>
             /*
             #ifndef PD12
               #define PD12
             #endif
             #ifndef PD13
               #define PD13
             #endif
             */
             #define __MAX_OPENED_FILES__ 32
             #define __FS_ROOT_SIZE__ 32
             #define LED1 PD12
             #define LED2 PD13
             #define LCD_RESET PD3
             #define LCD_CS PD7
             #define LCD_BACKL PD13
             #define GREENLEDON (GPIOD->BSRRL = 1<<12)
             #define ORANGELEDON (GPIOD->BSRRL = 1<<13)
             #define REDLEDON (GPIOD->BSRRL = 1<<14)
             #define BLUELEDON (GPIOD->BSRRL = 1<<15)
             #define GREENLEDOFF (GPIOD->BSRRH = 1<<12)
             #define ORANGELEDOFF (GPIOD->BSRRH = 1<<13)
             #define REDLEDOFF (GPIOD->BSRRH = 1<<14)
             #define BLUELEDOFF (GPIOD->BSRRH = 1<<15)
             extern float VREF0;
             extern uint32_t OSC0;
             extern uint32_t currentCpuFreq;
             extern int bsp_init();
             extern void bsp_GPIO_init();
             extern void bsp_uart_init();
             extern void bsp_iic_init();
             extern void bsp_spi_init();
             extern void bsp_SD_init();
             extern int bsp_FSMC_init();
             /*  VS1053  */
             extern void clearXCS();
             extern void setXCS();
             extern int vs10XXDREQ();
             /*   SD CARD */
             void bsppowersdcard(char onoff);
             char bspsdcardpresent();
             void bspsdcardselect(char YESNO);
             char bspsdcardwriteprotected();
             void bsp_lcd0_write_reg(uint32_t reg,uint32_t data);
             uint32_t bsp_lcd0_read_reg(uint32_t reg);
             void bsp_lcd0_writeGRAM(void *buffer, uint32_t count);
             void bsp_lcd0_readGRAM(void *buffer, uint32_t count);
             #endif

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

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2011, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
-            --                   Mail : alexis.jeandet@gmail.com
+            --                   Mail : alexis.jeandet@member.fsf.org
             -------------------------------------------------------------------------------*/
             #include "bsp.h"
             #include <streamdevices.h>
             #include <malloc.h>
             #include <gpio.h>
             #include <uart.h>
             #include <stdio.h>
             uint32_t OSC0  =8000000;
             uint32_t INTOSC =16000000;
             uint32_t RTCOSC =32768;
             uint32_t currentCpuFreq=0;
             extern streamdevice* __opnfiles__[__MAX_OPENED_FILES__];
             float VREF0 =(float)3.3;
             int bsp_init()
             {
                 int i=0;
                 for(i=0;i<32;i++)
                 {
                     __opnfiles__[i] = NULL;
                 }
                 bsp_GPIO_init();
                 bsp_uart_init();
                 printf("\r================================================================\n\r");
                 printf("================================================================\n\r");
                 printf(BSP);
                 printf(" initialised\n\r");
                 printf("================================================================\n\r");
                 return 1;
             }
             void bsp_GPIO_init()
             {
                 gpio_t gpio1 = gpioopen(PD12);//gpioopen(LED1);  //PD9 D=> 0x0300 9 => 0x0009
                 gpio_t gpio2 = gpioopen(PD13);//gpioopen(LED2);
                 gpio_t gpio3 = gpioopen(PD14);//gpioopen(LED2);
                 gpio_t gpio4 = gpioopen(PD15);//gpioopen(LED2);
                 gpiosetspeed(&gpio1,gpiohighspeed);
                 gpiosetspeed(&gpio2,gpiohighspeed);
                 gpiosetspeed(&gpio3,gpiohighspeed);
                 gpiosetspeed(&gpio4,gpiohighspeed);
                 gpiosetdir(&gpio1,gpiooutdir);
                 gpiosetdir(&gpio3,gpiooutdir);
                 gpiosetdir(&gpio2,gpiooutdir);
                 gpiosetdir(&gpio4,gpiooutdir);
             }
             void bsp_uart_init()
             {
                 if(__opnfiles__[1]==NULL)
                 {
                     //uart_t* uart1 = (uart_t*)malloc(sizeof(uart_t));
                     streamdevice* fd1 = (streamdevice*)malloc(sizeof(streamdevice));
                     uart_t uart = uartopenandconfig(uart3,uartparitynone | uart8bits | uartonestop,19200,PB10,PB11,-1,-1);
                     uartmkstreamdev(uart,fd1);
                     __opnfiles__[1] = fd1; //stdo
                     __opnfiles__[0] = fd1; //stdi
                 }
                 else
                 {
                     uartopenandconfig(2,uartparitynone | uart8bits | uartonestop,115200,PB10,PB11,-1,-1);
                 }
             }
             void bsp_spi_init()
             {
             }
             void bsp_iic_init()
             {
             }
             void bsp_SD_init()
             {
             }
             void vs10XXclearXCS(){}
             void vs10XXsetXCS(){}
             int vs10XXDREQ()
             {
                 return 1;
             }
             void bsppowersdcard(char onoff)   //always ON
             {
             }
             char bspsdcardpresent()
             {
                 return 0;
             }
             char bspsdcardwriteprotected()
             {
                 return 0;
             }
             void bspsdcardselect(char YESNO)
             {
             }

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

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2011, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
-            --                   Mail : alexis.jeandet@gmail.com
+            --                   Mail : alexis.jeandet@member.fsf.org
             -------------------------------------------------------------------------------*/
             #ifndef BSP_H
             #define BSP_H
             #include <stm32f4xx.h>
             #include <gpio.h>
             /*
             #ifndef PD12
               #define PD12
             #endif
             #ifndef PD13
               #define PD13
             #endif
             */
             #define __MAX_OPENED_FILES__ 32
             #define __FS_ROOT_SIZE__ 32
             #define LED1 PD12
             #define LED2 PD13
             #define GREENLEDON (GPIOD->BSRRL = 1<<12)
             #define ORANGELEDON (GPIOD->BSRRL = 1<<13)
             #define REDLEDON (GPIOD->BSRRL = 1<<14)
             #define BLUELEDON (GPIOD->BSRRL = 1<<15)
             #define GREENLEDOFF (GPIOD->BSRRH = 1<<12)
             #define ORANGELEDOFF (GPIOD->BSRRH = 1<<13)
             #define REDLEDOFF (GPIOD->BSRRH = 1<<14)
             #define BLUELEDOFF (GPIOD->BSRRH = 1<<15)
             extern float VREF0;
             extern uint32_t OSC0;
             extern uint32_t currentCpuFreq;
             extern int bsp_init();
             extern void bsp_GPIO_init();
             extern void bsp_uart_init();
             extern void bsp_iic_init();
             extern void bsp_spi_init();
             extern void bsp_SD_init();
             /*  VS1053  */
             extern void clearXCS();
             extern void setXCS();
             extern int vs10XXDREQ();
             /*   SD CARD */
             void bsppowersdcard(char onoff);
             char bspsdcardpresent();
             void bspsdcardselect(char YESNO);
             char bspsdcardwriteprotected();
             #endif

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

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2011, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
-            --                   Mail : alexis.jeandet@gmail.com
+            --                   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 int16_t* lcd0_CMD=(volatile int16_t*)  (0x60000000 | 0x08000000);
             volatile int16_t* lcd0_DATA=((volatile int16_t*)(0x60000000 | 0x08000002));
             float VREF0 =(float)3.3;
             int bsp_init()
             {
                 int i=0;
                 for(i=0;i<32;i++)
                 {
                     __opnfiles__[i] = NULL;
                 }
                 bsp_GPIO_init();
                 bsp_uart_init();
                 bsp_iic_init();
                 bsp_FSMC_init();
                 bsp_GTerm_init();
                 printf("\r=====================\n\r");
                 printf(  "=====================\n\r");
                 printf(BSP);
                 printf(" initialised\n\r");
                 printf(  "=====================\n\r");
                 return 1;
             }
             void bsp_GPIO_init()
             {
                 gpio_t gpio1 = gpioopen(LED1);
                 gpio_t gpio2 = gpioopen(LED2);
                 gpio_t gpio3 = gpioopen(LED3);
                 gpiosetspeed(&gpio1,gpiohighspeed);
                 gpiosetspeed(&gpio2,gpiohighspeed);
                 gpiosetspeed(&gpio3,gpiohighspeed);
                 gpiosetdir(&gpio1,gpiooutdir);
                 gpiosetdir(&gpio2,gpiooutdir);
                 gpiosetdir(&gpio3,gpiooutdir);
             }
             void bsp_uart_init()
             {
                 //if(__opnfiles__[1]==NULL)
                 //{
                 //uart_t* uart1 = (uart_t*)malloc(sizeof(uart_t));
                 //  streamdevice* fd1 = (streamdevice*)malloc(sizeof(streamdevice));
                 // uart_t uart = uartopenandconfig(uart1,uartparitynone | uart8bits | uartonestop,115200,PA9,PA10,-1,-1);
                 //uartmkstreamdev(uart,fd1);
                 //__opnfiles__[1] = fd1;
                 //}
                 //else
                 //{
                 uartopenandconfig(0,uartparitynone | uart8bits | uartonestop,115200,PA9,PA10,-1,-1);
                 //}
             }
             /*
             D0   PD14      D1   PD15      D2   PD0      D3   PD1      D4   PE7
             D5   PE8       D6   PE9       D7   PE10     D8   PE11     D9   PE12
             D10  PE13      D11  PE14      D12  PE15     D13  PD8      D14  PD9
             D15  PD10
             A0   PF0  = RS      FSMC_NE3 PG10 CS      FSMC_NWE PD5  W/S
             FSMC_NOE PD4  RD
             */
             /*-- GPIOs Configuration -----------------------------------------------------*/
             /*
              +-------------------+--------------------+------------------+------------------+
              +                       SRAM pins assignment                                   +
              +-------------------+--------------------+------------------+------------------+
              | PD0  <-> FSMC_D2  | PE0  <-> FSMC_NBL0 | PF0  <-> FSMC_A0 | PG0 <-> FSMC_A10 |
              | PD1  <-> FSMC_D3  | PE1  <-> FSMC_NBL1 | PF1  <-> FSMC_A1 | PG1 <-> FSMC_A11 |
              | PD4  <-> FSMC_NOE | PE3  <-> FSMC_A19  | PF2  <-> FSMC_A2 | PG2 <-> FSMC_A12 |
              | PD5  <-> FSMC_NWE | PE4  <-> FSMC_A20  | PF3  <-> FSMC_A3 | PG3 <-> FSMC_A13 |
              | PD8  <-> FSMC_D13 | PE7  <-> FSMC_D4   | PF4  <-> FSMC_A4 | PG4 <-> FSMC_A14 |
              | PD9  <-> FSMC_D14 | PE8  <-> FSMC_D5   | PF5  <-> FSMC_A5 | PG5 <-> FSMC_A15 |
              | PD10 <-> FSMC_D15 | PE9  <-> FSMC_D6   | PF12 <-> FSMC_A6 | PG9 <-> FSMC_NE2 |
              | PD11 <-> FSMC_A16 | PE10 <-> FSMC_D7   | PF13 <-> FSMC_A7 |------------------+
              | PD12 <-> FSMC_A17 | PE11 <-> FSMC_D8   | PF14 <-> FSMC_A8 |
              | PD13 <-> FSMC_A18 | PE12 <-> FSMC_D9   | PF15 <-> FSMC_A9 |
              | PD14 <-> FSMC_D0  | PE13 <-> FSMC_D10  |------------------+
              | PD15 <-> FSMC_D1  | PE14 <-> FSMC_D11  |
              |                   | PE15 <-> FSMC_D12  |
              +-------------------+--------------------+
             */
             int bsp_FSMC_init()
             {
             #define GPIOGETPORT(gpio)   ((GPIO_TypeDef*)(((((uint32_t)gpio) & (uint32_t)0x0000FF00)*(uint32_t)4) + (uint32_t)GPIOA))
             #define GPIOPORTNUM(gpio)   (((uint32_t)(gpio) & (uint32_t)0x0000FF00)>>(uint32_t)8)
                 gpio_t LCD_DBxList[]={
                     PD0 ,PD1 ,PD4 ,PD5 ,PD8 ,PD9 ,PD10,PD11,PD12,PD13,PD14,PD15,
                     PE0 ,PE1 ,PE3 ,PE4 ,PE7 ,PE8 ,PE9 ,PE10,PE11,PE12,PE13,PE14,
                     PE15,PF0 ,PF1 ,PF2 ,PF3 ,PF4 ,PF5 ,PF12,PF13,PF14,PF15,PG0 ,
                     PG1 ,PG2 ,PG3 ,PG4 ,PG5 ,PG9 ,PG10
                                      };
                 for(int i=0;i<43;i++)
                 {
                     gpio_t LCD_DBx = gpioopen(LCD_DBxList[i]);
                     LCD_DBx |=  gpiohighspeed | gpioaf | gpiopushpulltype | gpionopulltype;
                     gpiosetconfig(&LCD_DBx);
                     GPIO_PinAFConfig(GPIOGETPORT(LCD_DBx), (uint8_t)(LCD_DBx & 0xF), GPIO_AF_FSMC);
                 }
                 FSMC_NORSRAMInitTypeDef  FSMC_NORSRAMInitStructure;
                 FSMC_NORSRAMTimingInitTypeDef  p;
                 /* Enable FSMC clock */
                 RCC_AHB3PeriphClockCmd(RCC_AHB3Periph_FSMC, ENABLE);
                 /*-- FSMC Configuration ------------------------------------------------------*/
                 /*----------------------- SRAM Bank 3 ----------------------------------------*/
                 /* FSMC_Bank1_NORSRAM3 configuration */
                 p.FSMC_AddressSetupTime = 1;
                 p.FSMC_AddressHoldTime = 0;
                 p.FSMC_DataSetupTime = getCpuFreq()/14545450  ;// 11;
                 p.FSMC_BusTurnAroundDuration = 0;
                 p.FSMC_CLKDivision = 0;
                 p.FSMC_DataLatency = 0;
                 p.FSMC_AccessMode = FSMC_AccessMode_A;
                 /* Color LCD configuration ------------------------------------
                    LCD configured as follow:
                       - Data/Address MUX = Disable
                       - Memory Type = SRAM
                       - Data Width = 16bit
                       - Write Operation = Enable
                       - Extended Mode = Enable
                       - Asynchronous Wait = Disable */
                 FSMC_NORSRAMInitStructure.FSMC_Bank = FSMC_Bank1_NORSRAM3;
                 FSMC_NORSRAMInitStructure.FSMC_DataAddressMux = FSMC_DataAddressMux_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_MemoryType = FSMC_MemoryType_SRAM;
                 FSMC_NORSRAMInitStructure.FSMC_MemoryDataWidth = FSMC_MemoryDataWidth_16b;
                 FSMC_NORSRAMInitStructure.FSMC_BurstAccessMode = FSMC_BurstAccessMode_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_AsynchronousWait = FSMC_AsynchronousWait_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_WaitSignalPolarity = FSMC_WaitSignalPolarity_Low;
                 FSMC_NORSRAMInitStructure.FSMC_WrapMode = FSMC_WrapMode_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_WaitSignalActive = FSMC_WaitSignalActive_BeforeWaitState;
                 FSMC_NORSRAMInitStructure.FSMC_WriteOperation = FSMC_WriteOperation_Enable;
                 FSMC_NORSRAMInitStructure.FSMC_WaitSignal = FSMC_WaitSignal_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_ExtendedMode = FSMC_ExtendedMode_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_WriteBurst = FSMC_WriteBurst_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_ReadWriteTimingStruct = &p;
                 FSMC_NORSRAMInitStructure.FSMC_WriteTimingStruct = &p;
                 FSMC_NORSRAMInit(&FSMC_NORSRAMInitStructure);
                 /* Enable FSMC NOR/SRAM Bank1 */
                 FSMC_NORSRAMCmd(FSMC_Bank1_NORSRAM3, ENABLE);
                 p.FSMC_AddressSetupTime = getCpuFreq()/50000000;
                 p.FSMC_AddressHoldTime = 0;
                 p.FSMC_DataSetupTime = getCpuFreq()/25000000;
                 p.FSMC_BusTurnAroundDuration = 1;
                 p.FSMC_CLKDivision = 0;
                 p.FSMC_DataLatency = 0;
                 p.FSMC_AccessMode = FSMC_AccessMode_A;
                 FSMC_NORSRAMInitStructure.FSMC_Bank = FSMC_Bank1_NORSRAM2;
                 FSMC_NORSRAMInitStructure.FSMC_DataAddressMux = FSMC_DataAddressMux_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_MemoryType = FSMC_MemoryType_PSRAM;
                 FSMC_NORSRAMInitStructure.FSMC_MemoryDataWidth = FSMC_MemoryDataWidth_16b;
                 FSMC_NORSRAMInitStructure.FSMC_BurstAccessMode = FSMC_BurstAccessMode_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_AsynchronousWait = FSMC_AsynchronousWait_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_WaitSignalPolarity = FSMC_WaitSignalPolarity_Low;
                 FSMC_NORSRAMInitStructure.FSMC_WrapMode = FSMC_WrapMode_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_WaitSignalActive = FSMC_WaitSignalActive_BeforeWaitState;
                 FSMC_NORSRAMInitStructure.FSMC_WriteOperation = FSMC_WriteOperation_Enable;
                 FSMC_NORSRAMInitStructure.FSMC_WaitSignal = FSMC_WaitSignal_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_ExtendedMode = FSMC_ExtendedMode_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_WriteBurst = FSMC_WriteBurst_Disable;
                 FSMC_NORSRAMInitStructure.FSMC_ReadWriteTimingStruct = &p;
                 FSMC_NORSRAMInitStructure.FSMC_WriteTimingStruct = &p;
                 FSMC_NORSRAMInit(&FSMC_NORSRAMInitStructure);
                 /*!< Enable FSMC Bank1_SRAM2 Bank */
                 FSMC_NORSRAMCmd(FSMC_Bank1_NORSRAM2, ENABLE);
                 lcd0.init(&lcd0);
                 return 1;
             }
             void bsp_spi_init()
             {
             }
             void bsp_iic_init()
             {
                 i2copenandconfig(i2c1,0,10000,PB9,PB6);
             }
             void bsp_SD_init()
             {
                 gpio_t SDIO_DBxList[]={PC8 ,PC9 ,PC10 ,PC11 ,PC12,PD2};
                 for(int i=0;i<6;i++)
                 {
                     gpio_t SDIO_DBx = gpioopen(SDIO_DBxList[i]);
                     SDIO_DBx |=  gpiohighspeed | gpioaf | gpiopushpulltype | gpionopulltype;
                     gpiosetconfig(&SDIO_DBx);
                     GPIO_PinAFConfig(GPIOGETPORT(SDIO_DBx), (uint8_t)(SDIO_DBx & 0xF), GPIO_AF_SDIO);
                 }
             }
             void vs10XXclearXCS(){}
             void vs10XXsetXCS(){}
             int vs10XXDREQ()
             {
                 return 1;
             }
             void bsppowersdcard(char onoff)   //always ON
             {
             }
             char bspsdcardpresent()
             {
                 return 0;
             }
             char bspsdcardwriteprotected()
             {
                 return 0;
             }
             void bspsdcardselect(char YESNO)
             {
             }
             void bsp_lcd0_write_reg(uint32_t reg,uint32_t data)
             {
                 *lcd0_CMD=(uint16_t)reg;
                 *lcd0_DATA=(uint16_t)data;
             }
             uint32_t bsp_lcd0_read_reg(uint32_t reg)
             {
                 *lcd0_CMD=(uint16_t)reg;
                 return (uint16_t)*lcd0_DATA;
             }
             void bsp_lcd0_writeGRAM(void* buffer,uint32_t count)
             {
                 *lcd0_CMD=(uint16_t)ILI9328_REGISTER_WRITEDATATOGRAM;
                 uint16_t* castedBuff=(uint16_t*)buffer;
                 for(int i=0;i<(int)count;i++)
                 {
                     *lcd0_DATA=castedBuff[i];
                 }
             }
             void bsp_lcd0_readGRAM(void* buffer,uint32_t count)
             {
                 *lcd0_CMD=(uint16_t)ILI9328_REGISTER_WRITEDATATOGRAM;
                 uint16_t* castedBuff=(uint16_t*)buffer;
                 castedBuff[0]=*lcd0_DATA;
                 for(int i=0;i<(int)count;i++)
                 {
                     castedBuff[i]=*lcd0_DATA;
                 }
             }
             void bsp_GTerm_init()
             {
                 if(__opnfiles__[1]==NULL)
                 {
                     //uart_t* uart1 = (uart_t*)malloc(sizeof(uart_t));
                     streamdevice* fd1 = (streamdevice*)malloc(sizeof(streamdevice));
                     ili9328paintFilRect(&lcd0,0,0,240,320,0x7FFF,5,0);
                     terminal_init(&terminal0,&lcd0,&ComicSansMS_8,fd1);
                     __opnfiles__[1] = fd1;
                 }
                 else
                 {
                 }
             }

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

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2011, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
-            --                   Mail : alexis.jeandet@gmail.com
+            --                   Mail : alexis.jeandet@member.fsf.org
             -------------------------------------------------------------------------------*/
             #ifndef BSP_H
             #define BSP_H
             #include <stm32f4xx.h>
             #include <stm32f4xx_gpio.h>
             #include <stm32f4xx_rcc.h>
             #include <gpio.h>
             #include <ili9328.h>
             #include <genericLCD_Controler.h>
             #define __MAX_OPENED_FILES__ 4
             #define __FS_ROOT_SIZE__ 4
             #define LED1 PG6
             #define LED2 PG8
             #define LED3 PI9
             #define LED4 PC7
             extern float VREF0;
             extern uint32_t currentCpuFreq;
             extern LCD_t lcd0;
             extern int bsp_init();
             extern void bsp_GPIO_init();
             extern void bsp_uart_init();
             extern void bsp_iic_init();
             extern void bsp_spi_init();
             extern void bsp_SD_init();
             extern void bsp_GTerm_init();
             extern int bsp_FSMC_init();
             /*  VS1053  */
             extern void clearXCS();
             extern void setXCS();
             extern int vs10XXDREQ();
             /*   SD CARD */
             void bsppowersdcard(char onoff);
             char bspsdcardpresent();
             void bspsdcardselect(char YESNO);
             char bspsdcardwriteprotected();
             void bsp_lcd0_write_reg(uint32_t reg,uint32_t data);
             uint32_t bsp_lcd0_read_reg(uint32_t reg);
             void bsp_lcd0_writeGRAM(void *buffer, uint32_t count);
             void bsp_lcd0_readGRAM(void *buffer, uint32_t count);
             #endif

examples/SOLAR_PSU_HELLO/hello.pro +1 -1

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

examples/SOLAR_PSU_HELLO/main.c +1 0

             #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);
                 //printf("%s\n",direntName);
                 nextLba=fat32getdirentlba(file);
                 //printf("Streaming File\n");
                 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()
             {
+                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()
             {
                 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);
                 playAllparts();
                 return 0;
             }

examples/TEST_SIMULATOR/main.c +3 -2

             #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()
             {
                 char in[255];
                 lcd_print();
                 printf("hello world\n");
-                streamdevicePrint(__opnfiles__[1],"test Hello %d %f \n ",1234567,8.96);
+                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(3);
+                    sleep(5);
             //    }
             }

lib/src/common/AUDIO/CS43L22/CS43L22.c +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2012, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
-            --                   Mail : alexis.jeandet@gmail.com
+            --                   Mail : alexis.jeandet@member.fsf.org
             -------------------------------------------------------------------------------*/
             #include <CS43L22.h>
             #include <stdio.h>
             #include <stddef.h>
             #include <spi.h>
             int cs43l22open(CS43L22_t* dev,i2c_t i2cdev, uint8_t A0)
             {
                 if(dev != NULL)
                 {
                     dev->i2cdev=i2cdev;
                     dev->devAddress = CS43L22_I2C_ADDRESS | (A0 & 1);
                     return 1;
                 }
                 return -1;
             }
             uint8_t cs43l22getID(CS43L22_t* dev)
             {
                 if(dev != NULL)
                 {
                     char DATA[]={CS43L22_MAP_ID};
                     i2cwrite(dev->i2cdev,dev->devAddress,DATA,1);
                     i2cread(dev->i2cdev,dev->devAddress,DATA,1);
                     return DATA[0];
                 }
                 return -1;
             }

lib/src/common/AUDIO/VS10XX/VS10XX.c +1 -1

             /*------------------------------------------------------------------------------
             #--  This file is a part of the libuc, microcontroler library
             #--  Copyright (C) 2011, Alexis Jeandet
             #--
             #--  This program is free software; you can redistribute it and/or modify
             #--  it under the terms of the GNU General Public License as published by
             #--  the Free Software Foundation; either version 3 of the License, or
             #--  (at your option) any later version.
             #--
             #--  This program is distributed in the hope that it will be useful,
             #--  but WITHOUT ANY WARRANTY; without even the implied warranty of
             #--  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             #--  GNU General Public License for more details.
             #--
             #--  You should have received a copy of the GNU General Public License
             #--  along with this program; if not, write to the Free Software
             #--  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             #-------------------------------------------------------------------------------
             #--                 Author : Alexis Jeandet
-            #--                   Mail : alexis.jeandet@gmail.com
+            #--                   Mail : alexis.jeandet@member.fsf.org
             #-------------------------------------------------------------------------------*/
             #include <spi.h>
             #include <VS10XX.h>
             #include <core.h>
             #include <stdio.h>
             //#include <bsp.h>
             void vs10XXopen(vs10XXDev *codec, spi_t dev, void (*setxCS)(char), void (*setxRST)(char), void (*setxDCS)(char), int (*getDREQ)())
             {
                 codec->SPIdev = dev;
                 codec->setxCS = setxCS;
                 codec->setxDCS = setxDCS;
                 codec->setxRST = setxRST;
                 codec->getDREQ = getDREQ;
                 codec->setxDCS(1);
                 codec->setxCS(1);
                 codec->setxRST(0);
                 delay_100us(2);
                 codec->setxRST(1);
                 int status;
                 do{
                 status= vs10XXcmdread(codec,VSSTATUS);
                 }while (status==0xc);
                 printf("Status=0x%x\n",status);
                 status = (status>>4) & 0xF;
                 switch (status) {
                 case 0:
                     codec->VERSION = VS1001;
                     break;
                 case 1:
                     codec->VERSION = VS1011;
                     break;
                 case 2:
                     codec->VERSION = VS1002;
                     break;
                 case 3:
                     codec->VERSION = VS1003;
                     break;
                 case 4:
                     codec->VERSION = VS1053;
                     break;
                 case 5:
                     codec->VERSION = VS1033;
                     break;
                 case 7:
                     codec->VERSION = VS1103;
                     break;
                 default:
                     codec->VERSION = UNKNOWN;
                     break;
                 }
             }
             void vs10XXsoftreset(vs10XXDev* dev)
             {
                 vs10XXcmdwrite(dev,VSMODE,(1<<2));
             }
             void vs10XXsetCansel(vs10XXDev* dev)
             {
                 int mode=vs10XXcmdread(dev,VSMODE);
                 vs10XXcmdwrite(dev,VSMODE,mode|8);
             }
             void vs10XXsoftReset(vs10XXDev* dev)
             {
                 int mode=vs10XXcmdread(dev,VSMODE);
                 vs10XXcmdwrite(dev,VSMODE,mode|4);
             }
             int vs10XXcanselAccepted(vs10XXDev* dev)
             {
                 int mode=vs10XXcmdread(dev,VSMODE);
                 return ((mode & 8)!=8);
             }
             int vs10XXcmdread(vs10XXDev* dev,char address)
             {
                 int result;
                 while(!dev->getDREQ());
                 dev->setxCS(0);
                 spiputw(dev->SPIdev,3);
                 spiputw(dev->SPIdev,address);
                 result = (0xFF00 & (spigetw(dev->SPIdev)<<8)) + (0xFF & spigetw(dev->SPIdev));
                 dev->setxCS(1);
             	return result;
             }
             void vs10XXcmdwrite(vs10XXDev* dev,char address,int value)
             {
                 while(!dev->getDREQ());
                 dev->setxCS(0);
                 spiputw(dev->SPIdev,2<<8);
                 spiputw(dev->SPIdev,address);
                 spiputw(dev->SPIdev,value>>8);
                 spiputw(dev->SPIdev,value);
                 dev->setxCS(1);
             }
             void vs10XXstream32bytes(vs10XXDev* dev,char* buffer)
             {
                 while(!dev->getDREQ());
                 dev->setxCS(1);
                 dev->setxDCS(0);
                 spiputnc(dev->SPIdev,buffer,32);
                 dev->setxDCS(1);
             }

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

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2011, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
-            --                   Mail : alexis.jeandet@gmail.com
+            --                   Mail : alexis.jeandet@member.fsf.org
             -------------------------------------------------------------------------------*/
             #include <24LC0X.h>
             #include <i2c.h>
             #include <core.h>
             /*
             struct 24LC0X_str
             {
              i2cDev iicdev;
              unsigned char devAddress;
              unsigned char size;
             };
             */
             void eeprom24lc0xopen(eeprom24lc0xDev* dev, i2c_t iicdev, unsigned char A0_A1_A2_val, unsigned int size)
             {
             	dev->iicdev = iicdev;
             	dev->devAddress = 0x50 | (A0_A1_A2_val & 0x7);
             	if(size == 2048) dev->size = 2;
             	if(size == 1024) dev->size = 1;
             }
             void eeprom24lc0xpagewrite(eeprom24lc0xDev* dev,unsigned char address,unsigned char* page)
             {
             	int cmdcnt=1,datacnt=8;
                 //i2cwrite(dev.iicdev,address,page)
                 //i2cwrite2(dev.iicdev,dev.devAddress,&address,&cmdcnt,page,&datacnt);
             }
             void eeprom24lc0xpageread(eeprom24lc0xDev* dev,unsigned char address,unsigned char* page)
             {
             	int cmdcnt=1,datacnt=8;
                 /*i2cwrite(dev.iicdev,dev.devAddress,&address,&cmdcnt);
                 i2cread(dev.iicdev,dev.devAddress,page,&datacnt);*/
             }
             void eeprom24lc0xbytewrite(eeprom24lc0xDev* dev,unsigned char address,unsigned char data)
             {
             	int cmdcnt=1,datacnt=1;
                 //i2cwrite2(dev.iicdev,dev.devAddress,&address,&cmdcnt,&data,&datacnt);
             }
             unsigned char eeprom24lc0xbyteread(eeprom24lc0xDev* dev,unsigned char address)
             {
             	int cmdcnt=1,datacnt=1;
             	unsigned char data = 0;
             /*	i2cwrite(dev.iicdev,dev.devAddress,&address,&cmdcnt);
                 i2cread(dev.iicdev,dev.devAddress,&data,&datacnt);*/
             	return data;
             }
             void eeprom24lc0xreadn(eeprom24lc0xDev* dev,unsigned char address,unsigned char* data, unsigned int count)
             {
             	int cmdcnt=1,datacnt=count;
             /*	i2cwrite(dev.iicdev,dev.devAddress,&address,&cmdcnt);
                 i2cread(dev.iicdev,dev.devAddress,data,&datacnt);*/
             }
             void eeprom24lc0xwriten(eeprom24lc0xDev* dev,unsigned char address,unsigned char* data, unsigned int count)
             {
             	int cmdcnt=1,datacnt=8;
             	while(count >8)
             	{
             		cmdcnt=1;datacnt=8;
             //		while(i2noerr!=i2cwrite2(dev.iicdev,dev.devAddress,&address,&cmdcnt,data,&datacnt)){cmdcnt=1;datacnt=8;}
             		count-=8;
             		address+=8;
             		data+=8;
             	}
             	cmdcnt=1;datacnt=count;
             //	while(i2noerr!=i2cwrite2(dev.iicdev,dev.devAddress,&address,&cmdcnt,data,&datacnt)){cmdcnt=1;datacnt=count;}
             }

lib/src/common/EEPROMS/N25Q128/N25Q128.c +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2013, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
-            --                   Mail : alexis.jeandet@gmail.com
+            --                   Mail : alexis.jeandet@member.fsf.org
             -------------------------------------------------------------------------------*/
             #include <N25Q128.h>
             #include <core.h>
             #include <stdio.h>
             void eepromN25Q128open(eepromN25Q128Dev *dev, spi_t spidev, void (*select)(int), void (*writeprotect)(int), void (*holdreset)(int))
             {
                 dev->spidev = spidev;
                 dev->holdreset = holdreset;
                 dev->select = select;
                 dev->writeprotect = writeprotect;
             }
             void eepromN25Q128pagewrite(eepromN25Q128Dev* dev,uint32_t address,unsigned char* page)
             {
                 int cmdcnt=1,datacnt=8;
             }
             void eepromN25Q128pageread(eepromN25Q128Dev* dev,uint32_t address,unsigned char* page)
             {
                 int cmdcnt=1,datacnt=8;
             }
             void eepromN25Q128bytewrite(eepromN25Q128Dev* dev,uint32_t address,unsigned char data)
             {
                 int cmdcnt=1,datacnt=1;
             }
             unsigned char eepromN25Q128byteread(eepromN25Q128Dev* dev,uint32_t address)
             {
                 int cmdcnt=1,datacnt=1;
                 unsigned char data = 0;
                 return data;
             }
             void eepromN25Q128readn(eepromN25Q128Dev* dev,uint32_t address,unsigned char* data, unsigned int count)
             {
                 char baddress[3];
                 baddress[0]=(char)0xFF&((address)>>16);
                 baddress[1]=(char)0xFF&((address)>>8);
                 baddress[2]=(char)0xFF&((address));
                 printf("about to read %d bytes\n\r",count);
                 if(dev->select!=NULL)dev->select(0);
                 spiputw(dev->spidev,N25Q128_READ);
                 spiputnc(dev->spidev,baddress,3);
                 spigetnc(dev->spidev,data,count);
                 if(dev->select!=NULL)dev->select(1);
             }
             void eepromN25Q128writen(eepromN25Q128Dev* dev,uint32_t address,unsigned char* data, unsigned int count)
             {
                 char baddress[3];
                 if(dev->select!=NULL)dev->select(0);
                 for(int i=0;i<(count/N25Q128_PAGE_SZ);i++)
                 {
                     printf("about to send %d bytes\n\r",N25Q128_PAGE_SZ);
                     int index =i*N25Q128_PAGE_SZ;
                     baddress[0]=(char)0xFF&((address+index)>>16);
                     baddress[1]=(char)0xFF&((address+index)>>8);
                     baddress[2]=(char)0xFF&((address+index));
                     if(dev->select!=NULL)dev->select(0);
                     spiputw(dev->spidev,N25Q128_PP);
                     spiputnc(dev->spidev,baddress,3);
                     spiputnc(dev->spidev,data+(index),count);
                     if(dev->select!=NULL)
                     {
                         dev->select(1);
                     }
                     else {
                         while (!spitransactionfinished(dev->spidev));
                     }
                 }
                 int mod = count%N25Q128_PAGE_SZ;
                 if(mod)
                 {
                     baddress[0]=(char)0xFF&((address+(count-mod))>>16);
                     baddress[1]=(char)0xFF&((address+(count-mod))>>8);
                     baddress[2]=(char)0xFF&((address+(count-mod)));
                     printf("about to send %d bytes\n\r",mod);
                     if(dev->select!=NULL)dev->select(0);
                     spiputw(dev->spidev,N25Q128_PP);
                     spiputnc(dev->spidev,baddress,3);
                     spiputnc(dev->spidev,data+(count-mod),mod);
                     if(dev->select!=NULL)
                     {
                         dev->select(1);
                     }
                     else {
                         while (!spitransactionfinished(dev->spidev));
                     }
                 }
             }
             void eepromN25Q128enablewrite(eepromN25Q128Dev *dev)
             {
                 if(dev->select!=NULL)dev->select(0);
                 spiputw(dev->spidev,N25Q128_WREN);
                 if(dev->select!=NULL)dev->select(1);
             }

lib/src/common/FILE_SYSTEM/FAT32/fat32.c +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2012, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
-            --                   Mail : alexis.jeandet@gmail.com
+            --                   Mail : alexis.jeandet@member.fsf.org
             -------------------------------------------------------------------------------*/
             #define FAT32_PRIVATE
             #include <fat32.h>
             #include <stdio.h>
             #include <stdint.h>
             #include <hexviewer.h>
             char fat32buff[512]__attribute__ ((aligned (4)));
             uint32_t lastSecAddrs=-1;
             FAT32fs* lastFATFS=0;
             int fat32open(FAT32fs* fs,dikpartition* part)
             {
                 fs->valide = 0;
                 if(part->valide==0)return FATBadpart;
                 char sector[512];
                 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_NumFATs    = sector[BPB_NumFATsoff];
                 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->valide=1;
                 return FATnoErr;
             }
             int fat32mkdirent(FAT32fs* fs,ucdirent* dirent)
             {
                 if((fs==0) || (fs->valide==0)) return DIRENT_BabArg;
                 if(dirent==0) return DIRENT_BabArg;
                 dirent->fs = (UHANDLE)fs;
                 dirent->getrootfirstent = &fat32getrootfirstent;
                 dirent->nextdirent = &fat32nextdirent;
                 return DIRENT_noErr;
             }
             int fat32getrootfirstent(ucdirent* entry)
             {
                 if(entry==0) return DIRENT_BabArg;
                 entry->CurrentSec = ((FAT32fs*)entry->fs)->cluster_begin_lba;
                 entry->Currententry = 0;
                 return fat32nextdirent(entry);
             }
             int fat32getVolName(FAT32fs* fs,char* Name)
             {
                 if((fs==0) || (fs->valide==0)) return DIRENT_BabArg;
                 if(Name==0) return DIRENT_BabArg;
                 int i=0;
                 ucdirent entry;
                 if(DIRENT_noErr==fat32mkdirent(fs,&entry))
                 {
                     entry.CurrentSec = ((FAT32fs*)entry.fs)->cluster_begin_lba;
                     entry.Currententry = -1;
                     if(DIRENT_noErr!=fat32nextdirent(&entry))return DIRENT_ReadErr;
                     for(i=0;i<16;i++)
                     {
                         Name[i] = entry.DIR_Name[i];
                     }
                     return DIRENT_noErr;
                 }
                 return DIRENT_ReadErr;
             }
             int fat32enterdirent(ucdirent* currententry,ucdirent* firstentry)
             {
                 if(firstentry==0) return DIRENT_BabArg;
                 if(currententry==0) return DIRENT_BabArg;
                 fat32mkdirent(((FAT32fs*)currententry->fs),firstentry);
                 firstentry->CurrentSec = fat32getdirentlba(currententry);
                 firstentry->Currententry = -1;
                 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
                 {
                     //printf("reading new secotr\n",k);
                     fat32sectorreadout(((FAT32fs*)entry->fs),j);
                     //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
                             {
                                 uint8_t attribute=fat32buff[DIR_Attroff + k];
                                 if(       (attribute==ATTR_DIRECTORY)
                                           ||(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->Currententry = (uint8_t)(0xFF&(k>>5));
                                     return DIRENT_noErr;
                                 }
                             }
                         }
                     }
                     //printf("asking for next sector\n");
                     //printf("current = 0x%X\n",j);
                     j=fat32nextsectorlba(((FAT32fs*)entry->fs),j,&k);
                     //printf("got it 0x%x\n",k);
                     if(j!=DIRENT_noErr)
                     {
                         if(j==DIRENT_LastSect) return DIRENT_EndOfDir;   /*Not clean but can avoid some bugs*/
                         return j;
                     }
                     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(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;
             }
             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;
                 }
                 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)
                 {
                     return DIRENT_BadSect;
                 }
                 if((uint32_t)(*nextsector_lba)>=(uint32_t)0xFFFFFFF6)
                 {
                     return DIRENT_LastSect;
                 }
                 *nextsector_lba = clusterlba(fs,*nextsector_lba);
                 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*/
                 fatsec=fat32clusterinfatsect(fs,clusternum);              /*Get FAT sector number*/
                 while(fatsec>=fs->fat_begin_lba)
                 {
                     fat32sectorreadout(fs,fatsec);
                     fatsec--;
                     for(i=508;i>2;i-=4)
                     {
                         *nextsector_lba = fat32Ui8_2_Ui32(fat32buff,i);
                         if (*nextsector_lba ==clusternum)
                         {
                             *nextsector_lba = clusterlba(fs,*nextsector_lba);
                             return DIRENT_noErr;
                         }
                     }
                 }
                 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;
             }
             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.c +1 -1

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

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2012, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
-            --                   Mail : alexis.jeandet@gmail.com
+            --                   Mail : alexis.jeandet@member.fsf.org
             -------------------------------------------------------------------------------*/
             #include <sdcard.h>
             #include <sdcard-spi.h>
             #include <stdio.h>
             #include <core.h>
             int sdcardselect (blkdeviceptr _this);
             void sdcarddeselect (blkdeviceptr _this);
             int sdcardwait_ready (sdcardDev* sdcard);
             int sdcardxmit_datablock (sdcardDev* sdcard,const char *buff,char token);
             int sdcardrcvr_datablock (sdcardDev* sdcard,char *buff,uint32_t btr);
             char sdcardsend_cmd (blkdeviceptr _this,char cmd,uint32_t arg);
             DSTATUS sdcarddisk_status (blkdeviceptr _this);
             DSTATUS sdcarddisk_initialize (blkdeviceptr _this);
             DRESULT sdcarddisk_read (blkdeviceptr _this,char *buff,uint32_t sector,char count);
             DRESULT sdcarddisk_write (blkdeviceptr _this,const char *buff,uint32_t sector,char count);
             DRESULT sdcarddisk_ioctl (blkdeviceptr _this,char ctrl,void *buff);
             static volatile
             unsigned int Timer1, Timer2;	/* 1kHz decrement timer stopped at zero (disk_timerproc()) */
             void sdcarddeselect (blkdeviceptr _this)
             {
             	char d;
             	_this->select(0);
             	((sdcardDev*)_this->phy)->rcvr_mmc(((sdcardDev*)_this->phy)->phy,&d, 1);	/* Dummy clock (force DO hi-z for multiple slave SPI) */
             }
             int sdcardselect (blkdeviceptr _this)	/* 1:OK, 0:Timeout */
             {
             	char d;
             	_this->select(1);
             	((sdcardDev*)_this->phy)->rcvr_mmc(((sdcardDev*)_this->phy)->phy,&d, 1);	/* Dummy clock (force DO enabled) */
             	if (sdcardwait_ready(((sdcardDev*)_this->phy))) return 1;	/* OK */
             	_this->select(0);
             	return 0;	/* Timeout */
             }
             int sdcardwait_ready (sdcardDev* sdcard)	/* 1:OK, 0:Timeout */
             {
                 char d=0;
             	unsigned int tmr;
             	volatile unsigned int i=0;
                 for (tmr = 500; tmr>0; tmr--) {	/* Wait for ready in timeout of 500ms */
             		sdcard->rcvr_mmc(sdcard->phy,&d, 1);
             		if (d == 0xFF) break;
                     delay_100us(10);
             	}
                 return tmr != 0;
             }
             int sdcardrcvr_datablock (sdcardDev* sdcard,char *buff,uint32_t btr)
             {
             	char d[2];
             	unsigned int tmr;
             	volatile unsigned int i=0;
                 for (tmr = 100; tmr; tmr--) {	/* Wait for data packet in timeout of 100ms */
             		sdcard->rcvr_mmc(sdcard->phy,d, 1);
             		if (d[0] != 0xFF) break;
                     delay_100us(10);
             	}
             	if (d[0] != 0xFE) return 0;		/* If not valid data token, return with error */
             	sdcard->rcvr_mmc(sdcard->phy,buff, btr);			/* Receive the data block into buffer */
             	sdcard->rcvr_mmc(sdcard->phy,d, 2);					/* Discard CRC */
             	return 1;						/* Return with success */
             }
             int sdcardxmit_datablock (sdcardDev* sdcard,const char *buff,char token)
             {
             	char d[2];
             	if (!sdcardwait_ready(sdcard)) return 0;
             	d[0] = token;
             	sdcard->xmit_mmc(sdcard->phy,d, 1);				/* Xmit a token */
             	if (token != 0xFD) {		/* Is it data token? */
             		sdcard->xmit_mmc(sdcard->phy,buff, 512);	/* Xmit the 512 byte data block to MMC */
             		sdcard->rcvr_mmc(sdcard->phy,d, 2);			/* Xmit dummy CRC (0xFF,0xFF) */
             		sdcard->rcvr_mmc(sdcard->phy,d, 1);			/* Receive data response */
             		if ((d[0] & 0x1F) != 0x05)	/* If not accepted, return with error */
             			return 0;
             	}
             	return 1;
             }
             char sdcardsend_cmd (blkdeviceptr _this,char cmd,uint32_t arg)
             {
             	char n, d, buf[6];
             	if (cmd & 0x80) {	/* ACMD<n> is the command sequense of CMD55-CMD<n> */
             		cmd &= 0x7F;
             		n = sdcardsend_cmd(_this,CMD55, 0);
             		if (n > 1) return n;
             	}
             	/* Select the card and wait for ready */
             	sdcarddeselect(_this);
                 if (!sdcardselect(_this)) {printf("Can't select SDCARD\n");return 0xFF;}
             	/* Send a command packet */
             	buf[0] = 0x40 | cmd;			/* Start + Command index */
             	buf[1] = (char)(arg >> 24);		/* Argument[31..24] */
             	buf[2] = (char)(arg >> 16);		/* Argument[23..16] */
             	buf[3] = (char)(arg >> 8);		/* Argument[15..8] */
             	buf[4] = (char)arg;				/* Argument[7..0] */
             	n = 0x01;						/* Dummy CRC + Stop */
             	if (cmd == CMD0) n = 0x95;		/* (valid CRC for CMD0(0)) */
             	if (cmd == CMD8) n = 0x87;		/* (valid CRC for CMD8(0x1AA)) */
             	if (cmd == CMD55) n = 0x63;
             	buf[5] = n;
             	((sdcardDev*)_this->phy)->xmit_mmc(((sdcardDev*)_this->phy)->phy,buf, 6);
             	/* Receive command response */
                 if (cmd == CMD12)
                 {
                     ((sdcardDev*)_this->phy)->rcvr_mmc(((sdcardDev*)_this->phy)->phy,&d, 1);
                 }	/* Skip a stuff byte when stop reading */
                 n = 100;								/* Wait for a valid response in timeout of 100 attempts */
             	do
             	{
             		((sdcardDev*)_this->phy)->rcvr_mmc(((sdcardDev*)_this->phy)->phy,&d, 1);
                     delay_100us(10);
             		//libucprintf("resp=%d\n\r",d);
             	}while ((d & 0x80) && --n);
             	return d;			/* Return with the response value */
             }
             DSTATUS sdcarddisk_status (blkdeviceptr _this)
             {
             	DSTATUS s = ((sdcardDev*)_this->phy)->Stat;
             	char ocr[4];
             	if ((_this==0) || !_this->detect()) {
             		s = STA_NODISK | STA_NOINIT;
             	} else {
             		s &= ~STA_NODISK;
             		if (_this->writeprotected())						/* Check card write protection */
             			s |= STA_PROTECT;
             		else
             			s &= ~STA_PROTECT;
             		if (!(s & STA_NOINIT)) {
             			if (sdcardsend_cmd(_this,CMD58, 0))	/* Check if the card is kept initialized */
             				s |= STA_NOINIT;
             			((sdcardDev*)_this->phy)->rcvr_mmc(((sdcardDev*)_this->phy)->phy,ocr, 4);
             			_this->select(0);
             		}
             	}
             	((sdcardDev*)_this->phy)->Stat = s;
             	return s;
             }
             DSTATUS sdcarddisk_initialize (blkdeviceptr _this)
             {
                 char cmd, ty, ocr[4],ocr2[4];
                 int n;
                 const char dummy=0xff;
                 uint32_t speed = 1000000;
             	((sdcardDev*)_this->phy)->setspeed(((sdcardDev*)_this->phy)->phy,350000);
             	if (_this==0) return STA_NOINIT;			/* Supports only drive 0 */
                 /* Is card existing in the soket? */
                 if (((sdcardDev*)_this->phy)->Stat & STA_NODISK)
                 {
                     printf("No SDCARD\n");
                     return ((sdcardDev*)_this->phy)->Stat;
                 }
                 printf("SDCARD Detected\n");
                 for (n = 100; n; n--) ((sdcardDev*)_this->phy)->xmit_mmc(((sdcardDev*)_this->phy)->phy,&dummy, 1);	/* Send 80 dummy clocks */
             	ty = 0;
             	if (sdcardsend_cmd(_this,CMD0, 0) == 1) {			/* Put the card SPI/Idle state */
                     printf("SDCARD in Idle mode\n");
             		Timer1 = 1000;						/* Initialization timeout = 1 sec */
             		if (sdcardsend_cmd(_this,CMD8, 0x1AA) == 1) {	/* SDv2? */
                         printf("SDCARD V2\n");
             			((sdcardDev*)_this->phy)->rcvr_mmc(((sdcardDev*)_this->phy)->phy,ocr, 4);
             			//for (n = 0; n < 4; n++) ocr[n] = xchg_spi(0xFF);	/* Get 32 bit return value of R7 resp */
             			if (ocr[2] == 0x01 && ocr[3] == 0xAA) {				/* Is the card supports vcc of 2.7-3.6V? */
                             printf("The card supports vcc of 2.7-3.6V\n");
             				while (Timer1 && sdcardsend_cmd(_this,ACMD41, 1UL << 30)) ;	/* Wait for end of initialization with ACMD41(HCS) */
             				if (Timer1 && sdcardsend_cmd(_this,CMD58, 0) == 0) {		/* Check CCS bit in the OCR */
             					//for (n = 0; n < 4; n++) ocr[n] = xchg_spi(0xFF);
                                 printf("Check CCS bit in the OCR:\n");
                                 ((sdcardDev*)_this->phy)->rcvr_mmc(((sdcardDev*)_this->phy)->phy,ocr, 4);
                                 printf("OCR[0]=0x%X\n",ocr[0]);
             					ty = (ocr[0] & 0x40) ? CT_SD2 | CT_BLOCK : CT_SD2;	/* Card id SDv2 */
             				}
             			}
             		} else {	/* Not SDv2 card */
             			if (sdcardsend_cmd(_this,ACMD41, 0) <= 1) 	{	/* SDv1 or MMC? */
             				ty = CT_SD1; cmd = ACMD41;	/* SDv1 (ACMD41(0)) */
             			} else {
             				ty = CT_MMC; cmd = CMD1;	/* MMCv3 (CMD1(0)) */
             			}
             			while (Timer1 && sdcardsend_cmd(_this,cmd, 0)) ;		/* Wait for end of initialization */
             			if (!Timer1 || sdcardsend_cmd(_this,CMD16, 512) != 0)	/* Set block length: 512 */
             				ty = 0;
             		}
             	}
             	((sdcardDev*)_this->phy)->CardType = ty;	/* Card type */
                 printf("CardType=0x%X\n",ty);
             	if (ty) {			/* OK */
             		((sdcardDev*)_this->phy)->Stat &= ~STA_NOINIT;	/* Clear STA_NOINIT flag */
             		sdcardsend_cmd(_this,CMD58, 0);
             		((sdcardDev*)_this->phy)->rcvr_mmc(((sdcardDev*)_this->phy)->phy,ocr, 4);
             		do
             		{
             			speed+=1000000;
             			((sdcardDev*)_this->phy)->setspeed(((sdcardDev*)_this->phy)->phy,speed);
             			sdcardsend_cmd(_this,CMD58, 0);
             			((sdcardDev*)_this->phy)->rcvr_mmc(((sdcardDev*)_this->phy)->phy,ocr2, 4);
             			for(n=0;n<4;n++)
             			{
             				if(ocr[n]!=ocr2[n])
             				{
             					n=0;
             					break;
             				}
             			}
                         if((speed>(50*1000*1000)) || (speed >= getCpuFreq()))
             			{
             				break;
             			}
             		}while(n);
             		if(!n)
             		{
             			speed-=1000000;
             			((sdcardDev*)_this->phy)->setspeed(((sdcardDev*)_this->phy)->phy,speed);
             		}
                     printf("SDCARD speed = %dMHz\n",speed/1000000);
             	} else {			/* Failed */
             		//power_off();
             		((sdcardDev*)_this->phy)->Stat = STA_NOINIT;
             	}
             	sdcarddeselect (_this);
             	return ((sdcardDev*)_this->phy)->Stat;
             }
             DRESULT sdcarddisk_read (blkdeviceptr _this,char *buff,uint32_t sector,char count)
             {
             	DSTATUS s;
             	s = sdcarddisk_status(_this);
             	if (s & STA_NOINIT) return RES_NOTRDY;
             	if (!count) return RES_PARERR;
             	if (!(((sdcardDev*)_this->phy)->CardType & CT_BLOCK)) sector *= 512;	/* Convert LBA to byte address if needed */
             	if (count == 1) {	/* Single block read */
             		if ((sdcardsend_cmd(_this,CMD17, sector) == 0) && sdcardrcvr_datablock((sdcardDev*)(_this->phy),buff, 512))
             			count = 0;
             	}
             	else {				/* Multiple block read */
             		if (sdcardsend_cmd(_this,CMD18, sector) == 0) {	/* READ_MULTIPLE_BLOCK */
             			do {
             				if (!sdcardrcvr_datablock (((sdcardDev*)_this->phy),buff, 512)) break;
             				buff += 512;
             			} while (--count);
             			sdcardsend_cmd(_this,CMD12, 0);				/* STOP_TRANSMISSION */
             		}
             	}
             	sdcarddeselect (_this);
             	return count ? RES_ERROR : RES_OK;
             }
             DRESULT sdcarddisk_write (blkdeviceptr _this,const char *buff,uint32_t sector,char count)
             {
             	DSTATUS s;
             	s = sdcarddisk_status(_this);
             	if (s & STA_NOINIT) return RES_NOTRDY;
             	if (s & STA_PROTECT) return RES_WRPRT;
             	if (!count) return RES_PARERR;
             	if (!(((sdcardDev*)_this->phy)->CardType & CT_BLOCK)) sector *= 512;	/* Convert LBA to byte address if needed */
             	if (count == 1) {	/* Single block write */
             		if ((sdcardsend_cmd(_this,CMD24, sector) == 0)	/* WRITE_BLOCK */
             			&& sdcardxmit_datablock (((sdcardDev*)_this->phy),buff, 0xFE))
             			count = 0;
             	}
             	else {				/* Multiple block write */
             		if (((sdcardDev*)_this->phy)->CardType & CT_SDC) sdcardsend_cmd(_this,ACMD23, count);
             		if (sdcardsend_cmd(_this,CMD25, sector) == 0) {	/* WRITE_MULTIPLE_BLOCK */
             			do {
             				if (!sdcardxmit_datablock (((sdcardDev*)_this->phy),buff, 0xFC)) break;
             				buff += 512;
             			} while (--count);
             			if (!sdcardxmit_datablock (((sdcardDev*)_this->phy),0, 0xFD))	/* STOP_TRAN token */
             				count = 1;
             		}
             	}
             	sdcarddeselect (_this);
             	return count ? RES_ERROR : RES_OK;
             }
             DRESULT sdcarddisk_ioctl (blkdeviceptr _this,char ctrl,void *buff)
             {
             	DRESULT res;
                 const char dummy=0xff;
             	char n, csd[16], *ptr = buff;
                 uint16_t csize;
                 uint32_t *dp, st, ed;
             	if (_this==0) return RES_PARERR;					/* Check parameter */
             	if (((sdcardDev*)_this->phy)->Stat & STA_NOINIT) return RES_NOTRDY;	/* Check if drive is ready */
             	res = RES_ERROR;
             	switch (ctrl) {
             	case CTRL_SYNC :		/* Wait for end of internal write process of the drive */
             		if (sdcardselect (_this)) {
             			sdcarddeselect (_this);
             			res = RES_OK;
             		}
             		break;
             	case GET_SECTOR_COUNT :	/* Get drive capacity in unit of sector (DWORD) */
             		if ((sdcardsend_cmd(_this,CMD9, 0) == 0) && sdcardrcvr_datablock (((sdcardDev*)_this->phy),csd, 16)) {
             			if ((csd[0] >> 6) == 1) {	/* SDC ver 2.00 */
                             csize = csd[9] + ((uint16_t)csd[8] << 8) + 1;
                             *(uint32_t*)buff = (uint32_t)csize << 10;
             			} else {					/* SDC ver 1.XX or MMC ver 3 */
             				n = (csd[5] & 15) + ((csd[10] & 128) >> 7) + ((csd[9] & 3) << 1) + 2;
                             csize = (csd[8] >> 6) + ((uint16_t)csd[7] << 2) + ((uint16_t)(csd[6] & 3) << 10) + 1;
                             *(uint32_t*)buff = (uint32_t)csize << (n - 9);
             			}
             			res = RES_OK;
             		}
             		break;
             	case GET_SECTOR_SIZE :	/* Get sector size in unit of byte (WORD) */
                     *(uint16_t*)buff = 512;
             		res = RES_OK;
             		break;
             	case GET_BLOCK_SIZE :	/* Get erase block size in unit of sector (DWORD) */
             		if (((sdcardDev*)_this->phy)->CardType & CT_SD2) {	/* SDC ver 2.00 */
             			if (sdcardsend_cmd(_this,ACMD13, 0) == 0) {	/* Read SD status */
             				((sdcardDev*)_this->phy)->xmit_mmc(((sdcardDev*)_this->phy)->phy,&dummy, 1);
             				if (sdcardrcvr_datablock (((sdcardDev*)_this->phy),csd, 16)) {				/* Read partial block */
             					for (n = 64 - 16; n; n--) ((sdcardDev*)_this->phy)->xmit_mmc(((sdcardDev*)_this->phy)->phy,&dummy, 1);	/* Purge trailing data */
                                 *(uint32_t*)buff = 16UL << (csd[10] >> 4);
             					res = RES_OK;
             					((sdcardDev*)_this->phy)->xmit_mmc(((sdcardDev*)_this->phy)->phy,&dummy, 1);
             				}
             			}
             		} else {					/* SDC ver 1.XX or MMC */
             			if ((sdcardsend_cmd(_this,CMD9, 0) == 0) && sdcardrcvr_datablock (((sdcardDev*)_this->phy),csd, 16)) {	/* Read CSD */
             				if (((sdcardDev*)_this->phy)->CardType & CT_SD1) {	/* SDC ver 1.XX */
                                 *(uint32_t*)buff = (((csd[10] & 63) << 1) + ((uint16_t)(csd[11] & 128) >> 7) + 1) << ((csd[13] >> 6) - 1);
             				} else {					/* MMC */
                                 *(uint32_t*)buff = ((uint16_t)((csd[10] & 124) >> 2) + 1) * (((csd[11] & 3) << 3) + ((csd[11] & 224) >> 5) + 1);
             				}
             				res = RES_OK;
             			}
             		}
             		break;
             	case CTRL_ERASE_SECTOR :	/* Erase a block of sectors (used when _USE_ERASE == 1) */
             		if (!(((sdcardDev*)_this->phy)->CardType & CT_SDC)) break;				/* Check if the card is SDC */
             		if (sdcarddisk_ioctl(_this, MMC_GET_CSD, csd)) break;	/* Get CSD */
             		if (!(csd[0] >> 6) && !(csd[10] & 0x40)) break;	/* Check if sector erase can be applied to the card */
             		dp = buff; st = dp[0]; ed = dp[1];				/* Load sector block */
             		if (!(((sdcardDev*)_this->phy)->CardType & CT_BLOCK)) {
             			st *= 512; ed *= 512;
             		}
             		if (sdcardsend_cmd(_this,CMD32, st) == 0 && sdcardsend_cmd(_this,CMD33, ed) == 0 && sdcardsend_cmd(_this,CMD38, 0) == 0 && sdcardwait_ready(((sdcardDev*)_this->phy)))	/* Erase sector block */
             			res = RES_OK;	/* FatFs does not check result of this command */
             		break;
             	/* Following command are not used by FatFs module */
             	case MMC_GET_TYPE :		/* Get MMC/SDC type (BYTE) */
             		*ptr = ((sdcardDev*)_this->phy)->CardType;
             		res = RES_OK;
             		break;
             	case MMC_GET_CSD :		/* Read CSD (16 bytes) */
             		if (sdcardsend_cmd(_this,CMD9, 0) == 0		/* READ_CSD */
             			&& sdcardrcvr_datablock (((sdcardDev*)_this->phy),ptr, 16))
             			res = RES_OK;
             		break;
             	case MMC_GET_CID :		/* Read CID (16 bytes) */
             		if (sdcardsend_cmd(_this,CMD10, 0) == 0		/* READ_CID */
             			&& sdcardrcvr_datablock (((sdcardDev*)_this->phy),ptr, 16))
             			res = RES_OK;
             		break;
             	case MMC_GET_OCR :		/* Read OCR (4 bytes) */
             		if (sdcardsend_cmd(_this,CMD58, 0) == 0) {	/* READ_OCR */
             			//for (n = 4; n; n--) *ptr++ =
             			((sdcardDev*)_this->phy)->rcvr_mmc(((sdcardDev*)_this->phy)->phy,ptr, 4);
             			res = RES_OK;
             		}
             		break;
             	case MMC_GET_SDSTAT :	/* Read SD status (64 bytes) */
             		if (sdcardsend_cmd(_this,ACMD13, 0) == 0) {	/* SD_STATUS */
             			((sdcardDev*)_this->phy)->xmit_mmc(((sdcardDev*)_this->phy)->phy,&dummy, 1);
             			if (sdcardrcvr_datablock (((sdcardDev*)_this->phy),ptr, 64))
             				res = RES_OK;
             		}
             		break;
             	default:
             		res = RES_PARERR;
             	}
             	sdcarddeselect (_this);
             	return res;
             }
             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))
             {
             	sdcard->phy = phy;
             	sdcard->rcvr_mmc = rcvr_mmc;
             	sdcard->xmit_mmc = xmit_mmc;
             	sdcard->setspeed = setspeed;
             	sdcard->getspeed = getspeed;
             }
              void sdcardspimakeblkdev(blkdevice* dev,sdcardDev* sdcard, blkdevselect_t select,blkdevpower_t power,blkdevdetect_t detect,blkdevwriteprotected_t writeprotected)
              {
              	dev->phy=sdcard;
              	dev->select=select;
              	dev->power = power;
              	dev->detect = detect;
              	dev->writeprotected = writeprotected;
              	dev->write = sdcarddisk_write;
              	dev->read = sdcarddisk_read;
              	dev->ioctl = sdcarddisk_ioctl;
              	dev->initialize = sdcarddisk_initialize;
              	dev->status = sdcarddisk_status;
              }

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

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

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2013, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
-            --                   Mail : alexis.jeandet@gmail.com
+            --                   Mail : alexis.jeandet@member.fsf.org
             -------------------------------------------------------------------------------*/
             #include <ssd2119.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++)\
             {\
                 ssd2119setFrame(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++)\
             {\
                 ssd2119setFrame(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++)\
             {\
                 ssd2119setFrame(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++)\
             {\
                 ssd2119setFrame(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++)\
             {\
                 ssd2119setFrame(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 ssd2119setGRAMaddress(LCD_t* LCD,uint16_t Haddress,uint16_t Vaddress)
             {
                 LCD->interface->writereg(SSD2119_REGISTER_X_RAM_ADDR,Haddress);
                 LCD->interface->writereg(SSD2119_REGISTER_Y_RAM_ADDR,Vaddress);
             }
             void ssd2119refreshenable(struct LCD_t* LCD,int enable)
             {
                 if(enable)
                 {
                     //LCD->interface->writereg(ssd2119_REGISTER_ENTRYMODE,0x1018);
                 }
                 else
                 {
                     //LCD->interface->writereg(ssd2119_REGISTER_ENTRYMODE,0x1008);
                 }
             }
             void ssd2119setFrame(LCD_t* LCD,uint16_t X,uint16_t Y,uint16_t W,uint16_t H)
             {
                 LCD->interface->writereg(SSD2119_REGISTER_X_RAM_ADDR,(uint32_t)X);
                 LCD->interface->writereg(SSD2119_REGISTER_Y_RAM_ADDR,(uint32_t)Y);
                 LCD->interface->writereg(SSD2119_REGISTER_H_RAM_START,(uint32_t)X);
                 LCD->interface->writereg(SSD2119_REGISTER_H_RAM_END,(uint32_t)(W+X-1));
                 LCD->interface->writereg(SSD2119_REGISTER_V_RAM_POS,(((uint32_t)(Y+H-1))<<8) + (uint32_t)Y);
             }
             void ssd2119paint(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)))
                 {
                     ssd2119setFrame(LCD,Xpos,Ypos,Width,Height);
                     LCD->interface->writeGRAM(buffer,Width*Height);
                 }
             }
             void ssd2119paintFilCirc(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 ssd2119paintFilCirc_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;
                         ssd2119setFrame(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 ssd2119paintFilRect(LCD_t* LCD,uint16_t Xpos,uint16_t Ypos,uint16_t w,uint16_t h,uint32_t contColor,uint16_t contSz,uint32_t fillColor)
             {
                 ssd2119setFrame(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)
                 {
                     ssd2119setFrame(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);
                     }
                     ssd2119setFrame(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);
                     }
                     ssd2119setFrame(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);
                     }
                     ssd2119setFrame(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 ssd2119paintText(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')
                 {
                     ssd2119setFrame(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)
                             {
                                 ssd2119setFrame(LCD,Xpos+(charnum*(w-10)),Ypos + linenum -h,w,1); // TODO remove -10 and generate good fonts!
                                 LCD->interface->writeGRAM(tmp,w);
                                 ssd2119setFrame(LCD,Xpos+(charnum*(w-10)),Ypos + linenum + 1-h,w,1);
                                 LCD->interface->readGRAM(tmp,w);
                                 pix=0;
                             }
                         }
                         if((pix%8) == 0)
                         {
                             line=font->table[(((*buffer)-32)*h*bpl)+tableoffset++];
                         }
                         if((line & (uint8_t)0x01)==(uint8_t)1)tmp[pix]=(uint16_t)color;
                         pix++;
                         line>>=1;
                     }
                     linenum=0;
                     tableoffset=0;
                     charnum++;
                     buffer++;
                 }
             }
             int ssd2119init(struct LCD_t* LCD)
             {
                 if((LCD!=NULL) && (LCD->interface!=NULL) && (LCD->interface->writereg!=NULL))
                 {
                     LCD->interface->writereg(0x28,0x0006); // VCOM OTP - Page 55-56 of SSD2119 datasheet
                     LCD->interface->writereg(0x00,0x0001); // start Oscillator - Page 36 of SSD2119 datasheet
                     LCD->interface->writereg(0x10,0x0000); // Sleep mode - Page 49 of SSD2119 datasheet
                     LCD->interface->writereg(0x01,0x72ef); // Driver Output Control - Page 36-39 of SSD2119 datasheet
                     LCD->interface->writereg(0x02,0x0600); // LCD Driving Waveform Control - Page 40-42 of SSD2119 datasheet
                     LCD->interface->writereg(0x03,0x6a38); // Power Control 1 - Page 43-44 of SSD2119 datasheet
                     LCD->interface->writereg(0x11,0x6870); // Entry Mode - Page 50-52 of SSD2119 datasheet
                     //  RAM WRITE DATA MASK
                     LCD->interface->writereg(0x0f,0x0000); // Gate Scan Position - Page 49 of SSD2119 datasheet
                     //  RAM WRITE DATA MASK
                     LCD->interface->writereg(0x0b,0x5308); // Frame Cycle Control - Page 45 of SSD2119 datasheet
                     LCD->interface->writereg(0x0c,0x0003); // Power Control 2 - Page 47 of SSD2119 datasheet
                     LCD->interface->writereg(0x0d,0x000a); // Power Control 3 - Page 48 of SSD2119 datasheet
                     LCD->interface->writereg(0x0e,0x2e00); // Power Control 4 - Page 48 of SSD2119 datasheet
                     LCD->interface->writereg(0x1e,0x00be); // Power Control 5 - Page 53 of SSD2119 datasheet
                     LCD->interface->writereg(0x25,0x8000); // Frame Frequency Control - Page 53 of SSD2119 datasheet
                     LCD->interface->writereg(0x26,0x7800); // Analog setting - Page 54 of SSD2119 datasheet
                     LCD->interface->writereg(0x4e,0x0000); // Ram Address Set - Page 58 of SSD2119 datasheet
                     LCD->interface->writereg(0x4f,0x0000); // Ram Address Set - Page 58 of SSD2119 datasheet
                     LCD->interface->writereg(0x12,0x08d9); // Sleep mode - Page 49 of SSD2119 datasheet
                     // -----------------Adjust the Gamma Curve----//
                     LCD->interface->writereg(0x30,0x0000);	 //0007
                     LCD->interface->writereg(0x31,0x0104);	   //0203
                     LCD->interface->writereg(0x32,0x0100);		//0001
                     LCD->interface->writereg(0x33,0x0305);	  //0007
                     LCD->interface->writereg(0x34,0x0505);	  //0007
                     LCD->interface->writereg(0x35,0x0305);		 //0407
                     LCD->interface->writereg(0x36,0x0707);		 //0407
                     LCD->interface->writereg(0x37,0x0300);		  //0607
                     LCD->interface->writereg(0x3a,0x1200);		 //0106
                     LCD->interface->writereg(0x3b,0x0800);
                     LCD->interface->writereg(0x07,0x0033); // Display Control - Page 45 of SSD2119 datasheet
                 }
                 return 0;
             }

lib/src/common/GRAPHIC/GUI/FONTS/fonts8pts.c +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2012, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
-            --                   Mail : alexis.jeandet@gmail.com
+            --                   Mail : alexis.jeandet@member.fsf.org
             -------------------------------------------------------------------------------*/
             #include <fonts.h>
             const uint8_t ComicSansMS_18_TBL[] = {
             /* Character Data - Index: 32 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 33 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 34 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x24,0x00,0x24,0x00,0x24,0x00,0x24,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 35 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x02,0x20,0x02,0x20,0x02,0xFC,0x07,0x10,0x01,0x08,0x01,0xFE,0x03,0x88,0x00,0x44,0x00,0x44,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 36 */
 x00,0x00,0x00,0x00,0x10,0x00,0x10,0x00,0xF8,0x00,0x14,0x00,0x14,0x00,0x14,0x00,0x38,0x00,0x50,0x00,0x90,0x00,0x90,0x00,0x50,0x00,0x3C,0x00,0x10,0x00,0x10,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 37 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x01,0xA4,0x00,0xA4,0x00,0xD8,0x00,0x40,0x00,0x40,0x00,0x20,0x03,0xA0,0x04,0x90,0x04,0x10,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 38 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xC0,0x00,0xA0,0x00,0xA0,0x00,0x60,0x00,0x70,0x00,0x48,0x01,0x44,0x01,0x84,0x00,0xC4,0x01,0x78,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 39 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 40 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x00,0x10,0x00,0x08,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x08,0x00,0x10,0x00,0x20,0x00,0x00,0x00,
                 /* Character Data - Index: 41 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x00,0x08,0x00,0x08,0x00,0x10,0x00,0x10,0x00,0x10,0x00,0x10,0x00,0x10,0x00,0x10,0x00,0x10,0x00,0x08,0x00,0x08,0x00,0x04,0x00,0x00,0x00,
                 /* Character Data - Index: 42 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x00,0x7E,0x00,0x18,0x00,0x24,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 43 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x00,0x08,0x00,0x3E,0x00,0x08,0x00,0x08,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 44 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x00,0x0C,0x00,0x04,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 45 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x1E,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 46 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x00,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 47 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x40,0x00,0x20,0x00,0x20,0x00,0x20,0x00,0x10,0x00,0x18,0x00,0x08,0x00,0x04,0x00,0x04,0x00,0x02,0x00,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 48 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x30,0x00,0x48,0x00,0x84,0x00,0x84,0x00,0x84,0x00,0x84,0x00,0x84,0x00,0x84,0x00,0x48,0x00,0x30,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 49 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x00,0x0C,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x1C,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 50 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x78,0x00,0x84,0x00,0x80,0x00,0x80,0x00,0x40,0x00,0x30,0x00,0x08,0x00,0x04,0x00,0x04,0x00,0xFC,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 51 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x38,0x00,0x44,0x00,0x40,0x00,0x40,0x00,0x38,0x00,0x40,0x00,0x40,0x00,0x40,0x00,0x44,0x00,0x38,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 52 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x40,0x00,0x60,0x00,0x50,0x00,0x48,0x00,0x44,0x00,0x42,0x00,0xFE,0x00,0x40,0x00,0x40,0x00,0x40,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 53 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFC,0x00,0x04,0x00,0x04,0x00,0x74,0x00,0x8C,0x00,0x84,0x00,0x80,0x00,0x80,0x00,0x44,0x00,0x38,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 54 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x00,0x10,0x00,0x08,0x00,0x08,0x00,0x7C,0x00,0x84,0x00,0x84,0x00,0x84,0x00,0x84,0x00,0x78,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 55 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFE,0x00,0x40,0x00,0x20,0x00,0x20,0x00,0x20,0x00,0x10,0x00,0x10,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 56 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x78,0x00,0x84,0x00,0x84,0x00,0x84,0x00,0x78,0x00,0x84,0x00,0x84,0x00,0x84,0x00,0x84,0x00,0x78,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 57 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x78,0x00,0x84,0x00,0x84,0x00,0x84,0x00,0x84,0x00,0x84,0x00,0x78,0x00,0x40,0x00,0x30,0x00,0x0C,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 58 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x00,0x04,0x00,0x00,0x00,0x00,0x00,0x04,0x00,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 59 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x00,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x00,0x06,0x00,0x02,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 60 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x10,0x00,0x08,0x00,0x04,0x00,0x06,0x00,0x08,0x00,0x10,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 61 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x7C,0x00,0x00,0x00,0x00,0x00,0x7C,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 62 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x00,0x04,0x00,0x08,0x00,0x18,0x00,0x04,0x00,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 63 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x1E,0x00,0x60,0x00,0x40,0x00,0x40,0x00,0x20,0x00,0x10,0x00,0x08,0x00,0x00,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 64 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xF0,0x00,0x0C,0x03,0x64,0x06,0x32,0x04,0xCA,0x04,0xCA,0x04,0x72,0x03,0x02,0x00,0x04,0x00,0x08,0x02,0xF0,0x01,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 65 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x40,0x00,0x40,0x00,0x40,0x00,0xA0,0x00,0x90,0x00,0x90,0x00,0xF8,0x00,0x08,0x01,0x04,0x01,0x04,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 66 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3C,0x00,0x44,0x00,0x44,0x00,0x44,0x00,0x24,0x00,0x7C,0x00,0x84,0x00,0x84,0x00,0x44,0x00,0x3C,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 67 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xF0,0x00,0x88,0x00,0x04,0x00,0x04,0x00,0x02,0x00,0x02,0x00,0x02,0x00,0x02,0x00,0x82,0x00,0x7C,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 68 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0C,0x00,0x34,0x00,0x44,0x00,0x84,0x00,0x04,0x01,0x04,0x01,0x04,0x01,0x04,0x01,0x84,0x00,0x78,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 69 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFC,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0xFC,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0xF8,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 70 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFC,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x7C,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 71 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x70,0x00,0x88,0x00,0x04,0x00,0x04,0x00,0x02,0x00,0xF2,0x01,0x02,0x01,0x82,0x00,0x42,0x00,0x3C,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 72 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x02,0x04,0x02,0x04,0x02,0x04,0x02,0x04,0x02,0xFC,0x03,0x04,0x02,0x04,0x02,0x04,0x02,0x04,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 73 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x7C,0x00,0x10,0x00,0x10,0x00,0x10,0x00,0x10,0x00,0x10,0x00,0x10,0x00,0x10,0x00,0x10,0x00,0x7C,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 74 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xF8,0x01,0x40,0x00,0x40,0x00,0x40,0x00,0x40,0x00,0x40,0x00,0x40,0x00,0x44,0x00,0x44,0x00,0x78,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 75 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x84,0x00,0x44,0x00,0x24,0x00,0x14,0x00,0x0C,0x00,0x0C,0x00,0x14,0x00,0x24,0x00,0x44,0x00,0x84,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 76 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x7C,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 77 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x10,0x01,0x10,0x01,0x10,0x01,0x90,0x01,0xA8,0x02,0xA8,0x02,0xA8,0x02,0xA4,0x02,0x44,0x04,0x44,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 78 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x02,0x06,0x02,0x0A,0x02,0x0A,0x02,0x12,0x02,0x22,0x02,0x42,0x02,0x82,0x02,0x02,0x03,0x02,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 79 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xF0,0x00,0x08,0x01,0x04,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x01,0x84,0x00,0x78,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 80 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3C,0x00,0x44,0x00,0x44,0x00,0x44,0x00,0x44,0x00,0x3C,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 81 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xF0,0x01,0x08,0x03,0x04,0x02,0x02,0x04,0x02,0x04,0x02,0x04,0x42,0x04,0xC4,0x04,0x8C,0x03,0xF0,0x03,0x00,0x06,0x00,0x0C,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 82 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3C,0x00,0x44,0x00,0x84,0x00,0x84,0x00,0x84,0x00,0x44,0x00,0x3C,0x00,0x24,0x00,0x44,0x00,0x84,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 83 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xF0,0x01,0x08,0x00,0x04,0x00,0x04,0x00,0xF8,0x00,0x00,0x01,0x00,0x01,0x00,0x01,0x82,0x00,0x7C,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 84 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFC,0x01,0x20,0x00,0x20,0x00,0x20,0x00,0x20,0x00,0x20,0x00,0x20,0x00,0x20,0x00,0x20,0x00,0x20,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 85 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x02,0x04,0x02,0x04,0x02,0x04,0x02,0x04,0x02,0x04,0x02,0x04,0x02,0x04,0x02,0x08,0x01,0xF0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 86 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x01,0x02,0x01,0x82,0x00,0x84,0x00,0x44,0x00,0x44,0x00,0x28,0x00,0x28,0x00,0x10,0x00,0x10,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 87 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x84,0x10,0x84,0x10,0x84,0x08,0x48,0x09,0x48,0x09,0x28,0x05,0x28,0x05,0x28,0x05,0x10,0x02,0x10,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 88 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x02,0x04,0x01,0x88,0x00,0x50,0x00,0x20,0x00,0x20,0x00,0x50,0x00,0x88,0x00,0x04,0x01,0x02,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 89 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x01,0x84,0x00,0x88,0x00,0x48,0x00,0x50,0x00,0x30,0x00,0x20,0x00,0x10,0x00,0x10,0x00,0x10,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 90 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFE,0x01,0x80,0x00,0x40,0x00,0x20,0x00,0x10,0x00,0x10,0x00,0x08,0x00,0x04,0x00,0x02,0x00,0xFE,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 91 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x1C,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x1C,0x00,0x00,0x00,
                 /* Character Data - Index: 92 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x00,0x02,0x00,0x04,0x00,0x04,0x00,0x08,0x00,0x08,0x00,0x10,0x00,0x10,0x00,0x10,0x00,0x20,0x00,0x20,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 93 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x1C,0x00,0x10,0x00,0x10,0x00,0x10,0x00,0x10,0x00,0x10,0x00,0x10,0x00,0x10,0x00,0x10,0x00,0x10,0x00,0x10,0x00,0x10,0x00,0x1C,0x00,0x00,0x00,
                 /* Character Data - Index: 94 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x00,0x1C,0x00,0x22,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 95 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFE,0x01,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 96 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x00,0x04,0x00,0x08,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 97 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x70,0x00,0x48,0x00,0x44,0x00,0x44,0x00,0x44,0x00,0x44,0x00,0xB8,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 98 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x34,0x00,0x4C,0x00,0x84,0x00,0x84,0x00,0x84,0x00,0x44,0x00,0x3C,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 99 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x30,0x00,0x48,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x44,0x00,0x38,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 100 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,0x00,0x80,0x00,0x80,0x00,0xF0,0x00,0x88,0x00,0x84,0x00,0x84,0x00,0x84,0x00,0x84,0x00,0xF8,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 101 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x30,0x00,0x48,0x00,0x44,0x00,0x34,0x00,0x0C,0x00,0x44,0x00,0x38,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 102 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xE0,0x00,0x10,0x00,0x10,0x00,0x7C,0x00,0x10,0x00,0x10,0x00,0x10,0x00,0x10,0x00,0x10,0x00,0x10,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 103 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x30,0x00,0x48,0x00,0x44,0x00,0x44,0x00,0x44,0x00,0x64,0x00,0x58,0x00,0x40,0x00,0x40,0x00,0x20,0x00,0x1C,0x00,
                 /* Character Data - Index: 104 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x34,0x00,0x4C,0x00,0x44,0x00,0x44,0x00,0x44,0x00,0x44,0x00,0x44,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 105 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x00,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 106 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x09,0x00,0x06,0x00,
                 /* Character Data - Index: 107 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x44,0x00,0x24,0x00,0x14,0x00,0x1C,0x00,0x24,0x00,0x24,0x00,0x44,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 108 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 109 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xB4,0x00,0x6C,0x01,0x24,0x01,0x24,0x01,0x24,0x01,0x24,0x01,0x24,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 110 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x34,0x00,0x4C,0x00,0x44,0x00,0x44,0x00,0x44,0x00,0x44,0x00,0x44,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 111 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x38,0x00,0x44,0x00,0x44,0x00,0x44,0x00,0x44,0x00,0x44,0x00,0x38,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 112 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3C,0x00,0x44,0x00,0x44,0x00,0x44,0x00,0x44,0x00,0x44,0x00,0x3C,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,
                 /* Character Data - Index: 113 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x70,0x00,0x48,0x00,0x44,0x00,0x44,0x00,0x44,0x00,0x44,0x00,0x78,0x00,0x40,0x00,0x40,0x00,0x40,0x00,0x40,0x00,
                 /* Character Data - Index: 114 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x34,0x00,0x2C,0x00,0x24,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 115 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x38,0x00,0x24,0x00,0x04,0x00,0x18,0x00,0x20,0x00,0x20,0x00,0x1C,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 116 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x00,0x08,0x00,0x3E,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 117 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x44,0x00,0x44,0x00,0x44,0x00,0x44,0x00,0x44,0x00,0x44,0x00,0x78,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 118 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x44,0x00,0x44,0x00,0x28,0x00,0x28,0x00,0x28,0x00,0x10,0x00,0x10,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 119 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x22,0x02,0x22,0x02,0x54,0x01,0x54,0x01,0x54,0x01,0xC8,0x00,0x88,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 120 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x82,0x00,0x44,0x00,0x38,0x00,0x10,0x00,0x28,0x00,0x44,0x00,0x82,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 121 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x42,0x00,0x42,0x00,0x24,0x00,0x24,0x00,0x18,0x00,0x18,0x00,0x10,0x00,0x08,0x00,0x08,0x00,0x04,0x00,0x04,0x00,
                 /* Character Data - Index: 122 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x7C,0x00,0x20,0x00,0x20,0x00,0x10,0x00,0x08,0x00,0x08,0x00,0x7C,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 123 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x06,0x00,0x06,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x04,0x00,0x18,0x00,0x00,0x00,
                 /* Character Data - Index: 124 */
 x00,0x00,0x00,0x00,0x00,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 125 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x06,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x18,0x00,0x18,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x08,0x00,0x06,0x00,0x00,0x00,
                 /* Character Data - Index: 126 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x8C,0x00,0xD6,0x00,0x62,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                 /* Character Data - Index: 127 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
             };
             const uint8_t ComicSansMS_24_TBL[] = {
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 33 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x00,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 34 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xCC,0x00,0x00,0xCC,0x00,0x00,0xCC,0x00,0x00,0xCC,0x00,0x00,0xCC,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 35 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xC0,0x18,0x00,0xC0,0x18,0x00,0xC0,0x18,0x00,0xFC,0x7F,0x00,0xFC,0x7F,0x00,0x60,0x0C,0x00,0x60,0x0C,0x00,0x30,0x06,0x00,0xFE,0x3F,0x00,0xFE,0x3F,0x00,0x30,0x06,0x00,0x18,0x03,0x00,0x18,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 36 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xC0,0x00,0x00,0xC0,0x00,0x00,0xE0,0x03,0x00,0xF8,0x07,0x00,0xDC,0x00,0x00,0xCC,0x00,0x00,0xCC,0x00,0x00,0xFC,0x03,0x00,0xF0,0x07,0x00,0xC0,0x0E,0x00,0xC0,0x0C,0x00,0xC0,0x0C,0x00,0xCC,0x0E,0x00,0xFC,0x07,0x00,0xF8,0x03,0x00,0xC0,0x00,0x00,0xC0,0x00,0x00,0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 37 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x00,0x3C,0x06,0x00,0x7E,0x03,0x00,0x66,0x03,0x00,0xFE,0x03,0x00,0xBC,0x01,0x00,0x80,0x01,0x00,0xC0,0x00,0x00,0xC0,0x00,0x00,0xE0,0x1E,0x00,0x60,0x3F,0x00,0x60,0x33,0x00,0x30,0x3F,0x00,0x30,0x1E,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 38 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xE0,0x00,0x00,0xF0,0x01,0x00,0xB0,0x01,0x00,0xB0,0x01,0x00,0xF0,0x00,0x00,0x70,0x04,0x00,0xDC,0x04,0x00,0xCC,0x04,0x00,0x86,0x07,0x00,0x06,0x07,0x00,0x0E,0x07,0x00,0xFC,0x07,0x00,0xF8,0x08,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 39 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 40 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x60,0x00,0x00,0x70,0x00,0x00,0x30,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x08,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x38,0x00,0x00,0x70,0x00,0x00,0x60,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 41 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x06,0x00,0x00,0x0E,0x00,0x00,0x0C,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x10,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x1C,0x00,0x00,0x0E,0x00,0x00,0x06,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 42 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x10,0x00,0x00,0x10,0x00,0x00,0xFE,0x01,0x00,0xFC,0x00,0x00,0x78,0x00,0x00,0x6C,0x00,0x00,0x84,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 43 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0xFE,0x01,0x00,0xFE,0x01,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 44 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 45 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x7C,0x00,0x00,0x7C,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 46 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 47 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x80,0x01,0x00,0x80,0x01,0x00,0xC0,0x00,0x00,0xC0,0x00,0x00,0xC0,0x00,0x00,0x60,0x00,0x00,0x60,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 48 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xF0,0x00,0x00,0xF8,0x01,0x00,0x8C,0x01,0x00,0x0E,0x03,0x00,0x06,0x03,0x00,0x06,0x03,0x00,0x06,0x03,0x00,0x06,0x03,0x00,0x06,0x03,0x00,0x8E,0x03,0x00,0x8C,0x01,0x00,0xFC,0x01,0x00,0xF8,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 49 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x30,0x00,0x00,0x38,0x00,0x00,0x3C,0x00,0x00,0x34,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0xFC,0x00,0x00,0xFC,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 50 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xF0,0x00,0x00,0xF8,0x03,0x00,0x9C,0x03,0x00,0x0C,0x03,0x00,0x00,0x03,0x00,0x80,0x01,0x00,0xC0,0x00,0x00,0x70,0x00,0x00,0x18,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0xFC,0x03,0x00,0xFC,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 51 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xF0,0x00,0x00,0xFC,0x01,0x00,0x0C,0x03,0x00,0x00,0x03,0x00,0x80,0x03,0x00,0xF0,0x01,0x00,0xF0,0x00,0x00,0x80,0x03,0x00,0x00,0x03,0x00,0x04,0x03,0x00,0x8C,0x03,0x00,0xF8,0x01,0x00,0xF0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 52 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,0x01,0x00,0xC0,0x01,0x00,0xE0,0x01,0x00,0xA0,0x01,0x00,0x90,0x01,0x00,0x98,0x01,0x00,0x8C,0x01,0x00,0xFE,0x07,0x00,0xFE,0x07,0x00,0x80,0x01,0x00,0x80,0x01,0x00,0x80,0x01,0x00,0x80,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 53 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFC,0x03,0x00,0xFC,0x03,0x00,0x0C,0x00,0x00,0xFC,0x00,0x00,0xFC,0x01,0x00,0x8C,0x03,0x00,0x0C,0x03,0x00,0x00,0x03,0x00,0x00,0x03,0x00,0x00,0x03,0x00,0x8C,0x01,0x00,0xFC,0x01,0x00,0xF8,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 54 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xC0,0x00,0x00,0xE0,0x00,0x00,0x70,0x00,0x00,0x38,0x00,0x00,0x18,0x00,0x00,0xFC,0x00,0x00,0xFC,0x01,0x00,0x0C,0x03,0x00,0x0C,0x03,0x00,0x0C,0x03,0x00,0x9C,0x03,0x00,0xF8,0x01,0x00,0xF0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 55 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFE,0x07,0x00,0xFE,0x07,0x00,0x00,0x03,0x00,0x80,0x01,0x00,0xC0,0x00,0x00,0xC0,0x00,0x00,0x60,0x00,0x00,0x60,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x10,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 56 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xF8,0x00,0x00,0xFC,0x03,0x00,0x0E,0x03,0x00,0x06,0x03,0x00,0x8E,0x03,0x00,0xFE,0x01,0x00,0xFC,0x01,0x00,0x8E,0x03,0x00,0x06,0x03,0x00,0x06,0x03,0x00,0x8E,0x03,0x00,0xFC,0x01,0x00,0xF8,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 57 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xF8,0x00,0x00,0xFC,0x01,0x00,0x8E,0x03,0x00,0x06,0x03,0x00,0x06,0x03,0x00,0x06,0x03,0x00,0x8E,0x03,0x00,0xFC,0x03,0x00,0xF8,0x01,0x00,0x80,0x01,0x00,0xC0,0x00,0x00,0xE0,0x00,0x00,0x3C,0x00,0x00,0x0C,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 58 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 59 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 60 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x30,0x00,0x00,0x38,0x00,0x00,0x1C,0x00,0x00,0x06,0x00,0x00,0x0C,0x00,0x00,0x18,0x00,0x00,0x30,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 61 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFC,0x00,0x00,0xFC,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFC,0x00,0x00,0xFC,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 62 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0C,0x00,0x00,0x1C,0x00,0x00,0x30,0x00,0x00,0xE0,0x00,0x00,0xE0,0x00,0x00,0x38,0x00,0x00,0x1C,0x00,0x00,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 63 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x70,0x00,0x00,0xFC,0x01,0x00,0x8C,0x03,0x00,0x00,0x03,0x00,0x00,0x03,0x00,0x00,0x03,0x00,0x80,0x01,0x00,0xE0,0x00,0x00,0x30,0x00,0x00,0x10,0x00,0x00,0x00,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 64 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xC0,0x0F,0x00,0xE0,0x3F,0x00,0x70,0x78,0x00,0x18,0x60,0x00,0x98,0xC3,0x00,0xCC,0xC1,0x00,0x6C,0xC6,0x00,0x6C,0xC6,0x00,0xEC,0x7F,0x00,0xCC,0x3D,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x70,0x18,0x00,0xE0,0x1F,0x00,0xC0,0x07,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 65 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x00,0x00,0x03,0x00,0x80,0x03,0x00,0xC0,0x06,0x00,0xC0,0x06,0x00,0x60,0x06,0x00,0x60,0x07,0x00,0xF0,0x07,0x00,0x78,0x06,0x00,0x18,0x0E,0x00,0x18,0x0C,0x00,0x0C,0x0C,0x00,0x0C,0x0C,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 66 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x7C,0x00,0x00,0xFC,0x01,0x00,0x8C,0x03,0x00,0x0C,0x03,0x00,0x0C,0x03,0x00,0x8C,0x03,0x00,0xFC,0x01,0x00,0xFC,0x03,0x00,0x0C,0x07,0x00,0x0C,0x06,0x00,0x8C,0x07,0x00,0xFC,0x03,0x00,0xFC,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 67 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xE0,0x03,0x00,0xF0,0x03,0x00,0x38,0x03,0x00,0x18,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x06,0x00,0x00,0x06,0x00,0x00,0x06,0x00,0x00,0x06,0x03,0x00,0x8E,0x03,0x00,0xFC,0x01,0x00,0x78,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 68 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0C,0x00,0x00,0x7C,0x00,0x00,0xEC,0x01,0x00,0x8C,0x03,0x00,0x0C,0x06,0x00,0x0C,0x0E,0x00,0x0C,0x0C,0x00,0x0C,0x0C,0x00,0x0C,0x0C,0x00,0x0C,0x0E,0x00,0x0C,0x07,0x00,0xFC,0x03,0x00,0xF8,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 69 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFC,0x07,0x00,0xFC,0x07,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0xFC,0x03,0x00,0xFC,0x03,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0xFC,0x03,0x00,0xF8,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 70 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFC,0x03,0x00,0xFC,0x07,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0xFC,0x03,0x00,0xFC,0x03,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 71 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xE0,0x01,0x00,0xF0,0x07,0x00,0x38,0x06,0x00,0x18,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0xF6,0x0F,0x00,0xF6,0x0F,0x00,0x06,0x0C,0x00,0x06,0x06,0x00,0x0E,0x07,0x00,0xFC,0x03,0x00,0xF8,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 72 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0C,0x18,0x00,0x0C,0x18,0x00,0x0C,0x18,0x00,0x0C,0x18,0x00,0x0C,0x18,0x00,0x0C,0x18,0x00,0x8C,0x1F,0x00,0xFC,0x1F,0x00,0x7C,0x18,0x00,0x0C,0x18,0x00,0x0C,0x18,0x00,0x0C,0x18,0x00,0x0C,0x18,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 73 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFE,0x01,0x00,0xFE,0x01,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0xFE,0x01,0x00,0xFE,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 74 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xF0,0x0F,0x00,0xF0,0x0F,0x00,0x80,0x01,0x00,0x80,0x01,0x00,0x80,0x01,0x00,0x80,0x01,0x00,0x80,0x01,0x00,0x80,0x01,0x00,0x86,0x01,0x00,0x86,0x01,0x00,0xCE,0x01,0x00,0xFC,0x01,0x00,0xF0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 75 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0C,0x04,0x00,0x0C,0x06,0x00,0x0C,0x03,0x00,0x8C,0x01,0x00,0xEC,0x00,0x00,0x7C,0x00,0x00,0x3C,0x00,0x00,0x3C,0x00,0x00,0x6C,0x00,0x00,0xEC,0x00,0x00,0xCC,0x01,0x00,0x8C,0x07,0x00,0x0C,0x06,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 76 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0xFC,0x01,0x00,0xFC,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 77 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x60,0x08,0x00,0x70,0x1C,0x00,0x70,0x1C,0x00,0x70,0x1C,0x00,0x70,0x14,0x00,0xD8,0x34,0x00,0xD8,0x36,0x00,0xD8,0x36,0x00,0xD8,0x36,0x00,0xCC,0x36,0x00,0x8C,0x33,0x00,0x8C,0x63,0x00,0x8C,0x63,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 78 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0C,0x10,0x00,0x1C,0x30,0x00,0x1C,0x30,0x00,0x3C,0x30,0x00,0x6C,0x30,0x00,0xCC,0x30,0x00,0x8C,0x31,0x00,0x8C,0x31,0x00,0x0C,0x33,0x00,0x0C,0x36,0x00,0x0C,0x3C,0x00,0x0C,0x38,0x00,0x0C,0x30,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 79 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xC0,0x07,0x00,0xE0,0x1F,0x00,0x70,0x38,0x00,0x38,0x30,0x00,0x18,0x30,0x00,0x0C,0x30,0x00,0x0C,0x30,0x00,0x0C,0x30,0x00,0x0C,0x18,0x00,0x1C,0x18,0x00,0x38,0x0C,0x00,0xF0,0x07,0x00,0xE0,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 80 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x7C,0x00,0x00,0xFC,0x00,0x00,0xCC,0x01,0x00,0x8C,0x01,0x00,0x8C,0x01,0x00,0xCC,0x01,0x00,0xFC,0x00,0x00,0x7C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 81 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xC0,0x0F,0x00,0xE0,0x1F,0x00,0x70,0x38,0x00,0x18,0x30,0x00,0x1C,0x70,0x00,0x0C,0x60,0x00,0x0C,0x60,0x00,0x0C,0x60,0x00,0x0C,0x61,0x00,0x18,0x63,0x00,0x38,0x36,0x00,0xF0,0x3F,0x00,0xC0,0x1B,0x00,0x00,0x30,0x00,0x00,0x70,0x00,0x00,0x60,0x00,0x00,0x40,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 82 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3C,0x00,0x00,0xFC,0x00,0x00,0xCC,0x01,0x00,0x8C,0x03,0x00,0x0C,0x03,0x00,0x0C,0x03,0x00,0x8C,0x03,0x00,0xFC,0x01,0x00,0x7C,0x00,0x00,0xEC,0x00,0x00,0x8C,0x03,0x00,0x0C,0x07,0x00,0x0C,0x06,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 83 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xC0,0x03,0x00,0xF0,0x07,0x00,0x30,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0xF8,0x03,0x00,0xF0,0x07,0x00,0x00,0x0E,0x00,0x00,0x0C,0x00,0x0C,0x0C,0x00,0x1C,0x0E,0x00,0xF8,0x07,0x00,0xF0,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 84 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFE,0x0F,0x00,0xFE,0x0F,0x00,0x60,0x00,0x00,0x60,0x00,0x00,0x60,0x00,0x00,0x60,0x00,0x00,0x60,0x00,0x00,0x60,0x00,0x00,0x60,0x00,0x00,0x60,0x00,0x00,0x60,0x00,0x00,0x60,0x00,0x00,0x60,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 85 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0C,0x18,0x00,0x0C,0x18,0x00,0x0C,0x18,0x00,0x0C,0x18,0x00,0x0C,0x18,0x00,0x0C,0x18,0x00,0x0C,0x18,0x00,0x0C,0x18,0x00,0x0C,0x0C,0x00,0x1C,0x0C,0x00,0x38,0x0E,0x00,0xF8,0x07,0x00,0xE0,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 86 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0C,0x0C,0x00,0x0C,0x0C,0x00,0x0C,0x06,0x00,0x18,0x06,0x00,0x18,0x06,0x00,0x18,0x03,0x00,0x18,0x03,0x00,0x30,0x03,0x00,0xB0,0x01,0x00,0xB0,0x01,0x00,0xB0,0x01,0x00,0xE0,0x00,0x00,0xE0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 87 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0C,0x0C,0x02,0x0C,0x0E,0x03,0x1C,0x0E,0x03,0x18,0x0E,0x03,0x18,0x1B,0x03,0x18,0x9B,0x01,0x30,0x9B,0x01,0xB0,0x99,0x01,0xB0,0xD9,0x00,0xA0,0xD9,0x00,0xE0,0xD8,0x00,0xE0,0x78,0x00,0xE0,0x70,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 88 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0C,0x18,0x00,0x1C,0x18,0x00,0x38,0x0C,0x00,0x70,0x06,0x00,0x60,0x07,0x00,0xC0,0x03,0x00,0x80,0x01,0x00,0xC0,0x03,0x00,0x60,0x03,0x00,0x30,0x06,0x00,0x18,0x0C,0x00,0x1C,0x1C,0x00,0x0C,0x18,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 89 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x06,0x06,0x00,0x06,0x06,0x00,0x0C,0x03,0x00,0x18,0x03,0x00,0x98,0x01,0x00,0xB0,0x01,0x00,0xB0,0x01,0x00,0xE0,0x00,0x00,0xC0,0x00,0x00,0x60,0x00,0x00,0x60,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 90 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFC,0x1F,0x00,0xFC,0x1F,0x00,0x00,0x0E,0x00,0x00,0x03,0x00,0x80,0x01,0x00,0xC0,0x01,0x00,0xC0,0x00,0x00,0x60,0x00,0x00,0x30,0x00,0x00,0x18,0x00,0x00,0x0C,0x00,0x00,0xFC,0x1F,0x00,0xFC,0x1F,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 91 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xF8,0x00,0x00,0xF8,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0xF8,0x00,0x00,0xF8,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 92 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x60,0x00,0x00,0x60,0x00,0x00,0x40,0x00,0x00,0xC0,0x00,0x00,0xC0,0x00,0x00,0x80,0x01,0x00,0x80,0x01,0x00,0x80,0x01,0x00,0x00,0x03,0x00,0x00,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 93 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3E,0x00,0x00,0x3E,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x3E,0x00,0x00,0x3E,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 94 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x40,0x00,0x00,0xE0,0x00,0x00,0x30,0x01,0x00,0x18,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 95 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFE,0x0F,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 96 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0C,0x00,0x00,0x18,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 97 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xE0,0x01,0x00,0xF8,0x01,0x00,0x98,0x01,0x00,0x8C,0x01,0x00,0x8C,0x01,0x00,0x8C,0x01,0x00,0x8C,0x01,0x00,0xF8,0x03,0x00,0x70,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 98 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0xEC,0x00,0x00,0xFC,0x01,0x00,0x9C,0x03,0x00,0x0C,0x03,0x00,0x0C,0x03,0x00,0x0C,0x03,0x00,0x8C,0x03,0x00,0xFC,0x01,0x00,0xFC,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 99 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xF0,0x00,0x00,0xF8,0x01,0x00,0x98,0x01,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x9C,0x01,0x00,0xF8,0x01,0x00,0xF0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 100 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x03,0x00,0x00,0x03,0x00,0x00,0x03,0x00,0x00,0x03,0x00,0x00,0x03,0x00,0xF0,0x03,0x00,0xF8,0x03,0x00,0x1C,0x03,0x00,0x0C,0x03,0x00,0x0C,0x03,0x00,0x0C,0x03,0x00,0x9C,0x03,0x00,0xF8,0x03,0x00,0xF0,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 101 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xF0,0x01,0x00,0xF8,0x03,0x00,0x18,0x03,0x00,0xCC,0x03,0x00,0xFC,0x00,0x00,0x3C,0x00,0x00,0x1C,0x02,0x00,0xF8,0x03,0x00,0xF0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 102 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xC0,0x01,0x00,0xE0,0x01,0x00,0x70,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0xFC,0x01,0x00,0xFC,0x01,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 103 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xF0,0x00,0x00,0xF8,0x01,0x00,0x98,0x01,0x00,0x8C,0x01,0x00,0x8C,0x01,0x00,0x8C,0x01,0x00,0xCC,0x01,0x00,0xF8,0x01,0x00,0xB8,0x01,0x00,0x80,0x01,0x00,0x80,0x01,0x00,0xC0,0x00,0x00,0xFC,0x00,0x00,0x7C,0x00,0x00,
                     /* Character Data - Index: 104 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0xEC,0x00,0x00,0xFC,0x01,0x00,0x9C,0x01,0x00,0x8C,0x01,0x00,0x8C,0x01,0x00,0x8C,0x01,0x00,0x8C,0x01,0x00,0x8C,0x01,0x00,0x8C,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 105 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 106 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x33,0x00,0x00,0x33,0x00,0x00,0x3E,0x00,0x00,0x1C,0x00,0x00,
                     /* Character Data - Index: 107 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x03,0x00,0x8C,0x01,0x00,0xCC,0x00,0x00,0x6C,0x00,0x00,0x7C,0x00,0x00,0xDC,0x00,0x00,0x8C,0x01,0x00,0x0C,0x03,0x00,0x0C,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 108 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 109 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xCC,0x0E,0x00,0xEC,0x1F,0x00,0xBC,0x1B,0x00,0x9C,0x19,0x00,0x8C,0x19,0x00,0x8C,0x19,0x00,0x8C,0x19,0x00,0x8C,0x19,0x00,0x8C,0x19,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 110 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xEC,0x00,0x00,0xFC,0x01,0x00,0x9C,0x01,0x00,0x8C,0x01,0x00,0x8C,0x01,0x00,0x8C,0x01,0x00,0x8C,0x01,0x00,0x8C,0x01,0x00,0x8C,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 111 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xF0,0x00,0x00,0xF8,0x01,0x00,0x98,0x03,0x00,0x0C,0x03,0x00,0x0C,0x03,0x00,0x0C,0x03,0x00,0x9C,0x03,0x00,0xF8,0x01,0x00,0xF0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 112 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0C,0x00,0x00,0xEC,0x00,0x00,0xFC,0x00,0x00,0x9C,0x01,0x00,0x8C,0x01,0x00,0x8C,0x01,0x00,0x8C,0x01,0x00,0xCC,0x01,0x00,0xFC,0x00,0x00,0x7C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,
                     /* Character Data - Index: 113 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xE0,0x01,0x00,0xF8,0x01,0x00,0x98,0x01,0x00,0x8C,0x01,0x00,0x8C,0x01,0x00,0x8C,0x01,0x00,0x8C,0x01,0x00,0xF8,0x01,0x00,0xF0,0x01,0x00,0x80,0x01,0x00,0x80,0x01,0x00,0x80,0x01,0x00,0x80,0x01,0x00,0x80,0x01,0x00,
                     /* Character Data - Index: 114 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xEC,0x00,0x00,0xFC,0x00,0x00,0xDC,0x00,0x00,0xCC,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 115 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xE0,0x00,0x00,0xF8,0x00,0x00,0xDC,0x00,0x00,0x0C,0x00,0x00,0x7C,0x00,0x00,0xF0,0x00,0x00,0xC0,0x00,0x00,0xFC,0x00,0x00,0x7C,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 116 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0xFC,0x00,0x00,0xFC,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 117 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x8C,0x01,0x00,0x8C,0x01,0x00,0x8C,0x01,0x00,0x8C,0x01,0x00,0x8C,0x01,0x00,0x8C,0x01,0x00,0x8C,0x01,0x00,0xFC,0x01,0x00,0xF8,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 118 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x86,0x01,0x00,0x86,0x01,0x00,0x8C,0x00,0x00,0xCC,0x00,0x00,0xCC,0x00,0x00,0x78,0x00,0x00,0x78,0x00,0x00,0x38,0x00,0x00,0x30,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 119 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x8C,0x19,0x00,0x8C,0x19,0x00,0xCC,0x19,0x00,0xCC,0x0D,0x00,0xD8,0x0D,0x00,0x58,0x0D,0x00,0x78,0x0D,0x00,0x38,0x07,0x00,0x30,0x07,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 120 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x06,0x03,0x00,0x8E,0x03,0x00,0xDC,0x01,0x00,0xF8,0x00,0x00,0x70,0x00,0x00,0xF8,0x00,0x00,0xDC,0x01,0x00,0x8E,0x03,0x00,0x06,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 121 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x06,0x03,0x00,0x06,0x03,0x00,0x8C,0x01,0x00,0x8C,0x01,0x00,0xD8,0x00,0x00,0xD8,0x00,0x00,0x70,0x00,0x00,0x70,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x10,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x08,0x00,0x00,
                     /* Character Data - Index: 122 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFC,0x03,0x00,0xFC,0x03,0x00,0xC0,0x01,0x00,0xC0,0x00,0x00,0xE0,0x00,0x00,0x70,0x00,0x00,0x38,0x00,0x00,0xFC,0x03,0x00,0xFC,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 123 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x70,0x00,0x00,0x78,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0E,0x00,0x00,0x06,0x00,0x00,0x0E,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x0C,0x00,0x00,0x1C,0x00,0x00,0x78,0x00,0x00,0x70,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 124 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x30,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 125 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0E,0x00,0x00,0x1E,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x38,0x00,0x00,0x70,0x00,0x00,0x38,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x0E,0x00,0x00,0x0E,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 126 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x30,0x00,0x00,0x78,0x04,0x00,0xC8,0x06,0x00,0xCC,0x07,0x00,0x84,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
                     /* Character Data - Index: 127 */
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
             };
             /* Character bitmaps for Comic Sans MS 8pt */
             const uint8_t comicSansMS_8ptBitmaps[] =
             {
                 // @0 ' ' (11 pixels wide)
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @24 '!' (11 pixels wide)
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x00, 0x00, //
 x20, 0x00, //      #
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @48 '"' (11 pixels wide)
 x00, 0x00, //
 x50, 0x00, //     # #
 x50, 0x00, //     # #
 x50, 0x00, //     # #
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @72 '#' (11 pixels wide)
 x00, 0x00, //
 x10, 0x01, //     #   #
 x10, 0x01, //     #   #
 xFC, 0x03, //   ########
 x88, 0x00, //    #   #
 x88, 0x00, //    #   #
 xFE, 0x01, //  ########
 x44, 0x00, //   #   #
 x44, 0x00, //   #   #
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @96 '$' (11 pixels wide)
 x20, 0x00, //      #
 xF0, 0x00, //     ####
 x28, 0x00, //    # #
 x28, 0x00, //    # #
 x70, 0x00, //     ###
 xA0, 0x00, //      # #
 xA0, 0x00, //      # #
 xA0, 0x00, //      # #
 x78, 0x00, //    ####
 x20, 0x00, //      #
 x20, 0x00, //      #
 x00, 0x00, //
                 // @120 '%' (11 pixels wide)
 x80, 0x00, //        #
 xCC, 0x00, //   ##  ##
 x52, 0x00, //  #  # #
 x72, 0x00, //  #  ###
 x2C, 0x00, //   ## #
 xB0, 0x01, //     ## ##
 x50, 0x02, //     # #  #
 x58, 0x02, //    ## #  #
 x88, 0x01, //    #   ##
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @144 '&' (11 pixels wide)
 x00, 0x00, //
 x60, 0x00, //      ##
 x50, 0x00, //     # #
 x30, 0x00, //     ##
 xB8, 0x00, //    ### #
 xAC, 0x00, //   ## # #
 xC4, 0x00, //   #   ##
 x44, 0x00, //   #   #
 xB8, 0x00, //    ### #
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @168 ''' (11 pixels wide)
 x00, 0x00, //
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @192 '(' (11 pixels wide)
 x40, 0x00, //       #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x10, 0x00, //     #
 x10, 0x00, //     #
 x10, 0x00, //     #
 x10, 0x00, //     #
 x10, 0x00, //     #
 x10, 0x00, //     #
 x20, 0x00, //      #
 x40, 0x00, //       #
 x00, 0x00, //
                 // @216 ')' (11 pixels wide)
 x08, 0x00, //    #
 x10, 0x00, //     #
 x10, 0x00, //     #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x10, 0x00, //     #
 x08, 0x00, //    #
 x00, 0x00, //
                 // @240 '*' (11 pixels wide)
 x00, 0x00, //
 x10, 0x00, //     #
 x7C, 0x00, //   #####
 x38, 0x00, //    ###
 x2C, 0x00, //   ## #
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @264 '+' (11 pixels wide)
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x20, 0x00, //      #
 x20, 0x00, //      #
 xF8, 0x00, //    #####
 x20, 0x00, //      #
 x20, 0x00, //      #
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @288 ',' (11 pixels wide)
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x20, 0x00, //      #
 x10, 0x00, //     #
 x00, 0x00, //
 x00, 0x00, //
                 // @312 '-' (11 pixels wide)
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x70, 0x00, //     ###
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @336 '.' (11 pixels wide)
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x20, 0x00, //      #
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @360 '/' (11 pixels wide)
 x80, 0x00, //        #
 x40, 0x00, //       #
 x40, 0x00, //       #
 x40, 0x00, //       #
 x20, 0x00, //      #
 x10, 0x00, //     #
 x10, 0x00, //     #
 x08, 0x00, //    #
 x08, 0x00, //    #
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @384 '0' (11 pixels wide)
 x00, 0x00, //
 x70, 0x00, //     ###
 x88, 0x00, //    #   #
 x88, 0x00, //    #   #
 x88, 0x00, //    #   #
 x88, 0x00, //    #   #
 x88, 0x00, //    #   #
 x88, 0x00, //    #   #
 x70, 0x00, //     ###
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @408 '1' (11 pixels wide)
 x00, 0x00, //
 x20, 0x00, //      #
 x30, 0x00, //     ##
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x70, 0x00, //     ###
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @432 '2' (11 pixels wide)
 x00, 0x00, //
 x70, 0x00, //     ###
 x88, 0x00, //    #   #
 x80, 0x00, //        #
 x40, 0x00, //       #
 x20, 0x00, //      #
 x10, 0x00, //     #
 x08, 0x00, //    #
 xF8, 0x00, //    #####
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @456 '3' (11 pixels wide)
 x00, 0x00, //
 x70, 0x00, //     ###
 x88, 0x00, //    #   #
 x80, 0x00, //        #
 x70, 0x00, //     ###
 x80, 0x00, //        #
 x80, 0x00, //        #
 x88, 0x00, //    #   #
 x70, 0x00, //     ###
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @480 '4' (11 pixels wide)
 x00, 0x00, //
 x40, 0x00, //       #
 x60, 0x00, //      ##
 x50, 0x00, //     # #
 x50, 0x00, //     # #
 x48, 0x00, //    #  #
 xFC, 0x00, //   ######
 x40, 0x00, //       #
 x40, 0x00, //       #
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @504 '5' (11 pixels wide)
 x00, 0x00, //
 xF8, 0x00, //    #####
 x08, 0x00, //    #
 x78, 0x00, //    ####
 x88, 0x00, //    #   #
 x80, 0x00, //        #
 x80, 0x00, //        #
 x88, 0x00, //    #   #
 x70, 0x00, //     ###
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @528 '6' (11 pixels wide)
 x00, 0x00, //
 x40, 0x00, //       #
 x20, 0x00, //      #
 x10, 0x00, //     #
 x78, 0x00, //    ####
 x88, 0x00, //    #   #
 x88, 0x00, //    #   #
 x88, 0x00, //    #   #
 x70, 0x00, //     ###
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @552 '7' (11 pixels wide)
 x00, 0x00, //
 xFC, 0x00, //   ######
 x40, 0x00, //       #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x10, 0x00, //     #
 x10, 0x00, //     #
 x10, 0x00, //     #
 x08, 0x00, //    #
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @576 '8' (11 pixels wide)
 x00, 0x00, //
 x70, 0x00, //     ###
 x88, 0x00, //    #   #
 x88, 0x00, //    #   #
 x70, 0x00, //     ###
 x88, 0x00, //    #   #
 x88, 0x00, //    #   #
 x88, 0x00, //    #   #
 x70, 0x00, //     ###
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @600 '9' (11 pixels wide)
 x00, 0x00, //
 x70, 0x00, //     ###
 x88, 0x00, //    #   #
 x88, 0x00, //    #   #
 x88, 0x00, //    #   #
 xF0, 0x00, //     ####
 x40, 0x00, //       #
 x20, 0x00, //      #
 x18, 0x00, //    ##
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @624 ':' (11 pixels wide)
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x20, 0x00, //      #
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x20, 0x00, //      #
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @648 ';' (11 pixels wide)
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x20, 0x00, //      #
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x20, 0x00, //      #
 x10, 0x00, //     #
 x00, 0x00, //
 x00, 0x00, //
                 // @672 '<' (11 pixels wide)
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x20, 0x00, //      #
 x10, 0x00, //     #
 x08, 0x00, //    #
 x10, 0x00, //     #
 x20, 0x00, //      #
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @696 '=' (11 pixels wide)
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 xF0, 0x00, //     ####
 x00, 0x00, //
 x00, 0x00, //
 xF0, 0x00, //     ####
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @720 '>' (11 pixels wide)
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x08, 0x00, //    #
 x10, 0x00, //     #
 x20, 0x00, //      #
 x10, 0x00, //     #
 x08, 0x00, //    #
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @744 '?' (11 pixels wide)
 x00, 0x00, //
 x78, 0x00, //    ####
 x80, 0x00, //        #
 x80, 0x00, //        #
 x40, 0x00, //       #
 x20, 0x00, //      #
 x10, 0x00, //     #
 x00, 0x00, //
 x10, 0x00, //     #
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @768 '@' (11 pixels wide)
 xF8, 0x00, //    #####
 x04, 0x01, //   #     #
 x72, 0x02, //  #  ###  #
 xDA, 0x02, //  # ## ## #
 xCA, 0x02, //  # #  ## #
 xB2, 0x01, //  #  ## ##
 x02, 0x00, //  #
 x04, 0x01, //   #     #
 xF8, 0x00, //    #####
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @792 'A' (11 pixels wide)
 x00, 0x00, //
 x20, 0x00, //      #
 x20, 0x00, //      #
 x50, 0x00, //     # #
 x48, 0x00, //    #  #
 x78, 0x00, //    ####
 x44, 0x00, //   #   #
 x84, 0x00, //   #    #
 x82, 0x00, //  #     #
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @816 'B' (11 pixels wide)
 x00, 0x00, //
 x78, 0x00, //    ####
 x88, 0x00, //    #   #
 x88, 0x00, //    #   #
 x48, 0x00, //    #  #
 x78, 0x00, //    ####
 x88, 0x00, //    #   #
 x88, 0x00, //    #   #
 x78, 0x00, //    ####
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @840 'C' (11 pixels wide)
 x00, 0x00, //
 xE0, 0x00, //      ###
 x90, 0x00, //     #  #
 x08, 0x00, //    #
 x04, 0x00, //   #
 x04, 0x00, //   #
 x04, 0x00, //   #
 x84, 0x00, //   #    #
 x78, 0x00, //    ####
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @864 'D' (11 pixels wide)
 x00, 0x00, //
 x0C, 0x00, //   ##
 x34, 0x00, //   # ##
 x44, 0x00, //   #   #
 x84, 0x00, //   #    #
 x84, 0x00, //   #    #
 x84, 0x00, //   #    #
 x44, 0x00, //   #   #
 x3C, 0x00, //   ####
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @888 'E' (11 pixels wide)
 x00, 0x00, //
 xF8, 0x00, //    #####
 x08, 0x00, //    #
 x08, 0x00, //    #
 xF8, 0x00, //    #####
 x08, 0x00, //    #
 x08, 0x00, //    #
 x08, 0x00, //    #
 xF8, 0x00, //    #####
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @912 'F' (11 pixels wide)
 x00, 0x00, //
 xF0, 0x01, //     #####
 x10, 0x00, //     #
 x10, 0x00, //     #
 xF0, 0x00, //     ####
 x10, 0x00, //     #
 x10, 0x00, //     #
 x10, 0x00, //     #
 x10, 0x00, //     #
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @936 'G' (11 pixels wide)
 x00, 0x00, //
 xE0, 0x00, //      ###
 x10, 0x01, //     #   #
 x08, 0x00, //    #
 x04, 0x00, //   #
 xF4, 0x01, //   # #####
 x04, 0x01, //   #     #
 x84, 0x00, //   #    #
 x78, 0x00, //    ####
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @960 'H' (11 pixels wide)
 x00, 0x00, //
 x08, 0x01, //    #    #
 x08, 0x01, //    #    #
 x08, 0x01, //    #    #
 xF8, 0x01, //    ######
 x08, 0x01, //    #    #
 x08, 0x01, //    #    #
 x08, 0x01, //    #    #
 x08, 0x01, //    #    #
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @984 'I' (11 pixels wide)
 x00, 0x00, //
 x7C, 0x00, //   #####
 x10, 0x00, //     #
 x10, 0x00, //     #
 x10, 0x00, //     #
 x10, 0x00, //     #
 x10, 0x00, //     #
 x10, 0x00, //     #
 x7C, 0x00, //   #####
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @1008 'J' (11 pixels wide)
 x00, 0x00, //
 xF0, 0x01, //     #####
 x40, 0x00, //       #
 x40, 0x00, //       #
 x40, 0x00, //       #
 x40, 0x00, //       #
 x44, 0x00, //   #   #
 x44, 0x00, //   #   #
 x78, 0x00, //    ####
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @1032 'K' (11 pixels wide)
 x00, 0x00, //
 x88, 0x00, //    #   #
 x48, 0x00, //    #  #
 x28, 0x00, //    # #
 x18, 0x00, //    ##
 x18, 0x00, //    ##
 x28, 0x00, //    # #
 x48, 0x00, //    #  #
 x88, 0x00, //    #   #
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @1056 'L' (11 pixels wide)
 x00, 0x00, //
 x08, 0x00, //    #
 x08, 0x00, //    #
 x08, 0x00, //    #
 x08, 0x00, //    #
 x08, 0x00, //    #
 x08, 0x00, //    #
 x08, 0x00, //    #
 x78, 0x00, //    ####
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @1080 'M' (11 pixels wide)
 x00, 0x00, //
 x44, 0x00, //   #   #
 x44, 0x00, //   #   #
 x44, 0x00, //   #   #
 xAA, 0x00, //  # # # #
 xAA, 0x00, //  # # # #
 xAA, 0x00, //  # # # #
 x11, 0x01, // #   #   #
 x11, 0x01, // #   #   #
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @1104 'N' (11 pixels wide)
 x00, 0x00, //
 x04, 0x01, //   #     #
 x0C, 0x01, //   ##    #
 x14, 0x01, //   # #   #
 x14, 0x01, //   # #   #
 x24, 0x01, //   #  #  #
 x44, 0x01, //   #   # #
 x84, 0x01, //   #    ##
 x04, 0x01, //   #     #
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @1128 'O' (11 pixels wide)
 x00, 0x00, //
 xF0, 0x00, //     ####
 x08, 0x01, //    #    #
 x04, 0x01, //   #     #
 x04, 0x01, //   #     #
 x04, 0x01, //   #     #
 x04, 0x01, //   #     #
 x84, 0x00, //   #    #
 x78, 0x00, //    ####
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @1152 'P' (11 pixels wide)
 x00, 0x00, //
 x70, 0x00, //     ###
 x90, 0x00, //     #  #
 x90, 0x00, //     #  #
 x90, 0x00, //     #  #
 x90, 0x00, //     #  #
 x70, 0x00, //     ###
 x10, 0x00, //     #
 x10, 0x00, //     #
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @1176 'Q' (11 pixels wide)
 x00, 0x00, //
 xF0, 0x00, //     ####
 x08, 0x01, //    #    #
 x04, 0x02, //   #      #
 x04, 0x02, //   #      #
 x04, 0x02, //   #      #
 x24, 0x02, //   #  #   #
 x48, 0x01, //    #  # #
 xF0, 0x01, //     #####
 x00, 0x03, //         ##
 x00, 0x02, //          #
 x00, 0x00, //
                 // @1200 'R' (11 pixels wide)
 x00, 0x00, //
 x38, 0x00, //    ###
 x48, 0x00, //    #  #
 x48, 0x00, //    #  #
 x48, 0x00, //    #  #
 x38, 0x00, //    ###
 x28, 0x00, //    # #
 x48, 0x00, //    #  #
 x88, 0x00, //    #   #
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @1224 'S' (11 pixels wide)
 x00, 0x00, //
 xE0, 0x01, //      ####
 x10, 0x00, //     #
 x10, 0x00, //     #
 xE0, 0x00, //      ###
 x00, 0x01, //         #
 x00, 0x01, //         #
 x08, 0x01, //    #    #
 xF0, 0x00, //     ####
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @1248 'T' (11 pixels wide)
 x00, 0x00, //
 xFC, 0x01, //   #######
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @1272 'U' (11 pixels wide)
 x00, 0x00, //
 x84, 0x00, //   #    #
 x84, 0x00, //   #    #
 x84, 0x00, //   #    #
 x84, 0x00, //   #    #
 x84, 0x00, //   #    #
 x84, 0x00, //   #    #
 x84, 0x00, //   #    #
 x78, 0x00, //    ####
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @1296 'V' (11 pixels wide)
 x00, 0x00, //
 x88, 0x00, //    #   #
 x88, 0x00, //    #   #
 x88, 0x00, //    #   #
 x50, 0x00, //     # #
 x50, 0x00, //     # #
 x50, 0x00, //     # #
 x50, 0x00, //     # #
 x20, 0x00, //      #
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @1320 'W' (11 pixels wide)
 x00, 0x00, //
 x21, 0x04, // #    #    #
 x21, 0x04, // #    #    #
 x52, 0x02, //  #  # #  #
 x52, 0x02, //  #  # #  #
 x4A, 0x01, //  # #  # #
 x4A, 0x01, //  # #  # #
 x44, 0x01, //   #   # #
 x84, 0x00, //   #    #
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @1344 'X' (11 pixels wide)
 x00, 0x00, //
 x82, 0x00, //  #     #
 x44, 0x00, //   #   #
 x28, 0x00, //    # #
 x10, 0x00, //     #
 x10, 0x00, //     #
 x28, 0x00, //    # #
 x44, 0x00, //   #   #
 x82, 0x00, //  #     #
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @1368 'Y' (11 pixels wide)
 x00, 0x00, //
 x84, 0x00, //   #    #
 x48, 0x00, //    #  #
 x48, 0x00, //    #  #
 x50, 0x00, //     # #
 x30, 0x00, //     ##
 x20, 0x00, //      #
 x10, 0x00, //     #
 x10, 0x00, //     #
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @1392 'Z' (11 pixels wide)
 x00, 0x00, //
 xFC, 0x01, //   #######
 x80, 0x00, //        #
 x40, 0x00, //       #
 x20, 0x00, //      #
 x10, 0x00, //     #
 x08, 0x00, //    #
 x04, 0x00, //   #
 xFC, 0x01, //   #######
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @1416 '[' (11 pixels wide)
 x70, 0x00, //     ###
 x10, 0x00, //     #
 x10, 0x00, //     #
 x10, 0x00, //     #
 x10, 0x00, //     #
 x10, 0x00, //     #
 x10, 0x00, //     #
 x10, 0x00, //     #
 x10, 0x00, //     #
 x10, 0x00, //     #
 x70, 0x00, //     ###
 x00, 0x00, //
                 // @1440 '\' (11 pixels wide)
 x00, 0x00, //
 x08, 0x00, //    #
 x08, 0x00, //    #
 x10, 0x00, //     #
 x10, 0x00, //     #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x40, 0x00, //       #
 x40, 0x00, //       #
 x00, 0x00, //
 x00, 0x00, //
                 // @1464 ']' (11 pixels wide)
 x38, 0x00, //    ###
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x38, 0x00, //    ###
 x00, 0x00, //
                 // @1488 '^' (11 pixels wide)
 x30, 0x00, //     ##
 x30, 0x00, //     ##
 x48, 0x00, //    #  #
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @1512 '_' (11 pixels wide)
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 xFC, 0x01, //   #######
 x00, 0x00, //
                 // @1536 '`' (11 pixels wide)
 x04, 0x00, //   #
 x08, 0x00, //    #
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @1560 'a' (11 pixels wide)
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 xE0, 0x00, //      ###
 x90, 0x00, //     #  #
 x88, 0x00, //    #   #
 x88, 0x00, //    #   #
 x88, 0x00, //    #   #
 x70, 0x01, //     ### #
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @1584 'b' (11 pixels wide)
 x08, 0x00, //    #
 x08, 0x00, //    #
 x08, 0x00, //    #
 x78, 0x00, //    ####
 x88, 0x00, //    #   #
 x88, 0x00, //    #   #
 x88, 0x00, //    #   #
 x88, 0x00, //    #   #
 x78, 0x00, //    ####
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @1608 'c' (11 pixels wide)
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x60, 0x00, //      ##
 x90, 0x00, //     #  #
 x08, 0x00, //    #
 x08, 0x00, //    #
 x88, 0x00, //    #   #
 x70, 0x00, //     ###
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @1632 'd' (11 pixels wide)
 x80, 0x00, //        #
 x80, 0x00, //        #
 x80, 0x00, //        #
 xF0, 0x00, //     ####
 x88, 0x00, //    #   #
 x88, 0x00, //    #   #
 x88, 0x00, //    #   #
 x88, 0x00, //    #   #
 xF0, 0x00, //     ####
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @1656 'e' (11 pixels wide)
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x38, 0x00, //    ###
 x44, 0x00, //   #   #
 x24, 0x00, //   #  #
 x1C, 0x00, //   ###
 x44, 0x00, //   #   #
 x38, 0x00, //    ###
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @1680 'f' (11 pixels wide)
 xC0, 0x00, //       ##
 x20, 0x00, //      #
 x20, 0x00, //      #
 xF8, 0x00, //    #####
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @1704 'g' (11 pixels wide)
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x30, 0x00, //     ##
 x48, 0x00, //    #  #
 x44, 0x00, //   #   #
 x44, 0x00, //   #   #
 x44, 0x00, //   #   #
 x78, 0x00, //    ####
 x40, 0x00, //       #
 x20, 0x00, //      #
 x1C, 0x00, //   ###
                 // @1728 'h' (11 pixels wide)
 x08, 0x00, //    #
 x08, 0x00, //    #
 x08, 0x00, //    #
 x68, 0x00, //    # ##
 x98, 0x00, //    ##  #
 x88, 0x00, //    #   #
 x88, 0x00, //    #   #
 x88, 0x00, //    #   #
 x88, 0x00, //    #   #
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @1752 'i' (11 pixels wide)
 x00, 0x00, //
 x20, 0x00, //      #
 x00, 0x00, //
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @1776 'j' (11 pixels wide)
 x00, 0x00, //
 x10, 0x00, //     #
 x00, 0x00, //
 x10, 0x00, //     #
 x10, 0x00, //     #
 x10, 0x00, //     #
 x10, 0x00, //     #
 x10, 0x00, //     #
 x10, 0x00, //     #
 x10, 0x00, //     #
 x12, 0x00, //  #  #
 x0C, 0x00, //   ##
                 // @1800 'k' (11 pixels wide)
 x04, 0x00, //   #
 x04, 0x00, //   #
 x04, 0x00, //   #
 x44, 0x00, //   #   #
 x24, 0x00, //   #  #
 x14, 0x00, //   # #
 x1C, 0x00, //   ###
 x24, 0x00, //   #  #
 x44, 0x00, //   #   #
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @1824 'l' (11 pixels wide)
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @1848 'm' (11 pixels wide)
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x94, 0x00, //   # #  #
 x6C, 0x01, //   ## ## #
 x24, 0x01, //   #  #  #
 x24, 0x01, //   #  #  #
 x24, 0x01, //   #  #  #
 x24, 0x01, //   #  #  #
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @1872 'n' (11 pixels wide)
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x68, 0x00, //    # ##
 x98, 0x00, //    ##  #
 x88, 0x00, //    #   #
 x88, 0x00, //    #   #
 x88, 0x00, //    #   #
 x88, 0x00, //    #   #
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @1896 'o' (11 pixels wide)
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x70, 0x00, //     ###
 x88, 0x00, //    #   #
 x88, 0x00, //    #   #
 x88, 0x00, //    #   #
 x88, 0x00, //    #   #
 x70, 0x00, //     ###
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @1920 'p' (11 pixels wide)
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x3C, 0x00, //   ####
 x44, 0x00, //   #   #
 x44, 0x00, //   #   #
 x44, 0x00, //   #   #
 x44, 0x00, //   #   #
 x3C, 0x00, //   ####
 x04, 0x00, //   #
 x04, 0x00, //   #
 x04, 0x00, //   #
                 // @1944 'q' (11 pixels wide)
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 xE0, 0x00, //      ###
 x90, 0x00, //     #  #
 x88, 0x00, //    #   #
 x88, 0x00, //    #   #
 x88, 0x00, //    #   #
 xF0, 0x00, //     ####
 x80, 0x00, //        #
 x80, 0x00, //        #
 x80, 0x00, //        #
                 // @1968 'r' (11 pixels wide)
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x70, 0x00, //     ###
 x50, 0x00, //     # #
 x10, 0x00, //     #
 x10, 0x00, //     #
 x10, 0x00, //     #
 x10, 0x00, //     #
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @1992 's' (11 pixels wide)
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x70, 0x00, //     ###
 x08, 0x00, //    #
 x10, 0x00, //     #
 x20, 0x00, //      #
 x40, 0x00, //       #
 x38, 0x00, //    ###
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @2016 't' (11 pixels wide)
 x00, 0x00, //
 x10, 0x00, //     #
 x10, 0x00, //     #
 x38, 0x00, //    ###
 x10, 0x00, //     #
 x10, 0x00, //     #
 x10, 0x00, //     #
 x10, 0x00, //     #
 x10, 0x00, //     #
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @2040 'u' (11 pixels wide)
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x88, 0x00, //    #   #
 x88, 0x00, //    #   #
 x88, 0x00, //    #   #
 x88, 0x00, //    #   #
 x88, 0x00, //    #   #
 xF0, 0x00, //     ####
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @2064 'v' (11 pixels wide)
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x88, 0x00, //    #   #
 x88, 0x00, //    #   #
 x50, 0x00, //     # #
 x50, 0x00, //     # #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @2088 'w' (11 pixels wide)
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x24, 0x01, //   #  #  #
 x24, 0x01, //   #  #  #
 xB4, 0x00, //   # ## #
 xB4, 0x00, //   # ## #
 xA8, 0x00, //    # # #
 x48, 0x00, //    #  #
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @2112 'x' (11 pixels wide)
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x84, 0x00, //   #    #
 x48, 0x00, //    #  #
 x30, 0x00, //     ##
 x30, 0x00, //     ##
 x48, 0x00, //    #  #
 x84, 0x00, //   #    #
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @2136 'y' (11 pixels wide)
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x08, 0x01, //    #    #
 x88, 0x00, //    #   #
 x90, 0x00, //     #  #
 x50, 0x00, //     # #
 x60, 0x00, //      ##
 x20, 0x00, //      #
 x20, 0x00, //      #
 x10, 0x00, //     #
 x10, 0x00, //     #
                 // @2160 'z' (11 pixels wide)
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x78, 0x00, //    ####
 x40, 0x00, //       #
 x20, 0x00, //      #
 x10, 0x00, //     #
 x08, 0x00, //    #
 x78, 0x00, //    ####
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
                 // @2184 '{' (11 pixels wide)
 x60, 0x00, //      ##
 x10, 0x00, //     #
 x10, 0x00, //     #
 x10, 0x00, //     #
 x10, 0x00, //     #
 x18, 0x00, //    ##
 x10, 0x00, //     #
 x10, 0x00, //     #
 x10, 0x00, //     #
 x10, 0x00, //     #
 x60, 0x00, //      ##
 x00, 0x00, //
                 // @2208 '|' (11 pixels wide)
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x00, 0x00, //
                 // @2232 '}' (11 pixels wide)
 x18, 0x00, //    ##
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x60, 0x00, //      ##
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x20, 0x00, //      #
 x18, 0x00, //    ##
 x00, 0x00, //
                 // @2256 '~' (11 pixels wide)
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x98, 0x00, //    ##  #
 x9C, 0x00, //   ###  #
 x64, 0x00, //   #  ##
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
 x00, 0x00, //
             };
             sFONT ComicSansMS_18 = {
               .table = ComicSansMS_18_TBL,
               .Width = 16,
               .Height = 18,
               .bytesPerLine = 2
             };
             sFONT ComicSansMS_24 = {
               .table = ComicSansMS_24_TBL,
               .Width = 19,
               .Height = 24,
               .bytesPerLine = 3
             };
             sFONT ComicSansMS_8 = {
               .table = comicSansMS_8ptBitmaps,
               .Width = 11,
               .Height = 12,
               .bytesPerLine = 2
             };
             const uint8_t Monk_TBL[] = {
 x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xF8,0x7F,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFC,0xFF,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xEE,0xFF,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0xFF,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,0xAF,0xFB,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xC0,0xDF,0xFF,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xE0,0xEF,0xFF,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xB0,0xFF,0xFF,0x07,0x00,0x00,0x00,0x00,0x00,0x40,0x01,0x00,0x00,0x00,0x00,0x00,0xF0,0xFF,0xFF,0x0F,0x00,0x00,0x00,0x00,0x00,0xF8,0x07,0x00,0x00,0x00,0x00,0x00,0xB0,0xFF,0xFF,0x07,0x00,0x00,0x00,0x00,0x00,0xFE,0x3F,0x00,0x00,0x00,0x00,0x00,0xF0,0xDF,0xFF,0x07,0x00,0x00,0x00,0x00,0x00,0xAF,0xFA,0x00,0x00,0x00,0x00,0x00,0x70,0x7F,0xFB,0x07,0x00,0x00,0x00,0x00,0x00,0xFF,0xFE,0x00,0x00,0x00,0x00,0x00,0xE0,0xDF,0xFE,0x03,0x00,0x00,0x00,0x00,0x80,0x6F,0xFD,0x01,0x00,0x00,0x00,0x00,0xA0,0xFF,0xDE,0x01,0x00,0x00,0x00,0x00,0x00,0xFF,0xFF,0x03,0x00,0x00,0x00,0x00,0xC0,0xBF,0xF5,0x03,0x00,0x00,0x00,0x00,0x80,0xFF,0xFD,0x03,0x00,0x00,0x00,0x00,0xC0,0x7F,0xFD,0x01,0x00,0x00,0x00,0x00,0x80,0xB5,0xFF,0x03,0x00,0x00,0x00,0x00,0xC0,0x5F,0xDB,0x01,0x00,0x00,0x00,0x00,0xC0,0xED,0xFF,0x03,0x00,0x00,0x00,0x00,0xC0,0xFF,0xFF,0x01,0x00,0x00,0x00,0x00,0xE0,0xAA,0xFF,0x03,0x00,0x00,0x00,0x00,0x40,0xBF,0xFA,0x01,0x00,0x00,0x00,0x00,0xE0,0xF6,0xFF,0x07,0x00,0x00,0x00,0x00,0x60,0xBE,0xFB,0x01,0x00,0x00,0x00,0x00,0xF0,0xBA,0xFF,0x03,0x00,0x00,0x00,0x00,0x70,0xBC,0xEE,0x00,0x00,0x00,0x00,0x00,0xF0,0xF6,0xFF,0x07,0x00,0x00,0x00,0x00,0x7C,0x75,0xBD,0x00,0x00,0x00,0x00,0x00,0xF0,0xAA,0xFF,0x0F,0x00,0x00,0x00,0x00,0x7E,0xF0,0xFE,0x01,0x00,0x00,0x00,0x00,0xE0,0xF5,0xFF,0x0F,0x00,0x00,0x00,0x80,0xFF,0xF0,0xF5,0x07,0x00,0x00,0x00,0x00,0xE0,0xFB,0xFF,0x07,0x00,0x00,0x00,0xE0,0x7F,0xF4,0xFF,0x0F,0x00,0x00,0x00,0x00,0xE0,0xFF,0xFF,0x03,0x00,0x00,0x00,0xF8,0xFF,0xC8,0xEF,0x3F,0x00,0x00,0x00,0x00,0xE0,0xFF,0xFF,0x07,0x00,0x00,0x00,0xFC,0xFF,0x8A,0xFF,0x7F,0x00,0x00,0x00,0x00,0x00,0xBE,0xFD,0x07,0x00,0x00,0x00,0xFF,0xFF,0x90,0xFF,0xFF,0x00,0x00,0x00,0x00,0x80,0x5F,0xEA,0x0F,0x00,0x00,0x80,0xFF,0xFF,0xA2,0xF7,0xFF,0x01,0x00,0x00,0x00,0xE0,0x3F,0xF8,0x1F,0x00,0x00,0x80,0xFF,0xFF,0x80,0xBF,0xFF,0x03,0x00,0x00,0x00,0xF8,0x1E,0xF8,0x7F,0x00,0x00,0xC0,0xFF,0xFF,0xC9,0x5F,0xFF,0x0F,0x00,0x00,0x00,0x3F,0x0E,0xFD,0xFF,0x01,0x00,0xC0,0xFF,0xFF,0x81,0xBF,0xFF,0x0F,0x00,0x00,0xC0,0x9F,0x27,0xFE,0xFF,0x07,0x00,0xC0,0xFF,0xFF,0x91,0xBF,0xFF,0x0F,0x00,0x00,0xE0,0x9F,0x0F,0xFE,0xFF,0x0F,0x00,0xE0,0xFF,0xFF,0xC1,0x5F,0xFF,0x0F,0x00,0x00,0xE0,0xCF,0x07,0xFF,0xFF,0x0F,0x00,0xE0,0xFF,0xFF,0x89,0xBF,0xFF,0x1F,0x00,0x00,0xC0,0xE7,0x87,0xFF,0xFF,0x0F,0x00,0xE0,0xFF,0xFF,0xC1,0xBF,0xFF,0x1F,0x00,0x00,0xE0,0xE7,0xC7,0xFF,0xFF,0x1F,0x00,0xE0,0xFF,0xFF,0x89,0xBF,0xFF,0x1F,0x00,0x00,0xF0,0xF3,0xC3,0xFF,0xFF,0x1F,0x00,0xE0,0xFF,0xFF,0xC3,0xFF,0xFF,0x1F,0x00,0x00,0xF8,0xF3,0xE3,0xFF,0xFF,0x1F,0x00,0xE0,0xFF,0xFF,0x81,0xDF,0xFF,0x1F,0x00,0x00,0xF8,0xF3,0xE1,0xFF,0xFF,0x3F,0x00,0xF0,0xFF,0xFF,0xD3,0xBF,0xFF,0x1F,0x00,0x00,0xF0,0xFB,0xF3,0xFF,0xFF,0x3F,0x00,0xE0,0xFF,0xFF,0x83,0xDF,0xFF,0x3F,0x00,0x00,0xF8,0xF9,0xF1,0xFF,0xFF,0x3F,0x00,0xE0,0xFF,0xFF,0xA3,0xFF,0xFF,0x1F,0x00,0x00,0xF8,0xF9,0xF9,0xFF,0xFF,0x3F,0x00,0xF0,0xFF,0xFF,0xC3,0xDF,0xFF,0x1F,0x00,0x00,0xF8,0xF9,0xF9,0xFF,0xFF,0x3F,0x00,0xE0,0xFF,0xFF,0xD3,0xDF,0xFF,0x1F,0x00,0x00,0xF8,0xFC,0xF8,0xFF,0xFF,0x7F,0x00,0xE0,0xFF,0xFF,0xC3,0xFF,0xFF,0x1F,0x00,0x00,0xF8,0xFC,0xFD,0xFF,0xFF,0x3F,0x00,0xE0,0xFF,0xFF,0xCB,0xDF,0xFF,0x1F,0x00,0x00,0xF8,0xFD,0xFC,0xFF,0xFF,0x7F,0x00,0xE0,0xFF,0xFF,0xE7,0xDF,0xFF,0x0F,0x00,0x00,0xFC,0xFC,0xFE,0xFF,0xFF,0x7F,0x00,0xE0,0xFF,0xFF,0xC3,0xDF,0xFF,0x0F,0x00,0x00,0xFE,0xFE,0xFE,0xFF,0xFF,0x7F,0x00,0xE0,0xFF,0xFF,0xD7,0xDF,0xFF,0x0F,0x00,0x00,0xFE,0xFE,0xFF,0xFF,0xFF,0x7F,0x00,0xE0,0xFF,0xFF,0xE7,0xDF,0xFF,0x0F,0x00,0x00,0xFC,0xFE,0xFF,0xFF,0xFF,0x7F,0x00,0xC0,0xFF,0xFF,0xE3,0xDF,0xFF,0x0F,0x00,0x00,0xFC,0xFE,0xFF,0xFF,0xFF,0x7F,0x00,0xE0,0xFF,0xFF,0xD7,0xDF,0xFF,0x0F,0x00,0x00,0x7C,0xFE,0xFF,0xFF,0xFF,0x7F,0x00,0xC0,0xFF,0xFF,0xE7,0xDF,0xFF,0x0F,0x00,0x00,0x7C,0xFF,0xFF,0xFF,0xFF,0xFF,0x00,0xC0,0xFF,0xFF,0xE7,0xDF,0xFF,0x0F,0x00,0x00,0x78,0xFE,0xFF,0xFF,0xFF,0x7F,0x00,0xC0,0xFF,0xFF,0xCF,0xDF,0xFF,0x0F,0x00,0x00,0x7C,0xFF,0xFF,0xFF,0xFF,0x7F,0x00,0xC0,0xFF,0xFF,0xEF,0xDF,0xFF,0x0F,0x00,0x00,0x7C,0xFF,0xFF,0xFF,0xFF,0x7F,0x00,0xC0,0xFF,0xFF,0xEF,0xFF,0xFF,0x1F,0x00,0x00,0x3E,0xFF,0xFF,0xFF,0xFF,0x3F,0x00,0x80,0xFF,0xFF,0xEF,0xFF,0xFF,0x0F,0x00,0x00,0x3E,0xFF,0xFF,0xFF,0xFF,0x3F,0x00,0x80,0xFF,0xFF,0xFF,0xFF,0xFF,0x0F,0x00,0x00,0x3E,0xFF,0xFF,0xFF,0xFF,0x7F,0x00,0x80,0xFF,0xFF,0xEF,0xFF,0xFF,0x0F,0x00,0x00,0x1F,0xFF,0xFF,0xFF,0xFF,0x3F,0x00,0x80,0xFF,0xFF,0xFF,0xFF,0xFF,0x07,0x00,0x00,0x5F,0xFF,0xFF,0xFF,0xFF,0x3F,0x00,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0x07,0x00,0x80,0x9F,0xFF,0xFF,0xFF,0xFF,0x1F,0x00,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0x07,0x00,0x80,0x1F,0xFF,0xFF,0xFF,0xFF,0x3F,0x00,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0x07,0x00,0x80,0x9F,0xFF,0xFF,0xFF,0xFF,0x1F,0x00,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0x0F,0x00,0xC0,0xBF,0xFF,0xFF,0xFF,0xFF,0x1F,0x00,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0x0F,0x00,0xC0,0xBF,0xFF,0xFF,0xFF,0xFF,0x1F,0x00,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0x0F,0x00,0xE0,0xFF,0xFF,0xFF,0xFF,0xFF,0x1F,0x00,0x00,0xFE,0xFF,0xFF,0xFF,0xFF,0x07,0x00,0xE0,0xFF,0xFF,0xFF,0xFF,0xFF,0x0F,0x00,0x00,0xFE,0xFF,0xFF,0xFF,0xFF,0x07,0x00,0xF0,0xFF,0xFF,0xFF,0xFF,0xA3,0x0F,0x00,0x00,0xFE,0xFF,0xFF,0xFF,0xFF,0x07,0x00,0xF0,0xFF,0xFF,0xFF,0xFF,0x0B,0x0E,0x00,0x00,0xFE,0xFF,0xFF,0xFF,0xFF,0x03,0x00,0xF8,0xFF,0xFF,0xFF,0xFF,0x7F,0x0D,0x00,0x00,0xFE,0xFF,0xFF,0xFF,0xFF,0x03,0x00,0xF8,0xFF,0xFF,0xFF,0xFF,0xFF,0x0B,0x00,0x00,0xFE,0xFF,0xFF,0xFF,0xCF,0x03,0x00,0xF8,0xFF,0xFF,0xFF,0xFF,0xFF,0x07,0x00,0x00,0xFF,0xFF,0xFF,0xFF,0x1F,0x03,0x00,0xFC,0xFF,0xFF,0xFF,0xFF,0xFF,0x07,0x00,0x00,0xFE,0xFF,0xFF,0xFF,0x3F,0x02,0x00,0xFC,0xFF,0xFF,0xFF,0xFF,0xFF,0x03,0x00,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0x00,0x00,0xFE,0xFF,0xFF,0xFF,0xFF,0xFF,0x03,0x00,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0x00,0x00,0xFE,0xFF,0xFF,0xFF,0xFF,0xFF,0x01,0x00,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0x01,0x00,0xFE,0xFF,0xFF,0xFF,0xFF,0xFF,0x01,0x00,0x00,0xFF,0xE1,0xFF,0xFF,0x7F,0x03,0x00,0xFE,0xFF,0xFF,0xFF,0xFF,0xFF,0x03,0x00,0x00,0x3F,0xFC,0xFF,0xFF,0xFF,0x03,0x00,0xFC,0xFF,0xFF,0xFF,0xFF,0xFF,0x01,0x00,0x00,0xBF,0xBF,0xFF,0xFF,0xFF,0x03,0x00,0xF0,0xFF,0xFF,0xFF,0xFF,0xFF,0x03,0x00,0x80,0xDF,0xFF,0xFF,0xFD,0xFF,0x07,0x00,0xE0,0xFF,0xFF,0xFF,0xFF,0xFF,0x03,0x00,0x80,0xFF,0xFF,0xFF,0xFF,0xFF,0x07,0x00,0xE0,0xFF,0xFF,0xFF,0xFF,0xFF,0x07,0x00,0xC0,0xFF,0xFF,0x7E,0xFF,0xFF,0x0F,0x00,0xC0,0xFF,0xFF,0xFF,0xFF,0xFF,0x0F,0x00,0xC0,0xFF,0xFF,0xD7,0xFF,0xFF,0x0F,0x00,0xC0,0xFF,0xFF,0xFF,0xFF,0xFF,0x0F,0x00,0xE0,0xFF,0xFF,0xFF,0xFF,0xFF,0x1F,0x00,0x80,0xFF,0xFF,0xFF,0xFF,0xFF,0x0F,0x00,0xE0,0xFF,0xFF,0xFB,0xFF,0xFF,0x1F,0x00,0xC0,0xFF,0xFF,0xFF,0xFF,0xFF,0x0F,0x00,0xF0,0xFF,0xFF,0xEE,0xFF,0xFF,0x1F,0x00,0xC0,0xFF,0xFF,0xFF,0xFF,0xFF,0x0F,0x00,0xF0,0xFF,0xFF,0xFB,0xFF,0xFF,0x1F,0x00,0xC0,0xFF,0xFF,0xFF,0xFF,0xFF,0x07,0x00,0xF0,0xFF,0xFF,0xFE,0xFF,0xFF,0x3F,0x00,0xE0,0xFF,0xFF,0xFF,0xFF,0xFF,0x07,0x00,0xF0,0xFF,0xFF,0xFF,0xFE,0xFF,0x3F,0x00,0xE0,0xFF,0xFF,0xFF,0xFF,0xFF,0x03,0x00,0xF8,0xFF,0xFF,0xFB,0xFF,0xFF,0x7F,0x00,0xE0,0xFF,0xFF,0xFF,0xFF,0xFF,0x01,0x00,0xF8,0xFF,0xFF,0xBF,0xFF,0xFF,0x7F,0x00,0xF0,0xFF,0xFF,0xFF,0xFF,0xFF,0x01,0x00,0xFC,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0x00,0xE0,0xFF,0xFF,0xFF,0xFF,0xFF,0x00,0x00,0xFC,0xFF,0xFF,0x07,0xFF,0xFF,0x7F,0x00,0xE0,0xFF,0xFF,0xFF,0xFF,0xFF,0x01,0x00,0xFC,0xFF,0xFF,0x07,0xFF,0xFF,0xFF,0x00,0xE0,0xFF,0xFF,0xFF,0xFF,0xFF,0x01,0x00,0xFC,0xFF,0xFF,0x03,0xFF,0xFF,0xFF,0x00,0xE0,0xFF,0xFF,0xFF,0xFF,0xFF,0x01,0x00,0xFC,0xFF,0xFF,0x03,0xFF,0xFF,0x7F,0x00,0xC0,0xFF,0xFF,0xFD,0xFF,0xFF,0x03,0x00,0xFC,0xFF,0xFF,0x01,0xFE,0xFF,0xFF,0x00,0xC0,0xFF,0xFF,0xF9,0xFF,0xFF,0x03,0x00,0xFC,0xFF,0x7F,0x00,0xFC,0xFF,0x7F,0x00,0xC0,0xFF,0xFF,0xF9,0xFF,0xFF,0x07,0x00,0xFC,0xFF,0x3F,0x00,0xFC,0xFF,0x7F,0x00,0xC0,0xFF,0xFF,0xF9,0xFF,0xFF,0x03,0x00,0xFC,0xFF,0x3F,0x00,0xF8,0xFF,0xFF,0x00,0xC0,0xFF,0xFF,0xF1,0xFF,0xFF,0x07,0x00,0xFC,0xFF,0x1F,0x00,0xF0,0xFF,0x7F,0x00,0xC0,0xFF,0xFF,0xF1,0xFF,0xFF,0x07,0x00,0xFC,0xFF,0x0F,0x00,0xE0,0xFF,0x7F,0x00,0xC0,0xFF,0xFF,0xE1,0xFF,0xFF,0x07,0x00,0xFE,0xFF,0x0F,0x00,0xC0,0xFF,0x7F,0x00,0x80,0xFF,0xFF,0xE1,0xFF,0xFF,0x07,0x00,0xFE,0xFF,0x0F,0x00,0x80,0xFF,0x7F,0x00,0xC0,0xFF,0xFF,0xE1,0xFF,0xFF,0x07,0x00,0xFE,0xFF,0x07,0x00,0x00,0xFF,0x7F,0x00,0x80,0xFF,0xFF,0xC1,0xFF,0xFF,0x07,0x00,0xFE,0xFF,0x07,0x00,0x00,0xFF,0xFF,0x00,0x80,0xFF,0xFF,0xC1,0xFF,0xFF,0x07,0x00,0xFF,0xFF,0x03,0x00,0x00,0xFF,0x7F,0x00,0x00,0xFF,0xFF,0x81,0xFF,0xFF,0x07,0x00,0xFF,0xFF,0x01,0x00,0x00,0xFF,0x7F,0x00,0x80,0xFF,0xFF,0x80,0xFF,0xFF,0x03,0x00,0xFF,0xFF,0x00,0x00,0x00,0xFF,0xFF,0x00,0x80,0xFF,0xFF,0x80,0xFF,0xFF,0x07,0x80,0xFF,0xFF,0x00,0x00,0x00,0xFF,0x7F,0x00,0xE8,0xFF,0xFF,0x00,0xFF,0xFF,0x0F,0x80,0xFF,0x7F,0x00,0x00,0x80,0xFF,0xFF,0x00,0xFC,0xFF,0x7F,0x00,0xFE,0xFF,0x1F,0x80,0xFF,0x7F,0x00,0x00,0x80,0xFF,0xFF,0x00,0xFE,0xFF,0x3F,0x00,0xC0,0xFF,0x1F,0x80,0xFF,0x7F,0x00,0x00,0x80,0xFF,0xFF,0x00,0xBE,0xFF,0x1F,0x00,0xC0,0xFF,0x1F,0x80,0xFF,0x7F,0x00,0x00,0x80,0xFF,0xFF,0x01,0x04,0xFC,0x07,0x00,0xC0,0xFF,0x1F,0xC0,0xFF,0x7F,0x00,0x00,0xC0,0xFF,0xFF,0x1F,0x00,0x3C,0x00,0x00,0xF0,0xFF,0x07,0xC0,0xFF,0x7F,0x00,0x00,0x80,0xFF,0xFF,0x1F,0x00,0x00,0x00,0x00,0xF0,0xDD,0x0E,0x80,0xFF,0x7F,0x00,0x00,0x00,0xFE,0xFF,0x3B,0x00,0x00,0x00,0x00,0x50,0xE0,0x03,0xF0,0xFF,0x7F,0x00,0x00,0x00,0x80,0xFF,0x2E,0x00,0x00,0x00,0x00,0x00,0x40,0x01,0xF8,0xFF,0x3F,0x00,0x00,0x00,0x00,0x1A,0x30,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xEC,0x55,0x0F,0x00,0x00,0x00,0x00,0x1C,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x78,0xD2,0x05,0x00,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0E,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
             };
             sFONT  Monk_24 = {
               .table = Monk_TBL,
               .Width = 0x7F,
               .Height = 0x7E,
               .bytesPerLine = 16
             };

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

             /*------------------------------------------------------------------------------
             --  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
+            --                   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_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*(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);
+                //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->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_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/TC_CONTROLERS/STMPE811/STMPE811.c +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2013, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
-            --                   Mail : alexis.jeandet@gmail.com
+            --                   Mail : alexis.jeandet@member.fsf.org
             -------------------------------------------------------------------------------*/
             #include <STMPE811.h>
             int stmpe811init(STMPE811_t *dev, i2c_t i2cdev, uint8_t A0)
             {
                 dev->devAddress = 0x82;
                 if(A0) dev->devAddress = 0x88;
                 dev->i2cdev = i2cdev;
                 return 1;
             }
             int stmpe811getID(STMPE811_t *dev)
             {
                 if(dev != NULL)
                 {
                     char DATA[2];
                     DATA[0]=STMPE811_REGISTER_CHIP_ID;
                     i2cwrite(dev->i2cdev,dev->devAddress,DATA,1);
                     i2cread(dev->i2cdev,dev->devAddress,DATA,2);
                     uint16_t val=DATA[0];
                     val=(val<<8)+DATA[1];
                     return val;
                 }
                 return -1;
             }

lib/src/common/POWER/ina226/ina226.c +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2012, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
-            --                   Mail : alexis.jeandet@gmail.com
+            --                   Mail : alexis.jeandet@member.fsf.org
             -------------------------------------------------------------------------------*/
             #include <ina226.h>
             #include <stdio.h>
             #include <stddef.h>
             int ina226open(INA226_t *dev, i2c_t i2cdev, uint16_t config, uint8_t A0, uint8_t A1, uint32_t shuntmOhm, uint32_t CurrentRangeuAmp)
             {
                 if(dev != NULL)
                 {
                     dev->i2cdev=i2cdev;
                     dev->devAddress = INA226_I2C_ADDRESS | (A0 & 1) | ((A1<<2) & 5);
                     printf("dev->devAddress = %x\n\r",dev->devAddress);
                     dev->shuntmOhm = shuntmOhm;
                     dev->CurrentRangeuAmp = CurrentRangeuAmp;
                     ina226setReg(dev,INA226_Configuration_Reg,0x8000);
                     ina226setReg(dev,INA226_Configuration_Reg,config);
                     return ina226calibrate(dev,shuntmOhm,CurrentRangeuAmp);
                 }
                 return -1;
             }
             uint16_t ina226getID(INA226_t* dev)
             {
                 if(dev != NULL)
                 {
                     uint16_t id=ina226getReg(dev,INA226_Die_ID_Reg);
                     return id;
                 }
                 return -1;
             }
             int ina226calibrate(INA226_t* dev,uint32_t shuntmOhm, uint32_t CurrentRangeuAmp)
             {
                 dev->shuntmOhm = shuntmOhm;
                 dev->CurrentRangeuAmp = CurrentRangeuAmp;
                 uint32_t CAL= (uint32_t)(5210000/(shuntmOhm*(CurrentRangeuAmp>>15)));
                 return ina226setReg(dev,INA226_Calibration_Reg,(uint16_t)CAL);
             }
             uint32_t ina226getBusVoltage(INA226_t *dev)
             {
                 uint32_t busVoltage= ina226getReg(dev,INA226_Bus_Voltage_Reg);
                 busVoltage*= 1250;
                 return busVoltage;
             }
             uint32_t ina226getPower(INA226_t *dev)
             {
                 uint32_t power= ina226getReg(dev,INA226_Power_Reg);
                 power*= ((dev->CurrentRangeuAmp>>15)*25);
                 return power;
             }
             int32_t ina226getCurrent(INA226_t *dev)
             {
                 int32_t current= ina226getReg(dev,INA226_Current_Reg);
                 current<<=16;
                 current>>=16;
                 current = current*(dev->CurrentRangeuAmp>>15);
                 return current;
             }
             uint16_t ina226getReg(INA226_t* dev,char reg)
             {
                 if(dev != NULL)
                 {
                     char DATA[2];
                     DATA[0]=reg;
                     i2cwrite(dev->i2cdev,dev->devAddress,DATA,1);
                     i2cread(dev->i2cdev,dev->devAddress,DATA,2);
                     uint16_t val=DATA[0];
                     val=(val<<8)+DATA[1];
                     return val;
                 }
                 return -1;
             }
             int ina226setReg(INA226_t* dev,char reg,int16_t value)
             {
                 if(dev != NULL)
                 {
                     char DATA[3];
                     DATA[0]=INA226_Calibration_Reg;
                     DATA[1]=(char)(0xff & (value>>8));
                     DATA[2]=(char)(0xff & value);
                     if(3==i2cwrite(dev->i2cdev,dev->devAddress,DATA,3))return 1;
                 }
                 return -1;
             }

lib/src/common/Threading/thread.c +1 -1

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

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

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2011, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
-            --                   Mail : alexis.jeandet@gmail.com
+            --                   Mail : alexis.jeandet@member.fsf.org
             -------------------------------------------------------------------------------*/
             #ifndef B24LC0X_H
             #define B24LC0X_H
             #include <i2c.h>
             #include <uhandle.h>
             typedef struct eeprom24lc0xDev
             {
              i2c_t iicdev;
              unsigned char devAddress;
              unsigned char size;
             }eeprom24lc0xDev;
             extern void eeprom24lc0xopen(eeprom24lc0xDev* dev,i2c_t iicdev,unsigned char A0_A1_A2_val,unsigned int size);
             extern void eeprom24lc0xpagewrite(eeprom24lc0xDev* dev,unsigned char address,unsigned char* page);
             extern void eeprom24lc0xpageread(eeprom24lc0xDev* dev,unsigned char address,unsigned char* page);
             extern void eeprom24lc0xbytewrite(eeprom24lc0xDev* dev,unsigned char address,unsigned char data);
             extern unsigned char eeprom24lc0xbyteread(eeprom24lc0xDev* dev,unsigned char address);
             extern void eeprom24lc0xreadn(eeprom24lc0xDev* dev,unsigned char address,unsigned char* data, unsigned int count);
             extern void eeprom24lc0xwriten(eeprom24lc0xDev* dev,unsigned char address,unsigned char* data, unsigned int count);
             #endif

lib/src/includes/GRAPHIC/GUI/Widgets/terminal.h +1 -1

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

lib/src/includes/GRAPHIC/TC_CONTROLERS/STMPE811.h +1 -1

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

lib/src/includes/GRAPHIC/TC_CONTROLERS/genericTC_Controler.h +1 -1

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

lib/src/includes/N25Q128.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2013, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
-            --                   Mail : alexis.jeandet@gmail.com
+            --                   Mail : alexis.jeandet@member.fsf.org
             -------------------------------------------------------------------------------*/
             #ifndef N25Q128_H
             #define N25Q128_H
             #include <spi.h>
             #include <uhandle.h>
             #include <stdint.h>
             typedef struct eepromN25Q128Dev
             {
              spi_t spidev;
              void (*select)(int sel);
              void (*writeprotect)(int wp);
              void (*holdreset)(int hr);
             }eepromN25Q128Dev;
             #define N25Q128_PAGE_SZ  256
             #define N25Q128_CAPACITY_IN_BYTES (1024*1024*16)  /*16MB*/
             #define N25Q128_READID   0x9E
             #define N25Q128_READ     0x03
             #define N25Q128_FASTREAD 0x0B
             #define N25Q128_DOFR     0x3B
             #define N25Q128_DIOFR    0xBB
             #define N25Q128_QOFR     0x6B
             #define N25Q128_QIOFR    0xEB
             #define N25Q128_ROTP     0x4B
             #define N25Q128_WREN     0x06
             #define N25Q128_WRDI     0x04
             #define N25Q128_PP       0x02
             extern void eepromN25Q128open(eepromN25Q128Dev* dev,spi_t spidev,void (*select)(int sel),void (*writeprotect)(int wp),void (*holdreset)(int hr));
             extern void eepromN25Q128pagewrite(eepromN25Q128Dev* dev,uint32_t address,unsigned char* page);
             extern void eepromN25Q128pageread(eepromN25Q128Dev* dev,uint32_t address,unsigned char* page);
             extern void eepromN25Q128bytewrite(eepromN25Q128Dev* dev,uint32_t address,unsigned char data);
             extern unsigned char eepromN25Q128byteread(eepromN25Q128Dev* dev,uint32_t address);
             extern void eepromN25Q128readn(eepromN25Q128Dev* dev,uint32_t address,unsigned char* data, unsigned int count);
             extern void eepromN25Q128writen(eepromN25Q128Dev* dev,uint32_t address,unsigned char* data, unsigned int count);
             extern void eepromN25Q128enablewrite(eepromN25Q128Dev* dev);
             #endif

lib/src/includes/VS10XX.h +1 -1

             /*------------------------------------------------------------------------------
             #--  This file is a part of the libuc, microcontroler library
             #--  Copyright (C) 2011, Alexis Jeandet
             #--
             #--  This program is free software; you can redistribute it and/or modify
             #--  it under the terms of the GNU General Public License as published by
             #--  the Free Software Foundation; either version 3 of the License, or
             #--  (at your option) any later version.
             #--
             #--  This program is distributed in the hope that it will be useful,
             #--  but WITHOUT ANY WARRANTY; without even the implied warranty of
             #--  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             #--  GNU General Public License for more details.
             #--
             #--  You should have received a copy of the GNU General Public License
             #--  along with this program; if not, write to the Free Software
             #--  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             #-------------------------------------------------------------------------------
             #--                 Author : Alexis Jeandet
-            #--                   Mail : alexis.jeandet@gmail.com
+            #--                   Mail : alexis.jeandet@member.fsf.org
             #-------------------------------------------------------------------------------*/
             #ifndef VS10XX_H
             #define VS10XX_H
             #include <uhandle.h>
             #include <spi.h>
             #define VSMODE        0
             #define VSSTATUS      1
             #define VSBASS        2
             #define VSCLOCKF      3
             #define VSDECODE_TIME 4
             #define VSAUDATA      5
             #define VSWRAM        6
             #define VSWRAMADDR    7
             #define VSHDAT0       8
             #define VSHDAT1       9
             #define VSAIADDR      0xA
             #define VSVOL         0xB
             #define VSAICTRL0     0xC
             #define VSAICTRL1     0xD
             #define VSAICTRL2     0xE
             #define VSAICTRL3     0xF
             typedef enum VS10XXVER_en
             {
                 UNKNOWN,
                 VS1001,
                 VS1011,
                 VS1002,
                 VS1003,
                 VS1053,
                 VS1033,
                 VS1103
             }VS10XXVER_en;
             typedef struct vs10XXDev
             {
              spi_t SPIdev;
              void (*setxCS)(char);
              void (*setxRST)(char);
              void (*setxDCS)(char);
              int (*getDREQ)();
              VS10XXVER_en VERSION;
             }vs10XXDev;
             void vs10XXopen(vs10XXDev* codec,spi_t dev, void (*setxCS)(char),void (*setxRST)(char),void (*setxDCS)(char),int (*getDREQ)());
             void vs10XXsoftreset(vs10XXDev* dev);
             int vs10XXcmdread(vs10XXDev* dev,char address);
             void vs10XXcmdwrite(vs10XXDev* dev,char address,int value);
             void vs10XXstream32bytes(vs10XXDev* dev,char* buffer);
             void vs10XXsetCansel(vs10XXDev* dev);
             int vs10XXcanselAccepted(vs10XXDev* dev);
             void vs10XXsoftReset(vs10XXDev* dev);
             //extern void vs10XXclearXCS();
             //extern void vs10XXsetXCS();
             //extern int vs10XXDREQ();
             #endif //VS10XX_H

lib/src/includes/fat32.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2012, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
-            --                   Mail : alexis.jeandet@gmail.com
+            --                   Mail : alexis.jeandet@member.fsf.org
             -------------------------------------------------------------------------------*/
             #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_OEMNameoff 		    3
             #define BPB_BytsPerSecoff 	    11
             #define BPB_SecPerClusoff	    13
             #define BPB_RsvdSecCntoff	    14
             #define BPB_NumFATsoff 		    16
             #define BPB_RootEntCntoff	    17
             #define BPB_TotSec16off		    19
             #define BPB_Mediaoff 		    21
             #define BPB_FATSz16off 		    22
             #define BPB_SecPerTrkoff	    24
             #define BPB_NumHeadsoff		    26
             #define BPB_HiddSecoff 		    28
             #define BPB_TotSec32off		    32
             /*FAT16*/
             #define BS_DrvNumFAT16off	    36
             #define BS_Reserved1FAT16off	37
             #define BS_BootSigFAT16off 	    38
             #define BS_VolIDFAT16off	    39
             #define BS_VolLabFAT16off	    43
             #define BS_FilSysTypeFAT16off 	54
             /*FAT32*/
             #define BPB_FATSz32off 		    36
             #define BPB_ExtFlagsoff		    40
             #define BPB_FSVeroff 		    42
             #define BPB_RootClusoff	  	    44
             #define BPB_FSInfooff 		    48
             #define BPB_BkBootSecoff	    50
             #define BPB_Reservedoff		    52
             #define BS_DrvNumFAT32off	    64
             #define BS_Reserved1FAT32off    65
             #define BS_BootSigFAT32off 	    66
             #define BS_VolIDFAT32off	    67
             #define BS_VolLabFAT32off	    71
             #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 FATBabArg    2
             #define FATReadErr   3
             #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))
             /*
                 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)//(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))
             #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 -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
+            --                   Mail : alexis.jeandet@member.fsf.org
             -------------------------------------------------------------------------------*/
             #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/includes/sdcard.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2012, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
-            --                   Mail : alexis.jeandet@gmail.com
+            --                   Mail : alexis.jeandet@member.fsf.org
             -------------------------------------------------------------------------------*/
             #ifndef SDCARD_H
             #define SDCARD_H
             #include "blkdevice.h"
             #include <libucstrings.h>
             #include <uhandle.h>
             /* MMC/SD command */
             #define CMD0	(0)			/* GO_IDLE_STATE */
             #define CMD1	(1)			/* SEND_OP_COND (MMC) */
             #define	ACMD41	(0x80+41)	/* SEND_OP_COND (SDC) */
             #define CMD8	(8)			/* SEND_IF_COND */
             #define CMD9	(9)			/* SEND_CSD */
             #define CMD10	(10)		/* SEND_CID */
             #define CMD12	(12)		/* STOP_TRANSMISSION */
             #define ACMD13	(0x80+13)	/* SD_STATUS (SDC) */
             #define CMD16	(16)		/* SET_BLOCKLEN */
             #define CMD17	(17)		/* READ_SINGLE_BLOCK */
             #define CMD18	(18)		/* READ_MULTIPLE_BLOCK */
             #define CMD23	(23)		/* SET_BLOCK_COUNT (MMC) */
             #define	ACMD23	(0x80+23)	/* SET_WR_BLK_ERASE_COUNT (SDC) */
             #define CMD24	(24)		/* WRITE_BLOCK */
             #define CMD25	(25)		/* WRITE_MULTIPLE_BLOCK */
             #define CMD32	(32)		/* ERASE_ER_BLK_START */
             #define CMD33	(33)		/* ERASE_ER_BLK_END */
             #define CMD38	(38)		/* ERASE */
             #define CMD55	(55)		/* APP_CMD */
             #define CMD58	(58)		/* READ_OCR */
             /* Card type flags (CardType) */
             #define CT_MMC		0x01		/* MMC ver 3 */
             #define CT_SD1		0x02		/* SD ver 1 */
             #define CT_SD2		0x04		/* SD ver 2 */
             #define CT_SDC		(CT_SD1|CT_SD2)	/* SD */
             #define CT_BLOCK	0x08		/* Block addressing */
             struct sdcard_str
             {
             	UHANDLE phy;
                 int (*rcvr_mmc) (UHANDLE phy,char *buff,uint32_t bc);
                 int (*xmit_mmc) (UHANDLE phy,const char *buff,uint32_t bc);
                 int (*setspeed) (UHANDLE phy,uint32_t speed);
                 uint32_t (*getspeed) (UHANDLE phy);
             	DSTATUS Stat;
             	char CardType;
             };
             typedef volatile struct sdcard_str sdcardDev;
             //extern void sdcardmake(sdcardDev* sdcard,UHANDLE phy,void (*rcvr_mmc) (UHANDLE,char *,uint32_t ),void (*xmit_mmc) (UHANDLE,const char *,uint32_t ),void (*setspeed) (UHANDLE phy,uint32_t speed),uint32_t (*getspeed) (UHANDLE phy));
             //extern void sdcardmakeblkdev(blkdevice* dev,sdcardDev* sdcard, blkdevselect_t select,blkdevpower_t power,blkdevdetect_t detect,blkdevwriteprotected_t writeprotected);
             #endif

lib/src/includes/spi.h +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2012, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
-            --                   Mail : alexis.jeandet@gmail.com
+            --                   Mail : alexis.jeandet@member.fsf.org
             -------------------------------------------------------------------------------*/
             /*
             	TODO:
             	Add SPI slave mode
             	Add interrupt interface
             */
             #ifndef SPI_H
             #define SPI_H
             #include <stdint.h>
             #include <uhandle.h>
             #ifdef __cplusplus
              extern "C" {
             #endif
             /*
             typedef struct spi_t
             {
             	void* _dev;
             	int   cfg;
             	int   speed;
             }spi_t;*/
             typedef int spi_t;
              #define spi1 ((spi_t)0)
              #define spi2 ((spi_t)1)
              #define spi3 ((spi_t)2)
              #define spi4 ((spi_t)3)
              #define spi5 ((spi_t)4)
              #define spi6 ((spi_t)5)
              #define spi7 ((spi_t)6)
              #define spi8 ((spi_t)7)
              #define spi9 ((spi_t)8)
             typedef enum
             {
               spi4bits     = 0x3,
               spi5bits     = 0x4,
               spi6bits     = 0x5,
               spi7bits     = 0x6,
               spi8bits     = 0x7,
               spi9bits     = 0x8,
               spi10bits    = 0x9,
               spi11bits    = 0xA,
               spi12bits    = 0xB,
               spi13bits    = 0xC,
               spi14bits    = 0xD,
               spi15bits    = 0xE,
               spi16bits    = 0xF
             }spibits_t;
             #define SPIBITSMASK  0xF
             typedef enum
             {
               spislave    = 0x00,
               spimaster   = 0x10
             }spimode_t;
             #define SPIMODEMASK 0x10
             typedef enum
             {
               spiclkinhlow   = 0x00,
               spiclkinhhigh  = 0x20
             }spiclkinhlvl_t;
             #define SPICLKINHLVLMASK 0x20
             typedef enum
             {
               spiclkfirstedge    = 0x00,
               spiclksecondedge   = 0x40
             }spiclkphase_t;
             #define SPICLKPHASEMASK 0x40
             typedef enum
             {
               spimsbfirst    = 0x00,
               spilsbfirst    = 0x80
             }spibitorder_t;
             #define SPIBITORDERMASK 0x80
             extern spi_t spiopen(int count);
             extern spi_t spiopenandconfig(int count,uint32_t cfg,uint32_t speed,uint32_t MOSIpin,uint32_t MISOpin,uint32_t SCKpin,uint32_t SCSpin);
             extern int spiclose(spi_t spidev);
             extern int spisetpins(spi_t spidev,uint32_t MOSIpin,uint32_t MISOpin,uint32_t SCKpin,uint32_t SCSpin);
             extern int spienable(spi_t spidev);
             extern int spidisable(spi_t spidev);
             extern int spitransactionfinished(spi_t spidev);
             extern int spisetconfig(spi_t spidev,uint32_t config,uint32_t speed);
             extern int spisetspeed(spi_t spidev, uint32_t speed);
             extern uint32_t spigetspeed(spi_t spidev);
             extern int spisetbitorder(spi_t spidev,spibitorder_t order);
             extern int spisetdatabits(spi_t spidev,spibits_t bitscnt);
             extern int spisetclkinhlevel(spi_t spidev,spiclkinhlvl_t level);
             extern int spisetclkphase(spi_t spidev,spiclkphase_t phase);
             extern int spiputw(spi_t spidev,uint16_t data);
             extern uint16_t spigetw(spi_t spidev);
             extern int spiputs(spi_t spidev,char* s);
             extern int spigets(spi_t spidev,char* s);
             extern int spiputnw(spi_t spidev,uint16_t* w,int n);
             extern int spigetnw(spi_t spidev,uint16_t* w,int n);
             extern int spiputnc(spi_t spidev,char* c,int n);
             extern int spigetnc(spi_t spidev,char* c,int n);
             extern int spiavailiabledata(spi_t spidev);
             #ifdef __cplusplus
              }
             #endif
             #endif //SPI_H

lib/src/includes/thread.h +1 -1

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

lib/src/simulator/CORE/core.c +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2011, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
-            --                   Mail : alexis.jeandet@gmail.com
+            --                   Mail : alexis.jeandet@member.fsf.org
             -------------------------------------------------------------------------------*/
             #include <core.h>
             #include <stdint.h>
             #include <stdlib.h>
             #include <stdio.h>
             #include <gpio.h>
             #include <unistd.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)
             {
                 usleep(value);
             }
             void delay_100us(uint32_t value)
             {
                 usleep(value*100);
             }
             uint32_t getAPB1Freq()
             {
                 return 0;
             }
             uint32_t getAPB2Freq()
             {
                 return 0;
             }
             uint32_t getCpuFreq()
             {
                 return 0;
             }
             void reset_AHB1()
             {
             }
             void reset_AHB2()
             {
             }
             void reset_APB1()
             {
             }
             void reset_APB2()
             {
             }
             int optimizePLLcfg(uint32_t freq, uint32_t srcfreq,uint32_t PLLM,uint32_t* PLLP, uint32_t* PLLN,uint8_t* AHBPRindx)
             {
                 return 1;
             }
             int setPll(uint32_t freq)
             {
                 return freq;
             }
             void configureSysTick()
             {
             }
             int setCpuFreq(uint32_t freq)
             {
                 return 0;
             }
             void enable_FPU()
             {
             }

lib/src/simulator/CORE/threads.c +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2013, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
-            --                   Mail : alexis.jeandet@gmail.com
+            --                   Mail : alexis.jeandet@member.fsf.org
             -------------------------------------------------------------------------------*/
             #define __THREAD_PRIVATE__
             #include <thread.h>
             /*
              For CM4 cf lazy Stacking and context switching form ARM
               List of automatically saved registers:
                 R0
                 R1
                 R2
                 R3
                 R4
                 R5
                 R6
                 R7
                 R8
                 R9
                 R10
                 R11
                 R12
                 R13(SP)
                 R14(LR)
                 R15(PC)
                 xPSR
                 S0 to S15 (if enabled)
               List of registers to save:
                 S16 to S31
             */
             void __cpusavecontext(void* dataspace)
             {
             }
             void __cpurestorecontext(void* dataspace)
             {
             }

lib/src/simulator/GPIO/gpio.c +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2012, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
-            --                   Mail : alexis.jeandet@gmail.com
+            --                   Mail : alexis.jeandet@member.fsf.org
             -------------------------------------------------------------------------------*/
             #include <gpio.h>
             gpio_t gpioopen(uint32_t gpio)
             {
             	gpio &= -1^GPIOSPEEDMASK;
             	gpio |= gpiolowspeed;
             	gpio &= -1^GPIODIRMASK;
             	gpio |= gpioindir;
             	gpio &= -1^GPIOOUTTYPEMASK;
             	gpio |= gpiopushpulltype;
             	gpio &= -1^GPIOPULLTYPEMASK;
             	gpio |= gpionopulltype;
             	return gpio;
             }
             void gpioclose(gpio_t gpio)
             {
             }
             void gpiosetconfig(gpio_t* gpio)
             {
             	gpiosetdir(gpio, (*gpio & GPIODIRMASK));
             	gpiosetspeed(gpio, (*gpio & GPIOSPEEDMASK));
             	gpiosetouttype(gpio, (*gpio & GPIOOUTTYPEMASK));
             	gpiosetpulltype(gpio, (*gpio & GPIOPULLTYPEMASK));
             }
             extern void gpiosetspeed(gpio_t* gpio,gpiospeed_t speed)
             {
             }
             void gpiosetdir(gpio_t* gpio,gpiodir_t dir)
             {
             }
             void gpiosetouttype(gpio_t* gpio, gpioouttype_t outtype)
             {
             }
             void gpiosetpulltype(gpio_t* gpio,gpiopulltype_t pulltype)
             {
             }
             void gpioset(gpio_t gpio)
             {
             }
             void gpioclr(gpio_t gpio)
             {
             }
             void gpiosetval(gpio_t gpio,int val)
             {
             }
             int gpiogetval(gpio_t gpio)
             {
             	return 0;
             }

lib/src/simulator/I2C/i2c.c +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2012, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
-            --                   Mail : alexis.jeandet@gmail.com
+            --                   Mail : alexis.jeandet@member.fsf.org
             -------------------------------------------------------------------------------*/
             #include <i2c.h>
             #include <gpio.h>
             int i2ctimeout=1000*1000;
             i2c_t i2copen(int count)
             {
                 return -1;
             }
             i2c_t i2copenandconfig(int count,uint32_t cfg,uint32_t speed,uint32_t SDA,uint32_t SCL)
             {
                 i2c_t dev = i2copen(count);
                 if(dev!=-1)
                 {
                     i2cclose(dev);
                     i2csetpins(dev,SDA,SCL);
                     i2copen(count);
                     i2csetspeed(dev,speed);
                     i2cenable(count);
                 }
                 return dev;
             }
             int i2cclose(i2c_t dev)
             {
                 return 1;
             }
             int i2csetpins(i2c_t dev, uint32_t SDA, uint32_t SCL)
             {
                 if((dev<i2c4)&&(dev>=i2c1))
                 {
                     return 0;
                 }
                 return -1;
             }
             int i2cenable(i2c_t dev)
             {
                 if((dev<i2c4)&&(dev>=i2c1))
                 {
                     return 0;
                 }
                 return -1;
             }
             int i2cdisable(i2c_t dev)
             {
                 if((dev<i2c4)&&(dev>=i2c1))
                 {
                     return 0;
                 }
                 return -1;
             }
             int i2csetspeed(i2c_t dev,uint32_t speed)
             {
                 if((dev<i2c4)&&(dev>=i2c1))
                 {
                         return 0;
                 }
                 return -1;
             }
             int i2cbusy(i2c_t dev)
             {
                 if((dev<i2c4)&&(dev>=i2c1))
                 {
                     return 0;                           /* Dev isn't busy */
                 }
                 return -1;                              /* Error, dev is out of range */
             }
             int i2cwrite(i2c_t dev,char address,char* data,int count)
             {
                 if((dev<i2c4)&&(dev>=i2c1))
                 {
                     return 0;
                 }
                 return -1;
             }
             int i2cread(i2c_t dev,char address,char* data,int count)
             {
                 if((dev<i2c4)&&(dev>=i2c1))
                 {
                     return 0;
                 }
                 return -1;
             }
             int i2cStatusCheck(i2c_t dev,int32_t flagMask)
             {
                 int32_t flag;
                 if((dev<i2c4)&&(dev>=i2c1))
                 {
                     return 0;
                 }
                 return -1;
             }

lib/src/simulator/SDLCD/SDLCD.c +70 -3

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

lib/src/simulator/SDLCD/SDLCD.h +3 -1

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

lib/src/simulator/SPI/spi.c +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2011, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
-            --                   Mail : alexis.jeandet@gmail.com
+            --                   Mail : alexis.jeandet@member.fsf.org
             -------------------------------------------------------------------------------*/
             #include <spi.h>
             #include <gpio.h>
             spi_t spiopen(int count)
             {
                 return -1;
             }
             spi_t spiopenandconfig(int count, uint32_t cfg, uint32_t speed, uint32_t MOSIpin, uint32_t MISOpin, uint32_t SCKpin, uint32_t SCSpin)
             {
                 spi_t dev = spiopen(count);
                 if(dev!=-1)
                 {
                     spidisable(dev);
                     spisetpins(dev,MOSIpin, MISOpin, SCKpin, SCSpin);
                     spienable(dev);
                     spisetconfig(dev,cfg,speed);
                 }
                 return dev;
             }
             int spiclose(spi_t spidev)
             {
                 if((spidev<3)&&(spidev>=0))
                 {
                     return 1;
                 }
                 return -1;
             }
             int spisetpins(spi_t spidev,uint32_t MOSIpin,uint32_t MISOpin,uint32_t SCKpin,uint32_t SCSpin)
             {
                 if((spidev<3)&&(spidev>=0))
                 {
                     return 1;
                 }
                 return -1;
             }
             int spienable(spi_t spidev)
             {
                 if((spidev<3)&&(spidev>=0))
                 {
                     return 1;
                 }
                 return -1;
             }
             int spidisable(spi_t spidev)
             {
                 if((spidev<3)&&(spidev>=0))
                 {
                     return 1;
                 }
                 return -1;
             }
             int spisetconfig(spi_t spidev, uint32_t config, uint32_t speed)
             {
                 if((spidev<3)&&(spidev>=0))
                 {
                     return 0;
                 }
                 return 1;
             }
             int spisetspeed(spi_t spidev, uint32_t speed)
             {
                 if((spidev<3)&&(spidev>=0))
                 {
                     return 1;
                 }
                 return -1;
             }
             uint32_t spigetspeed(spi_t spidev)
             {
                 if((spidev<3)&&(spidev>=0))
                 {
                     return 0;
                 }
                 return -1;
             }
             int spisetdatabits(spi_t spidev,spibits_t bitscnt)
             {
                 if((spidev<3)&&(spidev>=0))
                 {
                     return 0;
                 }
                 return -1;
             }
             int spisetbitorder(spi_t spidev,spibitorder_t order)
             {
                 if((spidev<3)&&(spidev>=0))
                 {
                     return 1;
                 }
                 return -1;
             }
             int spisetclkinhlevel(spi_t spidev,spiclkinhlvl_t level)
             {
                 if((spidev<3)&&(spidev>=0))
                 {
                     return 1;
                 }
                 return -1;
             }
             int spisetclkphase(spi_t spidev,spiclkphase_t phase)
             {
                 if((spidev<3)&&(spidev>=0))
                 {
                     return 1;
                 }
                 return -1;
             }
             int spiputw(spi_t spidev,uint16_t data)
             {
                 if((spidev<3)&&(spidev>=0))
                 {
                     return 0;
                 }
                 return -1;
             }
             uint16_t spigetw(spi_t spidev)
             {
                 if((spidev<3)&&(spidev>=0))
                 {
                     return 0;
                 }
                 return -1;
             }
             int spiputs(spi_t spidev,char* s)
             {
                 while (*s) spiputw(spidev,*s++);
                 return 1;
             }
             int spigets(spi_t spidev,char* s)
             {
                 do
                 {
                     (*s) =  spigetw(spidev);
                 }
                 while(*s++);
                 return 1;
             }
             int spiputnw(spi_t spidev,uint16_t* w,int n)
             {
                 while(n!=0)
                 {
                     spiputw(spidev,*w++);
                     n--;
                 }
                 return 1;
             }
             int spigetnw(spi_t spidev,uint16_t* w,int n)
             {
                 while(n!=0)
                 {
                     *w++=spigetw(spidev);
                     n--;
                 }
                 return 1;
             }
             int spiputnc(spi_t spidev,char* c,int n)
             {
                 while(n!=0)
                 {
                     spiputw(spidev,*c++);
                     n--;
                 }
                 return 1;
             }
             int spigetnc(spi_t spidev,char* c,int n)
             {
                 while(n!=0)
                 {
                     *c++=spigetw(spidev);
                     n--;
                 }
                 return 1;
             }
             int spiavailiabledata(spi_t spidev)
             {
                 return 0;
             }
             int spitransactionfinished(spi_t spidev)
             {
                 if((spidev<3)&&(spidev>=0))
                 {
                     return 1;
                 }
                 return 0;
             }

lib/src/simulator/UART/uart.c +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2013, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
-            --                   Mail : alexis.jeandet@gmail.com
+            --                   Mail : alexis.jeandet@member.fsf.org
             -------------------------------------------------------------------------------*/
             #include <uart.h>
             #include <gpio.h>
             #include <stdio.h>
             int _uartstrsetpos(streamdevice* device,int pos);
             int _uartstrread(streamdevice* device,void* data,int size, int n);
             int _uartstrwrite(streamdevice* device,void* data,int size, int n);
             streamdevice_ops UART_OPS=
             {
                 .write = &_uartstrwrite,
                 .read  = &_uartstrread,
                 .setpos= &_uartstrsetpos,
                 .close = NULL
             };
             uart_t uartopen(int count)
             {
                 return -1;
             }
             uart_t uartopenandconfig(int count, uint32_t cfg, uint32_t speed, uint32_t TXpin, uint32_t RXpin, uint32_t RTSpin, uint32_t CTSpin)
             {
                 uart_t dev= uartopen(count);
                 uartsetconfig(dev,cfg,speed);
                 uartsetpins(dev,TXpin,RXpin,RTSpin,CTSpin);
                 return dev;
             }
             int uartclose(uart_t uart)
             {
                 return 1;
             }
             int uartsetpins(uart_t uart,uint32_t TXpin,uint32_t RXpin,uint32_t RTSpin,uint32_t CTSpin)
             {
                 if(uart >5)return -1;
                 if(uart <0)return -1;
                 return 1;
             }
             int uartsetconfig(uart_t uart, uint32_t cfg, uint32_t speed)
             {
                 int res=1;
                 uartdisable(uart);
                 uartsetspeed(uart,speed);
                 uartsetparity(uart,cfg & UARTPARITYMASK);
                 uartsetdatabits(uart,cfg & UARTBITSMASK);
                 uartsetstopbits(uart,cfg & UARTSTOPBITSMASK);
                 uartenable(uart);
                 return res;
             }
             int uartenable(uart_t uart)
             {
                 if((uart<6)&&(uart>=0))
                 {
                     return 1;
                 }
                 return -1;
             }
             int uartdisable(uart_t uart)
             {
                 if((uart<6)&&(uart>=0))
                 {
                     return 1;
                 }
                 return -1;
             }
             int uartsetspeed(uart_t uart,uint32_t speed)
             {
                 if((uart<6)&&(uart>=0))
                 {
                     return 1;
                 }
                 return -1;
             }
             int uartsetparity(uart_t uart,uartparity_t parity)
             {
                 if((uart<6)&&(uart>=0))
                 {
                     return 1;
                 }
                 return -1;
             }
             int uartsetdatabits(uart_t uart,uartbits_t databits)
             {
                 if((uart<6)&&(uart>=0))
                 {
                     return 1;
                 }
                 return -1;
             }
             int uartsetstopbits(uart_t uart,uartstopbits_t stopbits)
             {
                 if((uart<6)&&(uart>=0))
                 {
                     return 1;
                 }
                 return -1;
             }
             int uartputc(uart_t uart,char c)
             {
                 if((uart<6)&&(uart>=0))
                 {
                     return 1;
                 }
                 return -1;
             }
             char uartgetc(uart_t uart)
             {
                 if((uart<6)&&(uart>=0))
                 {
                     return 0;
                 }
                 return -1;
             }
             int uartputs(uart_t uart,char* s)
             {
                 while (*s) uartputc(uart,*s++);
                 return 1;
             }
             int uartgets(uart_t uart,char* s)
             {
                 do
                 {
                     (*s) =  uartgetc(uart);
                 }
                 while(*s++);
                 return 1;
             }
             int uartputnc(uart_t uart,char* c,int n)
             {
                 int l=0;
                 while(l<n)
                 {
                     uartputc(uart,*c++);
                     l++;
                 }
                 return n;
             }
             int uartgetnc(uart_t uart,char* c,int n)
             {
                 int l=0;
                 while(l<n)
                 {
                     *c++=uartgetc(uart);
                     l++;
                 }
                 return n;
             }
             int uartavailiabledata(uart_t uart)
             {
                 if((uart<6)&&(uart>=0))
                 {
                         return 1;
                 }
                 return -1;
             }
             int _uartstrwrite(streamdevice* device,void* data,int size, int n)
             {
                 return uartputnc((uart_t) device->_stream,(char*) data,size*n);
             }
             int _uartstrread(streamdevice* device,void* data,int size, int n)
             {
                 return uartgetnc((uart_t) device->_stream,(char*) data,size*n);
             }
             int _uartstrsetpos(streamdevice* device,int pos)
             {
                 return 1;
             }
             int uartmkstreamdev(uart_t uart,streamdevice* strdev)
             {
                 strdev->_stream = (UHANDLE)uart;
                 strdev->ops = &UART_OPS;
                 strdev->streamPt = 0;
                 return 1;
             }

lib/src/stm32f4/CORE/core.c +1 -1

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

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2013, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
-            --                   Mail : alexis.jeandet@gmail.com
+            --                   Mail : alexis.jeandet@member.fsf.org
             -------------------------------------------------------------------------------*/
             #define __THREAD_PRIVATE__
             #include <thread.h>
             /*
              For CM4 cf lazy Stacking and context switching form ARM
               List of automatically saved registers:
                 R0
                 R1
                 R2
                 R3
                 R4
                 R5
                 R6
                 R7
                 R8
                 R9
                 R10
                 R11
                 R12
                 R13(SP)
                 R14(LR)
                 R15(PC)
                 xPSR
                 S0 to S15 (if enabled)
               List of registers to save:
                 S16 to S31
             */
             void __cpusavecontext(void* dataspace)
             {
             }
             void __cpurestorecontext(void* dataspace)
             {
             }

lib/src/stm32f4/GPIO/gpio.c +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2012, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
-            --                   Mail : alexis.jeandet@gmail.com
+            --                   Mail : alexis.jeandet@member.fsf.org
             -------------------------------------------------------------------------------*/
             #include <gpio.h>
             #include <stm32f4xx_gpio.h>
             #include <stm32f4xx_rcc.h>
             #define GPIOGETPORT(gpio)   ((GPIO_TypeDef*)(((((uint32_t)gpio) & (uint32_t)0x0000FF00)*(uint32_t)4) + (uint32_t)GPIOA))
             #define GPIOPORTNUM(gpio)   (((uint32_t)(gpio) & (uint32_t)0x0000FF00)>>(uint32_t)8)
             gpio_t gpioopen(uint32_t gpio)
             {
             	gpio &= -1^GPIOSPEEDMASK;
             	gpio |= gpiolowspeed;
             	gpio &= -1^GPIODIRMASK;
             	gpio |= gpioindir;
             	gpio &= -1^GPIOOUTTYPEMASK;
             	gpio |= gpiopushpulltype;
             	gpio &= -1^GPIOPULLTYPEMASK;
             	gpio |= gpionopulltype;
             	gpiosetconfig(&gpio);
             	RCC_AHB1PeriphClockCmd(((uint32_t)0x00000001<<GPIOPORTNUM(gpio)), ENABLE);
             	return gpio;
             }
             void gpioclose(gpio_t gpio)
             {
             }
             void gpiosetconfig(gpio_t* gpio)
             {
             	gpiosetdir(gpio, (*gpio & GPIODIRMASK));
             	gpiosetspeed(gpio, (*gpio & GPIOSPEEDMASK));
             	gpiosetouttype(gpio, (*gpio & GPIOOUTTYPEMASK));
             	gpiosetpulltype(gpio, (*gpio & GPIOPULLTYPEMASK));
             }
             extern void gpiosetspeed(gpio_t* gpio,gpiospeed_t speed)
             {
             	GPIO_TypeDef* GPIOx = GPIOGETPORT((*gpio));
                     switch(speed)
             	{
             	case gpiolowspeed :
             		if((*gpio & 0xFF)==0xFF)
             		{
             			for(int i=0;i<16;i++)
             			{
             				GPIOx->OSPEEDR &= ~(GPIO_OSPEEDER_OSPEEDR0 << (i * 2));
                     			GPIOx->OSPEEDR |= ((uint32_t)(GPIO_Speed_2MHz) << (i * 2));
             			}
             		}
             		else
             		{
             			GPIOx->OSPEEDR &= ~(GPIO_OSPEEDER_OSPEEDR0 << ((*gpio & 0xFF) * 2));
                     		GPIOx->OSPEEDR |= ((uint32_t)(GPIO_Speed_2MHz) << ((*gpio & 0xFF) * 2));
             		}
             		*gpio &= ~GPIOSPEEDMASK;
             		*gpio |= gpiolowspeed;
             		break;
               	case gpiomediumspeed :
               		if((*gpio & 0xFF)==0xFF)
             		{
             			for(int i=0;i<16;i++)
             			{
             				GPIOx->OSPEEDR &= ~(GPIO_OSPEEDER_OSPEEDR0 << (i * 2));
                     			GPIOx->OSPEEDR |= ((uint32_t)(GPIO_Speed_25MHz) << (i * 2));
             			}
             		}
             		else
             		{
             			GPIOx->OSPEEDR &= ~(GPIO_OSPEEDER_OSPEEDR0 << ((*gpio & 0xFF) * 2));
                     		GPIOx->OSPEEDR |= ((uint32_t)(GPIO_Speed_25MHz) << ((*gpio & 0xFF) * 2));
             		}
             		*gpio &= ~GPIOSPEEDMASK;
             		*gpio |= gpiomediumspeed;
               		break;
               	case gpiofastspeed :
               		if((*gpio & 0xFF)==0xFF)
             		{
             			for(int i=0;i<16;i++)
             			{
             				GPIOx->OSPEEDR &= ~(GPIO_OSPEEDER_OSPEEDR0 << (i * 2));
                     			GPIOx->OSPEEDR |= ((uint32_t)(GPIO_Speed_50MHz) << (i * 2));
             			}
             		}
             		else
             		{
             			GPIOx->OSPEEDR &= ~(GPIO_OSPEEDER_OSPEEDR0 << ((*gpio & 0xFF) * 2));
                     		GPIOx->OSPEEDR |= ((uint32_t)(GPIO_Speed_50MHz) << ((*gpio & 0xFF) * 2));
             		}
             		*gpio &= ~GPIOSPEEDMASK;
             		*gpio |= gpiofastspeed;
               		break;
               	case gpiohighspeed :
               		if((*gpio & 0xFF)==0xFF)
             		{
             			for(int i=0;i<16;i++)
             			{
             				GPIOx->OSPEEDR &= ~(GPIO_OSPEEDER_OSPEEDR0 << (i * 2));
                     			GPIOx->OSPEEDR |= ((uint32_t)(GPIO_Speed_100MHz) << (i * 2));
             			}
             		}
             		else
             		{
             			GPIOx->OSPEEDR &= ~(GPIO_OSPEEDER_OSPEEDR0 << ((*gpio & 0xFF) * 2));
                     		GPIOx->OSPEEDR |= ((uint32_t)(GPIO_Speed_100MHz) << ((*gpio & 0xFF) * 2));
             		}
             		*gpio &= ~GPIOSPEEDMASK;
             		*gpio |= gpiohighspeed;
               		break;
               	}
             }
             void gpiosetdir(gpio_t* gpio,gpiodir_t dir)
             {
             	GPIO_TypeDef* GPIOx = GPIOGETPORT((*gpio));
             	switch(dir)
             	{
             	case gpiooutdir:
             		if((*gpio & 0xFF)==0xFF)
             		{
             			for(int i=0;i<16;i++)
             			{
             				GPIOx->MODER  &= ~(GPIO_MODER_MODER0 << (i * 2));
             				GPIOx->MODER |= (GPIO_Mode_OUT << (i * 2));
             			}
             		}
             		else
             		{
             			GPIOx->MODER  &= ~(GPIO_MODER_MODER0 << ((*gpio & 0xFF) * 2));
             			GPIOx->MODER |= (GPIO_Mode_OUT << ((*gpio & 0xFF) * 2));
             		}
             		*gpio &= ~GPIODIRMASK;
             		*gpio |= gpiooutdir;
             		break;
             	case gpioaf:
             		if((*gpio & 0xFF)==0xFF)
             		{
             			for(int i=0;i<16;i++)
             			{
             				GPIOx->MODER  &= ~(GPIO_MODER_MODER0 << (i * 2));
             				GPIOx->MODER |= (GPIO_Mode_AF << (i * 2));
             			}
             		}
             		else
             		{
             			GPIOx->MODER  &= ~(GPIO_MODER_MODER0 << ((*gpio & 0xFF) * 2));
             			GPIOx->MODER |= (GPIO_Mode_AF << ((*gpio & 0xFF) * 2));
             		}
             		*gpio &= ~GPIODIRMASK;
             		*gpio |= gpioaf;
             		break;
             	case gpioan:
             		if((*gpio & 0xFF)==0xFF)
             		{
             			for(int i=0;i<16;i++)
             			{
             				GPIOx->MODER  &= ~(GPIO_MODER_MODER0 << (i * 2));
             				GPIOx->MODER |= (GPIO_Mode_AN << (i * 2));
             			}
             		}
             		else
             		{
             			GPIOx->MODER  &= ~(GPIO_MODER_MODER0 << ((*gpio & 0xFF) * 2));
             			GPIOx->MODER |= (GPIO_Mode_AN << ((*gpio & 0xFF) * 2));
             		}
             		*gpio &= ~GPIODIRMASK;
             		*gpio |= gpioan;
             		break;
             	default :
             		if((*gpio & 0xFF)==0xFF)
             		{
             			for(int i=0;i<16;i++)
             			{
             				GPIOx->MODER  &= ~(GPIO_MODER_MODER0 << (i * 2));
             				GPIOx->MODER |= (GPIO_Mode_IN << (i * 2));
             			}
             		}
             		else
             		{
             			GPIOx->MODER  &= ~(GPIO_MODER_MODER0 << ((*gpio & 0xFF) * 2));
             			GPIOx->MODER |= (GPIO_Mode_IN << ((*gpio & 0xFF) * 2));
             		}
             		*gpio &= ~GPIODIRMASK;
             		*gpio |= gpioindir;
             		break;
             	}
             }
             void gpiosetouttype(gpio_t* gpio, gpioouttype_t outtype)
             {
             	GPIO_TypeDef* GPIOx = GPIOGETPORT((*gpio));
             	if(outtype == gpioopendraintype)
             	{
             		if((*gpio & 0xFF)==0xFF)
             		{
             			for(int i=0;i<16;i++)
             			{
             				GPIOx->OTYPER  &= ~((GPIO_OTYPER_OT_0) << ((uint16_t)i));
             				GPIOx->OTYPER |= (uint16_t)(GPIO_OType_OD<<((uint16_t)i));
             			}
             		}
             		else
             		{
             			GPIOx->OTYPER  &= ~((GPIO_OTYPER_OT_0) << ((uint16_t)(*gpio & 0xFF)));
             			GPIOx->OTYPER |= (uint16_t)(GPIO_OType_OD<<((uint16_t)(*gpio & 0xFF)));
             		}
             		*gpio &= ~GPIOOUTTYPEMASK;
             		*gpio |= gpioopendraintype;
             	}
             	else
             	{
             		if((*gpio & 0xFF)==0xFF)
             		{
             			for(int i=0;i<16;i++)
             			{
             				GPIOx->OTYPER  &= ~((GPIO_OTYPER_OT_0) << ((uint16_t)i));
             				GPIOx->OTYPER |= (uint16_t)(GPIO_OType_PP<<((uint16_t)i));
             			}
             		}
             		else
             		{
             			GPIOx->OTYPER  &= ~((GPIO_OTYPER_OT_0) << ((uint16_t)(*gpio & 0xFF)));
             			GPIOx->OTYPER |= (uint16_t)(GPIO_OType_PP<<((uint16_t)(*gpio & 0xFF)));
             		}
             		*gpio &= ~GPIOOUTTYPEMASK;
             		*gpio |= gpiopushpulltype;
             	}
             }
             void gpiosetpulltype(gpio_t* gpio,gpiopulltype_t pulltype)
             {
             	GPIO_TypeDef* GPIOx = GPIOGETPORT(*gpio);
             	switch(pulltype)
             	{
             	case gpiopulluptype:
             		if((*gpio & 0xFF)==0xFF)
             		{
             			for(int i=0;i<16;i++)
             			{
             				GPIOx->PUPDR &= ~(GPIO_PUPDR_PUPDR0 << ((uint16_t)i * 2));
             				GPIOx->PUPDR |= (GPIO_PuPd_UP << (i * 2));
             			}
             		}
             		else
             		{
             			GPIOx->PUPDR &= ~(GPIO_PUPDR_PUPDR0 << ((uint16_t)(*gpio & 0xFF) * 2));
             			GPIOx->PUPDR |= (GPIO_PuPd_UP << ((*gpio & 0xFF) * 2));
             		}
             		*gpio &= ~GPIOPULLTYPEMASK;
             		*gpio |= gpiopulluptype;
             		break;
             	case gpiopulldowntype:
             		if((*gpio & 0xFF)==0xFF)
             		{
             			for(int i=0;i<16;i++)
             			{
             				GPIOx->PUPDR &= ~(GPIO_PUPDR_PUPDR0 << ((uint16_t)i * 2));
             				GPIOx->PUPDR |= (GPIO_PuPd_DOWN << (i * 2));
             			}
             		}
             		else
             		{
             			GPIOx->PUPDR &= ~(GPIO_PUPDR_PUPDR0 << ((uint16_t)(*gpio & 0xFF) * 2));
             			GPIOx->PUPDR |= (GPIO_PuPd_DOWN << ((*gpio & 0xFF) * 2));
             		}
             		*gpio &= ~GPIOPULLTYPEMASK;
             		*gpio |= gpiopulldowntype;
             		break;
             	default :
             		if((*gpio & 0xFF)==0xFF)
             		{
             			for(int i=0;i<16;i++)
             			{
             				GPIOx->PUPDR &= ~(GPIO_PUPDR_PUPDR0 << ((uint16_t)i * 2));
             				GPIOx->PUPDR |= (GPIO_PuPd_NOPULL << (i * 2));
             			}
             		}
             		else
             		{
             			GPIOx->PUPDR &= ~(GPIO_PUPDR_PUPDR0 << ((uint16_t)(*gpio & 0xFF) * 2));
             			GPIOx->PUPDR |= (GPIO_PuPd_NOPULL << ((*gpio & 0xFF) * 2));
             		}
             		*gpio &= ~GPIOPULLTYPEMASK;
             		*gpio |= gpionopulltype;
             		break;
             	}
             }
             void gpioset(gpio_t gpio)
             {
             	GPIO_TypeDef* GPIOx = GPIOGETPORT(gpio);
             	if((gpio & 0xFF)==0xFF)
             	{
             		GPIOx->BSRRL = -1;
             	}
             	else
             	{
             		GPIOx->BSRRL = 1<<(gpio & 0xFF);
             	}
             }
             void gpioclr(gpio_t gpio)
             {
             	GPIO_TypeDef* GPIOx = GPIOGETPORT(gpio);
             	if((gpio & 0xFF)==0xFF)
             	{
             		GPIOx->BSRRH = -1;
             	}
             	else
             	{
             		GPIOx->BSRRH = 1<<(gpio & 0xFF);
             	}
             }
             void gpiosetval(gpio_t gpio,int val)
             {
             	GPIO_TypeDef* GPIOx = GPIOGETPORT(gpio);
             	if((gpio & 0xFF)==0xFF)
             	{
             		GPIOx->ODR = val;
             	}
             	else
             	{
                     if(val)
                         GPIOx->BSRRL = 1<<(gpio & 0xFF);
                     else
                         GPIOx->BSRRH = 1<<(gpio & 0xFF);
             	}
             }
             int gpiogetval(gpio_t gpio)
             {
             	GPIO_TypeDef* GPIOx = GPIOGETPORT(gpio);
             	if((gpio & 0xFF)==0xFF)
             	{
             		return GPIOx->IDR;
             	}
             	else
             	{
             		return ((GPIOx->IDR>>(gpio & 0xFF)) & 1);
             	}
             }

lib/src/stm32f4/I2C/i2c.c +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2012, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
-            --                   Mail : alexis.jeandet@gmail.com
+            --                   Mail : alexis.jeandet@member.fsf.org
             -------------------------------------------------------------------------------*/
             #include <i2c.h>
             #include <stm32f4xx_usart.h>
             #include <stm32f4xx_rcc.h>
             #include <stm32f4xx_gpio.h>
             #include <gpio.h>
             #include <core.h>
             #define GPIOGETPORT(gpio)   ((GPIO_TypeDef*)(((((uint32_t)gpio) & (uint32_t)0x0000FF00)*(uint32_t)4) + (uint32_t)GPIOA))
             #define GPIOPORTNUM(gpio)   (((uint32_t)(gpio) & (uint32_t)0x0000FF00)>>(uint32_t)8)
             int i2ctimeout=1000*1000;
             I2C_TypeDef* _i2c_dev_table[3]={I2C1,I2C2,I2C3};
             i2c_t i2copen(int count)
             {
             #define _INIT_DEV(_RCC_) \
                 RCC_APB1PeriphClockCmd(_RCC_, ENABLE); \
                 RCC_APB1PeriphResetCmd(_RCC_, ENABLE); \
                 RCC_APB1PeriphResetCmd(_RCC_, DISABLE);
                 switch(count)
                 {
                 case i2c1:
                     _INIT_DEV(RCC_APB1Periph_I2C1);
                     return i2c1;
                     break;
                 case i2c2:
                     _INIT_DEV(RCC_APB1Periph_I2C2);
                     return i2c2;
                     break;
                 case i2c3:
                     _INIT_DEV(RCC_APB1Periph_I2C3);
                     return i2c3;
                     break;
                 default:
                     break;
                 }
                 return -1;
             }
             i2c_t i2copenandconfig(int count,uint32_t cfg,uint32_t speed,uint32_t SDA,uint32_t SCL)
             {
                 i2c_t dev = i2copen(count);
                 if(dev!=-1)
                 {
                     i2cclose(dev);
                     i2csetpins(dev,SDA,SCL);
                     i2copen(count);
                     i2csetspeed(dev,speed);
                     i2cenable(count);
                 }
                 return dev;
             }
             int i2cclose(i2c_t dev)
             {
                 switch(dev)
                 {
                 case i2c1:
                     RCC_APB1PeriphResetCmd(RCC_APB1Periph_I2C1, ENABLE);
                     break;
                 case i2c2:
                     RCC_APB1PeriphResetCmd(RCC_APB1Periph_I2C2, ENABLE);
                     break;
                 case i2c3:
                     RCC_APB1PeriphResetCmd(RCC_APB1Periph_I2C3, ENABLE);
                     break;
                 default:
                     break;
                 }
                 return 1;
             }
             int i2csetpins(i2c_t dev, uint32_t SDA, uint32_t SCL)
             {
                 if((dev<i2c4)&&(dev>=i2c1))
                 {
                     gpio_t SDApin,SCLpin;
                     SDApin = gpioopen(SDA);
                     SCLpin = gpioopen(SCL);
                     SDApin |= gpiolowspeed | gpioaf | gpioopendraintype | gpionopulltype;
                     SCLpin |= gpiolowspeed | gpiooutdir | gpioopendraintype | gpionopulltype;
                     gpiosetconfig(&SCLpin);
                     for(int i=0;i<32;i++)
                     {
                         gpioclr(SCLpin);
                         for(int l=0;l<200;l++)
                         {__asm__("nop");}
                         gpioset(SCLpin);
                         for(int l=0;l<200;l++)
                         {__asm__("nop");}
                     }
                     SCLpin = gpioopen(SCL);
                     SCLpin |= gpiolowspeed | gpioaf | gpioopendraintype | gpionopulltype;
                     gpiosetconfig(&SDApin);
                     gpiosetconfig(&SCLpin);
                     uint8_t gpioAFi2cx = GPIO_AF_I2C1;
                     switch(dev)
                     {
                     case i2c1:
                         gpioAFi2cx = GPIO_AF_I2C1;
                         break;
                     case i2c2:
                         gpioAFi2cx = GPIO_AF_I2C2;
                         break;
                     case i2c3:
                         gpioAFi2cx = GPIO_AF_I2C3;
                         break;
                     default:
                         break;
                     }
                     GPIO_PinAFConfig(GPIOGETPORT(SDApin), (uint8_t)(SDApin & 0xF), gpioAFi2cx);
                     GPIO_PinAFConfig(GPIOGETPORT(SCLpin), (uint8_t)(SCLpin & 0xF), gpioAFi2cx);
                     return 0;
                 }
                 return -1;
             }
             int i2cenable(i2c_t dev)
             {
                 if((dev<i2c4)&&(dev>=i2c1))
                 {
                     I2C_TypeDef* _dev_ = _i2c_dev_table[(int)dev];
                     _dev_->CR1 |=1 ;
                     return 0;
                 }
                 return -1;
             }
             int i2cdisable(i2c_t dev)
             {
                 if((dev<i2c4)&&(dev>=i2c1))
                 {
                     I2C_TypeDef* _dev_ = _i2c_dev_table[(int)dev];
                     _dev_->CR1 &= ~1;
                     return 0;
                 }
                 return -1;
             }
             int i2csetspeed(i2c_t dev,uint32_t speed)
             {
                 if((dev<i2c4)&&(dev>=i2c1))
                 {
                     I2C_TypeDef* _dev_ = _i2c_dev_table[(int)dev];
                     int32_t APB1Freq=getAPB1Freq()/1000000;
                     if((APB1Freq>1)&&(APB1Freq<43))
                     {
                         uint16_t tmpreg=_dev_->CR2;
                         tmpreg &= ~(0x1f);
                         tmpreg |= APB1Freq;
                         _dev_->CR2=tmpreg;
                         i2cdisable(dev);
                         tmpreg=_dev_->CCR;
                         APB1Freq=getAPB1Freq();
                         if(speed>100000) //100kHz= standard mode, 400kHz= fast mode
                         {
                             if(speed<=400000)
                             {
                                 tmpreg |= 1<<15;
                                 tmpreg &= ~(1<<14);
                                 tmpreg &= ~(0xfff);
                                 tmpreg |= 0xfff & (APB1Freq/(3*speed));
                             }
                         }
                         else
                         {
                             tmpreg &= ~(1<<15);
                             tmpreg &= ~(0xfff);
                             tmpreg |= 0xfff & (APB1Freq/(2*speed));
                         }
                         _dev_->CCR=tmpreg;
                         tmpreg=_dev_->TRISE;
                         tmpreg &= ~(0x3f);
                         tmpreg |= (APB1Freq/1000000)+1;
                         _dev_->TRISE = tmpreg;
                         i2cenable(dev);
                         return 0;
                     }
                 }
                 return -1;
             }
             int i2cbusy(i2c_t dev)
             {
                 if((dev<i2c4)&&(dev>=i2c1))
                 {
                     I2C_TypeDef* _dev_ = _i2c_dev_table[(int)dev];
                     if((_dev_->SR2 & 2) ==2) return 1;  /* Dev is busy */
                     return 0;                           /* Dev isn't busy */
                 }
                 return -1;                              /* Error, dev is out of range */
             }
             int i2cwrite(i2c_t dev,char address,char* data,int count)
             {
                 if((dev<i2c4)&&(dev>=i2c1))
                 {
                     int timeout=i2ctimeout;
                     I2C_TypeDef* _dev_ = _i2c_dev_table[(int)dev];
                     while(i2cbusy(dev))
                     {
                         if(0==(timeout--))
                         {
                             printf("Exited on timeout @ line %d\n\r",__LINE__);
                             return -1;
                         }
                     }
                     _dev_->CR1 |= 1<<8;
                     timeout=i2ctimeout;
                     while(!i2cStatusCheck(dev,((uint32_t)0x00030001)))
                     {
                         if(0==(timeout--))
                         {
                             printf("Exited on timeout @ line %d\n\r",__LINE__);
                             return -1;
                         }
                     }
                     _dev_->DR= address<<1;
                     timeout=i2ctimeout;
                     while(!i2cStatusCheck(dev, ((uint32_t)0x00070082)))
                     {
                         if(0==(timeout--))
                         {
                             printf("Exited on timeout @ line %d\n\r",__LINE__);
                             return -1;
                         }
                     }
                     address=_dev_->SR2;
                     for(int i=0;i<count;i++)
                     {
                         timeout=i2ctimeout;
                         while(!i2cStatusCheck(dev,((uint32_t)0x00070080)))
                         {
                             if(0==(timeout--))
                             {
                                 printf("Exited on timeout @ line %d\n\r",__LINE__);
                                 return -1;
                             }
                         }
                         _dev_->DR= data[i];
                     }
                     timeout=i2ctimeout;
                     while(!i2cStatusCheck(dev,1<<7))
                     {
                         if(0==(timeout--))
                         {
                             printf("Exited on timeout @ line %d\n\r",__LINE__);
                             return -1;
                         }
                     }
                     timeout=i2ctimeout;
                     while(!i2cStatusCheck(dev,1<<2))
                     {
                         if(0==(timeout--))
                         {
                             printf("Exited on timeout @ line %d\n\r",__LINE__);
                             return -1;
                         }
                     }
                     _dev_->CR1 |= 1<<9;
                     return count;
                 }
                 return -1;
             }
             int i2cread(i2c_t dev,char address,char* data,int count)
             {
                 if((dev<i2c4)&&(dev>=i2c1))
                 {
                     int i=0;
                     int timeout=i2ctimeout;
                     while(i2cbusy(dev))
                     {
                         if(0==(timeout--))
                         {
                             printf("Exited on timeout @ line %d\n\r",__LINE__);
                             return -1;
                         }
                     }
                     I2C_TypeDef* _dev_ = _i2c_dev_table[(int)dev];
                     _dev_->CR1 |= (1<<8) + (1<<10);
                     timeout=i2ctimeout;
                     while(!i2cStatusCheck(dev,0x00030001))
                     {
                         if(0==(timeout--))
                         {
                             printf("Exited on timeout @ line %d\n\r",__LINE__);
                             return -1;
                         }
                     }
                     _dev_->DR= (address<<1) + 1;
                     while(!i2cStatusCheck(dev,0x000002))
                     {
                         if(0==(timeout--))
                         {
                             printf("Exited on timeout @ line %d\n\r",__LINE__);
                             return -1;
                         }
                     }
                     if(count==1)
                     {
                         _dev_->CR1 &= ~(1<<10);
                     }
                     address=_dev_->SR2;
                     for(i=0;i<(count-1);i++)
                     {
                         timeout=i2ctimeout;
                         while(!i2cStatusCheck(dev,0x0000040))
                         {
                             if(0==(timeout--))
                             {
                                 printf("Exited on timeout @ line %d\n\r",__LINE__);
                                 return -1;
                             }
                         }
                         data[i]=_dev_->DR;
                     }
                     _dev_->CR1 &= ~(1<<10);
                     _dev_->CR1 |= 1<<9;
                     timeout=i2ctimeout;
                     while(!i2cStatusCheck(dev,0x0000040))
                     {
                         if(0==(timeout--))
                         {
                             printf("Exited on timeout @ line %d\n\r",__LINE__);
                             return -1;
                         }
                     }
                     data[i]=_dev_->DR;
                     timeout=i2ctimeout;
                     while(_dev_->CR1 & ((uint16_t)0x0200))
                     {
                         if(0==(timeout--))
                         {
                             printf("Exited on timeout @ line %d\n\r",__LINE__);
                             return -1;
                         }
                     }
                     _dev_->CR1 |= 1<<10;
                     return count;
                 }
                 return -1;
             }
             int i2cStatusCheck(i2c_t dev,int32_t flagMask)
             {
                 int32_t flag;
                 if((dev<i2c4)&&(dev>=i2c1))
                 {
                     I2C_TypeDef* _dev_ = _i2c_dev_table[(int)dev];
                     flag= _dev_->SR1 + (_dev_->SR2<<16);
                     if(flagMask==(flag & flagMask))
                         return 1;
                     return 0;
                 }
                 return -1;
             }

lib/src/stm32f4/SDCARD-SDIO/sdcard-sdio.c +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2012, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
-            --                   Mail : alexis.jeandet@gmail.com
+            --                   Mail : alexis.jeandet@member.fsf.org
             -------------------------------------------------------------------------------*/
             #include <i2c.h>
             #include <stm32f4xx_usart.h>
             #include <stm32f4xx_rcc.h>
             #include <stm32f4xx_gpio.h>
             #include <stm32f4xx_sdio.h>
             #include <gpio.h>
             #include <core.h>
             #include <sdcard.h>
             #include <sdcard-sdio.h>
             void sdcardsdiomake(sdcardDev* sdcard,UHANDLE phy,void (*rcvr_mmc) (UHANDLE,char *,uint32_t ),void (*xmit_mmc) (UHANDLE,const char *,uint32_t ),void (*setspeed) (UHANDLE phy,uint32_t speed),uint32_t (*getspeed) (UHANDLE phy))
             {
                 sdcard->phy = phy;
                 sdcard->rcvr_mmc = rcvr_mmc;
                 sdcard->xmit_mmc = xmit_mmc;
                 sdcard->setspeed = setspeed;
                 sdcard->getspeed = getspeed;
             }
             void sdcardsdiomakeblkdev(blkdevice* dev,sdcardDev* sdcard, blkdevselect_t select,blkdevpower_t power,blkdevdetect_t detect,blkdevwriteprotected_t writeprotected)
             {
                 dev->phy=sdcard;
                 dev->select=select;
                 dev->power = power;
                 dev->detect = detect;
                 dev->writeprotected = writeprotected;
                 /*dev->write = sdcarddisk_write;
                 dev->read = sdcarddisk_read;
                 dev->ioctl = sdcarddisk_ioctl;
                 dev->initialize = sdcarddisk_initialize;
                 dev->status = sdcarddisk_status;*/
             }
             int sdcardselect (blkdeviceptr _this)
             {
             }
             void sdcarddeselect (blkdeviceptr _this)
             {
             }
             int sdcardwait_ready (sdcardDev* sdcard)
             {
             }
             int sdcardxmit_datablock (sdcardDev* sdcard,const char *buff,char token)
             {
             }
             int sdcardrcvr_datablock (sdcardDev* sdcard,char *buff,uint32_t btr)
             {
             }
             char sdcardsend_cmd (blkdeviceptr _this,char cmd,uint32_t arg)
             {
             }
             DSTATUS sdcarddisk_status (blkdeviceptr _this)
             {
                 return RES_OK;
             }
             DSTATUS sdcarddisk_initialize (blkdeviceptr _this)
             {
                 return RES_OK;
             }
             DRESULT sdcarddisk_read (blkdeviceptr _this,char *buff,uint32_t sector,char count)
             {
                 return RES_OK;
             }
             DRESULT sdcarddisk_write (blkdeviceptr _this,const char *buff,uint32_t sector,char count)
             {
             }
             DRESULT sdcarddisk_ioctl (blkdeviceptr _this,char ctrl,void *buff)
             {
                 return RES_OK;
             }

lib/src/stm32f4/SPI/spi.c +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2011, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
-            --                   Mail : alexis.jeandet@gmail.com
+            --                   Mail : alexis.jeandet@member.fsf.org
             -------------------------------------------------------------------------------*/
             #include <spi.h>
             #include <stm32f4xx_rcc.h>
             #include <stm32f4xx_gpio.h>
             #include <gpio.h>
             #define GPIOGETPORT(gpio)   ((GPIO_TypeDef*)(((((uint32_t)gpio) & (uint32_t)0x0000FF00)*(uint32_t)4) + (uint32_t)GPIOA))
             #define GPIOPORTNUM(gpio)   (((uint32_t)(gpio) & (uint32_t)0x0000FF00)>>(uint32_t)8)
             SPI_TypeDef* _spi_dev_table[3]={SPI1,SPI2,SPI3};
             spi_t spiopen(int count)
             {
             #define _INIT_DEV(_RCC_) \
                 RCC_APB1PeriphClockCmd(_RCC_, ENABLE); \
                 RCC_APB1PeriphResetCmd(_RCC_, ENABLE); \
                 RCC_APB1PeriphResetCmd(_RCC_, DISABLE); \
                 RCC_APB1PeriphClockCmd(_RCC_, ENABLE);
                 switch(count)
                 {
                 case spi1:
                     RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);
                     RCC_APB2PeriphResetCmd(RCC_APB2Periph_SPI1, ENABLE);
                     RCC_APB2PeriphResetCmd(RCC_APB2Periph_SPI1, DISABLE);
                     RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);
                     return spi1;
                     break;
                 case spi2:
                     _INIT_DEV(RCC_APB1Periph_SPI2);
                     return spi2;
                     break;
                 case spi3:
                     _INIT_DEV(RCC_APB1Periph_SPI3);
                     return spi3;
                     break;
                 default:
                     break;
                 }
                 return -1;
             }
             spi_t spiopenandconfig(int count, uint32_t cfg, uint32_t speed, uint32_t MOSIpin, uint32_t MISOpin, uint32_t SCKpin, uint32_t SCSpin)
             {
                 spi_t dev = spiopen(count);
                 if(dev!=-1)
                 {
                     spidisable(dev);
                     spisetpins(dev,MOSIpin, MISOpin, SCKpin, SCSpin);
                     spienable(dev);
                     spisetconfig(dev,cfg,speed);
                 }
                 return dev;
             }
             int spiclose(spi_t spidev)
             {
                 if((spidev<3)&&(spidev>=0))
                 {
                     switch(spidev)
                     {
                     case spi1:
                         RCC_APB2PeriphResetCmd(RCC_APB2Periph_SPI1, ENABLE);
                         break;
                     case spi2:
                         RCC_APB1PeriphResetCmd(RCC_APB1Periph_SPI2, ENABLE);
                         break;
                     case spi3:
                         RCC_APB1PeriphResetCmd(RCC_APB1Periph_SPI3, ENABLE);
                         break;
                     default:
                         return -1;
                         break;
                     }
                     return 1;
                 }
                 return -1;
             }
             int spisetpins(spi_t spidev,uint32_t MOSIpin,uint32_t MISOpin,uint32_t SCKpin,uint32_t SCSpin)
             {
                 if((spidev<3)&&(spidev>=0))
                 {
                     SPI_TypeDef* _dev_ = _spi_dev_table[(int)spidev];
                     gpio_t MISO,MOSI,SCK,SCS;
                     uint8_t gpioAFspix = GPIO_AF_SPI1;
                     switch(spidev)
                     {
                     case spi1:
                         gpioAFspix = GPIO_AF_SPI1;
                         break;
                     case spi2:
                         gpioAFspix = GPIO_AF_SPI2;
                         break;
                     case spi3:
                         gpioAFspix = GPIO_AF_SPI3;
                         break;
                     default:
                         break;
                     }
                     if(MISOpin!=-1)
                     {
                         MISO = gpioopen(MISOpin);
                         MISO |= gpiohighspeed | gpioaf | gpiopushpulltype | gpionopulltype;
                         gpiosetconfig(&MISO);
                         GPIO_PinAFConfig(GPIOGETPORT(MISO), (uint8_t)(MISO & 0xF), gpioAFspix);
                     }
                     if(MOSIpin!=-1)
                     {
                         MOSI = gpioopen(MOSIpin);
                         MOSI |= gpiohighspeed | gpioaf | gpiopushpulltype | gpionopulltype;
                         gpiosetconfig(&MOSI);
                         GPIO_PinAFConfig(GPIOGETPORT(MOSI), (uint8_t)(MOSI & 0xF), gpioAFspix);
                     }
                     if(SCKpin!=-1)
                     {
                         SCK  = gpioopen(SCKpin);
                         SCK  |= gpiohighspeed | gpioaf | gpiopushpulltype | gpionopulltype;
                         gpiosetconfig(&SCK);
                         GPIO_PinAFConfig(GPIOGETPORT(SCK), (uint8_t)(SCK  & 0xF), gpioAFspix);
                     }
                     if(SCSpin!=-1)
                     {
                         SCS = gpioopen(SCSpin);
                         SCS |= gpiohighspeed | gpioaf | gpiopushpulltype | gpionopulltype;
                         gpiosetconfig(&SCS);
                         GPIO_PinAFConfig(GPIOGETPORT(SCS), (uint8_t)(SCS & 0xF), gpioAFspix);
                         _dev_->CR2  |= (1<<2);
                     }
                     else
                     {
                         _dev_->CR2  &= ~(1<<2);
                     }
                     return 1;
                 }
                 return -1;
             }
             int spienable(spi_t spidev)
             {
                 if((spidev<3)&&(spidev>=0))
                 {
                     SPI_TypeDef* _dev_ = _spi_dev_table[(int)spidev];
                     _dev_->CR1  |= (1<<6);
                     return 1;
                 }
                 return -1;
             }
             int spidisable(spi_t spidev)
             {
                 if((spidev<3)&&(spidev>=0))
                 {
                     SPI_TypeDef* _dev_ = _spi_dev_table[(int)spidev];
                     _dev_->CR1  &= ~(1<<6);
                     return 1;
                 }
                 return -1;
             }
             int spisetconfig(spi_t spidev, uint32_t config, uint32_t speed)
             {
                 if((spidev<3)&&(spidev>=0))
                 {
                     SPI_TypeDef* _dev_ = _spi_dev_table[(int)spidev];
                     _dev_->CR2 |= (1<<2);
                     _dev_->CR1 |= (1<<2);
                     spisetspeed(spidev,speed);
                     spisetdatabits(spidev,config & SPIBITSMASK);
                     spisetbitorder(spidev,config & SPIBITORDERMASK);
                     spisetclkinhlevel(spidev,config & SPICLKINHLVLMASK);
                     spisetclkphase(spidev,config & SPICLKPHASEMASK);
                     return 0;
                 }
                 return 1;
             }
             int spisetspeed(spi_t spidev, uint32_t speed)
             {
                 if((spidev<3)&&(spidev>=0))
                 {
                     SPI_TypeDef* _dev_ = _spi_dev_table[(int)spidev];
                     uint32_t apbclock = 0x00;
                     RCC_ClocksTypeDef RCC_ClocksStatus;
                     RCC_GetClocksFreq(&RCC_ClocksStatus);
                     if (_dev_ == SPI1)
                     {
                         apbclock = RCC_ClocksStatus.PCLK2_Frequency;
                     }
                     else
                     {
                         apbclock = RCC_ClocksStatus.PCLK1_Frequency;
                     }
                     int32_t speederror = 0x7FFFFFFF; //max error
                     int32_t prev_speederror = 0x7FFFFFFF;
                     int32_t realspeed = 0;
                     unsigned char divider = 0;
                     do
                     {
                         divider ++;
                         prev_speederror = speederror;
                         realspeed = apbclock>>(divider);
                         speederror = realspeed - speed;
                         if(speederror<0)speederror=-speederror;
                         if(divider>8)break;
                     }while(speederror<prev_speederror);
                     speed = apbclock>>(divider-1);
                     divider-=2;
                     _dev_->CR1 &= 0xFFD7;  // clear prescaler bits 3:5
                     _dev_->CR1 |= ((0x7 & divider)<<3);
                     return 1;
                 }
                 return -1;
             }
             uint32_t spigetspeed(spi_t spidev)
             {
                 if((spidev<3)&&(spidev>=0))
                 {
                     SPI_TypeDef* _dev_ = _spi_dev_table[(int)spidev];
                     uint32_t apbclock = 0x00;
                     RCC_ClocksTypeDef RCC_ClocksStatus;
                     RCC_GetClocksFreq(&RCC_ClocksStatus);
                     if (_dev_ == SPI1)
                     {
                         apbclock = RCC_ClocksStatus.PCLK2_Frequency;
                     }
                     else
                     {
                         apbclock = RCC_ClocksStatus.PCLK1_Frequency;
                     }
                     int BR= (_dev_->CR1>>3)&0x7;
                     return apbclock>>(BR+1);
                 }
                 return -1;
             }
             int spisetdatabits(spi_t spidev,spibits_t bitscnt)
             {
                 if((spidev<3)&&(spidev>=0))
                 {
                     SPI_TypeDef* _dev_ = _spi_dev_table[(int)spidev];
                     int result = 0;
                     switch(bitscnt)
                     {
                     case spi8bits:
                         _dev_->CR1 &= ~(1<<11);
                         result = 1;
                         break;
                     case spi16bits:
                         _dev_->CR1 |= (1<<11);
                         result = 1;
                         break;
                     default:
                         result =-1;
                         break;
                     }
                     return result;
                 }
                 return -1;
             }
             int spisetbitorder(spi_t spidev,spibitorder_t order)
             {
                 if((spidev<3)&&(spidev>=0))
                 {
                     SPI_TypeDef* _dev_ = _spi_dev_table[(int)spidev];
                     if(order==spimsbfirst)
                     {
                         _dev_->CR1 &= ~(1<<7);
                         return 1;
                     }
                     else
                     {
                         if(order==spilsbfirst)
                         {
                             _dev_->CR1 |= (1<<7);
                             return 1;
                         }
                         else return -1;
                     }
                 }
                 return -1;
             }
             int spisetclkinhlevel(spi_t spidev,spiclkinhlvl_t level)
             {
                 if((spidev<3)&&(spidev>=0))
                 {
                     SPI_TypeDef* _dev_ = _spi_dev_table[(int)spidev];
                     if(level==spiclkinhlow)
                     {
                         _dev_->CR1 &= ~(1<<1);
                         return 1;
                     }
                     else
                     {
                         if(level==spiclkinhhigh)
                         {
                             _dev_->CR1 |= (1<<1);
                             return 1;
                         }
                         else return -1;
                     }
                 }
                 return -1;
             }
             int spisetclkphase(spi_t spidev,spiclkphase_t phase)
             {
                 if((spidev<3)&&(spidev>=0))
                 {
                     SPI_TypeDef* _dev_ = _spi_dev_table[(int)spidev];
                     if(phase==spiclkfirstedge)
                     {
                         _dev_->CR1 &= ~1;
                         return 1;
                     }
                     else
                     {
                         if(phase==spiclksecondedge)
                         {
                             _dev_->CR1 |= 1;
                             return 1;
                         }
                         else return -1;
                     }
                 }
                 return -1;
             }
             int spiputw(spi_t spidev,uint16_t data)
             {
                 if((spidev<3)&&(spidev>=0))
                 {
                     SPI_TypeDef* _dev_ = _spi_dev_table[(int)spidev];
                     while(((_dev_->SR & (1<<1)) == 0) );
                     _dev_->DR = data;
                     while(((_dev_->SR & (1<<0)) == 0) );
                     return _dev_->DR;
                 }
                 return -1;
             }
             uint16_t spigetw(spi_t spidev)
             {
                 if((spidev<3)&&(spidev>=0))
                 {
                     SPI_TypeDef* _dev_ = _spi_dev_table[(int)spidev];
                     while(((_dev_->SR & (1<<1)) == 0) );
                     _dev_->DR = 0xFFFF;
                     while(((_dev_->SR & (1<<0)) == 0) );
                     return _dev_->DR;
                 }
                 return -1;
             }
             int spiputs(spi_t spidev,char* s)
             {
                 while (*s) spiputw(spidev,*s++);
                 return 1;
             }
             int spigets(spi_t spidev,char* s)
             {
                 do
                 {
                     (*s) =  spigetw(spidev);
                 }
                 while(*s++);
                 return 1;
             }
             int spiputnw(spi_t spidev,uint16_t* w,int n)
             {
                 while(n!=0)
                 {
                     spiputw(spidev,*w++);
                     n--;
                 }
                 return 1;
             }
             int spigetnw(spi_t spidev,uint16_t* w,int n)
             {
                 while(n!=0)
                 {
                     *w++=spigetw(spidev);
                     n--;
                 }
                 return 1;
             }
             int spiputnc(spi_t spidev,char* c,int n)
             {
                 while(n!=0)
                 {
                     spiputw(spidev,*c++);
                     n--;
                 }
                 return 1;
             }
             int spigetnc(spi_t spidev,char* c,int n)
             {
                 while(n!=0)
                 {
                     *c++=spigetw(spidev);
                     n--;
                 }
                 return 1;
             }
             int spiavailiabledata(spi_t spidev)
             {
                 return 0;
             }
             int spitransactionfinished(spi_t spidev)
             {
                 SPI_TypeDef* _dev_ = _spi_dev_table[(int)spidev];
                 if((spidev<3)&&(spidev>=0))
                 {
                     if((_dev_->SR & (1<<7)) == (1<<7))return 1;
                 }
                 return 0;
             }

lib/src/stm32f4/UART/uart.c +1 -1

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2011, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
-            --                   Mail : alexis.jeandet@gmail.com
+            --                   Mail : alexis.jeandet@member.fsf.org
             -------------------------------------------------------------------------------*/
             #include <uart.h>
             #include <stm32f4xx_usart.h>
             #include <stm32f4xx_rcc.h>
             #include <stm32f4xx_gpio.h>
             #include <gpio.h>
             #include <stdio.h>
             #define GPIOGETPORT(gpio)   ((GPIO_TypeDef*)(((((uint32_t)gpio) & (uint32_t)0x0000FF00)*(uint32_t)4) + (uint32_t)GPIOA))
             #define GPIOPORTNUM(gpio)   (((uint32_t)(gpio) & (uint32_t)0x0000FF00)>>(uint32_t)8)
             USART_TypeDef* _uart_dev_table[6]={USART1,USART2,USART3,UART4,UART5,USART6};
             int _uartstrsetpos(streamdevice* device,int pos);
             int _uartstrread(streamdevice* device,void* data,int size, int n);
             int _uartstrwrite(streamdevice* device,void* data,int size, int n);
             streamdevice_ops UART_OPS=
             {
                 .write = &_uartstrwrite,
                 .read  = &_uartstrread,
                 .setpos= &_uartstrsetpos,
                 .close = NULL
             };
             uart_t uartopen(int count)
             {
                 switch(count)
                 {
                 case uart1:
                     RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
                     RCC_APB2PeriphResetCmd(RCC_APB2Periph_USART1, ENABLE);
                     RCC_APB2PeriphResetCmd(RCC_APB2Periph_USART1, DISABLE);
                     RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
                     USART1->CR3 &= ~((1<<8) + (1<<9));
                     return uart1;
                     break;
                 case uart2:
                     RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);
                     RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART2, ENABLE);
                     RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART2, DISABLE);
                     RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);
                     USART2->CR3 &= ~((1<<8) + (1<<9));
                     return uart2;
                     break;
                 case uart3:
                     RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);
                     RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART3, ENABLE);
                     RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART3, DISABLE);
                     RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);
                     USART3->CR3 &= ~((1<<8) + (1<<9));
                     return uart3;
                     break;
                 case uart4:
                     RCC_APB1PeriphResetCmd(RCC_APB1Periph_UART4, ENABLE);
                     RCC_APB1PeriphResetCmd(RCC_APB1Periph_UART4, DISABLE);
                     RCC_APB1PeriphClockCmd(RCC_APB1Periph_UART4, ENABLE);
                     UART4->CR3 &= ~((1<<8) + (1<<9));
                     return uart4;
                     break;
                 case uart5:
                     RCC_APB1PeriphResetCmd(RCC_APB1Periph_UART5, ENABLE);
                     RCC_APB1PeriphResetCmd(RCC_APB1Periph_UART5, DISABLE);
                     RCC_APB1PeriphClockCmd(RCC_APB1Periph_UART5, ENABLE);
                     return uart5;
                     break;
                 case uart6:
                     RCC_APB2PeriphResetCmd(RCC_APB2Periph_USART6, ENABLE);
                     RCC_APB2PeriphResetCmd(RCC_APB2Periph_USART6, DISABLE);
                     RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART6, ENABLE);
                     return uart6;
                     break;
                 default:
                     break;
                 }
                 return -1;
             }
             uart_t uartopenandconfig(int count, uint32_t cfg, uint32_t speed, uint32_t TXpin, uint32_t RXpin, uint32_t RTSpin, uint32_t CTSpin)
             {
                 uart_t dev= uartopen(count);
                 uartsetconfig(dev,cfg,speed);
                 uartsetpins(dev,TXpin,RXpin,RTSpin,CTSpin);
                 return dev;
             }
             int uartclose(uart_t uart)
             {
                 switch(uart)
                 {
                 case uart1:
                     RCC_APB2PeriphResetCmd(RCC_APB2Periph_USART1, ENABLE);
                     break;
                 case uart2:
                     RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART2, ENABLE);
                     break;
                 case uart3:
                     RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART3, ENABLE);
                     break;
                 case uart4:
                     RCC_APB1PeriphResetCmd(RCC_APB1Periph_UART4, ENABLE);
                     break;
                 case uart5:
                     RCC_APB1PeriphResetCmd(RCC_APB1Periph_UART5, ENABLE);
                     break;
                 case uart6:
                     RCC_APB2PeriphResetCmd(RCC_APB2Periph_USART6, ENABLE);
                     break;
                 default:
                     return -1;
                     break;
                 }
                 return 1;
             }
             int uartsetpins(uart_t uart,uint32_t TXpin,uint32_t RXpin,uint32_t RTSpin,uint32_t CTSpin)
             {
                 if(uart >5)return -1;
                 if(uart <0)return -1;
                 gpio_t TX,RX,CTS,RTS;
                 TX = gpioopen(TXpin);
                 RX = gpioopen(RXpin);
                 TX |= gpiolowspeed | gpioaf | gpiopushpulltype | gpionopulltype;
                 RX |= gpiolowspeed | gpioaf | gpiopushpulltype | gpionopulltype;
                 gpiosetconfig(&TX);
                 gpiosetconfig(&RX);
                 uint8_t gpioAFuartx = GPIO_AF_USART1;
                 switch(uart)
                 {
                 case uart1:
                     gpioAFuartx = GPIO_AF_USART1;
                     break;
                 case uart2:
                     gpioAFuartx = GPIO_AF_USART2;
                     break;
                 case uart3:
                     gpioAFuartx = GPIO_AF_USART3;
                     break;
                 case uart4:
                     gpioAFuartx = GPIO_AF_UART4;
                     break;
                 case uart5:
                     gpioAFuartx = GPIO_AF_UART5;
                     break;
                 case uart6:
                     gpioAFuartx = GPIO_AF_USART6;
                     break;
                 default:
                     return -1;
                     break;
                 }
                 GPIO_PinAFConfig(GPIOGETPORT(TX), (uint8_t)(TX & 0xF), gpioAFuartx);
                 GPIO_PinAFConfig(GPIOGETPORT(RX), (uint8_t)(RX & 0xF), gpioAFuartx);
                 if((gpioAFuartx!=GPIO_AF_UART5) && (gpioAFuartx!=GPIO_AF_UART4))
                 {
                     if(CTSpin!=-1)
                     {
                         CTS = gpioopen(CTSpin);
                         CTS |= gpiolowspeed | gpioaf | gpiopushpulltype | gpionopulltype;
                         gpiosetconfig(&CTS);
                         GPIO_PinAFConfig(GPIOGETPORT(CTS), (uint8_t)(CTS & 0xF), gpioAFuartx);
                     }
                     if(RTSpin!=-1)
                     {
                         RTS = gpioopen(RTSpin);
                         RTS |= gpiolowspeed | gpioaf | gpiopushpulltype | gpionopulltype;
                         gpiosetconfig(&RTS);
                         GPIO_PinAFConfig(GPIOGETPORT(RTS), (uint8_t)(RTS & 0xF), gpioAFuartx);
                     }
                 }
                 return 1;
             }
             int uartsetconfig(uart_t uart, uint32_t cfg, uint32_t speed)
             {
                 int res=1;
                 uartdisable(uart);
                 uartsetspeed(uart,speed);
                 uartsetparity(uart,cfg & UARTPARITYMASK);
                 uartsetdatabits(uart,cfg & UARTBITSMASK);
                 uartsetstopbits(uart,cfg & UARTSTOPBITSMASK);
                 uartenable(uart);
                 return res;
             }
             int uartenable(uart_t uart)
             {
                 if((uart<6)&&(uart>=0))
                 {
                     USART_TypeDef* _dev_ = _uart_dev_table[(int)uart];
                     _dev_->CR1  |= (1<<13);
                     _dev_->CR1  |= (1<<2) + (1<<3);
                     _dev_->DR = ' ';
                     return 1;
                 }
                 return -1;
             }
             int uartdisable(uart_t uart)
             {
                 if((uart<6)&&(uart>=0))
                 {
                     USART_TypeDef* _dev_ = _uart_dev_table[(int)uart];
                     if((_dev_->CR1 & ((1<<3) +(1<<13)))==((1<<3) +(1<<13)))
                     {
                         while((_dev_->SR & (uint16_t)(1<<7))!=(uint16_t)(1<<7));
                     }
                     _dev_->CR1 &= ~((1<<2) + (1<<3) +(1<<13));
                     return 1;
                 }
                 return -1;
             }
             int uartsetspeed(uart_t uart,uint32_t speed)
             {
                 if((uart<6)&&(uart>=0))
                 {
                     USART_TypeDef* _dev_ = _uart_dev_table[(int)uart];
                     uint32_t tmpreg = 0x00, apbclock = 0x00;
                     uint32_t integerdivider = 0x00;
                     uint32_t fractionaldivider = 0x00;
                     RCC_ClocksTypeDef RCC_ClocksStatus;
                     RCC_GetClocksFreq(&RCC_ClocksStatus);
                     if ((_dev_ == USART1) || ((_dev_ == USART6)))
                     {
                         apbclock = RCC_ClocksStatus.PCLK2_Frequency;
                     }
                     else
                     {
                         apbclock = RCC_ClocksStatus.PCLK1_Frequency;
                     }
                     if (((_dev_->CR1) & USART_CR1_OVER8) != (uint16_t)0)
                     {
                         integerdivider = ((25 * apbclock) / (2 * (speed)));
                     }
                     else
                     {
                         integerdivider = ((25 * apbclock) / (4 * (speed)));
                     }
                     tmpreg = (integerdivider / 100) << 4;
                     fractionaldivider = integerdivider - (100 * (tmpreg >> 4));
                     if ((_dev_->CR1 & USART_CR1_OVER8) != (uint16_t)0)
                     {
                         tmpreg |= ((((fractionaldivider * 8) + 50) / 100)) & ((uint8_t)0x07);
                     }
                     else
                     {
                         tmpreg |= ((((fractionaldivider * 16) + 50) / 100)) & ((uint8_t)0x0F);
                     }
                     _dev_->BRR = (uint16_t)tmpreg;
                     return 1;
                 }
                 return -1;
             }
             int uartsetparity(uart_t uart,uartparity_t parity)
             {
                 if((uart<6)&&(uart>=0))
                 {
                     USART_TypeDef* _dev_ = _uart_dev_table[(int)uart];
                     _dev_->CR1 &= ~(((1<<9)+(1<<10)));
                     switch(parity)
                     {
                     case uartparityeven:
                         _dev_->CR1 |= (1<<10);
                         break;
                     case uartparityodd:
                         _dev_->CR1 |= (1<<10) + (1<<9);
                         break;
                     case uartparitynone:
                         break;
                     default :
                         return 0;
                         break;
                     }
                     return 1;
                 }
                 return -1;
             }
             int uartsetdatabits(uart_t uart,uartbits_t databits)
             {
                 if((uart<6)&&(uart>=0))
                 {
                     USART_TypeDef* _dev_ = _uart_dev_table[(int)uart];
                     _dev_->CR1 &= ~(((1<<12)));
                     switch(databits)
                     {
                     case uart7bits:
                         return 0;
                         break;
                     case uart8bits:
                         break;
                     case uart9bits:
                         _dev_->CR1 |= (1<<12);
                         break;
                     default :
                         return 0;
                         break;
                     }
                     return 1;
                 }
                 return -1;
             }
             int uartsetstopbits(uart_t uart,uartstopbits_t stopbits)
             {
                 if((uart<6)&&(uart>=0))
                 {
                     USART_TypeDef* _dev_ = _uart_dev_table[(int)uart];
                     _dev_->CR2 &= ~(((1<<12)+(1<<13)));
                     switch(stopbits)
                     {
                     case uarthalfstop:
                         _dev_->CR2 |= (1<<12);
                         break;
                     case uartonestop:
                         break;
                     case uartonehalfstop:
                         _dev_->CR2 |= (1<<12) + (1<<13);
                         break;
                     case uarttwostop:
                         _dev_->CR2 |= (1<<13);
                         break;
                     default :
                         return 0;
                         break;
                     }
                     return 1;
                 }
                 return -1;
             }
             int uartputc(uart_t uart,char c)
             {
                 if((uart<6)&&(uart>=0))
                 {
                     USART_TypeDef* _dev_ = _uart_dev_table[(int)uart];
                     while((_dev_->SR & (uint16_t)(1<<7))!=(uint16_t)(1<<7));
                     _dev_->DR = c;
                     return 1;
                 }
                 return -1;
             }
             char uartgetc(uart_t uart)
             {
                 if((uart<6)&&(uart>=0))
                 {
                     USART_TypeDef* _dev_ = _uart_dev_table[(int)uart];
                     while(!(_dev_->SR & (1<<5)));
                     return (char)_dev_->DR;
                 }
                 return -1;
             }
             int uartputs(uart_t uart,char* s)
             {
                 while (*s) uartputc(uart,*s++);
                 return 1;
             }
             int uartgets(uart_t uart,char* s)
             {
                 do
                 {
                     (*s) =  uartgetc(uart);
                 }
                 while(*s++);
                 return 1;
             }
             int uartputnc(uart_t uart,char* c,int n)
             {
                 int l=0;
                 while(l<n)
                 {
                     uartputc(uart,*c++);
                     l++;
                 }
                 return n;
             }
             int uartgetnc(uart_t uart,char* c,int n)
             {
                 int l=0;
                 while(l<n)
                 {
                     *c++=uartgetc(uart);
                     l++;
                 }
                 return n;
             }
             int uartavailiabledata(uart_t uart)
             {
                 if((uart<6)&&(uart>=0))
                 {
                     USART_TypeDef* _dev_ = _uart_dev_table[(int)uart];
                     if(!(_dev_->SR & (1<<5)))
                         return 0;
                     else
                         return 1;
                 }
                 return -1;
             }
             int _uartstrwrite(streamdevice* device,void* data,int size, int n)
             {
                 return uartputnc((uart_t) device->_stream,(char*) data,size*n);
             }
             int _uartstrread(streamdevice* device,void* data,int size, int n)
             {
                 return uartgetnc((uart_t) device->_stream,(char*) data,size*n);
             }
             int _uartstrsetpos(streamdevice* device,int pos)
             {
                 return 1;
             }
             int uartmkstreamdev(uart_t uart,streamdevice* strdev)
             {
                 strdev->_stream = (UHANDLE)uart;/*
                 strdev->write = (write_t)&_uartstrwrite;
                 strdev->read = (read_t)&_uartstrread;
                 strdev->setpos = (setpos_t)&_uartstrsetpos;*/
                 strdev->ops = &UART_OPS;
                 strdev->streamPt = 0;
                 return 1;
             }

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