HG_REPOSITORIES/LPP/INSTRUMENTATION/libuc2 Commit - r27:75d21abb7f67

Sync

jeandet@PC-DE-JEANDET.lab-lpp.local -

r27:75d21abb7f67 default

parent child

Context file:

r27:75d21abb7f67

Collapse all files

examples/BeagleSynthHello/main.c +5 0

             #include <stdio.h>
             #include <fat32.h>
             #include <gpio.h>
             #include <uart.h>
             #include <stm32f4xx.h>
             #include <bsp.h>
             #include <i2c.h>
+            #include <CS43L22.h>
             extern streamdevice* __opnfiles__[];
             int main()
             {
+                CS43L22_t audioDac1;
+                cs43l22open(&audioDac1,i2c1,0);
+                char id=cs43l22getID(&audioDac1);
+                printf("DAC ID=%c\n\r",0x0ff&id);
                 while(1)
                 {
                     for(volatile int i=0;i<1024*2048;i++);
                     gpioset(LED1);
                     gpioclr(LED2);
                     for(volatile int i=0;i<1024*2048;i++);
                     gpioclr(LED1);
                     gpioset(LED2);
                     i2cwrite(i2c1,0x4a,"test",1);
                 }
                 printf("hello world\n\r");
                 return 0;
             }

lib/includes/CS43L22.h +6 -6

             /*------------------------------------------------------------------------------
             --  This file is a part of the libuc, microcontroler library
             --  Copyright (C) 2011, Alexis Jeandet
             --
             --  This program is free software; you can redistribute it and/or modify
             --  it under the terms of the GNU General Public License as published by
             --  the Free Software Foundation; either version 3 of the License, or
             --  (at your option) any later version.
             --
             --  This program is distributed in the hope that it will be useful,
             --  but WITHOUT ANY WARRANTY; without even the implied warranty of
             --  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             --  GNU General Public License for more details.
             --
             --  You should have received a copy of the GNU General Public License
             --  along with this program; if not, write to the Free Software
             --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             -------------------------------------------------------------------------------
             --                 Author : Alexis Jeandet
             --                   Mail : alexis.jeandet@gmail.com
             -------------------------------------------------------------------------------*/
             #ifndef CS43L22_H
             #define CS43L22_H
             #include <i2c.h>
             #include <uhandle.h>
             typedef struct CS43L22_t
             {
              i2c_t i2cdev;
              uint8_t devAddress;
             }CS43L22_t;
-            extern int cs43l22open(CS43L22_t* dev,uint8_t address);
+            extern int cs43l22open(CS43L22_t* dev,i2c_t i2cdev,uint8_t A0);
+            extern uint8_t cs43l22getID(CS43L22_t* dev);
+            #define CS43L22_I2C_ADDRESS 0x4a
             #define CS43L22_MAP_ID                      1
             #define CS43L22_MAP_Power_Ctl_1             2
             #define CS43L22_MAP_Power_Ctl_2             4
             #define CS43L22_MAP_Clocking_Ctl            5
             #define CS43L22_MAP_Interface_Ctl_1         6
             #define CS43L22_MAP_Interface_Ctl_2         7
             #define CS43L22_MAP_Passthrough_A           8
             #define CS43L22_MAP_Passthrough_B           9
             #define CS43L22_MAP_Analog_ZC_SR            0xA
             #define CS43L22_MAP_Passthrough             0xC
             #define CS43L22_MAP_Playback_Ctl_1          0xD
             #define CS43L22_MAP_Misc_Ctl                0xE
             #define CS43L22_MAP_Playback_Ctl_2          0xF
