##// END OF EJS Templates
HG_REPOSITORIES » LPP » INSTRUMENTATION » libuc2
RSS

Clone from http://pc-instru.lpp.polytechnique.fr:5000/libuc2

sync
jeandet@PC-DE-JEANDET.lab-lpp.local -
r22:3d19a50d01c6 default
parent child
Show More
Show file before | Show file after | Hide comments
@@ -0,0 +1,12
1 TEMPLATE = app
2 CONFIG += console
3 CONFIG -= qt
4
5 #BSP = BEAGLESYNTH
6 BSP = SOLAR_LFR_PSU
7 include($$(libuc2)/bsp/cfg/$$BSP/bsp.pri)
8 #include($$(libuc2)/rules/stm32f4-arm-none-eabi-gcc/rules.pri)
9
10 SOURCES += \
11 main.c
12
Show file before | Show file after | Hide comments
@@ -0,0 +1,121
1 #!/usr/bin/python
2
3 # Written by Antonio Galea - 2010/11/18
4 # Distributed under Gnu LGPL 3.0
5 # see http://www.gnu.org/licenses/lgpl-3.0.txt
6
7 import sys,struct,zlib,os
8 from optparse import OptionParser
9
10 DEFAULT_DEVICE="0x0483:0xdf11"
11
12 def named(tuple,names):
13 return dict(zip(names.split(),tuple))
14 def consume(fmt,data,names):
15 n = struct.calcsize(fmt)
16 return named(struct.unpack(fmt,data[:n]),names),data[n:]
17 def cstring(string):
18 return string.split('\0',1)[0]
19 def compute_crc(data):
20 return 0xFFFFFFFF & -zlib.crc32(data) -1
21
22 def parse(file,dump_images=False):
23 print 'File: "%s"' % file
24 data = open(file,'rb').read()
25 crc = compute_crc(data[:-4])
26 prefix, data = consume('<5sBIB',data,'signature version size targets')
27 print '%(signature)s v%(version)d, image size: %(size)d, targets: %(targets)d' % prefix
28 for t in range(prefix['targets']):
29 tprefix, data = consume('<6sBI255s2I',data,'signature altsetting named name size elements')
30 tprefix['num'] = t
31 if tprefix['named']:
32 tprefix['name'] = cstring(tprefix['name'])
33 else:
34 tprefix['name'] = ''
35 print '%(signature)s %(num)d, alt setting: %(altsetting)s, name: "%(name)s", size: %(size)d, elements: %(elements)d' % tprefix
36 tsize = tprefix['size']
37 target, data = data[:tsize], data[tsize:]
38 for e in range(tprefix['elements']):
39 eprefix, target = consume('<2I',target,'address size')
40 eprefix['num'] = e
41 print ' %(num)d, address: 0x%(address)08x, size: %(size)d' % eprefix
42 esize = eprefix['size']
43 image, target = target[:esize], target[esize:]
44 if dump_images:
45 out = '%s.target%d.image%d.bin' % (file,t,e)
46 open(out,'wb').write(image)
47 print ' DUMPED IMAGE TO "%s"' % out
48 if len(target):
49 print "target %d: PARSE ERROR" % t
50 suffix = named(struct.unpack('<4H3sBI',data[:16]),'device product vendor dfu ufd len crc')
51 print 'usb: %(vendor)04x:%(product)04x, device: 0x%(device)04x, dfu: 0x%(dfu)04x, %(ufd)s, %(len)d, 0x%(crc)08x' % suffix
52 if crc != suffix['crc']:
53 print "CRC ERROR: computed crc32 is 0x%08x" % crc
54 data = data[16:]
55 if data:
56 print "PARSE ERROR"
57
58 def build(file,targets,device=DEFAULT_DEVICE):
59 data = ''
60 for t,target in enumerate(targets):
61 tdata = ''
62 for image in target:
63 tdata += struct.pack('<2I',image['address'],len(image['data']))+image['data']
64 tdata = struct.pack('<6sBI255s2I','Target',0,1,'ST...',len(tdata),len(target)) + tdata
65 data += tdata
66 data = struct.pack('<5sBIB','DfuSe',1,len(data)+11,len(targets)) + data
67 v,d=map(lambda x: int(x,0) & 0xFFFF, device.split(':',1))
68 data += struct.pack('<4H3sB',0,d,v,0x011a,'UFD',16)
69 crc = compute_crc(data)
70 data += struct.pack('<I',crc)
71 open(file,'wb').write(data)
72
73 if __name__=="__main__":
74 usage = """
75 %prog [-d|--dump] infile.dfu
76 %prog {-b|--build} address:file.bin [-b address:file.bin ...] [{-D|--device}=vendor:device] outfile.dfu"""
77 parser = OptionParser(usage=usage)
78 parser.add_option("-b", "--build", action="append", dest="binfiles",
79 help="build a DFU file from given BINFILES", metavar="BINFILES")
80 parser.add_option("-D", "--device", action="store", dest="device",
81 help="build for DEVICE, defaults to %s" % DEFAULT_DEVICE, metavar="DEVICE")
82 parser.add_option("-d", "--dump", action="store_true", dest="dump_images",
83 default=False, help="dump contained images to current directory")
84 (options, args) = parser.parse_args()
85
86 if options.binfiles and len(args)==1:
87 target = []
88 for arg in options.binfiles:
89 try:
90 address,binfile = arg.split(':',1)
91 except ValueError:
92 print "Address:file couple '%s' invalid." % arg
93 sys.exit(1)
94 try:
95 address = int(address,0) & 0xFFFFFFFF
96 except ValueError:
97 print "Address %s invalid." % address
98 sys.exit(1)
99 if not os.path.isfile(binfile):
100 print "Unreadable file '%s'." % binfile
101 sys.exit(1)
102 target.append({ 'address': address, 'data': open(binfile,'rb').read() })
103 outfile = args[0]
104 device = DEFAULT_DEVICE
105 if options.device:
106 device=options.device
107 try:
108 v,d=map(lambda x: int(x,0) & 0xFFFF, device.split(':',1))
109 except:
110 print "Invalid device '%s'." % device
111 sys.exit(1)
112 build(outfile,[target],device)
113 elif len(args)==1:
114 infile = args[0]
115 if not os.path.isfile(infile):
116 print "Unreadable file '%s'." % infile
117 sys.exit(1)
118 parse(infile, dump_images=options.dump_images)
119 else:
120 parser.print_help()
121 sys.exit(1)
Show file before | Show file after | Hide comments
@@ -0,0 +1,41
1 #include <stdio.h>
2 #include <fat32.h>
3 #include <gpio.h>
4 #include <uart.h>
5 #include <stm32f4xx.h>
6 #include <bsp.h>
7 #include <i2c.h>
8
9
10 extern streamdevice* __opnfiles__[];
11
12 int main()
13 {
14 //gpioset(PSU_DISABLE);
15 printf("i2C Control register 1 (I2C_CR1) = %x\n\r",I2C1->CR1);
16 printf("i2C Control register 2 (I2C_CR2) = %x\n\r",I2C1->CR2);
17 printf("i2C Status register 1 (I2C_SR1) = %x\n\r",I2C1->SR1);
18 printf("i2C Status register 2 (I2C_SR2) = %x\n\r",I2C1->SR2);
19 printf("i2C Clock control register (I2C_CCR) = %x\n\r",I2C1->CCR);
20 while(1)
21 {
22 for(volatile int i=0;i<1024*2048;i++);
23 gpioset(LED1);
24 gpioclr(LED2);
25 for(volatile int i=0;i<1024*2048;i++);
26 gpioclr(LED1);
27 gpioset(LED2);
28 i2cwrite(i2c1,0x4a,"test",4);
29 }
30 printf("hello world\n\r");
31 return 0;
32 }
33
34
35
36
37
38
39
40
41
Show file before | Show file after | Hide comments
@@ -0,0 +1,71
1 /*------------------------------------------------------------------------------
2 -- This file is a part of the libuc, microcontroler library
3 -- Copyright (C) 2012, Alexis Jeandet
4 --
5 -- This program is free software; you can redistribute it and/or modify
6 -- it under the terms of the GNU General Public License as published by
7 -- the Free Software Foundation; either version 3 of the License, or
8 -- (at your option) any later version.
9 --
10 -- This program is distributed in the hope that it will be useful,
11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 -- GNU General Public License for more details.
14 --
15 -- You should have received a copy of the GNU General Public License
16 -- along with this program; if not, write to the Free Software
17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 -------------------------------------------------------------------------------
19 -- Author : Alexis Jeandet
20 -- Mail : alexis.jeandet@gmail.com
21 -------------------------------------------------------------------------------*/
22 #ifndef I2C_H
23 #define I2C_H
24 #include <stdint.h>
25 #include <uhandle.h>
26 #include <streamdevices.h>
27
28 #ifdef __cplusplus
29 extern "C" {
30 #endif
31
32 typedef int i2c_t;
33
34 #define i2c1 0
35 #define i2c2 1
36 #define i2c3 2
37 #define i2c4 3
38 #define i2c5 4
39 #define i2c6 5
40 #define i2c7 6
41 #define i2c8 7
42 #define i2c9 8
43
44 extern i2c_t i2copen(int count);
45 extern i2c_t i2copenandconfig(int count ,uint32_t cfg,uint32_t speed,uint32_t SDA,uint32_t SCL);
46 extern int i2cclose(i2c_t dev);
47 extern int i2csetpins(i2c_t dev,uint32_t SDA,uint32_t SCL);
48 extern int i2cenable(i2c_t dev);
49 extern int i2cdisable(i2c_t dev);
50 //extern int i2csetconfig(i2c_t dev);
51 extern int i2csetspeed(i2c_t dev,uint32_t speed);
52 //extern int i2csetdatabits(i2c_t* dev,uartbits_t databits);
53 extern int i2cwrite(i2c_t dev,char address,char* data,int count);
54 extern int i2cread(i2c_t dev,char address,char* data,int count);
55
56 #ifdef __cplusplus
57 }
58 #endif
59 #endif //I2C_H
60
61
62
63
64
65
66
67
68
69
70
71
Show file before | Show file after | Hide comments
@@ -0,0 +1,246
1 /*------------------------------------------------------------------------------
2 -- This file is a part of the libuc, microcontroler library
3 -- Copyright (C) 2012, Alexis Jeandet
4 --
5 -- This program is free software; you can redistribute it and/or modify
6 -- it under the terms of the GNU General Public License as published by
7 -- the Free Software Foundation; either version 3 of the License, or
8 -- (at your option) any later version.
9 --
10 -- This program is distributed in the hope that it will be useful,
11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 -- GNU General Public License for more details.
14 --
15 -- You should have received a copy of the GNU General Public License
16 -- along with this program; if not, write to the Free Software
17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 -------------------------------------------------------------------------------
19 -- Author : Alexis Jeandet
20 -- Mail : alexis.jeandet@gmail.com
21 -------------------------------------------------------------------------------*/
22
23 #include <i2c.h>
24 #include <stm32f4xx_usart.h>
25 #include <stm32f4xx_rcc.h>
26 #include <stm32f4xx_gpio.h>
27 #include <gpio.h>
28 #include <core.h>
29
30 #define GPIOGETPORT(gpio) ((GPIO_TypeDef*)(((((uint32_t)gpio) & (uint32_t)0x0000FF00)*(uint32_t)4) + (uint32_t)GPIOA))
31 #define GPIOPORTNUM(gpio) (((uint32_t)(gpio) & (uint32_t)0x0000FF00)>>(uint32_t)8)
32
33
34 I2C_TypeDef* _i2c_dev_table[3]={I2C1,I2C2,I2C3};
35
36 i2c_t i2copen(int count)
37 {
38 #define _INIT_DEV(_RCC_) \
39 RCC_APB1PeriphClockCmd(_RCC_, ENABLE); \
40 RCC_APB1PeriphResetCmd(_RCC_, ENABLE); \
41 RCC_APB1PeriphResetCmd(_RCC_, DISABLE); \
42 RCC_APB1PeriphClockCmd(_RCC_, ENABLE);
43
44 switch(count)
45 {
46 case 0:
47 _INIT_DEV(RCC_APB1Periph_I2C1);
48 return (i2c_t) 0;
49 break;
50 case 1:
51 _INIT_DEV(RCC_APB1Periph_I2C2);
52 return (i2c_t) 1;
53 break;
54 case 2:
55 _INIT_DEV(RCC_APB1Periph_I2C3);
56 return (i2c_t) 2;
57 break;
58 default:
59 break;
60 }
61 return -1;
62 }
63
64 i2c_t i2copenandconfig(int count,uint32_t cfg,uint32_t speed,uint32_t SDA,uint32_t SCL)
65 {
66 i2c_t dev = i2copen(count);
67 printf("dev = %d\n\r",dev);
68 if(dev!=-1)
69 {
70 i2cenable(count);
71 I2C_TypeDef* _dev_ = _i2c_dev_table[(int)dev];
72 _dev_->CR1 = (1<<15);
73 _dev_->CR1 &=~(1<<15);
74 i2cdisable(count);
75 i2csetpins(dev,SDA,SCL);
76 i2csetspeed(dev,speed);
77 i2cenable(count);
78 }
79 return dev;
80 }
81
82 int i2cclose(i2c_t dev)
83 {
84 switch((int)dev)
85 {
86 case (int)0:
87 RCC_APB1PeriphResetCmd(RCC_APB1Periph_I2C1, ENABLE);
88 break;
89 case (int)1:
90 RCC_APB1PeriphResetCmd(RCC_APB1Periph_I2C2, ENABLE);
91 break;
92 case (int)2:
93 RCC_APB1PeriphResetCmd(RCC_APB1Periph_I2C3, ENABLE);
94 break;
95 default:
96 break;
97 }
98 return 1;
99 }
100
101 int i2csetpins(i2c_t dev, uint32_t SDA, uint32_t SCL)
102 {
103 if((dev<3)&&(dev>=0))
104 {
105 gpio_t SDApin,SCLpin;
106 SDApin = gpioopen(SDA);
107 SCLpin = gpioopen(SCL);
108 SDApin |= gpiolowspeed | gpioaf | gpioopendraintype | gpionopulltype;
109 SCLpin |= gpiolowspeed | gpioaf | gpioopendraintype | gpionopulltype;
110 gpiosetconfig(&SDApin);
111 gpiosetconfig(&SCLpin);
112 uint8_t gpioAFi2cx = GPIO_AF_I2C1;
113 switch((int)dev)
114 {
115 case 0:
116 gpioAFi2cx = GPIO_AF_I2C1;
117 break;
118 case 1:
119 gpioAFi2cx = GPIO_AF_I2C2;
120 break;
121 case 2:
122 gpioAFi2cx = GPIO_AF_I2C3;
123 break;
124 default:
125 break;
126 }
127 GPIO_PinAFConfig(GPIOGETPORT(SDApin), (uint8_t)(SDApin & 0xF), gpioAFi2cx);
128 GPIO_PinAFConfig(GPIOGETPORT(SCLpin), (uint8_t)(SCLpin & 0xF), gpioAFi2cx);
129 return 0;
130 }
131 return -1;
132 }
133
134 int i2cenable(i2c_t dev)
135 {
136 if((dev<3)&&(dev>=0))
137 {
138 I2C_TypeDef* _dev_ = _i2c_dev_table[(int)dev];
139 _dev_->CR1 |=1 ;
140 return 0;
141 }
142 return -1;
143 }
144
145 int i2cdisable(i2c_t dev)
146 {
147 if((dev<3)&&(dev>=0))
148 {
149 I2C_TypeDef* _dev_ = _i2c_dev_table[(int)dev];
150 _dev_->CR1 &= ~1;
151 return 0;
152 }
153 return -1;
154 }
155
156
157 int i2csetspeed(i2c_t dev,uint32_t speed)
158 {
159 if((dev<3)&&(dev>=0))
160 {
161 I2C_TypeDef* _dev_ = _i2c_dev_table[(int)dev];
162 int32_t APB1Freq=getAPB1Freq()/1000000;
163 if((APB1Freq>1)&&(APB1Freq<43))
164 {
165 int enabled=((_dev_->CR1&1)==1);
166 i2cdisable(dev);
167 _dev_->CR2 &= ~(0x1f);
168 _dev_->CR2 |= APB1Freq;
169 if(speed>100000) //100kHz= standard mode, 400kHz= fast mode
170 {
171 if(speed<=400000)
172 {
173 _dev_->CCR |= 1<<15;
174 _dev_->CCR &= ~(1<<14);
175 _dev_->CCR &= ~(0xfff);
176 _dev_->CCR |= 0xfff & (APB1Freq/(3*speed));
177 }
178 }
179 else
180 {
181 _dev_->CCR &= ~(1<<15);
182 _dev_->CCR &= ~(0xfff);
183 _dev_->CCR |= 0xfff & (APB1Freq/(2*speed));
184 }
185 if(enabled)i2cenable(dev);
186 return 0;
187 }
188 }
189 return -1;
190 }
191
192 int i2cwrite(i2c_t dev,char address,char* data,int count)
193 {
194 if((dev<3)&&(dev>=0))
195 {
196 I2C_TypeDef* _dev_ = _i2c_dev_table[(int)dev];
197 _dev_->CR1 |= 1<<8;
198 while((_dev_->SR1&1)==0);
199 _dev_->DR= address<<1;
200 while((_dev_->SR1 & (1<<3))==0);
201 address=_dev_->SR2;
202 for(int i=0;i<count;i++)
203 {
204 while((_dev_->SR1 & (1<<7))==0);
205 _dev_->DR= data[i];
206 }
207 while((_dev_->SR1 & (1<<7))==0);
208 while((_dev_->SR1 & (1<<2))==0);
209 _dev_->CR1 |= 1<<9;
210 return count;
211 }
212 return -1;
213 }
214
215 int i2cread(i2c_t dev,char address,char* data,int count)
216 {
217 if((dev<3)&&(dev>=0))
218 {
219 I2C_TypeDef* _dev_ = _i2c_dev_table[(int)dev];
220 _dev_->CR1 |= (1<<8) | (1<<10);
221 if(count==1)
222 {
223 _dev_->CR1 &= ~(1<<10);
224 }
225 while((_dev_->SR1&1)==0);
226 _dev_->DR= (address<<1) + 1;
227 while((_dev_->SR1 & (1<<3))==0);
228 address=_dev_->SR2;
229 for(int i=0;i<count-1;i++)
230 {
231 while((_dev_->SR1 & (1<<6))==0);
232 data[i]=_dev_->DR;
233 }
234 _dev_->CR1 &= ~(1<<10);
235 _dev_->CR1 |= 1<<9;
236 while((_dev_->SR1 & (1<<6))==0);
237 data[count-1]=_dev_->DR;
238 return count;
239 }
240 return -1;
241 }
242
243
244
245
246
Show file before | Show file after | Hide comments
@@ -0,0 +1,13
1 TEMPLATE = lib
2 CONFIG += console
3 CONFIG -= qt
4 include($$(libuc2)/rules/stm32f4-arm-none-eabi-gcc/rules.pri)
5
6 SOURCES += \
7 i2c.c
8
9
10 HEADERS += \
11 $$(libuc2)/lib/includes/i2c.h
12
13
Show file before | Show file after | Hide comments
@@ -1,93 +1,96
1 /*------------------------------------------------------------------------------
1 /*------------------------------------------------------------------------------
2 -- This file is a part of the libuc, microcontroler library
2 -- This file is a part of the libuc, microcontroler library
3 -- Copyright (C) 2011, Alexis Jeandet
3 -- Copyright (C) 2011, Alexis Jeandet
4 --
4 --
5 -- This program is free software; you can redistribute it and/or modify
5 -- This program is free software; you can redistribute it and/or modify
6 -- it under the terms of the GNU General Public License as published by
6 -- it under the terms of the GNU General Public License as published by
7 -- the Free Software Foundation; either version 3 of the License, or
7 -- the Free Software Foundation; either version 3 of the License, or
8 -- (at your option) any later version.
8 -- (at your option) any later version.
9 --
9 --
10 -- This program is distributed in the hope that it will be useful,
10 -- This program is distributed in the hope that it will be useful,
11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 -- GNU General Public License for more details.
13 -- GNU General Public License for more details.
14 --
14 --
15 -- You should have received a copy of the GNU General Public License
15 -- You should have received a copy of the GNU General Public License
16 -- along with this program; if not, write to the Free Software
16 -- along with this program; if not, write to the Free Software
17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 -------------------------------------------------------------------------------
18 -------------------------------------------------------------------------------
19 -- Author : Alexis Jeandet
19 -- Author : Alexis Jeandet
20 -- Mail : alexis.jeandet@gmail.com
20 -- Mail : alexis.jeandet@gmail.com
21 -------------------------------------------------------------------------------*/
21 -------------------------------------------------------------------------------*/
22 #ifndef BSP_H
22 #ifndef BSP_H
23 #define BSP_H
23 #define BSP_H
24 #include <stm32f4xx.h>
24 #include <stm32f4xx.h>
25 #include <stm32f4xx_gpio.h>
25 #include <stm32f4xx_gpio.h>
26 #include <stm32f4xx_rcc.h>
26 #include <stm32f4xx_rcc.h>
27 #include <gpio.h>
27 #include <gpio.h>
28
28
29 #define __MAX_OPENED_FILES__ 4
29 #define __MAX_OPENED_FILES__ 4
30 #define __FS_ROOT_SIZE__ 4
30 #define __FS_ROOT_SIZE__ 4
31 /*
31 /*
32 #ifndef PD8
32 #ifndef PD8
33 #define PD8
33 #define PD8
34 #endif
34 #endif
35 #ifndef PD9
35 #ifndef PD9
36 #define PD9
36 #define PD9
37 #endif
37 #endif
38 */
38 */
39
39
40 #define LED1 PD8
40 #define LED1 PD12
41 #define LED2 PD9
41 #define LED2 PD13
42 #define LED3 PD14
43 #define LED4 PD15
44
42
45
43 #define LED3ON GPIOB->BSRRH = GPIO_Pin_15
46 #define LED3ON GPIOB->BSRRH = GPIO_Pin_15
44 #define LED2ON GPIOD->BSRRH = GPIO_Pin_8
47 #define LED2ON GPIOD->BSRRH = GPIO_Pin_8
45 #define LED1ON GPIOD->BSRRH = GPIO_Pin_9
48 #define LED1ON GPIOD->BSRRH = GPIO_Pin_9
46
49
47 #define LED3OFF GPIOB->BSRRL = GPIO_Pin_15
50 #define LED3OFF GPIOB->BSRRL = GPIO_Pin_15
48 #define LED2OFF GPIOD->BSRRL = GPIO_Pin_8
51 #define LED2OFF GPIOD->BSRRL = GPIO_Pin_8
49 #define LED1OFF GPIOD->BSRRL = GPIO_Pin_9
52 #define LED1OFF GPIOD->BSRRL = GPIO_Pin_9
50
53
51 extern float VREF0;
54 extern float VREF0;
52
55
53 extern uint32_t currentCpuFreq;
56 extern uint32_t currentCpuFreq;
54
57
55 extern int bsp_init();
58 extern int bsp_init();
56
59
57 extern void bsp_GPIO_init();
60 extern void bsp_GPIO_init();
58 extern void bsp_uart_init();
61 extern void bsp_uart_init();
59 extern void bsp_iic_init();
62 extern void bsp_iic_init();
60 extern void bsp_spi_init();
63 extern void bsp_spi_init();
61 extern void bsp_SD_init();
64 extern void bsp_SD_init();
62
65
63 /* VS1053 */
66 /* VS1053 */
64 extern void clearXCS();
67 extern void clearXCS();
65 extern void setXCS();
68 extern void setXCS();
66 extern int vs10XXDREQ();
69 extern int vs10XXDREQ();
67
70
68 /* SD CARD */
71 /* SD CARD */
69 void bsppowersdcard(char onoff);
72 void bsppowersdcard(char onoff);
70 char bspsdcardpresent();
73 char bspsdcardpresent();
71 void bspsdcardselect(char YESNO);
74 void bspsdcardselect(char YESNO);
72 char bspsdcardwriteprotected();
75 char bspsdcardwriteprotected();
73
76
74 #endif
77 #endif
75
78
76
79
77
80
78
81
79
82
80
83
81
84
82
85
83
86
84
87
85
88
86
89
87
90
88
91
89
92
90
93
91
94
92
95
93
96
Show file before | Show file after | Hide comments
@@ -1,132 +1,136
1 /*------------------------------------------------------------------------------
1 /*------------------------------------------------------------------------------
2 -- This file is a part of the libuc, microcontroler library
2 -- This file is a part of the libuc, microcontroler library
3 -- Copyright (C) 2011, Alexis Jeandet
3 -- Copyright (C) 2011, Alexis Jeandet
4 --
4 --
5 -- This program is free software; you can redistribute it and/or modify
5 -- This program is free software; you can redistribute it and/or modify
6 -- it under the terms of the GNU General Public License as published by
6 -- it under the terms of the GNU General Public License as published by
7 -- the Free Software Foundation; either version 3 of the License, or
7 -- the Free Software Foundation; either version 3 of the License, or
8 -- (at your option) any later version.
8 -- (at your option) any later version.
9 --
9 --
10 -- This program is distributed in the hope that it will be useful,
10 -- This program is distributed in the hope that it will be useful,
11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 -- GNU General Public License for more details.
13 -- GNU General Public License for more details.
14 --
14 --
15 -- You should have received a copy of the GNU General Public License
15 -- You should have received a copy of the GNU General Public License
16 -- along with this program; if not, write to the Free Software
16 -- along with this program; if not, write to the Free Software
17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 -------------------------------------------------------------------------------
18 -------------------------------------------------------------------------------
19 -- Author : Alexis Jeandet
19 -- Author : Alexis Jeandet
20 -- Mail : alexis.jeandet@gmail.com
20 -- Mail : alexis.jeandet@gmail.com
21 -------------------------------------------------------------------------------*/
21 -------------------------------------------------------------------------------*/
22 #include "bsp.h"
22 #include "bsp.h"
23 #include <streamdevices.h>
23 #include <streamdevices.h>
24 #include <malloc.h>
24 #include <malloc.h>
25 #include <gpio.h>
25 #include <gpio.h>
26 #include <uart.h>
26 #include <uart.h>
27 #include <stdio.h>
27 #include <stdio.h>
28 #include <i2c.h>
29
28 uint32_t OSC0 =8000000;
30 uint32_t OSC0 =8000000;
29 uint32_t INTOSC =16000000;
31 uint32_t INTOSC =16000000;
30 uint32_t RTCOSC =32768;
32 uint32_t RTCOSC =32768;
31 uint32_t currentCpuFreq=0;
33 uint32_t currentCpuFreq=0;
32 extern streamdevice* __opnfiles__[__MAX_OPENED_FILES__];
34 extern streamdevice* __opnfiles__[__MAX_OPENED_FILES__];
33
35
34 float VREF0 =(float)3.3;
36 float VREF0 =(float)3.3;
35
37
36 int bsp_init()
38 int bsp_init()
37 {
39 {
38 int i=0;
40 int i=0;
39 for(i=0;i<32;i++)
41 for(i=0;i<32;i++)
40 {
42 {
41 __opnfiles__[i] = NULL;
43 __opnfiles__[i] = NULL;
42 }
44 }
43 bsp_GPIO_init();
45 bsp_GPIO_init();
44 bsp_uart_init();
46 bsp_uart_init();
47 bsp_iic_init();
45 printf("\r================================================================\n\r");
48 printf("\r================================================================\n\r");
46 printf("================================================================\n\r");
49 printf("================================================================\n\r");
47 printf(BSP);
50 printf(BSP);
48 printf(" initialised\n\r");
51 printf(" initialised\n\r");
49 printf("================================================================\n\r");
52 printf("================================================================\n\r");
50 return 1;
53 return 1;
51 }
54 }
52
55
53 void bsp_GPIO_init()
56 void bsp_GPIO_init()
54 {
57 {
55 gpio_t gpio1 = gpioopen(PD12);//gpioopen(LED1); //PD9 D=> 0x0300 9 => 0x0009
58 gpio_t gpio1 = gpioopen(PD12);//gpioopen(LED1); //PD9 D=> 0x0300 9 => 0x0009
56 gpio_t gpio2 = gpioopen(PD13);//gpioopen(LED2);
59 gpio_t gpio2 = gpioopen(PD13);//gpioopen(LED2);
57 gpio_t gpio3 = gpioopen(PD14);//gpioopen(LED2);
60 gpio_t gpio3 = gpioopen(PD14);//gpioopen(LED2);
58 gpio_t gpio4 = gpioopen(PD15);//gpioopen(LED2);
61 gpio_t gpio4 = gpioopen(PD15);//gpioopen(LED2);
59 gpiosetspeed(&gpio1,gpiohighspeed);
62 gpiosetspeed(&gpio1,gpiohighspeed);
60 gpiosetspeed(&gpio2,gpiohighspeed);
63 gpiosetspeed(&gpio2,gpiohighspeed);
61 gpiosetspeed(&gpio3,gpiohighspeed);
64 gpiosetspeed(&gpio3,gpiohighspeed);
62 gpiosetspeed(&gpio4,gpiohighspeed);
65 gpiosetspeed(&gpio4,gpiohighspeed);
63 gpiosetdir(&gpio1,gpiooutdir);
66 gpiosetdir(&gpio1,gpiooutdir);
64 gpiosetdir(&gpio3,gpiooutdir);
67 gpiosetdir(&gpio3,gpiooutdir);
65 gpiosetdir(&gpio2,gpiooutdir);
68 gpiosetdir(&gpio2,gpiooutdir);
66 gpiosetdir(&gpio4,gpiooutdir);
69 gpiosetdir(&gpio4,gpiooutdir);
67 }
70 }
68
71
69 void bsp_uart_init()
72 void bsp_uart_init()
70 {
73 {
71 if(__opnfiles__[1]==NULL)
74 if(__opnfiles__[1]==NULL)
72 {
75 {
73 uart_t* uart1 = (uart_t*)malloc(sizeof(uart_t));
76 uart_t* uart1 = (uart_t*)malloc(sizeof(uart_t));
74 streamdevice* fd1 = (streamdevice*)malloc(sizeof(streamdevice));
77 streamdevice* fd1 = (streamdevice*)malloc(sizeof(streamdevice));
75 uartopenandconfig(2,uart1,uartparitynone | uart8bits | uartonestop,115200,PB10,PB11,-1,-1);
78 uartopenandconfig(2,uart1,uartparitynone | uart8bits | uartonestop,115200,PB10,PB11,-1,-1);
76 uartmkstreamdev(uart1,fd1);
79 uartmkstreamdev(uart1,fd1);
77 __opnfiles__[1] = fd1;
80 __opnfiles__[1] = fd1;
78 }
81 }
79 else
82 else
80 {
83 {
81 uartopenandconfig(2,(uart_t*)__opnfiles__[1]->_stream,uartparitynone | uart8bits | uartonestop,115200,PB10,PB11,-1,-1);
84 uartopenandconfig(2,(uart_t*)__opnfiles__[1]->_stream,uartparitynone | uart8bits | uartonestop,115200,PB10,PB11,-1,-1);
82 }
85 }
83 }
86 }
84
87
85 void bsp_spi_init()
88 void bsp_spi_init()
86 {
89 {
87
90
88 }
91 }
89
92
90
93
91 void bsp_iic_init()
94 void bsp_iic_init()
92 {
95 {
93
96 if(0==i2copenandconfig(i2c1,0,100000,PB9,PB6))printf("I2C1 opened\n\r");
97 i2cenable(i2c1);
94 }
98 }
95
99
96 void bsp_SD_init()
100 void bsp_SD_init()
97 {
101 {
98
102
99 }
103 }
100
104
101 void vs10XXclearXCS(){}
105 void vs10XXclearXCS(){}
102 void vs10XXsetXCS(){}
106 void vs10XXsetXCS(){}
103 int vs10XXDREQ()
107 int vs10XXDREQ()
104 {
108 {
105 return 1;
109 return 1;
106 }
110 }
107
111
108
112
109 void bsppowersdcard(char onoff) //always ON
113 void bsppowersdcard(char onoff) //always ON
110 {
114 {
111
115
112 }
116 }
113
117
114 char bspsdcardpresent()
118 char bspsdcardpresent()
115 {
119 {
116 return 0;
120 return 0;
117 }
121 }
118
122
119 char bspsdcardwriteprotected()
123 char bspsdcardwriteprotected()
120 {
124 {
121 return 0;
125 return 0;
122 }
126 }
123
127
124 void bspsdcardselect(char YESNO)
128 void bspsdcardselect(char YESNO)
125 {
129 {
126
130
127 }
131 }
128
132
129
133
130
134
131
135
132
136
Show file before | Show file after | Hide comments
@@ -1,11 +1,12
1 TEMPLATE = app
1 TEMPLATE = app
2 CONFIG += console
2 CONFIG += console
3 CONFIG -= qt
3 CONFIG -= qt
4
4
5 BSP = BEAGLESYNTH
5 #BSP = BEAGLESYNTH
6 BSP = SOLAR_LFR_PSU
6 include($$(libuc2)/bsp/cfg/$$BSP/bsp.pri)
7 include($$(libuc2)/bsp/cfg/$$BSP/bsp.pri)
7 #include($$(libuc2)/rules/stm32f4-arm-none-eabi-gcc/rules.pri)
8 #include($$(libuc2)/rules/stm32f4-arm-none-eabi-gcc/rules.pri)
8
9
9 SOURCES += \
10 SOURCES += \
10 main.c
11 main.c
11
12
Show file before | Show file after | Hide comments
@@ -1,45 +1,45
1 #include <stdio.h>
1 #include <stdio.h>
2 #include <fat32.h>
2 #include <fat32.h>
3 #include <gpio.h>
3 #include <gpio.h>
4 #include <uart.h>
4 #include <uart.h>
5 #include <stm32f4xx.h>
5 #include <stm32f4xx.h>
6 #include <bsp.h>
6 #include <bsp.h>
7
7
8
8
9 extern streamdevice* __opnfiles__[];
9 extern streamdevice* __opnfiles__[];
10
10
11 int main()
11 int main()
12 {
12 {
13 gpioset(PSU_DISABLE);
13 //gpioset(PSU_DISABLE);
14 while(1)
14 while(1)
15 {
15 {
16 for(volatile int i=0;i<1024*2048;i++);
16 for(volatile int i=0;i<1024*2048;i++);
17 gpioset(LED1);
17 gpioset(LED1);
18 gpioclr(LED2);
18 gpioclr(LED2);
19 for(volatile int i=0;i<1024*2048;i++);
19 for(volatile int i=0;i<1024*2048;i++);
20 gpioclr(LED1);
20 gpioclr(LED1);
21 gpioset(LED2);
21 gpioset(LED2);
22 }
22 }
23 printf("hello world\n\r");
23 printf("hello world\n\r");
24 return 0;
24 return 0;
25 }
25 }
26
26
27
27
28
28
29 void USART3_IRQHandler(void)
29 void USART3_IRQHandler(void)
30 {
30 {
31 while(1)
31 while(1)
32 {
32 {
33 for(volatile int i=0;i<1024*2048;i++);
33 for(volatile int i=0;i<1024*2048;i++);
34 gpioset(PD12);
34 gpioset(PD12);
35 gpioclr(PD14);
35 gpioclr(PD14);
36 for(volatile int i=0;i<1024*2048;i++);
36 for(volatile int i=0;i<1024*2048;i++);
37 gpioclr(PD12);
37 gpioclr(PD12);
38 gpioset(PD14);
38 gpioset(PD14);
39 }
39 }
40 }
40 }
41
41
42
42
43
43
44
44
45
45
Show file before | Show file after | Hide comments
@@ -1,12 +1,13
1 TEMPLATE = subdirs
1 TEMPLATE = subdirs
2 CONFIG += ordered
2 CONFIG += ordered
3 SUBDIRS += QtTest/test.pro \
3 SUBDIRS += QtTest/test.pro \
4 SOLAR_PSU_HELLO/hello.pro \
4 SOLAR_PSU_HELLO/hello.pro \
5 SDCARD \
5 SDCARD \
6 STM32F4IT
6 STM32F4IT \
7 BeagleSynthHello
7
8
8
9
9
10
10
11
11
12
12
13
Show file before | Show file after | Hide comments
@@ -1,53 +1,62
1 /*------------------------------------------------------------------------------
1 /*------------------------------------------------------------------------------
2 -- This file is a part of the libuc, microcontroler library
2 -- This file is a part of the libuc, microcontroler library
3 -- Copyright (C) 2011, Alexis Jeandet
3 -- Copyright (C) 2011, Alexis Jeandet
4 --
4 --
5 -- This program is free software; you can redistribute it and/or modify
5 -- This program is free software; you can redistribute it and/or modify
6 -- it under the terms of the GNU General Public License as published by
6 -- it under the terms of the GNU General Public License as published by
7 -- the Free Software Foundation; either version 3 of the License, or
7 -- the Free Software Foundation; either version 3 of the License, or
8 -- (at your option) any later version.
8 -- (at your option) any later version.
9 --
9 --
10 -- This program is distributed in the hope that it will be useful,
10 -- This program is distributed in the hope that it will be useful,
11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 -- GNU General Public License for more details.
13 -- GNU General Public License for more details.
14 --
14 --
15 -- You should have received a copy of the GNU General Public License
15 -- You should have received a copy of the GNU General Public License
16 -- along with this program; if not, write to the Free Software
16 -- along with this program; if not, write to the Free Software
17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 -------------------------------------------------------------------------------
18 -------------------------------------------------------------------------------
19 -- Author : Alexis Jeandet
19 -- Author : Alexis Jeandet
20 -- Mail : alexis.jeandet@gmail.com
20 -- Mail : alexis.jeandet@gmail.com
21 -------------------------------------------------------------------------------*/
21 -------------------------------------------------------------------------------*/
22 #include <stm32f4xx.h>
22 #include <stm32f4xx.h>
23
23
24 /*
24 /*
25 #define pll0useInternal 0
25 #define pll0useInternal 0
26 #define pll0useMainOsc 1
26 #define pll0useMainOsc 1
27 #define pll0useRTC 2
27 #define pll0useRTC 2
28 */
28 */
29
29
30 //#define pll0setClksrc(src) if((unsigned int)(src)<3) LPC_SC->CLKSRCSEL=(src)
30 //#define pll0setClksrc(src) if((unsigned int)(src)<3) LPC_SC->CLKSRCSEL=(src)
31 //#define pll0getClksrc (LPC_SC->CLKSRCSEL & 3)
31 //#define pll0getClksrc (LPC_SC->CLKSRCSEL & 3)
32 #ifdef __cplusplus
32 #ifdef __cplusplus
33 extern "C" {
33 extern "C" {
34 #endif
34 #endif
35
35
36 extern void coresetCpuFreq(unsigned int freq);
36 extern uint32_t getAPB1Freq();
37 extern unsigned int coregetCpuFreq();
37 extern uint32_t getAPB2Freq();
38 extern uint32_t getCpuFreq();
39 extern int setCpuFreq(uint32_t freq);
40 extern int optimizePLLcfg(uint32_t freq, uint32_t srcfreq,uint32_t PLLM,uint32_t* PLLP, uint32_t* PLLN,uint8_t* AHBPRindx);
41 extern int setPll(uint32_t freq);
42 extern void enable_FPU();
43 extern void reset_AHB1();
44 extern void reset_AHB2();
45 extern void reset_APB1();
46 extern void reset_APB2();
38
47
39 #ifdef __cplusplus
48 #ifdef __cplusplus
40 }
49 }
41 #endif
50 #endif
42
51
43
52
44
53
45
54
46
55
47
56
48
57
49
58
50
59
51
60
52
61
53
62
Show file before | Show file after | Hide comments
@@ -1,59 +1,329
1 /*------------------------------------------------------------------------------
1 /*------------------------------------------------------------------------------
2 -- This file is a part of the libuc, microcontroler library
2 -- This file is a part of the libuc, microcontroler library
3 -- Copyright (C) 2011, Alexis Jeandet
3 -- Copyright (C) 2011, Alexis Jeandet
4 --
4 --
5 -- This program is free software; you can redistribute it and/or modify
5 -- This program is free software; you can redistribute it and/or modify
6 -- it under the terms of the GNU General Public License as published by
6 -- it under the terms of the GNU General Public License as published by
7 -- the Free Software Foundation; either version 3 of the License, or
7 -- the Free Software Foundation; either version 3 of the License, or
8 -- (at your option) any later version.
8 -- (at your option) any later version.
9 --
9 --
10 -- This program is distributed in the hope that it will be useful,
10 -- This program is distributed in the hope that it will be useful,
11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 -- GNU General Public License for more details.
13 -- GNU General Public License for more details.
14 --
14 --
15 -- You should have received a copy of the GNU General Public License
15 -- You should have received a copy of the GNU General Public License
16 -- along with this program; if not, write to the Free Software
16 -- along with this program; if not, write to the Free Software
17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 -------------------------------------------------------------------------------
18 -------------------------------------------------------------------------------
19 -- Author : Alexis Jeandet
19 -- Author : Alexis Jeandet
20 -- Mail : alexis.jeandet@gmail.com
20 -- Mail : alexis.jeandet@gmail.com
21 -------------------------------------------------------------------------------*/
21 -------------------------------------------------------------------------------*/
22 #include "core.h"
22 #include "core.h"
23 #include <stm32f4xx_rcc.h>
23 #include <stm32f4xx_rcc.h>
24 #include <stdint.h>
25 #include <stdlib.h>
26 #include <stdio.h>
24
27
25 //extern uint32_t OSC0;
28 extern uint32_t OSC0;
26 extern uint32_t INTOSC;
29 extern uint32_t INTOSC;
27 extern uint32_t RTCOSC;
30 extern uint32_t RTCOSC;
28
31
29 void coresetCpuFreq(unsigned int freq)
32
33 uint32_t getAPB1Freq()
30 {
34 {
35 RCC_ClocksTypeDef RCC_ClocksStatus;
36 RCC_GetClocksFreq(&RCC_ClocksStatus);
37 return RCC_ClocksStatus.PCLK1_Frequency;
38 }
39
40 uint32_t getAPB2Freq()
41 {
42 RCC_ClocksTypeDef RCC_ClocksStatus;
43 RCC_GetClocksFreq(&RCC_ClocksStatus);
44 return RCC_ClocksStatus.PCLK2_Frequency;
45 }
31
46
32
47
48 uint32_t getCpuFreq()
49 {
50 uint32_t cpufreq = OSC0;
51 uint32_t PLLN,PLLM,PLLP;
52
53 if((RCC->CFGR & 0xC) == 8) //PLL used as sys clk
54 {
55 uint32_t pllinput=INTOSC;
56 if((RCC->PLLCFGR & (1<<22)) == (1<<22))
57 {
58 pllinput=OSC0;
59 }
60 PLLN = (RCC->PLLCFGR>>6) & 0x1FF;
61 PLLM = RCC->PLLCFGR & 0x3F;
62 PLLP = 1<<(((RCC->PLLCFGR>>16) & 3 )+1);
63 cpufreq = (pllinput * PLLN )/(PLLM*PLLP);
64 }
65 else if((RCC->CFGR & 0xC) == 0) //HSI used as sys clk
66 {
67 cpufreq=INTOSC;
68 }
69 if((RCC->CFGR & (1<<7))==1<<7)
70 {
71 return cpufreq>>((RCC->CFGR & (7<<4))>>4);
72 }
73 return cpufreq;
74 }
75
76 void reset_AHB1()
77 {
78 RCC->AHB1RSTR = -1;
79 RCC->AHB1RSTR = 0;
80 }
81
82 void reset_AHB2()
83 {
84 RCC->AHB2RSTR = -1;
85 RCC->AHB2RSTR = 0;
86 }
87
88 void reset_APB1()
89 {
90 RCC->APB1RSTR = -1;
91 RCC->APB1RSTR = 0;
92 }
93
94 void reset_APB2()
95 {
96 RCC->APB2RSTR = -1;
97 RCC->APB2RSTR = 0;
33 }
98 }
34
99
35
100
36
101
102 /*
103 | 2.7->3.6V
104 -------------------------
105 0WS | 0<HCLK<=30
106 1WS | 30<HCLK<=60
107 2WS | 60<HCLK<=90
108 3WS | 90<HCLK<=120
109 4WS | 120<HCLK<=150
110 5WS | 150<HCLK<=168
37
111
38 unsigned int coregetCpuFreq()
112 f(VCO clock) = f(PLL clock input) × (PLLN / PLLM) [1]
113 64MHz <= f(VCO clock) <= 432MHz [2]
114
115 f(VCO clock input) must be between 1MHz and 2MHz and as close to 2MHz as possible!! [3]
116
117 f(PLL general clock output) = f(VCO clock) / PLLP [4]
118
119 CPU<168MHz AHB1<168MHz AHB2<168MHz APB1<42MHz APB2<84MHz [5]
120
121 ! 63<=PLLN<=432 [6]
122 ! 2<=PLLM<=63 [7]
123 ! PLLP=2,4,6,8 [8]
124 4<=PLLM*PLLP<=504
125
126 F= f(PLL clock input) * A/B with
127 63<=A<=432
128 4<=B<=504
129
130 */
131
132
133 int optimizePLLcfg(uint32_t freq, uint32_t srcfreq,uint32_t PLLM,uint32_t* PLLP, uint32_t* PLLN,uint8_t* AHBPRindx)
134 {
135 uint32_t AHBPRtbl[9]={1,2,4,8,16,64,128,256,512};
136 uint32_t AHBPR=0,AHBPR_r=0,PLLN_r=0,PLLP_r=0;
137 uint32_t Fplli=0;
138 int32_t f_error=100000000;
139 int32_t f_errornw=100000000;
140 Fplli = srcfreq / PLLM;
141 //not efficient but should find the best parameters
142 for((*AHBPRindx)=0;(*AHBPRindx)<9;(*AHBPRindx)++) //lowest priority
143 {
144 AHBPR = AHBPRtbl[(*AHBPRindx)];
145 for(*PLLP=2;*PLLP<9;*PLLP+=2)
146 {
147 *PLLN = (freq*(*PLLP)*AHBPR)/Fplli;
148 if(((*PLLN)>62) && ((*PLLN)<433) && ((Fplli * (*PLLN)) < 433000000))
149 {
150 f_errornw = abs((int32_t)((int32_t)((Fplli*(*PLLN))/((*PLLP)*AHBPR))-freq));
151 if( ( (f_error)>(f_errornw) ) || ( (*AHBPRindx==0)&&(*PLLP==2)&&(*PLLN==63) ) )
152 {
153 f_error=f_errornw;
154 PLLN_r = *PLLN;
155 PLLP_r = *PLLP;
156 AHBPR_r=*AHBPRindx;
157 if(f_error==0)
158 {
159 *PLLN = PLLN_r;
160 *PLLP = PLLP_r;
161 *AHBPRindx = AHBPR_r;
162 return 1;
163 }
164 }
165 }
166 }
167 }
168 *PLLN = PLLN_r;
169 *PLLP = PLLP_r;
170 *AHBPRindx = AHBPR_r;
171 return 1;
172 }
173
174
175 int setPll(uint32_t freq)
39 {
176 {
40 RCC_ClocksTypeDef RCC_ClocksStatus;
177 extern uint32_t OSC0;
41 RCC_GetClocksFreq(&RCC_ClocksStatus);
178 extern uint32_t INTOSC;
42 return RCC_ClocksStatus.SYSCLK_Frequency;
179 uint32_t srcfreq = INTOSC;
180 uint8_t AHBPRindx;
181 uint32_t AHBPRtbl[9]={1,2,4,8,16,64,128,256,512};
182 uint32_t PLLN=0,PLLM=0,PLLP=0,AHBPR=0;
183 uint32_t Fplli=0;
184 if((RCC->PLLCFGR & (1<<22))==(1<<22))
185 {
186 srcfreq = OSC0;
187 }
188 PLLM = srcfreq / 1500000; // [3]
189 Fplli = srcfreq / PLLM;
190 optimizePLLcfg(freq,srcfreq,PLLM,&PLLP,&PLLN,&AHBPRindx);
191 srcfreq = (Fplli*PLLN)/(PLLP*AHBPRtbl[AHBPRindx]); //Put real clk freq in srcfreq for return value
192 //now switch to HSIs
193 if((RCC->CR & 1)==0)RCC->CR |= 1; //turn ON HSI
194 while((RCC->CR & 2)!=2); //wait for HSI Ready
195 RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_SW));
196 RCC->CFGR |= RCC_CFGR_SW_HSI; //set HSI as main clk
197 while ((RCC->CFGR & (uint32_t)RCC_CFGR_SWS ) != RCC_CFGR_SWS_HSI);
198 RCC->CR &= ~(1<<24); //Turn OFF PLL
199 RCC->PLLCFGR &= ~0x37FFF; //clear PLLP PLLM PLLN
200 RCC->PLLCFGR |= PLLM + (PLLN<<6) + (((PLLP>>1) -1)<<16);
201 RCC->CR |= RCC_CR_PLLON; //Turn ON PLL
202 while((RCC->CR & (1<<25))!=(1<<25)); //wait for PLL Ready
203 if(AHBPRindx!=0)AHBPRindx|=0x8;
204 RCC->CFGR &= ~(0xF<<4);
205 RCC->CFGR |= (uint32_t)(AHBPRindx<<4);
206 AHBPR=0;
207 while((srcfreq>>AHBPR)>42000000)AHBPR++; //[5] //Thune APB1 prescaler to keep APB1 CLK below 42MHz
208 if(AHBPR!=0)
209 {
210 AHBPR-=1;
211 AHBPR|=0x4;
212 }
213 RCC->CFGR &= ~(0x7<<10);
214 RCC->CFGR |= (uint32_t)(AHBPR<<10);
215 AHBPR=0;
216 while((srcfreq>>AHBPR)>84000000)AHBPR++; //[5] //Thune APB2 prescaler to keep APB2 CLK below 42MHz
217 if(AHBPR!=0)
218 {
219 AHBPR-=1;
220 AHBPR|=0x4;
221 }
222 RCC->CFGR &= ~(0x7<<13);
223 RCC->CFGR |= (uint32_t)(AHBPR<<13);
224 FLASH->ACR |= FLASH_ACR_LATENCY_7WS;
225 RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_SW));//Switch to PLL as main clk source
226 RCC->CFGR |= RCC_CFGR_SW_PLL;
227 /* Wait till the main PLL is used as system clock source */
228 while ((RCC->CFGR & (uint32_t)RCC_CFGR_SWS ) != RCC_CFGR_SWS_PLL);
229 if(srcfreq>150000000)
230 {
231 FLASH->ACR &= (~7)|FLASH_ACR_LATENCY_5WS;
232 }
233 if((srcfreq<150000000) && (srcfreq>=120000000))
234 {
235 FLASH->ACR &= (~7)|FLASH_ACR_LATENCY_4WS;
236 }
237 if((srcfreq<120000000) && (srcfreq>=90000000))
238 {
239 FLASH->ACR &= (~7)|FLASH_ACR_LATENCY_3WS;
240 }
241 if((srcfreq<90000000) && (srcfreq>=60000000))
242 {
243 FLASH->ACR &= (~7)|FLASH_ACR_LATENCY_2WS;
244 }
245 if((srcfreq<60000000) && (srcfreq>=30000000))
246 {
247 FLASH->ACR &= (~7)|FLASH_ACR_LATENCY_1WS;
248 }
249 if(srcfreq<30000000)
250 {
251 FLASH->ACR &= (~7)|FLASH_ACR_LATENCY_0WS;
252 }
253 return srcfreq;
254 }
255
256 int setCpuFreq(uint32_t freq)
257 {
258 extern uint32_t OSC0;
259 extern uint32_t INTOSC;
260 uint8_t i=0;
261 uint32_t curentFeq = getCpuFreq();
262 if(curentFeq==freq)return curentFeq;
263 if((freq>2000000) && (freq<=250000000)) //be carefull with 250MHz!!!
264 {
265 if((RCC->CFGR & 0xC) == 8) //PLL used as sys clk
266 {
267 return setPll(freq);
268 }
269 else if((RCC->CFGR & 0xC) == 0) //HSI used as sys clk
270 {
271 if((INTOSC%freq)==0) //now check if we can directly divide HSI
272 {
273 if(freq==INTOSC)
274 {
275 RCC->CFGR &= ~(0xF<<4);
276 return freq;
277 }
278 for(i=1;i<8;i++)
279 {
280 if((freq<<i)==INTOSC)
281 {
282 RCC->CFGR &= ~(0xF<<4);
283 RCC->CFGR |= ((0x8|i)<<4);
284 return freq;
285 }
286 }
287 }
288 else
289 return setPll(freq);
290 }
291 else //HSE used as sys clk
292 {
293 if((OSC0%freq)==0) //now check if we can directly divide HSI
294 {
295 if(freq==OSC0)
296 {
297 RCC->CFGR &= ~(0xF<<4);
298 return freq;
299 }
300 for(i=1;i<8;i++)
301 {
302 if((freq<<i)==OSC0)
303 {
304 RCC->CFGR &= ~(0xF<<4);
305 RCC->CFGR |= ((0x8|i)<<4);
306 return freq;
307 }
308 }
309 }
310 else
311 return setPll(freq);
312 }
313 }
314 return 0;
315 }
316
317
318 void enable_FPU()
319 {
320 SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
321 __asm__("dsb");
322 __asm__("isb");
43 }
323 }
44
324
45
325
46
326
47
327
48
328
49
329
50
51
52
53
54
55
56
57
58
59
Show file before | Show file after | Hide comments
@@ -1,337 +1,59
1 #include "stm32f4xx.h"
1 #include "stm32f4xx.h"
2 #include <stdint.h>
2 #include <stdint.h>
3 #include <stdlib.h>
3 #include <stdlib.h>
4 #include <stdio.h>
4 #include <stdio.h>
5 #include <bsp.h>
5 #include <bsp.h>
6 #include <stm32f4xx_rcc.h>
6 #include <stm32f4xx_rcc.h>
7
7 #include <core.h>
8 void reset_AHB1()
8 extern int main();
9 {
10 RCC->AHB1RSTR = -1;
11 RCC->AHB1RSTR = 0;
12 }
13
14 void reset_AHB2()
15 {
16 RCC->AHB2RSTR = -1;
17 RCC->AHB2RSTR = 0;
18 }
19
20 void reset_APB1()
21 {
22 RCC->APB1RSTR = -1;
23 RCC->APB1RSTR = 0;
24 }
25
26 void reset_APB2()
27 {
28 RCC->APB2RSTR = -1;
29 RCC->APB2RSTR = 0;
30 }
31
32
33
34 uint32_t getCpuFreq()
35 {
36 extern uint32_t OSC0;
37 extern uint32_t INTOSC;
38 uint32_t cpufreq = OSC0;
39 uint32_t PLLN,PLLM,PLLP;
40
41 if((RCC->CFGR & 0xC) == 8) //PLL used as sys clk
42 {
43 uint32_t pllinput=INTOSC;
44 if((RCC->PLLCFGR & (1<<22)) == (1<<22))
45 {
46 pllinput=OSC0;
47 }
48 PLLN = (RCC->PLLCFGR>>6) & 0x1FF;
49 PLLM = RCC->PLLCFGR & 0x3F;
50 PLLP = 1<<(((RCC->PLLCFGR>>16) & 3 )+1);
51 cpufreq = (pllinput * PLLN )/(PLLM*PLLP);
52 }
53 else if((RCC->CFGR & 0xC) == 0) //HSI used as sys clk
54 {
55 cpufreq=INTOSC;
56 }
57 if((RCC->CFGR & (1<<7))==1<<7)
58 {
59 return cpufreq>>((RCC->CFGR & (7<<4))>>4);
60 }
61 return cpufreq;
62 }
63
64
65 /*
66 | 2.7->3.6V
67 -------------------------
68 0WS | 0<HCLK<=30
69 1WS | 30<HCLK<=60
70 2WS | 60<HCLK<=90
71 3WS | 90<HCLK<=120
72 4WS | 120<HCLK<=150
73 5WS | 150<HCLK<=168
74
75 f(VCO clock) = f(PLL clock input) × (PLLN / PLLM) [1]
76 64MHz <= f(VCO clock) <= 432MHz [2]
77
78 f(VCO clock input) must be between 1MHz and 2MHz and as close to 2MHz as possible!! [3]
79
80 f(PLL general clock output) = f(VCO clock) / PLLP [4]
81
82 CPU<168MHz AHB1<168MHz AHB2<168MHz APB1<42MHz APB2<84MHz [5]
83
84 ! 63<=PLLN<=432 [6]
85 ! 2<=PLLM<=63 [7]
86 ! PLLP=2,4,6,8 [8]
87 4<=PLLM*PLLP<=504
88
89 F= f(PLL clock input) * A/B with
90 63<=A<=432
91 4<=B<=504
92
93 */
94
95
96 int optimizePLLcfg(uint32_t freq, uint32_t srcfreq,uint32_t PLLM,uint32_t* PLLP, uint32_t* PLLN,uint8_t* AHBPRindx)
97 {
98 uint32_t AHBPRtbl[9]={1,2,4,8,16,64,128,256,512};
99 uint32_t AHBPR=0,AHBPR_r=0,PLLN_r=0,PLLP_r=0;
100 uint32_t Fplli=0;
101 int32_t f_error=100000000;
102 int32_t f_errornw=100000000;
103 Fplli = srcfreq / PLLM;
104 //not efficient but should find the best parameters
105 for((*AHBPRindx)=0;(*AHBPRindx)<9;(*AHBPRindx)++) //lowest priority
106 {
107 AHBPR = AHBPRtbl[(*AHBPRindx)];
108 for(*PLLP=2;*PLLP<9;*PLLP+=2)
109 {
110 *PLLN = (freq*(*PLLP)*AHBPR)/Fplli;
111 if(((*PLLN)>62) && ((*PLLN)<433) && ((Fplli * (*PLLN)) < 433000000))
112 {
113 f_errornw = abs((int32_t)((int32_t)((Fplli*(*PLLN))/((*PLLP)*AHBPR))-freq));
114 if( ( (f_error)>(f_errornw) ) || ( (*AHBPRindx==0)&&(*PLLP==2)&&(*PLLN==63) ) )
115 {
116 f_error=f_errornw;
117 PLLN_r = *PLLN;
118 PLLP_r = *PLLP;
119 AHBPR_r=*AHBPRindx;
120 if(f_error==0)
121 {
122 *PLLN = PLLN_r;
123 *PLLP = PLLP_r;
124 *AHBPRindx = AHBPR_r;
125 return 1;
126 }
127 }
128 }
129 }
130 }
131 *PLLN = PLLN_r;
132 *PLLP = PLLP_r;
133 *AHBPRindx = AHBPR_r;
134 return 1;
135 }
136
9
137
10
138 int setPll(uint32_t freq)
139 {
140 extern uint32_t OSC0;
141 extern uint32_t INTOSC;
142 uint32_t srcfreq = INTOSC;
143 uint8_t AHBPRindx;
144 uint32_t AHBPRtbl[9]={1,2,4,8,16,64,128,256,512};
145 uint32_t PLLN=0,PLLM=0,PLLP=0,AHBPR=0;
146 uint32_t Fplli=0;
147 if((RCC->PLLCFGR & (1<<22))==(1<<22))
148 {
149 srcfreq = OSC0;
150 }
151 PLLM = srcfreq / 1500000; // [3]
152 Fplli = srcfreq / PLLM;
153 optimizePLLcfg(freq,srcfreq,PLLM,&PLLP,&PLLN,&AHBPRindx);
154 srcfreq = (Fplli*PLLN)/(PLLP*AHBPRtbl[AHBPRindx]); //Put real clk freq in srcfreq for return value
155 //now switch to HSIs
156 if((RCC->CR & 1)==0)RCC->CR |= 1; //turn ON HSI
157 while((RCC->CR & 2)!=2); //wait for HSI Ready
158 RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_SW));
159 RCC->CFGR |= RCC_CFGR_SW_HSI; //set HSI as main clk
160 while ((RCC->CFGR & (uint32_t)RCC_CFGR_SWS ) != RCC_CFGR_SWS_HSI);
161 RCC->CR &= ~(1<<24); //Turn OFF PLL
162 RCC->PLLCFGR &= ~0x37FFF; //clear PLLP PLLM PLLN
163 RCC->PLLCFGR |= PLLM + (PLLN<<6) + (((PLLP>>1) -1)<<16);
164 RCC->CR |= RCC_CR_PLLON; //Turn ON PLL
165 while((RCC->CR & (1<<25))!=(1<<25)); //wait for PLL Ready
166 if(AHBPRindx!=0)AHBPRindx|=0x8;
167 RCC->CFGR &= ~(0xF<<4);
168 RCC->CFGR |= (uint32_t)(AHBPRindx<<4);
169 AHBPR=0;
170 while((srcfreq>>AHBPR)>42000000)AHBPR++; //[5] //Thune APB1 prescaler to keep APB1 CLK below 42MHz
171 if(AHBPR!=0)
172 {
173 AHBPR-=1;
174 AHBPR|=0x4;
175 }
176 RCC->CFGR &= ~(0x7<<10);
177 RCC->CFGR |= (uint32_t)(AHBPR<<10);
178 AHBPR=0;
179 while((srcfreq>>AHBPR)>84000000)AHBPR++; //[5] //Thune APB2 prescaler to keep APB2 CLK below 42MHz
180 if(AHBPR!=0)
181 {
182 AHBPR-=1;
183 AHBPR|=0x4;
184 }
185 RCC->CFGR &= ~(0x7<<13);
186 RCC->CFGR |= (uint32_t)(AHBPR<<13);
187 FLASH->ACR |= FLASH_ACR_LATENCY_7WS;
188 RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_SW));//Switch to PLL as main clk source
189 RCC->CFGR |= RCC_CFGR_SW_PLL;
190 /* Wait till the main PLL is used as system clock source */
191 while ((RCC->CFGR & (uint32_t)RCC_CFGR_SWS ) != RCC_CFGR_SWS_PLL);
192 if(srcfreq>150000000)
193 {
194 FLASH->ACR &= (~7)|FLASH_ACR_LATENCY_5WS;
195 }
196 if((srcfreq<150000000) && (srcfreq>=120000000))
197 {
198 FLASH->ACR &= (~7)|FLASH_ACR_LATENCY_4WS;
199 }
200 if((srcfreq<120000000) && (srcfreq>=90000000))
201 {
202 FLASH->ACR &= (~7)|FLASH_ACR_LATENCY_3WS;
203 }
204 if((srcfreq<90000000) && (srcfreq>=60000000))
205 {
206 FLASH->ACR &= (~7)|FLASH_ACR_LATENCY_2WS;
207 }
208 if((srcfreq<60000000) && (srcfreq>=30000000))
209 {
210 FLASH->ACR &= (~7)|FLASH_ACR_LATENCY_1WS;
211 }
212 if(srcfreq<30000000)
213 {
214 FLASH->ACR &= (~7)|FLASH_ACR_LATENCY_0WS;
215 }
216 return srcfreq;
217 }
218
219 int setCpuFreq(uint32_t freq)
220 {
221 extern uint32_t OSC0;
222 extern uint32_t INTOSC;
223 uint8_t i=0;
224 uint32_t curentFeq = getCpuFreq();
225 if(curentFeq==freq)return curentFeq;
226 if((freq>2000000) && (freq<=250000000)) //be carefull with 250MHz!!!
227 {
228 if((RCC->CFGR & 0xC) == 8) //PLL used as sys clk
229 {
230 return setPll(freq);
231 }
232 else if((RCC->CFGR & 0xC) == 0) //HSI used as sys clk
233 {
234 if((INTOSC%freq)==0) //now check if we can directly divide HSI
235 {
236 if(freq==INTOSC)
237 {
238 RCC->CFGR &= ~(0xF<<4);
239 return freq;
240 }
241 for(i=1;i<8;i++)
242 {
243 if((freq<<i)==INTOSC)
244 {
245 RCC->CFGR &= ~(0xF<<4);
246 RCC->CFGR |= ((0x8|i)<<4);
247 return freq;
248 }
249 }
250 }
251 else
252 return setPll(freq);
253 }
254 else //HSE used as sys clk
255 {
256 if((OSC0%freq)==0) //now check if we can directly divide HSI
257 {
258 if(freq==OSC0)
259 {
260 RCC->CFGR &= ~(0xF<<4);
261 return freq;
262 }
263 for(i=1;i<8;i++)
264 {
265 if((freq<<i)==OSC0)
266 {
267 RCC->CFGR &= ~(0xF<<4);
268 RCC->CFGR |= ((0x8|i)<<4);
269 return freq;
270 }
271 }
272 }
273 else
274 return setPll(freq);
275 }
276 }
277 return 0;
278 }
279
280 #include <stdio.h>
281 extern int main();
282
283 inline void enable_FPU()
284 {
285 SCB->CPACR |= ((3UL << 10*2)|(3UL << 11*2)); /* set CP10 and CP11 Full Access */
286 __asm__("dsb");
287 __asm__("isb");
288 }
289
11
290 void cpu_init()
12 void cpu_init()
291 {
13 {
292 extern uint32_t currentCpuFreq;
14 extern uint32_t currentCpuFreq;
293 currentCpuFreq = 80000000;
15 currentCpuFreq = 80000000;
294 enable_FPU();
16 enable_FPU();
295 RCC->CR |= (uint32_t)0x00000001;
17 RCC->CR |= (uint32_t)0x00000001;
296 FLASH->ACR = FLASH_ACR_ICEN |FLASH_ACR_DCEN |FLASH_ACR_LATENCY_5WS;
18 FLASH->ACR = FLASH_ACR_ICEN |FLASH_ACR_DCEN |FLASH_ACR_LATENCY_5WS;
297 reset_AHB1();
19 reset_AHB1();
298 reset_AHB2();
20 reset_AHB2();
299 reset_APB1();
21 reset_APB1();
300 reset_APB2();
22 reset_APB2();
301 RCC->CR |= (uint32_t)0x00000001;
23 RCC->CR |= (uint32_t)0x00000001;
302 FLASH->ACR = FLASH_ACR_ICEN |FLASH_ACR_DCEN |FLASH_ACR_LATENCY_5WS;
24 FLASH->ACR = FLASH_ACR_ICEN |FLASH_ACR_DCEN |FLASH_ACR_LATENCY_5WS;
303 RCC->CFGR = 0x00000000;
25 RCC->CFGR = 0x00000000;
304 RCC->CIR = 0x00000000;
26 RCC->CIR = 0x00000000;
305 SCB->VTOR = FLASH_BASE;
27 SCB->VTOR = FLASH_BASE;
306 RCC->APB1ENR |= RCC_APB1ENR_PWREN;
28 RCC->APB1ENR |= RCC_APB1ENR_PWREN;
307 PWR->CR |= PWR_CR_PMODE;
29 PWR->CR |= PWR_CR_PMODE;
308 bsp_init();
30 bsp_init();
309 printf("Configure PLL to reach %uHz\n\r",(unsigned int)currentCpuFreq);
31 printf("Configure PLL to reach %uHz\n\r",(unsigned int)currentCpuFreq);
310 currentCpuFreq=setCpuFreq(currentCpuFreq);
32 currentCpuFreq=setCpuFreq(currentCpuFreq);
311 bsp_uart_init();
33 bsp_uart_init();
312 RCC_ClocksTypeDef RCC_ClocksStatus;
34 RCC_ClocksTypeDef RCC_ClocksStatus;
313 RCC_GetClocksFreq(&RCC_ClocksStatus);
35 RCC_GetClocksFreq(&RCC_ClocksStatus);
314 printf("PLL Configured got:\n\r SYS=%uHz\n\r CPU=%uHz\n\r APB1=%uHz\n\r APB2=%uHz\n\r",(unsigned int)RCC_ClocksStatus.SYSCLK_Frequency,(unsigned int)RCC_ClocksStatus.HCLK_Frequency,(unsigned int)RCC_ClocksStatus.PCLK1_Frequency,(unsigned int)RCC_ClocksStatus.PCLK2_Frequency);
36 printf("PLL Configured got:\n\r SYS=%uHz\n\r CPU=%uHz\n\r APB1=%uHz\n\r APB2=%uHz\n\r",(unsigned int)RCC_ClocksStatus.SYSCLK_Frequency,(unsigned int)RCC_ClocksStatus.HCLK_Frequency,(unsigned int)RCC_ClocksStatus.PCLK1_Frequency,(unsigned int)RCC_ClocksStatus.PCLK2_Frequency);
315 printf("Enter Main\n\r");
37 printf("Enter Main\n\r");
316 int res=main();
38 int res=main();
317 printf("\n\rprogram exited with code ");
39 printf("\n\rprogram exited with code ");
318 printf("%u",res);
40 printf("%u",res);
319 printf("\n\r");
41 printf("\n\r");
320 while(1)
42 while(1)
321 {
43 {
322 for(volatile int i=0;i<1024*64;i++);
44 for(volatile int i=0;i<1024*64;i++);
323 gpioset(PD14);
45 gpioset(PD14);
324 for(volatile int i=0;i<1024*64;i++);
46 for(volatile int i=0;i<1024*64;i++);
325 gpioclr(PD14);
47 gpioclr(PD14);
326 }
48 }
327 }
49 }
328
50
329
51
330
52
331
53
332
54
333
55
334
56
335
57
336
58
337
59
Show file before | Show file after | Hide comments
@@ -1,430 +1,430
1 /*------------------------------------------------------------------------------
1 /*------------------------------------------------------------------------------
2 -- This file is a part of the libuc, microcontroler library
2 -- This file is a part of the libuc, microcontroler library
3 -- Copyright (C) 2011, Alexis Jeandet
3 -- Copyright (C) 2011, Alexis Jeandet
4 --
4 --
5 -- This program is free software; you can redistribute it and/or modify
5 -- This program is free software; you can redistribute it and/or modify
6 -- it under the terms of the GNU General Public License as published by
6 -- it under the terms of the GNU General Public License as published by
7 -- the Free Software Foundation; either version 3 of the License, or
7 -- the Free Software Foundation; either version 3 of the License, or
8 -- (at your option) any later version.
8 -- (at your option) any later version.
9 --
9 --
10 -- This program is distributed in the hope that it will be useful,
10 -- This program is distributed in the hope that it will be useful,
11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
11 -- but WITHOUT ANY WARRANTY; without even the implied warranty of
12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 -- GNU General Public License for more details.
13 -- GNU General Public License for more details.
14 --
14 --
15 -- You should have received a copy of the GNU General Public License
15 -- You should have received a copy of the GNU General Public License
16 -- along with this program; if not, write to the Free Software
16 -- along with this program; if not, write to the Free Software
17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 -------------------------------------------------------------------------------
18 -------------------------------------------------------------------------------
19 -- Author : Alexis Jeandet
19 -- Author : Alexis Jeandet
20 -- Mail : alexis.jeandet@gmail.com
20 -- Mail : alexis.jeandet@gmail.com
21 -------------------------------------------------------------------------------*/
21 -------------------------------------------------------------------------------*/
22
22
23 #include <uart.h>
23 #include <uart.h>
24 #include <stm32f4xx_usart.h>
24 #include <stm32f4xx_usart.h>
25 #include <stm32f4xx_rcc.h>
25 #include <stm32f4xx_rcc.h>
26 #include <stm32f4xx_gpio.h>
26 #include <stm32f4xx_gpio.h>
27 #include <gpio.h>
27 #include <gpio.h>
28 #define GPIOGETPORT(gpio) ((GPIO_TypeDef*)(((((uint32_t)gpio) & (uint32_t)0x0000FF00)*(uint32_t)4) + (uint32_t)GPIOA))
28 #define GPIOGETPORT(gpio) ((GPIO_TypeDef*)(((((uint32_t)gpio) & (uint32_t)0x0000FF00)*(uint32_t)4) + (uint32_t)GPIOA))
29 #define GPIOPORTNUM(gpio) (((uint32_t)(gpio) & (uint32_t)0x0000FF00)>>(uint32_t)8)
29 #define GPIOPORTNUM(gpio) (((uint32_t)(gpio) & (uint32_t)0x0000FF00)>>(uint32_t)8)
30
30
31 int uartopen(int count ,uart_t* uart)
31 int uartopen(int count ,uart_t* uart)
32 {
32 {
33
33
34 switch(count)
34 switch(count)
35 {
35 {
36 case 0:
36 case 0:
37 uart->_dev = (void*)USART1;
37 uart->_dev = (void*)USART1;
38 RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
38 RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
39 RCC_APB2PeriphResetCmd(RCC_APB2Periph_USART1, ENABLE);
39 RCC_APB2PeriphResetCmd(RCC_APB2Periph_USART1, ENABLE);
40 RCC_APB2PeriphResetCmd(RCC_APB2Periph_USART1, DISABLE);
40 RCC_APB2PeriphResetCmd(RCC_APB2Periph_USART1, DISABLE);
41 RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
41 RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
42 ((USART_TypeDef *)(uart->_dev))->CR3 &= ~((1<<8) + (1<<9));
42 ((USART_TypeDef *)(uart->_dev))->CR3 &= ~((1<<8) + (1<<9));
43 //uartenable(uart);
43 //uartenable(uart);
44 break;
44 break;
45 case 1:
45 case 1:
46 uart->_dev = (void*)USART2;
46 uart->_dev = (void*)USART2;
47 RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);
47 RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);
48 RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART2, ENABLE);
48 RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART2, ENABLE);
49 RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART2, DISABLE);
49 RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART2, DISABLE);
50 RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);
50 RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);
51 ((USART_TypeDef *)(uart->_dev))->CR3 &= ~((1<<8) + (1<<9));
51 ((USART_TypeDef *)(uart->_dev))->CR3 &= ~((1<<8) + (1<<9));
52 //uartenable(uart);
52 //uartenable(uart);
53 break;
53 break;
54 case 2:
54 case 2:
55 uart->_dev = (void*)USART3;
55 uart->_dev = (void*)USART3;
56 RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);
56 RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);
57 RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART3, ENABLE);
57 RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART3, ENABLE);
58 RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART3, DISABLE);
58 RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART3, DISABLE);
59 RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);
59 RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);
60 ((USART_TypeDef *)(uart->_dev))->CR3 &= ~((1<<8) + (1<<9));
60 ((USART_TypeDef *)(uart->_dev))->CR3 &= ~((1<<8) + (1<<9));
61 //uartenable(uart);
61 //uartenable(uart);
62 break;
62 break;
63 case 3:
63 case 3:
64 uart->_dev = (void*)UART4;
64 uart->_dev = (void*)UART4;
65 RCC_APB1PeriphResetCmd(RCC_APB1Periph_UART4, ENABLE);
65 RCC_APB1PeriphResetCmd(RCC_APB1Periph_UART4, ENABLE);
66 RCC_APB1PeriphResetCmd(RCC_APB1Periph_UART4, DISABLE);
66 RCC_APB1PeriphResetCmd(RCC_APB1Periph_UART4, DISABLE);
67 RCC_APB1PeriphClockCmd(RCC_APB1Periph_UART4, ENABLE);
67 RCC_APB1PeriphClockCmd(RCC_APB1Periph_UART4, ENABLE);
68 ((USART_TypeDef *)(uart->_dev))->CR3 &= ~((1<<8) + (1<<9));
68 ((USART_TypeDef *)(uart->_dev))->CR3 &= ~((1<<8) + (1<<9));
69 //uartenable(uart);
69 //uartenable(uart);
70 break;
70 break;
71 case 4:
71 case 4:
72 uart->_dev = (void*)UART5;
72 uart->_dev = (void*)UART5;
73 RCC_APB1PeriphResetCmd(RCC_APB1Periph_UART5, ENABLE);
73 RCC_APB1PeriphResetCmd(RCC_APB1Periph_UART5, ENABLE);
74 RCC_APB1PeriphResetCmd(RCC_APB1Periph_UART5, DISABLE);
74 RCC_APB1PeriphResetCmd(RCC_APB1Periph_UART5, DISABLE);
75 RCC_APB1PeriphClockCmd(RCC_APB1Periph_UART5, ENABLE);
75 RCC_APB1PeriphClockCmd(RCC_APB1Periph_UART5, ENABLE);
76 break;
76 break;
77 case 5:
77 case 5:
78 uart->_dev = (void*)USART6;
78 uart->_dev = (void*)USART6;
79 RCC_APB2PeriphResetCmd(RCC_APB2Periph_USART6, ENABLE);
79 RCC_APB2PeriphResetCmd(RCC_APB2Periph_USART6, ENABLE);
80 RCC_APB2PeriphResetCmd(RCC_APB2Periph_USART6, DISABLE);
80 RCC_APB2PeriphResetCmd(RCC_APB2Periph_USART6, DISABLE);
81 RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART6, ENABLE);
81 RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART6, ENABLE);
82 break;
82 break;
83 default:
83 default:
84 break;
84 break;
85 }
85 }
86 return 1;
86 return 1;
87 }
87 }
88
88
89 int uartopenandconfig(int count ,uart_t* uart,uint32_t cfg,uint32_t speed,uint32_t TXpin,uint32_t RXpin,uint32_t RTSpin,uint32_t CTSpin)
89 int uartopenandconfig(int count ,uart_t* uart,uint32_t cfg,uint32_t speed,uint32_t TXpin,uint32_t RXpin,uint32_t RTSpin,uint32_t CTSpin)
90 {
90 {
91 uartopen(count ,uart);
91 uartopen(count ,uart);
92 uart->cfg = cfg;
92 uart->cfg = cfg;
93 uart->speed = speed;
93 uart->speed = speed;
94 uartsetconfig(uart);
94 uartsetconfig(uart);
95 uartsetpins(uart,TXpin,RXpin,RTSpin,CTSpin);
95 uartsetpins(uart,TXpin,RXpin,RTSpin,CTSpin);
96 return 1;
96 return 1;
97 }
97 }
98
98
99
99
100 int uartclose(uart_t* uart)
100 int uartclose(uart_t* uart)
101 {
101 {
102 switch((int)uart->_dev)
102 switch((int)uart->_dev)
103 {
103 {
104 case (int)(void*)USART1:
104 case (int)(void*)USART1:
105 uart->_dev = (void*)USART1;
105 uart->_dev = (void*)USART1;
106 RCC_APB2PeriphResetCmd(RCC_APB2Periph_USART1, ENABLE);
106 RCC_APB2PeriphResetCmd(RCC_APB2Periph_USART1, ENABLE);
107 break;
107 break;
108 case (int)(void*)USART2:
108 case (int)(void*)USART2:
109 uart->_dev = (void*)USART2;
109 uart->_dev = (void*)USART2;
110 RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART2, ENABLE);
110 RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART2, ENABLE);
111 break;
111 break;
112 case (int)(void*)USART3:
112 case (int)(void*)USART3:
113 uart->_dev = (void*)USART3;
113 uart->_dev = (void*)USART3;
114 RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART3, ENABLE);
114 RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART3, ENABLE);
115 break;
115 break;
116 case (int)(void*)UART4:
116 case (int)(void*)UART4:
117 uart->_dev = (void*)UART4;
117 uart->_dev = (void*)UART4;
118 RCC_APB1PeriphResetCmd(RCC_APB1Periph_UART4, ENABLE);
118 RCC_APB1PeriphResetCmd(RCC_APB1Periph_UART4, ENABLE);
119 break;
119 break;
120 case (int)(void*)UART5:
120 case (int)(void*)UART5:
121 uart->_dev = (void*)UART5;
121 uart->_dev = (void*)UART5;
122 RCC_APB1PeriphResetCmd(RCC_APB1Periph_UART5, ENABLE);
122 RCC_APB1PeriphResetCmd(RCC_APB1Periph_UART5, ENABLE);
123 break;
123 break;
124 case (int)(void*)USART6:
124 case (int)(void*)USART6:
125 uart->_dev = (void*)USART6;
125 uart->_dev = (void*)USART6;
126 RCC_APB2PeriphResetCmd(RCC_APB2Periph_USART6, ENABLE);
126 RCC_APB2PeriphResetCmd(RCC_APB2Periph_USART6, ENABLE);
127 break;
127 break;
128 default:
128 default:
129 break;
129 break;
130 }
130 }
131 return 1;
131 return 1;
132 }
132 }
133
133
134 int uartsetpins(uart_t* uart,uint32_t TXpin,uint32_t RXpin,uint32_t RTSpin,uint32_t CTSpin)
134 int uartsetpins(uart_t* uart,uint32_t TXpin,uint32_t RXpin,uint32_t RTSpin,uint32_t CTSpin)
135 {
135 {
136 gpio_t TX,RX,CTS,RTS;
136 gpio_t TX,RX,CTS,RTS;
137 TX = gpioopen(TXpin);
137 TX = gpioopen(TXpin);
138 RX = gpioopen(RXpin);
138 RX = gpioopen(RXpin);
139 TX |= gpiolowspeed | gpioaf | gpiopushpulltype | gpionopulltype;
139 TX |= gpiolowspeed | gpioaf | gpiopushpulltype | gpionopulltype;
140 RX |= gpiolowspeed | gpioaf | gpiopushpulltype | gpionopulltype;
140 RX |= gpiolowspeed | gpioaf | gpiopushpulltype | gpionopulltype;
141 gpiosetconfig(&TX);
141 gpiosetconfig(&TX);
142 gpiosetconfig(&RX);
142 gpiosetconfig(&RX);
143 uint8_t gpioAFuartx = GPIO_AF_USART1;
143 uint8_t gpioAFuartx = GPIO_AF_USART1;
144 switch((int)uart->_dev)
144 switch((int)uart->_dev)
145 {
145 {
146 case (int)(void*)USART1:
146 case (int)(void*)USART1:
147 gpioAFuartx = GPIO_AF_USART1;
147 gpioAFuartx = GPIO_AF_USART1;
148 break;
148 break;
149 case (int)(void*)USART2:
149 case (int)(void*)USART2:
150 gpioAFuartx = GPIO_AF_USART2;
150 gpioAFuartx = GPIO_AF_USART2;
151 break;
151 break;
152 case (int)(void*)USART3:
152 case (int)(void*)USART3:
153 gpioAFuartx = GPIO_AF_USART3;
153 gpioAFuartx = GPIO_AF_USART3;
154 break;
154 break;
155 case (int)(void*)UART4:
155 case (int)(void*)UART4:
156 gpioAFuartx = GPIO_AF_UART4;
156 gpioAFuartx = GPIO_AF_UART4;
157 break;
157 break;
158 case (int)(void*)UART5:
158 case (int)(void*)UART5:
159 gpioAFuartx = GPIO_AF_UART5;
159 gpioAFuartx = GPIO_AF_UART5;
160 break;
160 break;
161 case (int)(void*)USART6:
161 case (int)(void*)USART6:
162 gpioAFuartx = GPIO_AF_USART6;
162 gpioAFuartx = GPIO_AF_USART6;
163 break;
163 break;
164 default:
164 default:
165 break;
165 break;
166 }
166 }
167 GPIO_PinAFConfig(GPIOGETPORT(TX), (uint8_t)(TX & 0xF), gpioAFuartx);
167 GPIO_PinAFConfig(GPIOGETPORT(TX), (uint8_t)(TX & 0xF), gpioAFuartx);
168 GPIO_PinAFConfig(GPIOGETPORT(TX), (uint8_t)(RX & 0xF), gpioAFuartx);
168 GPIO_PinAFConfig(GPIOGETPORT(RX), (uint8_t)(RX & 0xF), gpioAFuartx);
169 if((gpioAFuartx!=GPIO_AF_UART5) && (gpioAFuartx!=GPIO_AF_UART4))
169 if((gpioAFuartx!=GPIO_AF_UART5) && (gpioAFuartx!=GPIO_AF_UART4))
170 {
170 {
171 if(CTSpin!=-1)
171 if(CTSpin!=-1)
172 {
172 {
173 CTS = gpioopen(CTSpin);
173 CTS = gpioopen(CTSpin);
174 CTS |= gpiolowspeed | gpioaf | gpiopushpulltype | gpionopulltype;
174 CTS |= gpiolowspeed | gpioaf | gpiopushpulltype | gpionopulltype;
175 gpiosetconfig(&CTS);
175 gpiosetconfig(&CTS);
176 GPIO_PinAFConfig(GPIOGETPORT(CTS), (uint8_t)(CTS & 0xF), gpioAFuartx);
176 GPIO_PinAFConfig(GPIOGETPORT(CTS), (uint8_t)(CTS & 0xF), gpioAFuartx);
177 }
177 }
178
178
179 if(RTSpin!=-1)
179 if(RTSpin!=-1)
180 {
180 {
181 RTS = gpioopen(RTSpin);
181 RTS = gpioopen(RTSpin);
182 RTS |= gpiolowspeed | gpioaf | gpiopushpulltype | gpionopulltype;
182 RTS |= gpiolowspeed | gpioaf | gpiopushpulltype | gpionopulltype;
183 gpiosetconfig(&RTS);
183 gpiosetconfig(&RTS);
184 GPIO_PinAFConfig(GPIOGETPORT(RTS), (uint8_t)(RTS & 0xF), gpioAFuartx);
184 GPIO_PinAFConfig(GPIOGETPORT(RTS), (uint8_t)(RTS & 0xF), gpioAFuartx);
185 }
185 }
186 }
186 }
187 return 1;
187 return 1;
188 }
188 }
189
189
190 int uartsetconfig(uart_t* uart)
190 int uartsetconfig(uart_t* uart)
191 {
191 {
192 int res=1;
192 int res=1;
193 uartdisable(uart);
193 uartdisable(uart);
194 uartsetspeed(uart,uart->speed);
194 uartsetspeed(uart,uart->speed);
195 uartsetparity(uart,uart->cfg & UARTPARITYMASK);
195 uartsetparity(uart,uart->cfg & UARTPARITYMASK);
196 uartsetdatabits(uart,uart->cfg & UARTBITSMASK);
196 uartsetdatabits(uart,uart->cfg & UARTBITSMASK);
197 uartsetstopbits(uart,uart->cfg & UARTSTOPBITSMASK);
197 uartsetstopbits(uart,uart->cfg & UARTSTOPBITSMASK);
198 uartenable(uart);
198 uartenable(uart);
199 return res;
199 return res;
200 }
200 }
201
201
202 int uartenable(uart_t* uart)
202 int uartenable(uart_t* uart)
203 {
203 {
204 ((USART_TypeDef *)(uart->_dev))->CR1 |= (1<<13);
204 ((USART_TypeDef *)(uart->_dev))->CR1 |= (1<<13);
205 ((USART_TypeDef *)(uart->_dev))->CR1 |= (1<<2) + (1<<3);
205 ((USART_TypeDef *)(uart->_dev))->CR1 |= (1<<2) + (1<<3);
206 ((USART_TypeDef *)(uart->_dev))->DR = ' ';
206 ((USART_TypeDef *)(uart->_dev))->DR = ' ';
207 return 1;
207 return 1;
208 }
208 }
209
209
210 int uartdisable(uart_t* uart)
210 int uartdisable(uart_t* uart)
211 {
211 {
212 if((((USART_TypeDef *)(uart->_dev))->CR1 & ((1<<3) +(1<<13)))==((1<<3) +(1<<13)))
212 if((((USART_TypeDef *)(uart->_dev))->CR1 & ((1<<3) +(1<<13)))==((1<<3) +(1<<13)))
213 {
213 {
214 while((((USART_TypeDef *)(uart->_dev))->SR & (uint16_t)(1<<7))!=(uint16_t)(1<<7));
214 while((((USART_TypeDef *)(uart->_dev))->SR & (uint16_t)(1<<7))!=(uint16_t)(1<<7));
215 }
215 }
216 ((USART_TypeDef *)(uart->_dev))->CR1 &= ~((1<<2) + (1<<3) +(1<<13));
216 ((USART_TypeDef *)(uart->_dev))->CR1 &= ~((1<<2) + (1<<3) +(1<<13));
217 return 1;
217 return 1;
218 }
218 }
219
219
220 int uartsetspeed(uart_t* uart,int speed)
220 int uartsetspeed(uart_t* uart,int speed)
221 {
221 {
222 uart->speed = speed;
222 uart->speed = speed;
223 uint32_t tmpreg = 0x00, apbclock = 0x00;
223 uint32_t tmpreg = 0x00, apbclock = 0x00;
224 uint32_t integerdivider = 0x00;
224 uint32_t integerdivider = 0x00;
225 uint32_t fractionaldivider = 0x00;
225 uint32_t fractionaldivider = 0x00;
226 RCC_ClocksTypeDef RCC_ClocksStatus;
226 RCC_ClocksTypeDef RCC_ClocksStatus;
227 RCC_GetClocksFreq(&RCC_ClocksStatus);
227 RCC_GetClocksFreq(&RCC_ClocksStatus);
228
228
229 if (((USART_TypeDef *)(uart->_dev) == USART1) || (((USART_TypeDef *)(uart->_dev) == USART6)))
229 if (((USART_TypeDef *)(uart->_dev) == USART1) || (((USART_TypeDef *)(uart->_dev) == USART6)))
230 {
230 {
231 apbclock = RCC_ClocksStatus.PCLK2_Frequency;
231 apbclock = RCC_ClocksStatus.PCLK2_Frequency;
232 }
232 }
233 else
233 else
234 {
234 {
235 apbclock = RCC_ClocksStatus.PCLK1_Frequency;
235 apbclock = RCC_ClocksStatus.PCLK1_Frequency;
236 }
236 }
237 if (((((USART_TypeDef *)(uart->_dev))->CR1) & USART_CR1_OVER8) != (uint16_t)0)
237 if (((((USART_TypeDef *)(uart->_dev))->CR1) & USART_CR1_OVER8) != (uint16_t)0)
238 {
238 {
239 integerdivider = ((25 * apbclock) / (2 * (speed)));
239 integerdivider = ((25 * apbclock) / (2 * (speed)));
240 }
240 }
241 else
241 else
242 {
242 {
243 integerdivider = ((25 * apbclock) / (4 * (speed)));
243 integerdivider = ((25 * apbclock) / (4 * (speed)));
244 }
244 }
245 tmpreg = (integerdivider / 100) << 4;
245 tmpreg = (integerdivider / 100) << 4;
246 fractionaldivider = integerdivider - (100 * (tmpreg >> 4));
246 fractionaldivider = integerdivider - (100 * (tmpreg >> 4));
247 if ((((USART_TypeDef *)(uart->_dev))->CR1 & USART_CR1_OVER8) != (uint16_t)0)
247 if ((((USART_TypeDef *)(uart->_dev))->CR1 & USART_CR1_OVER8) != (uint16_t)0)
248 {
248 {
249 tmpreg |= ((((fractionaldivider * 8) + 50) / 100)) & ((uint8_t)0x07);
249 tmpreg |= ((((fractionaldivider * 8) + 50) / 100)) & ((uint8_t)0x07);
250 }
250 }
251 else
251 else
252 {
252 {
253 tmpreg |= ((((fractionaldivider * 16) + 50) / 100)) & ((uint8_t)0x0F);
253 tmpreg |= ((((fractionaldivider * 16) + 50) / 100)) & ((uint8_t)0x0F);
254 }
254 }
255 ((USART_TypeDef *)(uart->_dev))->BRR = (uint16_t)tmpreg;
255 ((USART_TypeDef *)(uart->_dev))->BRR = (uint16_t)tmpreg;
256 return 1;
256 return 1;
257 }
257 }
258
258
259 int uartsetparity(uart_t* uart,uartparity_t parity)
259 int uartsetparity(uart_t* uart,uartparity_t parity)
260 {
260 {
261 uart->cfg &= ~(UARTPARITYMASK);
261 uart->cfg &= ~(UARTPARITYMASK);
262 uart->cfg |= parity;
262 uart->cfg |= parity;
263 ((USART_TypeDef *)(uart->_dev))->CR1 &= ~(((1<<9)+(1<<10)));
263 ((USART_TypeDef *)(uart->_dev))->CR1 &= ~(((1<<9)+(1<<10)));
264 switch(parity)
264 switch(parity)
265 {
265 {
266 case uartparityeven:
266 case uartparityeven:
267 ((USART_TypeDef *)(uart->_dev))->CR1 |= (1<<10);
267 ((USART_TypeDef *)(uart->_dev))->CR1 |= (1<<10);
268 break;
268 break;
269 case uartparityodd:
269 case uartparityodd:
270 ((USART_TypeDef *)(uart->_dev))->CR1 |= (1<<10) + (1<<9);
270 ((USART_TypeDef *)(uart->_dev))->CR1 |= (1<<10) + (1<<9);
271 break;
271 break;
272 case uartparitynone:
272 case uartparitynone:
273 break;
273 break;
274 default :
274 default :
275 return 0;
275 return 0;
276 break;
276 break;
277 }
277 }
278 return 1;
278 return 1;
279 }
279 }
280
280
281 int uartsetdatabits(uart_t* uart,uartbits_t databits)
281 int uartsetdatabits(uart_t* uart,uartbits_t databits)
282 {
282 {
283 uart->cfg &= ~UARTBITSMASK;
283 uart->cfg &= ~UARTBITSMASK;
284 uart->cfg |= databits;
284 uart->cfg |= databits;
285 ((USART_TypeDef *)(uart->_dev))->CR1 &= ~(((1<<12)));
285 ((USART_TypeDef *)(uart->_dev))->CR1 &= ~(((1<<12)));
286 switch(databits)
286 switch(databits)
287 {
287 {
288 case uart7bits:
288 case uart7bits:
289 return 0;
289 return 0;
290 break;
290 break;
291 case uart8bits:
291 case uart8bits:
292 break;
292 break;
293 case uart9bits:
293 case uart9bits:
294 ((USART_TypeDef *)(uart->_dev))->CR1 |= (1<<12);
294 ((USART_TypeDef *)(uart->_dev))->CR1 |= (1<<12);
295 break;
295 break;
296 default :
296 default :
297 return 0;
297 return 0;
298 break;
298 break;
299 }
299 }
300 return 1;
300 return 1;
301 }
301 }
302
302
303 int uartsetstopbits(uart_t* uart,uartstopbits_t stopbits)
303 int uartsetstopbits(uart_t* uart,uartstopbits_t stopbits)
304 {
304 {
305 uart->cfg &= ~UARTSTOPBITSMASK;
305 uart->cfg &= ~UARTSTOPBITSMASK;
306 uart->cfg |= stopbits;
306 uart->cfg |= stopbits;
307 ((USART_TypeDef *)(uart->_dev))->CR2 &= ~(((1<<12)+(1<<13)));
307 ((USART_TypeDef *)(uart->_dev))->CR2 &= ~(((1<<12)+(1<<13)));
308 switch(stopbits)
308 switch(stopbits)
309 {
309 {
310 case uarthalfstop:
310 case uarthalfstop:
311 ((USART_TypeDef *)(uart->_dev))->CR2 |= (1<<12);
311 ((USART_TypeDef *)(uart->_dev))->CR2 |= (1<<12);
312 break;
312 break;
313 case uartonestop:
313 case uartonestop:
314 break;
314 break;
315 case uartonehalfstop:
315 case uartonehalfstop:
316 ((USART_TypeDef *)(uart->_dev))->CR2 |= (1<<12) + (1<<13);
316 ((USART_TypeDef *)(uart->_dev))->CR2 |= (1<<12) + (1<<13);
317 break;
317 break;
318 case uarttwostop:
318 case uarttwostop:
319 ((USART_TypeDef *)(uart->_dev))->CR2 |= (1<<13);
319 ((USART_TypeDef *)(uart->_dev))->CR2 |= (1<<13);
320 break;
320 break;
321 default :
321 default :
322 return 0;
322 return 0;
323 break;
323 break;
324 }
324 }
325 return 1;
325 return 1;
326 }
326 }
327
327
328 int uartputc(uart_t* uart,char c)
328 int uartputc(uart_t* uart,char c)
329 {
329 {
330 while((((USART_TypeDef *)(uart->_dev))->SR & (uint16_t)(1<<7))!=(uint16_t)(1<<7));
330 while((((USART_TypeDef *)(uart->_dev))->SR & (uint16_t)(1<<7))!=(uint16_t)(1<<7));
331 ((USART_TypeDef *)(uart->_dev))->DR = c;
331 ((USART_TypeDef *)(uart->_dev))->DR = c;
332 return 1;
332 return 1;
333 }
333 }
334
334
335 char uartgetc(uart_t* uart)
335 char uartgetc(uart_t* uart)
336 {
336 {
337 while(!(((USART_TypeDef *)(uart->_dev))->SR & (1<<5)));
337 while(!(((USART_TypeDef *)(uart->_dev))->SR & (1<<5)));
338 return (char)((USART_TypeDef *)(uart->_dev))->DR;
338 return (char)((USART_TypeDef *)(uart->_dev))->DR;
339 }
339 }
340
340
341 int uartputs(uart_t* uart,char* s)
341 int uartputs(uart_t* uart,char* s)
342 {
342 {
343 while (*s) uartputc(uart,*s++);
343 while (*s) uartputc(uart,*s++);
344 return 1;
344 return 1;
345 }
345 }
346
346
347 int uartgets(uart_t* uart,char* s)
347 int uartgets(uart_t* uart,char* s)
348 {
348 {
349 do
349 do
350 {
350 {
351 (*s) = uartgetc(uart);
351 (*s) = uartgetc(uart);
352 }
352 }
353 while(*s++);
353 while(*s++);
354 return 1;
354 return 1;
355 }
355 }
356
356
357 int uartputnc(uart_t* uart,char* c,int n)
357 int uartputnc(uart_t* uart,char* c,int n)
358 {
358 {
359 int l=0;
359 int l=0;
360 while(l<n)
360 while(l<n)
361 {
361 {
362 uartputc(uart,*c++);
362 uartputc(uart,*c++);
363 l++;
363 l++;
364 }
364 }
365 return n;
365 return n;
366 }
366 }
367
367
368 int uartgetnc(uart_t* uart,char* c,int n)
368 int uartgetnc(uart_t* uart,char* c,int n)
369 {
369 {
370 int l=0;
370 int l=0;
371 while(l<n)
371 while(l<n)
372 {
372 {
373 *c++=uartgetc(uart);
373 *c++=uartgetc(uart);
374 l++;
374 l++;
375 }
375 }
376 return n;
376 return n;
377 }
377 }
378
378
379 int uartavailiabledata(uart_t* uart)
379 int uartavailiabledata(uart_t* uart)
380 {
380 {
381 if(!(((USART_TypeDef *)(uart->_dev))->SR & (1<<5)))
381 if(!(((USART_TypeDef *)(uart->_dev))->SR & (1<<5)))
382 return 0;
382 return 0;
383 else
383 else
384 return 1;
384 return 1;
385 }
385 }
386
386
387
387
388 int _uartstrwrite(streamdevice* device,void* data,int size, int n)
388 int _uartstrwrite(streamdevice* device,void* data,int size, int n)
389 {
389 {
390 return uartputnc((uart_t*) device->_stream,(char*) data,size*n);
390 return uartputnc((uart_t*) device->_stream,(char*) data,size*n);
391 }
391 }
392
392
393 int _uartstrread(streamdevice* device,void* data,int size, int n)
393 int _uartstrread(streamdevice* device,void* data,int size, int n)
394 {
394 {
395 return uartgetnc((uart_t*) device->_stream,(char*) data,size*n);
395 return uartgetnc((uart_t*) device->_stream,(char*) data,size*n);
396 }
396 }
397
397
398 int _uartstrsetpos(streamdevice* device,int pos)
398 int _uartstrsetpos(streamdevice* device,int pos)
399 {
399 {
400 return 1;
400 return 1;
401 }
401 }
402
402
403 int uartmkstreamdev(uart_t* uart,streamdevice* strdev)
403 int uartmkstreamdev(uart_t* uart,streamdevice* strdev)
404 {
404 {
405 strdev->_stream = (UHANDLE)uart;
405 strdev->_stream = (UHANDLE)uart;
406 strdev->write = (write_t)&_uartstrwrite;
406 strdev->write = (write_t)&_uartstrwrite;
407 strdev->read = (read_t)&_uartstrread;
407 strdev->read = (read_t)&_uartstrread;
408 strdev->setpos = (setpos_t)&_uartstrsetpos;
408 strdev->setpos = (setpos_t)&_uartstrsetpos;
409 strdev->streamPt = 0;
409 strdev->streamPt = 0;
410 return 1;
410 return 1;
411 }
411 }
412
412
413
413
414
414
415
415
416
416
417
417
418
418
419
419
420
420
421
421
422
422
423
423
424
424
425
425
426
426
427
427
428
428
429
429
430
430
Show file before | Show file after | Hide comments
@@ -1,11 +1,12
1 TEMPLATE = subdirs
1 TEMPLATE = subdirs
2 CONFIG += ordered
2 CONFIG += ordered
3 SUBDIRS = CORE/core.pro \
3 SUBDIRS = CORE/core.pro \
4 CPU/cpu.pro \
4 CPU/cpu.pro \
5 GPIO/gpio.pro \
5 GPIO/gpio.pro \
6 UART/uart.pro \
6 UART/uart.pro \
7 SPI/spi.pro
7 SPI/spi.pro \
8 I2C/i2c.pro
8
9
9
10
10
11
11
12
Show file before | Show file after | Hide comments
@@ -1,207 +1,212
1 #---------------------------------------------------------------------------------
1 #---------------------------------------------------------------------------------
2 # LIBRARY DEFINITIONS
2 # LIBRARY DEFINITIONS
3 #---------------------------------------------------------------------------------
3 #---------------------------------------------------------------------------------
4 LIBUC_LIBS_DIR = $$libuc2/lib
4 LIBUC_LIBS_DIR = $$libuc2/lib
5
5
6 INCLUDEPATH += $$LIBUC_LIBS_DIR/includes \
6 INCLUDEPATH += $$LIBUC_LIBS_DIR/includes \
7 $$LIBUC_LIBS_DIR/includes/$$ARCH
7 $$LIBUC_LIBS_DIR/includes/$$ARCH
8
8
9 LIBUC_BIN_LIBS_DIR = $$LIBUC_LIBS_DIR/bin/$$ARCH
9 LIBUC_BIN_LIBS_DIR = $$LIBUC_LIBS_DIR/bin/$$ARCH
10
10
11
12 LIBS += -L$$LIBUC_LIBS_DIR/bin/$$ARCH \
11 LIBS += -L$$LIBUC_LIBS_DIR/bin/$$ARCH \
13 -lsdcard
12 -lsdcard
14
13
15 LIBS += -L$$LIBUC_LIBS_DIR/bin/$$ARCH \
14 LIBS += -L$$LIBUC_LIBS_DIR/bin/$$ARCH \
16 -lfat32
15 -lfat32
17
16
18 LIBS += -L$$LIBUC_LIBS_DIR/bin/$$ARCH \
17 LIBS += -L$$LIBUC_LIBS_DIR/bin/$$ARCH \
19 -lmbr
18 -lmbr
20
19
21 LIBS += -L$$LIBUC_LIBS_DIR/bin/$$ARCH \
20 LIBS += -L$$LIBUC_LIBS_DIR/bin/$$ARCH \
22 -luart
21 -luart
23
22
24 LIBS += -L$$LIBUC_LIBS_DIR/bin/$$ARCH \
23 LIBS += -L$$LIBUC_LIBS_DIR/bin/$$ARCH \
24 -li2c
25
26 LIBS += -L$$LIBUC_LIBS_DIR/bin/$$ARCH \
25 -lgpio
27 -lgpio
26
28
27 LIBS += -L$$LIBUC_LIBS_DIR/bin/$$ARCH \
29 LIBS += -L$$LIBUC_LIBS_DIR/bin/$$ARCH \
28 -lspi
30 -lspi
29
31
30 LIBS += -L$$LIBUC_LIBS_DIR/bin/$$ARCH \
32 LIBS += -L$$LIBUC_LIBS_DIR/bin/$$ARCH \
31 -lcpu
33 -lcpu
32
34
35 LIBS += -L$$LIBUC_LIBS_DIR/bin/$$ARCH \
36 -lcore
37
33
38
34
39
35
40
36 LIBUC_LIBS_CORE = -L $(LIBUC_LIBS_DIR_CORE) -static -lcore
41 LIBUC_LIBS_CORE = -L $(LIBUC_LIBS_DIR_CORE) -static -lcore
37 LIBUC_LIBS_DIR_CORE = $(LIBUC_LIBS_DIR)
42 LIBUC_LIBS_DIR_CORE = $(LIBUC_LIBS_DIR)
38 LIBUC_LIBS_DIR_CORE_CMD = -L $(LIBUC_LIBS_DIR_CORE)
43 LIBUC_LIBS_DIR_CORE_CMD = -L $(LIBUC_LIBS_DIR_CORE)
39 LIBUC_INC_DIR_CORE = $(LIBUC_INC_DIR)
44 LIBUC_INC_DIR_CORE = $(LIBUC_INC_DIR)
40 LIBUC_INC_DIR_CORE_CMD =
45 LIBUC_INC_DIR_CORE_CMD =
41
46
42 LIBUC_LIBS_CPU = -static -lcpu
47 LIBUC_LIBS_CPU = -static -lcpu
43 LIBUC_LIBS_DIR_CPU = $(LIBUC_LIBS_DIR)
48 LIBUC_LIBS_DIR_CPU = $(LIBUC_LIBS_DIR)
44 LIBUC_LIBS_DIR_CPU_CMD = -L $(LIBUC_LIBS_DIR_CPU)
49 LIBUC_LIBS_DIR_CPU_CMD = -L $(LIBUC_LIBS_DIR_CPU)
45 LIBUC_INC_DIR_CPU = $(LIBUC_INC_DIR)/$(ARCH)
50 LIBUC_INC_DIR_CPU = $(LIBUC_INC_DIR)/$(ARCH)
46 LIBUC_INC_DIR_CPU_CMD = -I $(LIBUC_INC_DIR_CPU)
51 LIBUC_INC_DIR_CPU_CMD = -I $(LIBUC_INC_DIR_CPU)
47
52
48 LIBUC_LIBS_GPIO = -static -lgpio
53 LIBUC_LIBS_GPIO = -static -lgpio
49 LIBUC_LIBS_DIR_GPIO = $(LIBUC_LIBS_DIR)
54 LIBUC_LIBS_DIR_GPIO = $(LIBUC_LIBS_DIR)
50 LIBUC_LIBS_DIR_GPIO_CMD = -L $(LIBUC_LIBS_DIR_GPIO)
55 LIBUC_LIBS_DIR_GPIO_CMD = -L $(LIBUC_LIBS_DIR_GPIO)
51 LIBUC_INC_DIR_GPIO = $(LIBUC_INC_DIR)
56 LIBUC_INC_DIR_GPIO = $(LIBUC_INC_DIR)
52 LIBUC_INC_DIR_GPIO_CMD =
57 LIBUC_INC_DIR_GPIO_CMD =
53
58
54 LIBUC_LIBS_APB = -static -lapb
59 LIBUC_LIBS_APB = -static -lapb
55 LIBUC_LIBS_DIR_APB = $(LIBUC_LIBS_DIR)
60 LIBUC_LIBS_DIR_APB = $(LIBUC_LIBS_DIR)
56 LIBUC_LIBS_DIR_APB_CMD = -L $(LIBUC_LIBS_DIR_APB)
61 LIBUC_LIBS_DIR_APB_CMD = -L $(LIBUC_LIBS_DIR_APB)
57 LIBUC_INC_DIR_APB = $(LIBUC_INC_DIR)
62 LIBUC_INC_DIR_APB = $(LIBUC_INC_DIR)
58 LIBUC_INC_DIR_APB_CMD =
63 LIBUC_INC_DIR_APB_CMD =
59
64
60 LIBUC_LIBS_UCSTRINGS = -static -lucstrings
65 LIBUC_LIBS_UCSTRINGS = -static -lucstrings
61 LIBUC_LIBS_DIR_UCSTRINGS = $(LIBUC_LIBS_DIR)
66 LIBUC_LIBS_DIR_UCSTRINGS = $(LIBUC_LIBS_DIR)
62 LIBUC_LIBS_DIR_UCSTRINGS_CMD = -L $(LIBUC_LIBS_DIR_UCSTRINGS)
67 LIBUC_LIBS_DIR_UCSTRINGS_CMD = -L $(LIBUC_LIBS_DIR_UCSTRINGS)
63 LIBUC_INC_DIR_UCSTRINGS = $(LIBUC_INC_DIR)
68 LIBUC_INC_DIR_UCSTRINGS = $(LIBUC_INC_DIR)
64 LIBUC_INC_DIR_UCSTRINGS_CMD =
69 LIBUC_INC_DIR_UCSTRINGS_CMD =
65
70
66 LIBUC_LIBS_UART = -static -luart
71 LIBUC_LIBS_UART = -static -luart
67 LIBUC_LIBS_DIR_UART = $(LIBUC_LIBS_DIR)
72 LIBUC_LIBS_DIR_UART = $(LIBUC_LIBS_DIR)
68 LIBUC_LIBS_DIR_UART_CMD = -L $(LIBUC_LIBS_DIR_UART)
73 LIBUC_LIBS_DIR_UART_CMD = -L $(LIBUC_LIBS_DIR_UART)
69 LIBUC_INC_DIR_UART = $(LIBUC_INC_DIR)
74 LIBUC_INC_DIR_UART = $(LIBUC_INC_DIR)
70 LIBUC_INC_DIR_UART_CMD =
75 LIBUC_INC_DIR_UART_CMD =
71
76
72 LIBUC_LIBS_SPI = -static -lspi
77 LIBUC_LIBS_SPI = -static -lspi
73 LIBUC_LIBS_DIR_SPI = $(LIBUC_LIBS_DIR)
78 LIBUC_LIBS_DIR_SPI = $(LIBUC_LIBS_DIR)
74 LIBUC_LIBS_DIR_SPI_CMD = -L $(LIBUC_LIBS_DIR_SPI)
79 LIBUC_LIBS_DIR_SPI_CMD = -L $(LIBUC_LIBS_DIR_SPI)
75 LIBUC_INC_DIR_SPI = $(LIBUC_INC_DIR)
80 LIBUC_INC_DIR_SPI = $(LIBUC_INC_DIR)
76 LIBUC_INC_DIR_SPI_CMD =
81 LIBUC_INC_DIR_SPI_CMD =
77
82
78 LIBUC_LIBS_SSP = -static -lssp
83 LIBUC_LIBS_SSP = -static -lssp
79 LIBUC_LIBS_DIR_SSP = $(LIBUC_LIBS_DIR)
84 LIBUC_LIBS_DIR_SSP = $(LIBUC_LIBS_DIR)
80 LIBUC_LIBS_DIR_SSP_CMD = -L $(LIBUC_LIBS_DIR_SSP)
85 LIBUC_LIBS_DIR_SSP_CMD = -L $(LIBUC_LIBS_DIR_SSP)
81 LIBUC_INC_DIR_SSP = $(LIBUC_INC_DIR)
86 LIBUC_INC_DIR_SSP = $(LIBUC_INC_DIR)
82 LIBUC_INC_DIR_SSP_CMD =
87 LIBUC_INC_DIR_SSP_CMD =
83
88
84 LIBUC_LIBS_IIC = -static -liic
89 LIBUC_LIBS_IIC = -static -liic
85 LIBUC_LIBS_DIR_IIC = $(LIBUC_LIBS_DIR)
90 LIBUC_LIBS_DIR_IIC = $(LIBUC_LIBS_DIR)
86 LIBUC_LIBS_DIR_IIC_CMD = -L $(LIBUC_LIBS_DIR_IIC)
91 LIBUC_LIBS_DIR_IIC_CMD = -L $(LIBUC_LIBS_DIR_IIC)
87 LIBUC_INC_DIR_IIC = $(LIBUC_INC_DIR)
92 LIBUC_INC_DIR_IIC = $(LIBUC_INC_DIR)
88 LIBUC_INC_DIR_IIC_CMD =
93 LIBUC_INC_DIR_IIC_CMD =
89
94
90 LIBUC_LIBS_ADC = -static -ladc
95 LIBUC_LIBS_ADC = -static -ladc
91 LIBUC_LIBS_DIR_ADC = $(LIBUC_LIBS_DIR)
96 LIBUC_LIBS_DIR_ADC = $(LIBUC_LIBS_DIR)
92 LIBUC_LIBS_DIR_ADC_CMD = -L $(LIBUC_LIBS_DIR_ADC)
97 LIBUC_LIBS_DIR_ADC_CMD = -L $(LIBUC_LIBS_DIR_ADC)
93 LIBUC_INC_DIR_ADC = $(LIBUC_INC_DIR)
98 LIBUC_INC_DIR_ADC = $(LIBUC_INC_DIR)
94 LIBUC_INC_DIR_ADC_CMD =
99 LIBUC_INC_DIR_ADC_CMD =
95
100
96 LIBUC_LIBS_24LC0X = -static -l24lc0X
101 LIBUC_LIBS_24LC0X = -static -l24lc0X
97 LIBUC_LIBS_DIR_24LC0X = $(LIBUC_LIBS_DIR)
102 LIBUC_LIBS_DIR_24LC0X = $(LIBUC_LIBS_DIR)
98 LIBUC_LIBS_DIR_24LC0X_CMD = -L $(LIBUC_LIBS_DIR_24LC0X)
103 LIBUC_LIBS_DIR_24LC0X_CMD = -L $(LIBUC_LIBS_DIR_24LC0X)
99 LIBUC_INC_DIR_24LC0X = $(LIBUC_INC_DIR)
104 LIBUC_INC_DIR_24LC0X = $(LIBUC_INC_DIR)
100 LIBUC_INC_DIR_24LC0X_CMD =
105 LIBUC_INC_DIR_24LC0X_CMD =
101
106
102 LIBUC_LIBS_SDCARD = -static -lsdcard
107 LIBUC_LIBS_SDCARD = -static -lsdcard
103 LIBUC_LIBS_DIR_SDCARD = $(LIBUC_LIBS_DIR)
108 LIBUC_LIBS_DIR_SDCARD = $(LIBUC_LIBS_DIR)
104 LIBUC_LIBS_DIR_SDCARD_CMD = -L $(LIBUC_LIBS_DIR_SDCARD)
109 LIBUC_LIBS_DIR_SDCARD_CMD = -L $(LIBUC_LIBS_DIR_SDCARD)
105 LIBUC_INC_DIR_SDCARD = $(LIBUC_INC_DIR)
110 LIBUC_INC_DIR_SDCARD = $(LIBUC_INC_DIR)
106 LIBUC_INC_DIR_SDCARD_CMD =
111 LIBUC_INC_DIR_SDCARD_CMD =
107
112
108 LIBUC_LIBS_VS10XX = -static -lvs10XX
113 LIBUC_LIBS_VS10XX = -static -lvs10XX
109 LIBUC_LIBS_DIR_VS10XX = $(LIBUC_LIBS_DIR)
114 LIBUC_LIBS_DIR_VS10XX = $(LIBUC_LIBS_DIR)
110 LIBUC_LIBS_DIR_VS10XX_CMD = -L $(LIBUC_LIBS_DIR_VS10XX)
115 LIBUC_LIBS_DIR_VS10XX_CMD = -L $(LIBUC_LIBS_DIR_VS10XX)
111 LIBUC_INC_DIR_VS10XX = $(LIBUC_INC_DIR)
116 LIBUC_INC_DIR_VS10XX = $(LIBUC_INC_DIR)
112 LIBUC_INC_DIR_VS10XX_CMD =
117 LIBUC_INC_DIR_VS10XX_CMD =
113
118
114 LIBUC_LIBS_BLKDEVICE = -static -lblkdevice
119 LIBUC_LIBS_BLKDEVICE = -static -lblkdevice
115 LIBUC_LIBS_DIR_BLKDEVICE = $(LIBUC_LIBS_DIR)
120 LIBUC_LIBS_DIR_BLKDEVICE = $(LIBUC_LIBS_DIR)
116 LIBUC_LIBS_DIR_BLKDEVICE_CMD = -L $(LIBUC_LIBS_DIR_BLKDEVICE)
121 LIBUC_LIBS_DIR_BLKDEVICE_CMD = -L $(LIBUC_LIBS_DIR_BLKDEVICE)
117 LIBUC_INC_DIR_BLKDEVICE = $(LIBUC_INC_DIR)
122 LIBUC_INC_DIR_BLKDEVICE = $(LIBUC_INC_DIR)
118 LIBUC_INC_DIR_BLKDEVICE_CMD =
123 LIBUC_INC_DIR_BLKDEVICE_CMD =
119
124
120 LIBUC_LIBS_FAT32 = -static -lfat32
125 LIBUC_LIBS_FAT32 = -static -lfat32
121 LIBUC_LIBS_DIR_FAT32 = $(LIBUC_LIBS_DIR)
126 LIBUC_LIBS_DIR_FAT32 = $(LIBUC_LIBS_DIR)
122 LIBUC_LIBS_DIR_FAT32_CMD = -L $(LIBUC_LIBS_DIR_FAT32)
127 LIBUC_LIBS_DIR_FAT32_CMD = -L $(LIBUC_LIBS_DIR_FAT32)
123 LIBUC_INC_DIR_FAT32 = $(LIBUC_INC_DIR)
128 LIBUC_INC_DIR_FAT32 = $(LIBUC_INC_DIR)
124 LIBUC_INC_DIR_FAT32_CMD =
129 LIBUC_INC_DIR_FAT32_CMD =
125
130
126 LIBUC_LIBS_UHANDLE = -static -luhandle
131 LIBUC_LIBS_UHANDLE = -static -luhandle
127 LIBUC_LIBS_DIR_UHANDLE = $(LIBUC_LIBS_DIR)
132 LIBUC_LIBS_DIR_UHANDLE = $(LIBUC_LIBS_DIR)
128 LIBUC_LIBS_DIR_UHANDLE_CMD = -L $(LIBUC_LIBS_DIR_UHANDLE)
133 LIBUC_LIBS_DIR_UHANDLE_CMD = -L $(LIBUC_LIBS_DIR_UHANDLE)
129 LIBUC_INC_DIR_UHANDLE = $(LIBUC_INC_DIR)
134 LIBUC_INC_DIR_UHANDLE = $(LIBUC_INC_DIR)
130 LIBUC_INC_DIR_UHANDLE_CMD =
135 LIBUC_INC_DIR_UHANDLE_CMD =
131
136
132 LIBUC_LIBS_STREAMDEVICES = -static -lstreamdevices
137 LIBUC_LIBS_STREAMDEVICES = -static -lstreamdevices
133 LIBUC_LIBS_DIR_STREAMDEVICES = $(LIBUC_LIBS_DIR)
138 LIBUC_LIBS_DIR_STREAMDEVICES = $(LIBUC_LIBS_DIR)
134 LIBUC_LIBS_DIR_STREAMDEVICES_CMD = -L $(LIBUC_LIBS_DIR_STREAMDEVICES)
139 LIBUC_LIBS_DIR_STREAMDEVICES_CMD = -L $(LIBUC_LIBS_DIR_STREAMDEVICES)
135 LIBUC_INC_DIR_STREAMDEVICES = $(LIBUC_INC_DIR)
140 LIBUC_INC_DIR_STREAMDEVICES = $(LIBUC_INC_DIR)
136 LIBUC_INC_DIR_STREAMDEVICES_CMD =
141 LIBUC_INC_DIR_STREAMDEVICES_CMD =
137
142
138 LIBUC_LIBS_HEXVIEWER = -static -lhexviewer
143 LIBUC_LIBS_HEXVIEWER = -static -lhexviewer
139 LIBUC_LIBS_DIR_HEXVIEWER = $(LIBUC_LIBS_DIR)
144 LIBUC_LIBS_DIR_HEXVIEWER = $(LIBUC_LIBS_DIR)
140 LIBUC_LIBS_DIR_HEXVIEWER_CMD = -L $(LIBUC_LIBS_DIR_HEXVIEWER)
145 LIBUC_LIBS_DIR_HEXVIEWER_CMD = -L $(LIBUC_LIBS_DIR_HEXVIEWER)
141 LIBUC_INC_DIR_HEXVIEWER = $(LIBUC_INC_DIR)
146 LIBUC_INC_DIR_HEXVIEWER = $(LIBUC_INC_DIR)
142 LIBUC_INC_DIR_HEXVIEWER_CMD =
147 LIBUC_INC_DIR_HEXVIEWER_CMD =
143
148
144 LIBUC_LIBS_MBR = -static -lmbr
149 LIBUC_LIBS_MBR = -static -lmbr
145 LIBUC_LIBS_DIR_MBR = $(LIBUC_LIBS_DIR)
150 LIBUC_LIBS_DIR_MBR = $(LIBUC_LIBS_DIR)
146 LIBUC_LIBS_DIR_MBR_CMD = -L $(LIBUC_LIBS_DIR_MBR)
151 LIBUC_LIBS_DIR_MBR_CMD = -L $(LIBUC_LIBS_DIR_MBR)
147 LIBUC_INC_DIR_MBR = $(LIBUC_INC_DIR)
152 LIBUC_INC_DIR_MBR = $(LIBUC_INC_DIR)
148 LIBUC_INC_DIR_MBR_CMD =
153 LIBUC_INC_DIR_MBR_CMD =
149
154
150 LIBUC_LIBS_UCDIRENT = -static -lucdirent
155 LIBUC_LIBS_UCDIRENT = -static -lucdirent
151 LIBUC_LIBS_DIR_UCDIRENT = $(LIBUC_LIBS_DIR)
156 LIBUC_LIBS_DIR_UCDIRENT = $(LIBUC_LIBS_DIR)
152 LIBUC_LIBS_DIR_UCDIRENT_CMD = -L $(LIBUC_LIBS_DIR_UCDIRENT)
157 LIBUC_LIBS_DIR_UCDIRENT_CMD = -L $(LIBUC_LIBS_DIR_UCDIRENT)
153 LIBUC_INC_DIR_UCDIRENT = $(LIBUC_INC_DIR)
158 LIBUC_INC_DIR_UCDIRENT = $(LIBUC_INC_DIR)
154 LIBUC_INC_DIR_UCDIRENT_CMD =
159 LIBUC_INC_DIR_UCDIRENT_CMD =
155
160
156 LIBUC_LIBS_FS = -static -lfs
161 LIBUC_LIBS_FS = -static -lfs
157 LIBUC_LIBS_DIR_FS = $(LIBUC_LIBS_DIR)
162 LIBUC_LIBS_DIR_FS = $(LIBUC_LIBS_DIR)
158 LIBUC_LIBS_DIR_FS_CMD = -L $(LIBUC_LIBS_DIR_FS)
163 LIBUC_LIBS_DIR_FS_CMD = -L $(LIBUC_LIBS_DIR_FS)
159 LIBUC_INC_DIR_FS = $(LIBUC_INC_DIR)
164 LIBUC_INC_DIR_FS = $(LIBUC_INC_DIR)
160 LIBUC_INC_DIR_FS_CMD =
165 LIBUC_INC_DIR_FS_CMD =
161
166
162 LIBUC_LIBS_FSEXPLORER = -static -lfsexplorer
167 LIBUC_LIBS_FSEXPLORER = -static -lfsexplorer
163 LIBUC_LIBS_DIR_FSEXPLORER = $(LIBUC_LIBS_DIR)
168 LIBUC_LIBS_DIR_FSEXPLORER = $(LIBUC_LIBS_DIR)
164 LIBUC_LIBS_DIR_FSEXPLORER_CMD = -L $(LIBUC_LIBS_DIR_FSEXPLORER)
169 LIBUC_LIBS_DIR_FSEXPLORER_CMD = -L $(LIBUC_LIBS_DIR_FSEXPLORER)
165 LIBUC_INC_DIR_FSEXPLORER = $(LIBUC_INC_DIR)
170 LIBUC_INC_DIR_FSEXPLORER = $(LIBUC_INC_DIR)
166 LIBUC_INC_DIR_FSEXPLORER_CMD =
171 LIBUC_INC_DIR_FSEXPLORER_CMD =
167
172
168 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)
173 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)
169 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)
174 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)
170 LIBUC_LIBS_ALLFS = $(LIBUC_LIBS_UCDIRENT) $(LIBUC_LIBS_FS) $(LIBUC_LIBS_MBR) $(LIBUC_LIBS_FAT32) $(LIBUC_LIBS_SDCARD) $(LIBUC_LIBS_BLKDEVICE)
175 LIBUC_LIBS_ALLFS = $(LIBUC_LIBS_UCDIRENT) $(LIBUC_LIBS_FS) $(LIBUC_LIBS_MBR) $(LIBUC_LIBS_FAT32) $(LIBUC_LIBS_SDCARD) $(LIBUC_LIBS_BLKDEVICE)
171
176
172
177
173 LIBUC_LIBS_ADS127X = -static -lads127X
178 LIBUC_LIBS_ADS127X = -static -lads127X
174 LIBUC_LIBS_DIR_ADS127X = $(LIBUC_LIBS_DIR)
179 LIBUC_LIBS_DIR_ADS127X = $(LIBUC_LIBS_DIR)
175 LIBUC_LIBS_DIR_ADS127X_CMD = -L $(LIBUC_LIBS_DIR_ADS127X)
180 LIBUC_LIBS_DIR_ADS127X_CMD = -L $(LIBUC_LIBS_DIR_ADS127X)
176 LIBUC_INC_DIR_ADS127X = $(LIBUC_INC_DIR)
181 LIBUC_INC_DIR_ADS127X = $(LIBUC_INC_DIR)
177 LIBUC_INC_DIR_ADS127X_CMD =
182 LIBUC_INC_DIR_ADS127X_CMD =
178
183
179
184
180 LIBUC_LIBS_NXPLIB = -static -lnxplib
185 LIBUC_LIBS_NXPLIB = -static -lnxplib
181 LIBUC_LIBS_DIR_NXPLIB = $(LIBUC_LIBS_DIR)
186 LIBUC_LIBS_DIR_NXPLIB = $(LIBUC_LIBS_DIR)
182 LIBUC_LIBS_DIR_NXPLIB_CMD = -L $(LIBUC_LIBS_DIR_NXPLIB)
187 LIBUC_LIBS_DIR_NXPLIB_CMD = -L $(LIBUC_LIBS_DIR_NXPLIB)
183 LIBUC_INC_DIR_NXPLIB = $(LIBUC_INC_DIR)/LPCXXXX
188 LIBUC_INC_DIR_NXPLIB = $(LIBUC_INC_DIR)/LPCXXXX
184 LIBUC_INC_DIR_NXPLIB_CMD = -I $(LIBUC_INC_DIR_NXPLIB)
189 LIBUC_INC_DIR_NXPLIB_CMD = -I $(LIBUC_INC_DIR_NXPLIB)
185
190
186 LIBUC_LIBS_ARMMATH = -static -larmmath
191 LIBUC_LIBS_ARMMATH = -static -larmmath
187 LIBUC_LIBS_DIR_ARMMATH = $(LIBUC_LIBS_DIR)
192 LIBUC_LIBS_DIR_ARMMATH = $(LIBUC_LIBS_DIR)
188 LIBUC_LIBS_DIR_ARMMATH_CMD = -L $(LIBUC_LIBS_DIR_ARMMATH)
193 LIBUC_LIBS_DIR_ARMMATH_CMD = -L $(LIBUC_LIBS_DIR_ARMMATH)
189 LIBUC_INC_DIR_ARMMATH = $(LIBUC_INC_DIR)/ARM
194 LIBUC_INC_DIR_ARMMATH = $(LIBUC_INC_DIR)/ARM
190 LIBUC_INC_DIR_ARMMATH_CMD = $(LIBUC_INC_DIR_ARMMATH)
195 LIBUC_INC_DIR_ARMMATH_CMD = $(LIBUC_INC_DIR_ARMMATH)
191
196
192
197
193
198
194
199
195
200
196
201
197
202
198
203
199
204
200
205
201
206
202
207
203
208
204
209
205
210
206
211
207
212
General Comments 0
You need to be logged in to leave comments. Login now