HG_REPOSITORIES/LPP/INSTRUMENTATION/libuc2 Commit - r56:bf21d93f0037

Corrected bug

jeandet -

r56:bf21d93f0037 dev_alexis

parent child

Context file:

r56:bf21d93f0037

Collapse all files

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

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2011, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
             --                   Mail : alexis.jeandet@gmail.com
             -------------------------------------------------------------------------------*/
             #include "bsp.h"
             #include <streamdevices.h>
             #include <malloc.h>
             #include <gpio.h>
             #include <uart.h>
             #include <stdio.h>
             #include <stm32f4xx_gpio.h>
             #include <stm32f4xx_fsmc.h>
             #include <i2c.h>
             #include <core.h>
             #include <terminal.h>
             uint32_t OSC0  =8000000;
             uint32_t INTOSC =16000000;
             uint32_t RTCOSC =32768;
             uint32_t currentCpuFreq=0;
             extern streamdevice* __opnfiles__[__MAX_OPENED_FILES__];
             LCD_IF_t lcdIF0={
                 .init = &bsp_FSMC_init,
                 .writereg = &bsp_lcd0_write_reg,
                 .readreg = &bsp_lcd0_read_reg,
                 .writeGRAM = &bsp_lcd0_writeGRAM,
                 .readGRAM = &bsp_lcd0_readGRAM
             };
             LCD_t lcd0={
                 .interface = &lcdIF0,
                 .init = &ili9328init,
                 .paint = &ili9328paint,
                 .paintText = &ili9328paintText,
                 .paintFilRect = &ili9328paintFilRect,
                 .refreshenable = &ili9328refreshenable,
                 .width= 240,
                 .height = 320
             };
             terminal_t terminal0;
             volatile int16_t* lcd0_CMD=(volatile int16_t*)  0x60000000;
             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,400000,PF0,PF1);
+                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.pri +5 -2

             CPU=stm32f4xxxG
             DEFINES+=BSP=\\\"BEAGLESYNTH\\\"
             beagleCp.target = beagleCp
-            beagleCp.commands = scp $$DESTDIR/$(QMAKE_TARGET).bin root@192.168.7.2://opt/stm32flashAje/hello.bin
+            beagleCp.commands = cd bin && scp $(QMAKE_TARGET).bin root@192.168.7.2://opt/stm32flashAje/hello.bin
-            QMAKE_EXTRA_TARGETS += beagleCp
+            beagleCp131.target = beagleCp131
+            beagleCp131.commands = cd bin && scp $(QMAKE_TARGET).bin root@129.104.27.131://opt/stm32flashAje/hello.bin
+            QMAKE_EXTRA_TARGETS += beagleCp beagleCp131
             UCMODEL=stm32f4

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

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

examples/BeagleSynthHelloSupMon/BeagleSynthHelloSupMon.pro +12 -3

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

examples/BeagleSynthHelloSupMon/main.c +14 -4

             #include <stdio.h>
             #include <fat32.h>
             #include <gpio.h>
             #include <uart.h>
             #include <stm32f4xx.h>
             #include <math.h>
             #include <bsp.h>
             #include <i2c.h>
             #include <CS43L22.h>
             #include <ina226.h>
             #include <fonts.h>
             #include <stdlib.h>
             #include <core.h>
+            #include <malloc.h>
             extern streamdevice* __opnfiles__[];
             #define LCD_COLOR_WHITE          0xFFFF
             #define LCD_COLOR_BLACK          0x0000
             #define LCD_COLOR_GREY           0xF7DE
             #define LCD_COLOR_BLUE           0x001F
             #define LCD_COLOR_BLUE2          0x051F
             #define LCD_COLOR_RED            0xF800
             #define LCD_COLOR_MAGENTA        0xF81F
             #define LCD_COLOR_GREEN          0x07E0
             #define LCD_COLOR_CYAN           0x7FFF
             #define LCD_COLOR_YELLOW         0xFFE0
             #ifndef PSU_DISABLE
             #define PSU_DISABLE LED1
             #endif