-            #define CS43L22_MAP_Passthrough_A           0x14
+            #define CS43L22_MAP_Passthrough_A_Vol       0x14
-            #define CS43L22_MAP_Passthrough_B           0x15
+            #define CS43L22_MAP_Passthrough_B_Vol       0x15
             #define CS43L22_MAP_PCMA_Vol                0x1A
             #define CS43L22_MAP_PCMB_Vol                0x1B
             #define CS43L22_MAP_BEEP_Freq               0x1C
             #define CS43L22_MAP_BEEP_Vol                0x1d
             #define CS43L22_MAP_BEEP_Tone_Cfg           0x1E
             #define CS43L22_MAP_Tone_Ctl                0x1F
             #define CS43L22_MAP_Master_A_Vol            0x20
             #define CS43L22_MAP_Master_B_Vol            0x21
             #define CS43L22_MAP_Headphone_A_Vol         0x22
             #define CS43L22_MAP_Headphone_B_Vol         0x23
             #define CS43L22_MAP_Speaker_A_Vol           0x24
             #define CS43L22_MAP_Speaker_B_Vol           0x25
             #define CS43L22_MAP_Channel_Mixer           0x26
             #define CS43L22_MAP_Limit_Ctl_1             0x27
             #define CS43L22_MAP_Limit Ctl_2             0x28
             #define CS43L22_MAP_Limiter_Attack          0x29
-            #define CS43L22_MAP_Overflow_&_Clock_Status 0x2E
+            #define CS43L22_MAP_Overflow_And_Clock_Status 0x2E
             #define CS43L22_MAP_Battery_Compensation    0x2F
             #define CS43L22_MAP_VP_Battery_Level        0x30
             #define CS43L22_MAP_Speaker_Status          0x31
             #define CS43L22_MAP_Temperature_Monitor_Control 0x32
             #define CS43L22_MAP_Thermal_Foldback        0x33
             #define CS43L22_MAP_Charge_Pump_Frequency   0x34
             #endif

lib/src/common/AUDIO/CS43L22/CS43L22.c +27 -2

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

             /*------------------------------------------------------------------------------
             --  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)
             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_APB1PeriphClockCmd(_RCC_, ENABLE);
                 switch(count)
                 {
-                case 0:
+                case i2c1:
                     _INIT_DEV(RCC_APB1Periph_I2C1);
-                    return (i2c_t) 0;
+                    return i2c1;
                     break;
-                case 1:
+                case i2c2:
                     _INIT_DEV(RCC_APB1Periph_I2C2);
-                    return (i2c_t) 1;
+                    return i2c2;
                     break;
-                case 2:
+                case i2c3:
                     _INIT_DEV(RCC_APB1Periph_I2C3);
-                    return (i2c_t) 2;
+                    return i2c3;
                     break;
                 default:
                     break;
                 }
                 return -1;
             }
             i2c_t i2copenandconfig(int count,uint32_t cfg,uint32_t speed,uint32_t SDA,uint32_t SCL)
             {
                 i2c_t dev = i2copen(count);
                 if(dev!=-1)
                 {
                     i2cclose(dev);
                     i2csetpins(dev,SDA,SCL);
                     i2copen(count);
                     i2cenable(count);
                     //I2C_TypeDef* _dev_ = _i2c_dev_table[(int)dev];
                     i2csetspeed(dev,speed);
                     i2cenable(count);
                 }
                 return dev;
             }
             int i2cclose(i2c_t dev)
             {
-                switch((int)dev)
+                switch(dev)
                 {
-                case (int)0:
+                case i2c1:
                     RCC_APB1PeriphResetCmd(RCC_APB1Periph_I2C1, ENABLE);
                     break;
-                case (int)1:
+                case i2c2:
                     RCC_APB1PeriphResetCmd(RCC_APB1Periph_I2C2, ENABLE);
                     break;
-                case (int)2:
+                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))
                 {
                     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((int)dev)
+                    switch(dev)
                     {
-                    case 0:
+                    case i2c1:
                         gpioAFi2cx = GPIO_AF_I2C1;
                         break;
-                    case 1:
+                    case i2c2:
                         gpioAFi2cx = GPIO_AF_I2C2;
                         break;
-                    case 2:
+                    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))
                 {
                     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))
                 {
                     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))
                 {
                     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<3)&&(dev>=0))
                 {
                     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))
                 {
                     I2C_TypeDef* _dev_ = _i2c_dev_table[(int)dev];
                     while(i2cbusy(dev));
                     _dev_->CR1 |= 1<<8;
                     while(!i2cStatusCheck(dev,((uint32_t)0x00030001)));
                     _dev_->DR= address<<1;
                     while(!i2cStatusCheck(dev, ((uint32_t)0x00070082)));
                     address=_dev_->SR2;
                     for(int i=0;i<count;i++)
                     {
                         while(!i2cStatusCheck(dev,((uint32_t)0x00070080)));
                         _dev_->DR= data[i];
                     }
                     while(!i2cStatusCheck(dev,1<<7));
                     while(!i2cStatusCheck(dev,1<<2));
                     _dev_->CR1 |= 1<<9;
                     return count;
                 }
                 return -1;
             }
             int i2cread(i2c_t dev,char address,char* data,int count)
             {
                 if((dev<3)&&(dev>=0))
                 {
                     while(i2cbusy(dev));
                     I2C_TypeDef* _dev_ = _i2c_dev_table[(int)dev];
                     _dev_->CR1 |= (1<<8) | (1<<10);
+                    while(!i2cStatusCheck(dev,0x00030001));
+                    _dev_->DR= (address<<1) + 1;
+                    while(!i2cStatusCheck(dev, ((uint32_t)0x00070082)));
                     if(count==1)
                     {
                         _dev_->CR1 &= ~(1<<10);
                     }
-                    while(!i2cStatusCheck(dev,0x00030001));
-                    _dev_->DR= (address<<1) + 1;
-                    while(!i2cStatusCheck(dev, ((uint32_t)0x00070082)));
                     address=_dev_->SR2;
-                    for(int i=0;i<count-1;i++)
+                    for(int i=0;i<(count-1);i++)
                     {
                         while((_dev_->SR1 & (1<<6))==0);
                         data[i]=_dev_->DR;
                     }
                     _dev_->CR1 &= ~(1<<10);
                     _dev_->CR1 |= 1<<9;
-                    while((_dev_->SR1 & (1<<6))==0);
+                    while(!i2cStatusCheck(dev, ((uint32_t)0x10000040)));
                     data[count-1]=_dev_->DR;
+                    while(_dev_->CR1 & ((uint16_t)0x0200));
+                    _dev_->CR1 |= 1<<10;
                     return count;
                 }
                 return -1;
             }
             int i2cStatusCheck(i2c_t dev,int32_t flagMask)
             {
                 int32_t flag;
-                __asm__("nop");
-                __asm__("nop");
-                __asm__("nop");
-                __asm__("nop");
                 if((dev<3)&&(dev>=0))
                 {
                     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/SPI/spi.c +12 -12

             /*------------------------------------------------------------------------------
             --  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 <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 0:
+                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 (spi_t) 0;
+                    return spi1;
                     break;
-                case 1:
+                case spi2:
                     _INIT_DEV(RCC_APB1Periph_SPI2);
-                    return (spi_t) 1;
+                    return spi2;
                     break;
-                case 2:
+                case spi3:
                     _INIT_DEV(RCC_APB1Periph_SPI3);
-                    return (spi_t) 2;
+                    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 0:
+                    case spi1:
                         RCC_APB2PeriphResetCmd(RCC_APB2Periph_SPI1, ENABLE);
                         break;
-                    case 1:
+                    case spi2:
                         RCC_APB1PeriphResetCmd(RCC_APB1Periph_SPI2, ENABLE);
                         break;
-                    case 2:
+                    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 0:
+                    case spi1:
                         gpioAFspix = GPIO_AF_SPI1;
                         break;
-                    case 1:
+                    case spi2:
                         gpioAFspix = GPIO_AF_SPI2;
                         break;
-                    case 2:
+                    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;
             }
             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];
                     _dev_->DR = data;
                     while((_dev_->SR & (1<<7)) == (1<<7));
                     return 1;
                 }
                 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<<7)) == (1<<7));
                     _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;
             }

lib/src/stm32f4/UART/uart.c +25 -38

             /*------------------------------------------------------------------------------
             --  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 <uart.h>
             #include <stm32f4xx_usart.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)
             USART_TypeDef* _uart_dev_table[6]={USART1,USART2,USART3,UART4,UART5,USART6};
             uart_t uartopen(int count)
             {
                 switch(count)
                 {
-                case 0:
+                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 (uart_t)0;
+                    return uart1;
                     break;
-                case 1:
+                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 (uart_t)1;
+                    return uart2;
                     break;
-                case 2:
+                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 (uart_t)2;
+                    return uart3;
                     break;
-                case 3:
+                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 (uart_t)3;
+                    return uart4;
                     break;
-                case 4:
+                case uart5:
                     RCC_APB1PeriphResetCmd(RCC_APB1Periph_UART5, ENABLE);
                     RCC_APB1PeriphResetCmd(RCC_APB1Periph_UART5, DISABLE);
                     RCC_APB1PeriphClockCmd(RCC_APB1Periph_UART5, ENABLE);
-                    return (uart_t)4;
+                    return uart5;
                     break;
-                case 5:
+                case uart6:
                     RCC_APB2PeriphResetCmd(RCC_APB2Periph_USART6, ENABLE);
                     RCC_APB2PeriphResetCmd(RCC_APB2Periph_USART6, DISABLE);
                     RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART6, ENABLE);
-                    return (uart_t)5;
+                    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 1;
+                return dev;
             }
             int uartclose(uart_t uart)
             {
                 switch(uart)
                 {
-                case 0:
+                case uart1:
                     RCC_APB2PeriphResetCmd(RCC_APB2Periph_USART1, ENABLE);
                     break;
-                case 1:
+                case uart2:
                     RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART2, ENABLE);
                     break;
-                case 2:
+                case uart3:
                     RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART3, ENABLE);
                     break;
-                case 3:
+                case uart4:
                     RCC_APB1PeriphResetCmd(RCC_APB1Periph_UART4, ENABLE);
                     break;
-                case 4:
+                case uart5:
                     RCC_APB1PeriphResetCmd(RCC_APB1Periph_UART5, ENABLE);
                     break;
-                case 5:
+                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 0:
+                case uart1:
                     gpioAFuartx = GPIO_AF_USART1;
                     break;
-                case 1:
+                case uart2:
                     gpioAFuartx = GPIO_AF_USART2;
                     break;
-                case 2:
+                case uart3:
                     gpioAFuartx = GPIO_AF_USART3;
                     break;
-                case 3:
+                case uart4:
                     gpioAFuartx = GPIO_AF_UART4;
                     break;
-                case 4:
+                case uart5:
                     gpioAFuartx = GPIO_AF_UART5;
                     break;
-                case 5:
+                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->streamPt = 0;
                 return 1;
             }

rules/common/librules.pri +3 0

             #---------------------------------------------------------------------------------
             #       LIBRARY DEFINITIONS
             #---------------------------------------------------------------------------------
             LIBUC_LIBS_DIR = $$libuc2/lib
             INCLUDEPATH += $$LIBUC_LIBS_DIR/includes \
                         $$LIBUC_LIBS_DIR/includes/$$ARCH
             LIBUC_BIN_LIBS_DIR = $$LIBUC_LIBS_DIR/bin/$$ARCH
             LIBS += -L$$LIBUC_LIBS_DIR/bin/$$ARCH \
+                     -lCS43L22
+            LIBS += -L$$LIBUC_LIBS_DIR/bin/$$ARCH \
                      -lsdcard
             LIBS += -L$$LIBUC_LIBS_DIR/bin/$$ARCH \
                      -lfat32
             LIBS += -L$$LIBUC_LIBS_DIR/bin/$$ARCH \
                      -lmbr
             LIBS += -L$$LIBUC_LIBS_DIR/bin/$$ARCH \
                      -luart
             LIBS += -L$$LIBUC_LIBS_DIR/bin/$$ARCH \
                      -li2c
             LIBS += -L$$LIBUC_LIBS_DIR/bin/$$ARCH \
                      -lgpio
             LIBS += -L$$LIBUC_LIBS_DIR/bin/$$ARCH \
                      -lspi
             LIBS += -L$$LIBUC_LIBS_DIR/bin/$$ARCH \
                      -lcpu
             LIBS += -L$$LIBUC_LIBS_DIR/bin/$$ARCH \
                      -lcore
             LIBUC_LIBS_CORE          = -L $(LIBUC_LIBS_DIR_CORE) -static -lcore
             LIBUC_LIBS_DIR_CORE      = $(LIBUC_LIBS_DIR)
             LIBUC_LIBS_DIR_CORE_CMD  = -L $(LIBUC_LIBS_DIR_CORE)
             LIBUC_INC_DIR_CORE       = $(LIBUC_INC_DIR)
             LIBUC_INC_DIR_CORE_CMD   =
             LIBUC_LIBS_CPU          = -static -lcpu
             LIBUC_LIBS_DIR_CPU      = $(LIBUC_LIBS_DIR)
             LIBUC_LIBS_DIR_CPU_CMD  = -L $(LIBUC_LIBS_DIR_CPU)
             LIBUC_INC_DIR_CPU       = $(LIBUC_INC_DIR)/$(ARCH)
             LIBUC_INC_DIR_CPU_CMD   = -I $(LIBUC_INC_DIR_CPU)
             LIBUC_LIBS_GPIO          = -static -lgpio
             LIBUC_LIBS_DIR_GPIO      = $(LIBUC_LIBS_DIR)
             LIBUC_LIBS_DIR_GPIO_CMD  = -L $(LIBUC_LIBS_DIR_GPIO)
             LIBUC_INC_DIR_GPIO       = $(LIBUC_INC_DIR)
             LIBUC_INC_DIR_GPIO_CMD   =
             LIBUC_LIBS_APB          = -static -lapb
             LIBUC_LIBS_DIR_APB      = $(LIBUC_LIBS_DIR)
             LIBUC_LIBS_DIR_APB_CMD  = -L $(LIBUC_LIBS_DIR_APB)
             LIBUC_INC_DIR_APB       = $(LIBUC_INC_DIR)
             LIBUC_INC_DIR_APB_CMD   =
             LIBUC_LIBS_UCSTRINGS         = -static -lucstrings
             LIBUC_LIBS_DIR_UCSTRINGS     = $(LIBUC_LIBS_DIR)
             LIBUC_LIBS_DIR_UCSTRINGS_CMD = -L $(LIBUC_LIBS_DIR_UCSTRINGS)
             LIBUC_INC_DIR_UCSTRINGS      = $(LIBUC_INC_DIR)
             LIBUC_INC_DIR_UCSTRINGS_CMD  =
             LIBUC_LIBS_UART          = -static -luart
             LIBUC_LIBS_DIR_UART      = $(LIBUC_LIBS_DIR)
             LIBUC_LIBS_DIR_UART_CMD  = -L $(LIBUC_LIBS_DIR_UART)
             LIBUC_INC_DIR_UART       = $(LIBUC_INC_DIR)
             LIBUC_INC_DIR_UART_CMD   =
             LIBUC_LIBS_SPI          = -static -lspi
             LIBUC_LIBS_DIR_SPI      = $(LIBUC_LIBS_DIR)
             LIBUC_LIBS_DIR_SPI_CMD  = -L $(LIBUC_LIBS_DIR_SPI)
             LIBUC_INC_DIR_SPI       = $(LIBUC_INC_DIR)
             LIBUC_INC_DIR_SPI_CMD   =
             LIBUC_LIBS_SSP           = -static -lssp
             LIBUC_LIBS_DIR_SSP       = $(LIBUC_LIBS_DIR)
             LIBUC_LIBS_DIR_SSP_CMD   = -L $(LIBUC_LIBS_DIR_SSP)
             LIBUC_INC_DIR_SSP        = $(LIBUC_INC_DIR)
             LIBUC_INC_DIR_SSP_CMD    =
             LIBUC_LIBS_IIC          = -static -liic
             LIBUC_LIBS_DIR_IIC      = $(LIBUC_LIBS_DIR)
             LIBUC_LIBS_DIR_IIC_CMD  = -L $(LIBUC_LIBS_DIR_IIC)
             LIBUC_INC_DIR_IIC       = $(LIBUC_INC_DIR)
             LIBUC_INC_DIR_IIC_CMD   =
             LIBUC_LIBS_ADC          = -static -ladc
             LIBUC_LIBS_DIR_ADC      = $(LIBUC_LIBS_DIR)
             LIBUC_LIBS_DIR_ADC_CMD  = -L $(LIBUC_LIBS_DIR_ADC)
             LIBUC_INC_DIR_ADC       = $(LIBUC_INC_DIR)
             LIBUC_INC_DIR_ADC_CMD   =
             LIBUC_LIBS_24LC0X           = -static -l24lc0X
             LIBUC_LIBS_DIR_24LC0X       = $(LIBUC_LIBS_DIR)
             LIBUC_LIBS_DIR_24LC0X_CMD   = -L $(LIBUC_LIBS_DIR_24LC0X)
             LIBUC_INC_DIR_24LC0X        = $(LIBUC_INC_DIR)
             LIBUC_INC_DIR_24LC0X_CMD    =
             LIBUC_LIBS_SDCARD           = -static -lsdcard
             LIBUC_LIBS_DIR_SDCARD       = $(LIBUC_LIBS_DIR)
             LIBUC_LIBS_DIR_SDCARD_CMD   = -L $(LIBUC_LIBS_DIR_SDCARD)
             LIBUC_INC_DIR_SDCARD        = $(LIBUC_INC_DIR)
             LIBUC_INC_DIR_SDCARD_CMD    =
             LIBUC_LIBS_VS10XX           = -static -lvs10XX
             LIBUC_LIBS_DIR_VS10XX       = $(LIBUC_LIBS_DIR)
             LIBUC_LIBS_DIR_VS10XX_CMD   = -L $(LIBUC_LIBS_DIR_VS10XX)
             LIBUC_INC_DIR_VS10XX        = $(LIBUC_INC_DIR)
             LIBUC_INC_DIR_VS10XX_CMD    =
             LIBUC_LIBS_BLKDEVICE          = -static -lblkdevice
             LIBUC_LIBS_DIR_BLKDEVICE      = $(LIBUC_LIBS_DIR)
             LIBUC_LIBS_DIR_BLKDEVICE_CMD  = -L $(LIBUC_LIBS_DIR_BLKDEVICE)
             LIBUC_INC_DIR_BLKDEVICE       = $(LIBUC_INC_DIR)
             LIBUC_INC_DIR_BLKDEVICE_CMD   =
             LIBUC_LIBS_FAT32           = -static -lfat32
             LIBUC_LIBS_DIR_FAT32       = $(LIBUC_LIBS_DIR)
             LIBUC_LIBS_DIR_FAT32_CMD   = -L $(LIBUC_LIBS_DIR_FAT32)
             LIBUC_INC_DIR_FAT32        = $(LIBUC_INC_DIR)
             LIBUC_INC_DIR_FAT32_CMD    =
             LIBUC_LIBS_UHANDLE          = -static -luhandle
             LIBUC_LIBS_DIR_UHANDLE      = $(LIBUC_LIBS_DIR)
             LIBUC_LIBS_DIR_UHANDLE_CMD  = -L $(LIBUC_LIBS_DIR_UHANDLE)
             LIBUC_INC_DIR_UHANDLE       = $(LIBUC_INC_DIR)
             LIBUC_INC_DIR_UHANDLE_CMD   =
             LIBUC_LIBS_STREAMDEVICES          = -static -lstreamdevices
             LIBUC_LIBS_DIR_STREAMDEVICES      = $(LIBUC_LIBS_DIR)
             LIBUC_LIBS_DIR_STREAMDEVICES_CMD  = -L $(LIBUC_LIBS_DIR_STREAMDEVICES)
             LIBUC_INC_DIR_STREAMDEVICES       = $(LIBUC_INC_DIR)
             LIBUC_INC_DIR_STREAMDEVICES_CMD   =
             LIBUC_LIBS_HEXVIEWER          = -static -lhexviewer
             LIBUC_LIBS_DIR_HEXVIEWER      = $(LIBUC_LIBS_DIR)
             LIBUC_LIBS_DIR_HEXVIEWER_CMD  = -L $(LIBUC_LIBS_DIR_HEXVIEWER)
             LIBUC_INC_DIR_HEXVIEWER       = $(LIBUC_INC_DIR)
             LIBUC_INC_DIR_HEXVIEWER_CMD   =
             LIBUC_LIBS_MBR           = -static -lmbr
             LIBUC_LIBS_DIR_MBR       = $(LIBUC_LIBS_DIR)
             LIBUC_LIBS_DIR_MBR_CMD   = -L $(LIBUC_LIBS_DIR_MBR)
             LIBUC_INC_DIR_MBR        = $(LIBUC_INC_DIR)
             LIBUC_INC_DIR_MBR_CMD    =
             LIBUC_LIBS_UCDIRENT          = -static -lucdirent
             LIBUC_LIBS_DIR_UCDIRENT      = $(LIBUC_LIBS_DIR)
             LIBUC_LIBS_DIR_UCDIRENT_CMD  = -L $(LIBUC_LIBS_DIR_UCDIRENT)
             LIBUC_INC_DIR_UCDIRENT       = $(LIBUC_INC_DIR)
             LIBUC_INC_DIR_UCDIRENT_CMD   =
             LIBUC_LIBS_FS           = -static -lfs
             LIBUC_LIBS_DIR_FS       = $(LIBUC_LIBS_DIR)
             LIBUC_LIBS_DIR_FS_CMD   = -L $(LIBUC_LIBS_DIR_FS)
             LIBUC_INC_DIR_FS        = $(LIBUC_INC_DIR)
             LIBUC_INC_DIR_FS_CMD    =
             LIBUC_LIBS_FSEXPLORER           = -static -lfsexplorer
             LIBUC_LIBS_DIR_FSEXPLORER       = $(LIBUC_LIBS_DIR)
             LIBUC_LIBS_DIR_FSEXPLORER_CMD  	= -L $(LIBUC_LIBS_DIR_FSEXPLORER)
             LIBUC_INC_DIR_FSEXPLORER        = $(LIBUC_INC_DIR)
             LIBUC_INC_DIR_FSEXPLORER_CMD    =
             LIBUC_LIBS_DIR_ALLFS_CMD        = $(LIBUC_LIBS_DIR_UCDIRENT_CMD) $(LIBUC_LIBS_DIR_FS_CMD) $(LIBUC_LIBS_DIR_MBR_CMD) $(LIBUC_LIBS_DIR_FAT32_CMD) $(LIBUC_LIBS_DIR_SDCARD_CMD) $(LIBUC_LIBS_DIR_BLKDEVICE_CMD)
             LIBUC_INC_DIR_ALLFS_CMD         = $(LIBUC_INC_DIR_UCDIRENT_CMD) $(LIBUC_INC_DIR_FS_CMD) $(LIBUC_INC_DIR_MBR_CMD) $(LIBUC_INC_DIR_FAT32_CMD) $(LIBUC_INC_DIR_SDCARD_CMD) $(LIBUC_INC_DIR_BLKDEVICE_CMD)
             LIBUC_LIBS_ALLFS                = $(LIBUC_LIBS_UCDIRENT) $(LIBUC_LIBS_FS) $(LIBUC_LIBS_MBR) $(LIBUC_LIBS_FAT32) $(LIBUC_LIBS_SDCARD) $(LIBUC_LIBS_BLKDEVICE)
             LIBUC_LIBS_ADS127X          = -static -lads127X
             LIBUC_LIBS_DIR_ADS127X      = $(LIBUC_LIBS_DIR)
             LIBUC_LIBS_DIR_ADS127X_CMD  = -L $(LIBUC_LIBS_DIR_ADS127X)
             LIBUC_INC_DIR_ADS127X       = $(LIBUC_INC_DIR)
             LIBUC_INC_DIR_ADS127X_CMD   =
             LIBUC_LIBS_NXPLIB           = -static -lnxplib
             LIBUC_LIBS_DIR_NXPLIB       = $(LIBUC_LIBS_DIR)
             LIBUC_LIBS_DIR_NXPLIB_CMD   = -L $(LIBUC_LIBS_DIR_NXPLIB)
             LIBUC_INC_DIR_NXPLIB        = $(LIBUC_INC_DIR)/LPCXXXX
             LIBUC_INC_DIR_NXPLIB_CMD    = -I $(LIBUC_INC_DIR_NXPLIB)
             LIBUC_LIBS_ARMMATH           = -static -larmmath
             LIBUC_LIBS_DIR_ARMMATH       = $(LIBUC_LIBS_DIR)
             LIBUC_LIBS_DIR_ARMMATH_CMD   = -L $(LIBUC_LIBS_DIR_ARMMATH)
             LIBUC_INC_DIR_ARMMATH        = $(LIBUC_INC_DIR)/ARM
             LIBUC_INC_DIR_ARMMATH_CMD    = $(LIBUC_INC_DIR_ARMMATH)

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