+            void setUartAsStdout()
+            {
+                streamdevice* fd1 = (streamdevice*)malloc(sizeof(streamdevice));
+                uart_t uart = uartopenandconfig(uart1,uartparitynone | uart8bits | uartonestop,115200,PA9,PA10,-1,-1);
+                uartmkstreamdev(uart,fd1);
+                __opnfiles__[1] = fd1;
+            }
             int main()
             {
                 delay_100us(20000);
                 INA226_t ina5VSens,ina33VSens,ina15VSens;
                 gpioset(PSU_DISABLE);//enable psu!
-                ili9328paintFilRect(&lcd0,0,0,240,320,LCD_COLOR_BLACK,1,LCD_COLOR_BLACK);
+                setUartAsStdout();
+                //ili9328paintFilRect(&lcd0,0,0,240,320,LCD_COLOR_BLACK,1,LCD_COLOR_BLACK);
                 if(-1==ina226open(&ina33VSens,i2c2,INA226_MODE_SHUNT_VOLTAGE_CONTINUOUS|INA226_AVERAGES_16|INA226_BUS_CONV_8244us|INA226_SHUNT_CONV_8244us,0,0,15,1000000))
                 {
                     printf("Can't open 3.3V monitor\n\r");
                 }
                 if(-1==ina226open(&ina5VSens,i2c2,INA226_MODE_SHUNT_VOLTAGE_CONTINUOUS|INA226_AVERAGES_16|INA226_BUS_CONV_8244us|INA226_SHUNT_CONV_8244us,0,1,15,1000000))
                 {
                     printf("Can't open 5V monitor\n\r");
                 }
                 if(-1==ina226open(&ina15VSens,i2c2,INA226_MODE_SHUNT_VOLTAGE_CONTINUOUS|INA226_AVERAGES_16|INA226_BUS_CONV_8244us|INA226_SHUNT_CONV_8244us,1,0,15,1000000))
                 {
                     printf("Can't open 1.5V monitor\n\r");
                 }
                 int current5V,current33V,current15V;
                 while(1)
                 {
                     current5V = ina226getCurrent(&ina5VSens);
                     current33V = ina226getCurrent(&ina33VSens);
                     current15V = ina226getCurrent(&ina15VSens);
-                    printf("%dmA\n",current15V/1000);
+                    printf("%dmA\n\r",current15V/1000);
-                    printf("%dmA\n",current33V/1000);
+                    printf("%dmA\n\r",current33V/1000);
-                    printf("%dmA\n",current5V/1000);
+                    printf("%dmA\n\r",current5V/1000);
+                    delay_100us(10000);
                 }
                 printf("Exit\n\r");
                 return 0;
             }

examples/lcdTerminal/lcdTerminal.pro +1 -1

             TEMPLATE = app
             CONFIG += cpu
             UCMODEL=stm32f4
             BSP = STM32F4Eval
-            DEFINES += CPUFREQ=160000000
+            DEFINES += CPUFREQ=40000000
             SOURCES += \
                 main.c

examples/lcdTerminal/main.c +10 0

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

lib/src/common/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
             -------------------------------------------------------------------------------*/
             #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<<1) & 2);
+                    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/stm32f4/I2C/i2c.c +73 -26

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2012, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
             --                   Mail : alexis.jeandet@gmail.com
             -------------------------------------------------------------------------------*/
             #include <i2c.h>
             #include <stm32f4xx_usart.h>
             #include <stm32f4xx_rcc.h>
             #include <stm32f4xx_gpio.h>
             #include <gpio.h>
             #include <core.h>
             #define GPIOGETPORT(gpio)   ((GPIO_TypeDef*)(((((uint32_t)gpio) & (uint32_t)0x0000FF00)*(uint32_t)4) + (uint32_t)GPIOA))
             #define GPIOPORTNUM(gpio)   (((uint32_t)(gpio) & (uint32_t)0x0000FF00)>>(uint32_t)8)
             int i2ctimeout=1000*1000;
             I2C_TypeDef* _i2c_dev_table[3]={I2C1,I2C2,I2C3};
             i2c_t i2copen(int count)
             {
             #define _INIT_DEV(_RCC_) \
                 RCC_APB1PeriphClockCmd(_RCC_, ENABLE); \
                 RCC_APB1PeriphResetCmd(_RCC_, ENABLE); \
-                RCC_APB1PeriphResetCmd(_RCC_, DISABLE); \
+                RCC_APB1PeriphResetCmd(_RCC_, DISABLE);
-                RCC_APB1PeriphClockCmd(_RCC_, ENABLE);
                 switch(count)
                 {
                 case i2c1:
                     _INIT_DEV(RCC_APB1Periph_I2C1);
                     return i2c1;
                     break;
                 case i2c2:
                     _INIT_DEV(RCC_APB1Periph_I2C2);
                     return i2c2;
                     break;
                 case i2c3:
                     _INIT_DEV(RCC_APB1Periph_I2C3);
                     return i2c3;
                     break;
                 default:
                     break;
                 }
                 return -1;
             }
             i2c_t i2copenandconfig(int count,uint32_t cfg,uint32_t speed,uint32_t SDA,uint32_t SCL)
             {
                 i2c_t dev = i2copen(count);
                 if(dev!=-1)
                 {
                     i2cclose(dev);
                     i2csetpins(dev,SDA,SCL);
                     i2copen(count);
-                    i2cenable(count);
+                    //i2cenable(count);
                     //I2C_TypeDef* _dev_ = _i2c_dev_table[(int)dev];
                     i2csetspeed(dev,speed);
                     i2cenable(count);
                 }
                 return dev;
             }
             int i2cclose(i2c_t dev)
             {
                 switch(dev)
                 {
                 case i2c1:
                     RCC_APB1PeriphResetCmd(RCC_APB1Periph_I2C1, ENABLE);
                     break;
                 case i2c2:
                     RCC_APB1PeriphResetCmd(RCC_APB1Periph_I2C2, ENABLE);
                     break;
                 case i2c3:
                     RCC_APB1PeriphResetCmd(RCC_APB1Periph_I2C3, ENABLE);
                     break;
                 default:
                     break;
                 }
                 return 1;
             }
             int i2csetpins(i2c_t dev, uint32_t SDA, uint32_t SCL)
             {
-                if((dev<3)&&(dev>=0))
+                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<3)&&(dev>=0))
+                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<3)&&(dev>=0))
+                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<3)&&(dev>=0))
+                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 &= ~(1<<15);
-                                tmpreg &= ~(0xfff);
+                            tmpreg &= ~(0xfff);
-                                tmpreg |= 0xfff & (APB1Freq/(2*speed));
+                            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<3)&&(dev>=0))
+                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<3)&&(dev>=0))
+                if((dev<i2c4)&&(dev>=i2c1))
                 {
                     int timeout=i2ctimeout;
                     I2C_TypeDef* _dev_ = _i2c_dev_table[(int)dev];
                     while(i2cbusy(dev))
                     {
-                        if(0==(timeout--))return -1;
+                        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--))return -1;
+                        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--))return -1;
+                        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--))return -1;
+                            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--))return -1;
+                        if(0==(timeout--))
+                        {
+                            printf("Exited on timeout @ line %d\n\r",__LINE__);
+                            return -1;
+                        }
                     }
                     timeout=i2ctimeout;
                     while(!i2cStatusCheck(dev,1<<2))
                     {
-                        if(0==(timeout--))return -1;
+                        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<3)&&(dev>=0))
+                if((dev<i2c4)&&(dev>=i2c1))
                 {
                     int i=0;
                     int timeout=i2ctimeout;
                     while(i2cbusy(dev))
                     {
-                        if(0==(timeout--))return -1;
+                        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--))return -1;
+                        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--))return -1;
+                        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--))return -1;
+                            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--))return -1;
+                        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--))return -1;
+                        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<3)&&(dev>=0))
+                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;
             }

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