@@ -22,25 +22,40 | |||
|
22 | 22 | |
|
23 | 23 | #include <gpio.h> |
|
24 | 24 | |
|
25 | #define bsp_gpio_init_list(list) __bsp_gpio_init_list(list,sizeof(list)/sizeof(gpioinitlist_str)) | |
|
26 | ||
|
27 | typedef struct | |
|
28 | { | |
|
29 | gpio_t gpio; | |
|
30 | gpioconfig_str config; | |
|
31 | }gpioinitlist_str; | |
|
32 | ||
|
33 | ||
|
34 | ||
|
35 | void __bsp_gpio_init_list(gpioinitlist_str* list, int len) | |
|
36 | { | |
|
37 | for(int i=0;i<len;i++) | |
|
38 | { | |
|
39 | gpioopenandconfig(list[i].gpio,&(list[i].config)); | |
|
40 | } | |
|
41 | } | |
|
42 | ||
|
25 | 43 | void bsp_gpio_set_outputs(gpio_t* GPIO_Out_init_List,int len) |
|
26 | 44 | { |
|
27 | 45 | gpio_t GPIO_init; |
|
28 | 46 | for(int i=0;i<len;i++) |
|
29 | 47 | { |
|
30 | 48 | GPIO_init = gpioopen(GPIO_Out_init_List[i]); |
|
31 | GPIO_init |= gpiohighspeed | gpiooutdir | gpiopushpulltype; | |
|
32 | gpiosetconfig(&GPIO_init); | |
|
49 | gpiosetconfig(GPIO_init,gpiooutdir,gpiohighspeed,gpiopushpulltype,gpionopulltype); | |
|
33 | 50 | } |
|
34 | 51 | } |
|
35 | 52 | |
|
36 | 53 | void bsp_gpio_set_inputs(gpio_t* GPIO_In_init_List,int len) |
|
37 | 54 | { |
|
38 | gpio_t GPIO_init; | |
|
39 | 55 | for(int i=0;i<len;i++) |
|
40 | 56 | { |
|
41 | GPIO_init = gpioopen(GPIO_In_init_List[i]); | |
|
42 | GPIO_init |= gpiohighspeed | gpioindir; | |
|
43 | gpiosetconfig(&GPIO_init); | |
|
57 | gpio_t GPIO_init = gpioopen(GPIO_In_init_List[i]); | |
|
58 | gpiosetconfig(GPIO_init,gpioindir,gpiohighspeed,0,0); | |
|
44 | 59 | } |
|
45 | 60 | } |
|
46 | 61 |
@@ -94,21 +94,21 void bsp_GPIO_init() | |||
|
94 | 94 | gpio_t gpio5 = gpioopen(PSU_ALERT_5V); |
|
95 | 95 | gpio_t gpio6 = gpioopen(PSU_ALERT_1_5V); |
|
96 | 96 | gpio_t gpio7 = gpioopen(PSU_ALERT_3_3V); |
|
97 |
gpiosetspeed( |
|
|
98 |
gpiosetspeed( |
|
|
99 |
gpiosetspeed( |
|
|
100 |
gpiosetspeed( |
|
|
101 |
gpiosetspeed( |
|
|
102 |
gpiosetspeed( |
|
|
103 |
gpiosetspeed( |
|
|
97 | gpiosetspeed(gpio1,gpiohighspeed); | |
|
98 | gpiosetspeed(gpio2,gpiohighspeed); | |
|
99 | gpiosetspeed(gpio3,gpiohighspeed); | |
|
100 | gpiosetspeed(gpio4,gpiohighspeed); | |
|
101 | gpiosetspeed(gpio5,gpiohighspeed); | |
|
102 | gpiosetspeed(gpio6,gpiohighspeed); | |
|
103 | gpiosetspeed(gpio7,gpiohighspeed); | |
|
104 | 104 | gpioclr(PSU_DISABLE); |
|
105 |
gpiosetdir( |
|
|
106 |
gpiosetdir( |
|
|
107 |
gpiosetdir( |
|
|
108 |
gpiosetdir( |
|
|
109 |
gpiosetdir( |
|
|
110 |
gpiosetdir( |
|
|
111 |
gpiosetdir( |
|
|
105 | gpiosetdir(gpio1,gpiooutdir); | |
|
106 | gpiosetdir(gpio3,gpiooutdir); | |
|
107 | gpiosetdir(gpio2,gpiooutdir); | |
|
108 | gpiosetdir(gpio4,gpiooutdir); | |
|
109 | gpiosetdir(gpio5,gpioindir); | |
|
110 | gpiosetdir(gpio6,gpioindir); | |
|
111 | gpiosetdir(gpio7,gpioindir); | |
|
112 | 112 | gpioclr(PSU_DISABLE); |
|
113 | 113 | } |
|
114 | 114 | |
@@ -136,8 +136,8 int bsp_FSMC_init() | |||
|
136 | 136 | #define GPIOPORTNUM(gpio) (((uint32_t)(gpio) & (uint32_t)0x0000FF00)>>(uint32_t)8) |
|
137 | 137 | |
|
138 | 138 | gpio_t gpio1 = gpioopen(LCD_RESET); |
|
139 |
gpiosetspeed( |
|
|
140 |
gpiosetdir( |
|
|
139 | gpiosetspeed(gpio1,gpiohighspeed); | |
|
140 | gpiosetdir(gpio1,gpiooutdir); | |
|
141 | 141 | gpioclr(LCD_RESET); |
|
142 | 142 | |
|
143 | 143 | gpio_t LCD_DBxList[]={PD14,PD15,PD0,PD1,PE7,PE8,PE9,PE10,PE11,PE12,PE13,PE14,PE15\ |
@@ -145,8 +145,7 int bsp_FSMC_init() | |||
|
145 | 145 | for(int i=0;i<20;i++) |
|
146 | 146 | { |
|
147 | 147 | gpio_t LCD_DBx = gpioopen(LCD_DBxList[i]); |
|
148 |
LCD_DBx |
|
|
149 | gpiosetconfig(&LCD_DBx); | |
|
148 | gpiosetconfig(LCD_DBx, gpioaf, gpiohighspeed, gpiopushpulltype, gpionopulltype); | |
|
150 | 149 | GPIO_PinAFConfig(GPIOGETPORT(LCD_DBx), (uint8_t)(LCD_DBx & 0xF), GPIO_AF_FSMC); |
|
151 | 150 | } |
|
152 | 151 |
@@ -55,10 +55,10 void bsp_GPIO_init() | |||
|
55 | 55 | { |
|
56 | 56 | gpio_t gpio1 = gpioopen(PC6);//gpioopen(LED1); //PD9 D=> 0x0300 9 => 0x0009 |
|
57 | 57 | gpio_t gpio2 = gpioopen(PC7);//gpioopen(LED2); |
|
58 |
gpiosetspeed( |
|
|
59 |
gpiosetspeed( |
|
|
60 |
gpiosetdir( |
|
|
61 |
gpiosetdir( |
|
|
58 | gpiosetspeed(gpio1,gpiohighspeed); | |
|
59 | gpiosetspeed(gpio2,gpiohighspeed); | |
|
60 | gpiosetdir(gpio1,gpiooutdir); | |
|
61 | gpiosetdir(gpio2,gpiooutdir); | |
|
62 | 62 | } |
|
63 | 63 | |
|
64 | 64 | void bsp_uart_init() |
@@ -62,9 +62,9 void bsp_GPIO_init() | |||
|
62 | 62 | for(int i=0;i<8;i++) |
|
63 | 63 | { |
|
64 | 64 | GPIOx = gpioopen(GPIOList[i]); |
|
65 |
gpiosetspeed( |
|
|
66 |
gpiosetdir( |
|
|
67 |
gpiosetouttype( |
|
|
65 | gpiosetspeed(GPIOx,gpiohighspeed); | |
|
66 | gpiosetdir(GPIOx,gpiooutdir); | |
|
67 | gpiosetouttype(GPIOx,gpiopushpulltype); | |
|
68 | 68 | } |
|
69 | 69 | gpioset(ADC_CLKDIV); |
|
70 | 70 | gpioset(ADC_MODE0); |
@@ -60,8 +60,7 int bsp_FSMC_init() | |||
|
60 | 60 | for(int i=0;i<10;i++) |
|
61 | 61 | { |
|
62 | 62 | gpio_t LCD_DBx = gpioopen(LCD_DBxList[i]); |
|
63 |
LCD_DBx |
|
|
64 | gpiosetconfig(&LCD_DBx); | |
|
63 | gpiosetconfig(LCD_DBx, gpioaf, gpiohighspeed, gpiopushpulltype, gpionopulltype); | |
|
65 | 64 | GPIO_PinAFConfig(GPIOGETPORT(LCD_DBx), (uint8_t)(LCD_DBx & 0xF), GPIO_AF_FSMC); |
|
66 | 65 | } |
|
67 | 66 |
@@ -41,8 +41,7 void bsp_spi_init() | |||
|
41 | 41 | for(int i=0;i<3;i++) |
|
42 | 42 | { |
|
43 | 43 | gpio_t SPI_DBx = gpioopen(VSSPI_DBxList[i]); |
|
44 |
SPI_DBx |
|
|
45 | gpiosetconfig(&SPI_DBx); | |
|
44 | gpiosetconfig(SPI_DBx, gpioaf, gpiohighspeed, gpiopushpulltype, gpionopulltype); | |
|
46 | 45 | GPIO_PinAFConfig(GPIOGETPORT(SPI_DBx), (uint8_t)(SPI_DBx & 0xF), GPIO_AF_SPI1); |
|
47 | 46 | } |
|
48 | 47 | spiopenandconfig(VS1053SPI,spi8bits|spimaster|spimsbfirst,2*1000*1000,VS1053MOSI,VS1053MISO,VS1053SCK,-1); |
@@ -51,8 +50,7 void bsp_spi_init() | |||
|
51 | 50 | for(int i=0;i<3;i++) |
|
52 | 51 | { |
|
53 | 52 | gpio_t SPI_DBx = gpioopen(SDSPI_DBxList[i]); |
|
54 |
SPI_DBx |
|
|
55 | gpiosetconfig(&SPI_DBx); | |
|
53 | gpiosetconfig(SPI_DBx, gpioaf, gpiohighspeed, gpiopushpulltype, gpionopulltype); | |
|
56 | 54 | GPIO_PinAFConfig(GPIOGETPORT(SPI_DBx), (uint8_t)(SPI_DBx & 0xF), GPIO_AF_SPI3); |
|
57 | 55 | } |
|
58 | 56 | spiopenandconfig(SDCARD2SPI,spi8bits|spimaster|spimsbfirst,400*1000,SDCARD2MOSI,SDCARD2MISO,SDCARD2SCK,-1); |
@@ -61,8 +59,7 void bsp_spi_init() | |||
|
61 | 59 | for(int i=0;i<3;i++) |
|
62 | 60 | { |
|
63 | 61 | gpio_t SPI_DBx = gpioopen(TCSPI_DBxList[i]); |
|
64 |
SPI_DBx |
|
|
65 | gpiosetconfig(&SPI_DBx); | |
|
62 | gpiosetconfig(SPI_DBx, gpioaf, gpiohighspeed, gpiopushpulltype, gpionopulltype); | |
|
66 | 63 | GPIO_PinAFConfig(GPIOGETPORT(SPI_DBx), (uint8_t)(SPI_DBx & 0xF), GPIO_AF_SPI2); |
|
67 | 64 | } |
|
68 | 65 | spiopenandconfig(TC_SPI,spi8bits|spimaster|spimsbfirst,500*1000,TC_DIN,TC_DOUT,TC_CLK,-1); |
@@ -61,16 +61,16 void bsp_GPIO_init() | |||
|
61 | 61 | gpio_t gpio3 = gpioopen(PD14);//gpioopen(LED2); |
|
62 | 62 | gpio_t gpio4 = gpioopen(PD15);//gpioopen(LED2); |
|
63 | 63 | gpio_t dacRst=gpioopen(PD4); |
|
64 |
gpiosetspeed( |
|
|
65 |
gpiosetspeed( |
|
|
66 |
gpiosetspeed( |
|
|
67 |
gpiosetspeed( |
|
|
68 |
gpiosetspeed( |
|
|
69 |
gpiosetdir( |
|
|
70 |
gpiosetdir( |
|
|
71 |
gpiosetdir( |
|
|
72 |
gpiosetdir( |
|
|
73 |
gpiosetdir( |
|
|
64 | gpiosetspeed(gpio1,gpiohighspeed); | |
|
65 | gpiosetspeed(gpio2,gpiohighspeed); | |
|
66 | gpiosetspeed(gpio3,gpiohighspeed); | |
|
67 | gpiosetspeed(gpio4,gpiohighspeed); | |
|
68 | gpiosetspeed(dacRst,gpiohighspeed); | |
|
69 | gpiosetdir(gpio1,gpiooutdir); | |
|
70 | gpiosetdir(gpio3,gpiooutdir); | |
|
71 | gpiosetdir(gpio2,gpiooutdir); | |
|
72 | gpiosetdir(gpio4,gpiooutdir); | |
|
73 | gpiosetdir(dacRst,gpiooutdir); | |
|
74 | 74 | gpioset(dacRst); |
|
75 | 75 | } |
|
76 | 76 |
@@ -32,6 +32,8 | |||
|
32 | 32 | #include <terminal.h> |
|
33 | 33 | #include <pwm.h> |
|
34 | 34 | #include <spi.h> |
|
35 | #include <core.h> | |
|
36 | #include "../../common/bsp_gpio.h" | |
|
35 | 37 | |
|
36 | 38 | uint32_t OSC0 =12000000; |
|
37 | 39 | uint32_t INTOSC =16000000; |
@@ -106,6 +108,22 LCD_t* FRAME_BUFFER=&FRAME_BUFFER0; | |||
|
106 | 108 | |
|
107 | 109 | float VREF0 =(float)3.3; |
|
108 | 110 | |
|
111 | // GPIO config list | |
|
112 | gpioinitlist_str gpios[]={ | |
|
113 | {LED1,{gpiooutdir,gpiohighspeed,0,0}}, | |
|
114 | {LED2,{gpiooutdir,gpiohighspeed,0,0}}, | |
|
115 | {LED3,{gpiooutdir,gpiohighspeed,0,0}}, | |
|
116 | {PSU_DISABLE,{gpiooutdir,gpiohighspeed,gpiopushpulltype,0}}, | |
|
117 | {PSU_ALERT_5V,{gpioindir,gpiohighspeed,0,0}}, | |
|
118 | {PSU_ALERT_1_5V,{gpioindir,gpiohighspeed,0,0}}, | |
|
119 | {PSU_ALERT_3_3V,{gpioindir,gpiohighspeed,0,0}}, | |
|
120 | {BP1,{gpioindir,gpiohighspeed,0,0}}, | |
|
121 | {BP2,{gpioindir,gpiohighspeed,0,0}}, | |
|
122 | {BP3,{gpioindir,gpiohighspeed,0,0}}, | |
|
123 | {BP4,{gpioindir,gpiohighspeed,0,0}}, | |
|
124 | {TC_IRQ,{gpioindir,gpiohighspeed,0,gpiopulluptype}} | |
|
125 | }; | |
|
126 | ||
|
109 | 127 | int bsp_init() |
|
110 | 128 | { |
|
111 | 129 | int i=0; |
@@ -125,50 +143,20 int bsp_init() | |||
|
125 | 143 | printf(BSP); |
|
126 | 144 | printf(" initialised\n\r"); |
|
127 | 145 | printf( "=====================\n\r"); |
|
146 | char uuid[12]; | |
|
147 | getCpuUUID(uuid); | |
|
148 | printf("CPU UUID ="); | |
|
149 | for(int i=0;i<12;i++) | |
|
150 | { | |
|
151 | printf( "%02x",uuid[i]); | |
|
152 | } | |
|
153 | printf( "\n\r=====================\n\r"); | |
|
128 | 154 | return 1; |
|
129 | 155 | } |
|
130 | 156 | |
|
131 | 157 | void bsp_GPIO_init() |
|
132 | 158 | { |
|
133 | gpio_t gpio1 = gpioopen(LED1); | |
|
134 | gpio_t gpio2 = gpioopen(LED2); | |
|
135 | gpio_t gpio3 = gpioopen(LED3); | |
|
136 | gpio_t gpio4 = gpioopen(PSU_DISABLE); | |
|
137 | gpio_t gpio5 = gpioopen(PSU_ALERT_5V); | |
|
138 | gpio_t gpio6 = gpioopen(PSU_ALERT_1_5V); | |
|
139 | gpio_t gpio7 = gpioopen(PSU_ALERT_3_3V); | |
|
140 | gpio_t gpio8 = gpioopen(BP1); | |
|
141 | gpio_t gpio9 = gpioopen(BP2); | |
|
142 | gpio_t gpio10 = gpioopen(BP3); | |
|
143 | gpio_t gpio11 = gpioopen(BP4); | |
|
144 | gpio_t gpio12 = gpioopen(TC_IRQ); | |
|
145 | gpiosetspeed(&gpio1,gpiohighspeed); | |
|
146 | gpiosetspeed(&gpio2,gpiohighspeed); | |
|
147 | gpiosetspeed(&gpio3,gpiohighspeed); | |
|
148 | gpiosetspeed(&gpio4,gpiohighspeed); | |
|
149 | gpiosetspeed(&gpio5,gpiohighspeed); | |
|
150 | gpiosetspeed(&gpio6,gpiohighspeed); | |
|
151 | gpiosetspeed(&gpio7,gpiohighspeed); | |
|
152 | gpiosetspeed(&gpio8,gpiohighspeed); | |
|
153 | gpiosetspeed(&gpio9,gpiohighspeed); | |
|
154 | gpiosetspeed(&gpio10,gpiohighspeed); | |
|
155 | gpiosetspeed(&gpio11,gpiohighspeed); | |
|
156 | gpiosetspeed(&gpio12,gpiohighspeed); | |
|
157 | gpioclr(PSU_DISABLE); | |
|
158 | gpiosetdir(&gpio1,gpiooutdir); | |
|
159 | gpiosetdir(&gpio3,gpiooutdir); | |
|
160 | gpiosetdir(&gpio2,gpiooutdir); | |
|
161 | gpiosetdir(&gpio4,gpiooutdir); | |
|
162 | gpiosetdir(&gpio5,gpioindir); | |
|
163 | gpiosetdir(&gpio6,gpioindir); | |
|
164 | gpiosetdir(&gpio7,gpioindir); | |
|
165 | gpiosetdir(&gpio8,gpioindir); | |
|
166 | gpiosetdir(&gpio9,gpioindir); | |
|
167 | gpiosetdir(&gpio10,gpioindir); | |
|
168 | gpiosetdir(&gpio11,gpioindir); | |
|
169 | gpiosetdir(&gpio12,gpioindir); | |
|
170 | gpiosetpulltype(&gpio4,gpiopushpulltype); | |
|
171 | gpiosetpulltype(&gpio12,gpiopulluptype); | |
|
159 | bsp_gpio_init_list(gpios); | |
|
172 | 160 | gpioclr(PSU_DISABLE); |
|
173 | 161 | pwmopen(PWM9_CH2,LCD_BACKLIGHT); |
|
174 | 162 | int error = pwmsetconfig(PWM9_CH2,100,80.0); |
@@ -197,8 +185,8 int bsp_FSMC_init() | |||
|
197 | 185 | #define GPIOPORTNUM(gpio) (((uint32_t)(gpio) & (uint32_t)0x0000FF00)>>(uint32_t)8) |
|
198 | 186 | |
|
199 | 187 | gpio_t gpio1 = gpioopen(LCD_RESET); |
|
200 |
gpiosetspeed( |
|
|
201 |
gpiosetdir( |
|
|
188 | gpiosetspeed(gpio1,gpiohighspeed); | |
|
189 | gpiosetdir(gpio1,gpiooutdir); | |
|
202 | 190 | gpioclr(LCD_RESET); |
|
203 | 191 | |
|
204 | 192 | gpio_t LCD_DBxList[]={ |
@@ -226,8 +214,7 int bsp_FSMC_init() | |||
|
226 | 214 | for(int i=0;i<20;i++) |
|
227 | 215 | { |
|
228 | 216 | gpio_t LCD_DBx = gpioopen(LCD_DBxList[i]); |
|
229 |
LCD_DBx |
|
|
230 | gpiosetconfig(&LCD_DBx); | |
|
217 | gpiosetconfig(LCD_DBx, gpioaf, gpiohighspeed, gpiopushpulltype, gpionopulltype); | |
|
231 | 218 | GPIO_PinAFConfig(GPIOGETPORT(LCD_DBx), (uint8_t)(LCD_DBx & 0xF), GPIO_AF_FSMC); |
|
232 | 219 | } |
|
233 | 220 | |
@@ -316,8 +303,7 int bsp_FSMC_init() | |||
|
316 | 303 | for(int i=0;i<23;i++) |
|
317 | 304 | { |
|
318 | 305 | gpio_t SRAM_DBx = gpioopen(SRAM_DBxList[i]); |
|
319 |
SRAM_DBx |
|
|
320 | gpiosetconfig(&SRAM_DBx); | |
|
306 | gpiosetconfig(SRAM_DBx, gpioaf, gpiohighspeed, gpiopushpulltype, gpionopulltype); | |
|
321 | 307 | GPIO_PinAFConfig(GPIOGETPORT(SRAM_DBx), (uint8_t)(SRAM_DBx & 0xF), GPIO_AF_FSMC); |
|
322 | 308 | } |
|
323 | 309 | /*-- FSMC Configuration ------------------------------------------------------*/ |
@@ -364,13 +350,12 void bsp_spi_init() | |||
|
364 | 350 | { |
|
365 | 351 | |
|
366 | 352 | // ads7843init(&tc_dev,spi1,ADS7843_POWER_ADC_ON|ADS7843_MODE_12BITS,&TC_setnCS,&TC_busy); |
|
367 | spiopenandconfig(spi1,spimaster|spi8bits|spimsbfirst|spiclkfirstedge,10000000,TC_DIN,TC_DOUT,TC_CLK,-1); | |
|
368 | 353 | } |
|
369 | 354 | |
|
370 | 355 | |
|
371 | 356 | void bsp_iic_init() |
|
372 | 357 | { |
|
373 | i2copenandconfig(i2c3,0,10000,PH8,PH7); | |
|
358 | i2copenandconfig(i2c3,0,100000,PH8,PH7); | |
|
374 | 359 | } |
|
375 | 360 | |
|
376 | 361 | void bsp_SD_init() |
@@ -470,31 +455,15 void bsp_TC_init() | |||
|
470 | 455 | #define GPIOPORTNUM(gpio) (((uint32_t)(gpio) & (uint32_t)0x0000FF00)>>(uint32_t)8) |
|
471 | 456 | |
|
472 | 457 | gpio_t gpio1 = gpioopen(TC_BUSY); |
|
473 | gpio1 |= gpiohighspeed | gpioindir | gpionopulltype; | |
|
474 | gpiosetconfig(&gpio1); | |
|
458 | gpiosetconfig(gpio1,gpioindir,gpiohighspeed, 0, 0); | |
|
475 | 459 | |
|
476 | 460 | gpio1 = gpioopen(TC_IRQ); |
|
477 | gpio1 |= gpiohighspeed | gpioindir | gpiopulluptype; | |
|
478 | gpiosetconfig(&gpio1); | |
|
461 | gpiosetconfig(gpio1,gpioindir,gpiohighspeed, 0, 0); | |
|
479 | 462 | |
|
480 | 463 | gpio1 = gpioopen(TC_CS); |
|
481 | gpio1 |= gpiohighspeed | gpiooutdir | gpionopulltype; | |
|
482 | gpiosetconfig(&gpio1); | |
|
483 | ||
|
484 | gpio1 = gpioopen(TC_CLK); | |
|
485 | gpio1 |= gpiohighspeed | gpioaf | gpionopulltype; | |
|
486 | gpiosetconfig(&gpio1); | |
|
487 | GPIO_PinAFConfig(GPIOGETPORT(TC_CLK), (uint8_t)(TC_CLK & 0xF), GPIO_AF_SPI1); | |
|
464 | gpiosetconfig(gpio1, gpiooutdir, gpiohighspeed, 0, 0); | |
|
488 | 465 | |
|
489 | gpio1 = gpioopen(TC_DIN); | |
|
490 | gpio1 |= gpiohighspeed | gpioaf | gpionopulltype; | |
|
491 | gpiosetconfig(&gpio1); | |
|
492 | GPIO_PinAFConfig(GPIOGETPORT(gpio1), (uint8_t)(gpio1 & 0xF), GPIO_AF_SPI1); | |
|
493 | ||
|
494 | gpio1 = gpioopen(TC_DOUT); | |
|
495 | gpio1 |= gpiohighspeed | gpioaf | gpionopulltype; | |
|
496 | gpiosetconfig(&gpio1); | |
|
497 | GPIO_PinAFConfig(GPIOGETPORT(gpio1), (uint8_t)(gpio1 & 0xF), GPIO_AF_SPI1); | |
|
466 | spiopenandconfig(spi1,spimaster|spi8bits|spimsbfirst|spiclkfirstedge,10000000,TC_DIN,TC_DOUT,TC_CLK,-1); | |
|
498 | 467 | } |
|
499 | 468 | |
|
500 | 469 |
@@ -25,6 +25,7 | |||
|
25 | 25 | #include <gpio.h> |
|
26 | 26 | #include <uart.h> |
|
27 | 27 | #include <stdio.h> |
|
28 | #include "../../common/bsp_gpio.h" | |
|
28 | 29 | uint32_t OSC0 =8000000; |
|
29 | 30 | uint32_t INTOSC =16000000; |
|
30 | 31 | uint32_t RTCOSC =32768; |
@@ -33,6 +34,10 extern streamdevice* __opnfiles__[__MAX_ | |||
|
33 | 34 | gpio_t TickLed = LED1; |
|
34 | 35 | |
|
35 | 36 | float VREF0 =(float)3.3; |
|
37 | gpioinitlist_str gpios[]={ | |
|
38 | {LED1,{gpiooutdir,gpiohighspeed,0,0}}, | |
|
39 | {LED2,{gpiooutdir,gpiohighspeed,0,0}}, | |
|
40 | {BP0,{gpioindir,gpiohighspeed,0,0}}}; | |
|
36 | 41 | |
|
37 | 42 | int bsp_init() |
|
38 | 43 | { |
@@ -53,22 +58,13 int bsp_init() | |||
|
53 | 58 | |
|
54 | 59 | void bsp_GPIO_init() |
|
55 | 60 | { |
|
56 | gpio_t gpio1 = gpioopen(LED1); | |
|
57 | gpio_t gpio2 = gpioopen(LED2); | |
|
58 | gpio_t gpio3 = gpioopen(BP0); | |
|
59 | gpiosetspeed(&gpio1,gpiohighspeed); | |
|
60 | gpiosetspeed(&gpio2,gpiohighspeed); | |
|
61 | gpiosetspeed(&gpio3,gpiohighspeed); | |
|
62 | gpiosetdir(&gpio1,gpiooutdir); | |
|
63 | gpiosetdir(&gpio2,gpiooutdir); | |
|
64 | gpiosetdir(&gpio3,gpioindir); | |
|
61 | bsp_gpio_init_list(gpios); | |
|
65 | 62 | } |
|
66 | 63 | |
|
67 | 64 | void bsp_uart_init() |
|
68 | 65 | { |
|
69 | 66 | if(__opnfiles__[1]==NULL) |
|
70 | 67 | { |
|
71 | //uart_t* uart1 = (uart_t*)malloc(sizeof(uart_t)); | |
|
72 | 68 | streamdevice* fd1 = (streamdevice*)malloc(sizeof(streamdevice)); |
|
73 | 69 | uart_t uart = uartopenandconfig(uart1,uartparitynone | uart8bits | uartonestop,115200,PA9,PA10,-1,-1); |
|
74 | 70 | uartmkstreamdev(uart,fd1); |
@@ -97,6 +93,17 void bsp_SD_init() | |||
|
97 | 93 | |
|
98 | 94 | } |
|
99 | 95 | |
|
96 | /* | |
|
97 | * IM0=0 | |
|
98 | * IM1=1 | |
|
99 | * IM2=1 | |
|
100 | * IM3=0 | |
|
101 | * 4-wire 8-bit data serial interface I | |
|
102 | */ | |
|
103 | void bsp_LCD_init() | |
|
104 | { | |
|
105 | ||
|
106 | } | |
|
100 | 107 | |
|
101 | 108 | void vs10XXclearXCS(){} |
|
102 | 109 | void vs10XXsetXCS(){} |
@@ -128,5 +135,16 void bspsdcardselect(char YESNO) | |||
|
128 | 135 | |
|
129 | 136 | |
|
130 | 137 | |
|
138 | void bsp_lcd0_write_reg(uint32_t reg,uint32_t data) | |
|
139 | { | |
|
140 | ||
|
141 | } | |
|
142 | ||
|
143 | uint32_t bsp_lcd0_read_reg(uint32_t reg) | |
|
144 | { | |
|
145 | uint16_t value; | |
|
146 | ||
|
147 | return value; | |
|
148 | } | |
|
131 | 149 | |
|
132 | 150 |
@@ -32,6 +32,14 | |||
|
32 | 32 | |
|
33 | 33 | #define BP0 PA0 |
|
34 | 34 | |
|
35 | //LCD Signals | |
|
36 | //#define LCD_RST PE2 | |
|
37 | #define LCD_DCX PD13 | |
|
38 | #define LCD_SCL PF7 | |
|
39 | #define LCD_SDA PF9 | |
|
40 | #define LCD_CSX PC2 | |
|
41 | ||
|
42 | ||
|
35 | 43 | extern float VREF0; |
|
36 | 44 | |
|
37 | 45 | extern uint32_t OSC0; |
@@ -46,6 +54,7 extern void bsp_uart_init(); | |||
|
46 | 54 | extern void bsp_iic_init(); |
|
47 | 55 | extern void bsp_spi_init(); |
|
48 | 56 | extern void bsp_SD_init(); |
|
57 | extern void bsp_LCD_init(); | |
|
49 | 58 | |
|
50 | 59 | /* VS1053 */ |
|
51 | 60 | extern void clearXCS(); |
@@ -58,6 +67,9 char bspsdcardpresent(); | |||
|
58 | 67 | void bspsdcardselect(char YESNO); |
|
59 | 68 | char bspsdcardwriteprotected(); |
|
60 | 69 | |
|
70 | void bsp_lcd0_write_reg(uint32_t reg,uint32_t data); | |
|
71 | uint32_t bsp_lcd0_read_reg(uint32_t reg); | |
|
72 | ||
|
61 | 73 | #endif |
|
62 | 74 | |
|
63 | 75 |
@@ -87,12 +87,12 void bsp_GPIO_init() | |||
|
87 | 87 | // gpio_t gpio2 = gpioopen(PD13);//gpioopen(LED2); |
|
88 | 88 | gpio_t gpio3 = gpioopen(PD14);//gpioopen(LED2); |
|
89 | 89 | // gpio_t gpio4 = gpioopen(PD15);//gpioopen(LED2); |
|
90 |
gpiosetspeed( |
|
|
90 | gpiosetspeed(gpio1,gpiohighspeed); | |
|
91 | 91 | //gpiosetspeed(&gpio2,gpiohighspeed); |
|
92 |
gpiosetspeed( |
|
|
92 | gpiosetspeed(gpio3,gpiohighspeed); | |
|
93 | 93 | //gpiosetspeed(&gpio4,gpiohighspeed); |
|
94 |
gpiosetdir( |
|
|
95 |
gpiosetdir( |
|
|
94 | gpiosetdir(gpio1,gpiooutdir); | |
|
95 | gpiosetdir(gpio3,gpiooutdir); | |
|
96 | 96 | // gpiosetdir(&gpio2,gpiooutdir); |
|
97 | 97 | //gpiosetdir(&gpio4,gpiooutdir); |
|
98 | 98 | } |
@@ -149,12 +149,12 int bsp_FSMC_init() | |||
|
149 | 149 | #define GPIOPORTNUM(gpio) (((uint32_t)(gpio) & (uint32_t)0x0000FF00)>>(uint32_t)8) |
|
150 | 150 | |
|
151 | 151 | gpio_t gpio1 = gpioopen(LCD_RESET); |
|
152 |
gpiosetspeed( |
|
|
153 |
gpiosetdir( |
|
|
152 | gpiosetspeed(gpio1,gpiohighspeed); | |
|
153 | gpiosetdir(gpio1,gpiooutdir); | |
|
154 | 154 | gpioclr(LCD_RESET); |
|
155 | 155 | gpio1 = gpioopen(LCD_CS); |
|
156 |
gpiosetspeed( |
|
|
157 |
gpiosetdir( |
|
|
156 | gpiosetspeed(gpio1,gpiohighspeed); | |
|
157 | gpiosetdir(gpio1,gpiooutdir); | |
|
158 | 158 | gpioset(LCD_CS); |
|
159 | 159 | gpio_t LCD_DBxList[]={ |
|
160 | 160 | PD0 ,PD1 ,PD4 ,PD5 ,PD8 ,PD9 ,PD10,PD14,PD15, |
@@ -164,8 +164,7 int bsp_FSMC_init() | |||
|
164 | 164 | for(int i=0;i<19;i++) |
|
165 | 165 | { |
|
166 | 166 | gpio_t LCD_DBx = gpioopen(LCD_DBxList[i]); |
|
167 |
LCD_DBx |
|
|
168 | gpiosetconfig(&LCD_DBx); | |
|
167 | gpiosetconfig(LCD_DBx, gpioaf, gpiohighspeed, gpiopushpulltype, gpionopulltype); | |
|
169 | 168 | GPIO_PinAFConfig(GPIOGETPORT(LCD_DBx), (uint8_t)(LCD_DBx & 0xF), GPIO_AF_FSMC); |
|
170 | 169 | } |
|
171 | 170 |
@@ -102,14 +102,14 void bsp_GPIO_init() | |||
|
102 | 102 | gpio_t gpio2 = gpioopen(PD13);//gpioopen(LED2); |
|
103 | 103 | gpio_t gpio3 = gpioopen(PD14);//gpioopen(LED2); |
|
104 | 104 | gpio_t gpio4 = gpioopen(PD15);//gpioopen(LED2); |
|
105 |
gpiosetspeed( |
|
|
106 |
gpiosetspeed( |
|
|
107 |
gpiosetspeed( |
|
|
108 |
gpiosetspeed( |
|
|
109 |
gpiosetdir( |
|
|
110 |
gpiosetdir( |
|
|
111 |
gpiosetdir( |
|
|
112 |
gpiosetdir( |
|
|
105 | gpiosetspeed(gpio1,gpiohighspeed); | |
|
106 | gpiosetspeed(gpio2,gpiohighspeed); | |
|
107 | gpiosetspeed(gpio3,gpiohighspeed); | |
|
108 | gpiosetspeed(gpio4,gpiohighspeed); | |
|
109 | gpiosetdir(gpio1,gpiooutdir); | |
|
110 | gpiosetdir(gpio3,gpiooutdir); | |
|
111 | gpiosetdir(gpio2,gpiooutdir); | |
|
112 | gpiosetdir(gpio4,gpiooutdir); | |
|
113 | 113 | } |
|
114 | 114 | |
|
115 | 115 | void bsp_uart_init() |
@@ -145,8 +145,7 int bsp_FSMC_init() | |||
|
145 | 145 | for(int i=0;i<12;i++) |
|
146 | 146 | { |
|
147 | 147 | gpio_t LCD_DBx = gpioopen(LCD_DBxList[i]); |
|
148 |
LCD_DBx |
|
|
149 | gpiosetconfig(&LCD_DBx); | |
|
148 | gpiosetconfig(LCD_DBx, gpioaf, gpiohighspeed, gpiopushpulltype, gpionopulltype); | |
|
150 | 149 | GPIO_PinAFConfig(GPIOGETPORT(LCD_DBx), (uint8_t)(LCD_DBx & 0xF), GPIO_AF_FSMC); |
|
151 | 150 | } |
|
152 | 151 |
@@ -57,14 +57,14 void bsp_GPIO_init() | |||
|
57 | 57 | gpio_t gpio2 = gpioopen(PD13);//gpioopen(LED2); |
|
58 | 58 | gpio_t gpio3 = gpioopen(PD14);//gpioopen(LED2); |
|
59 | 59 | gpio_t gpio4 = gpioopen(PD15);//gpioopen(LED2); |
|
60 |
gpiosetspeed( |
|
|
61 |
gpiosetspeed( |
|
|
62 |
gpiosetspeed( |
|
|
63 |
gpiosetspeed( |
|
|
64 |
gpiosetdir( |
|
|
65 |
gpiosetdir( |
|
|
66 |
gpiosetdir( |
|
|
67 |
gpiosetdir( |
|
|
60 | gpiosetspeed(gpio1,gpiohighspeed); | |
|
61 | gpiosetspeed(gpio2,gpiohighspeed); | |
|
62 | gpiosetspeed(gpio3,gpiohighspeed); | |
|
63 | gpiosetspeed(gpio4,gpiohighspeed); | |
|
64 | gpiosetdir(gpio1,gpiooutdir); | |
|
65 | gpiosetdir(gpio3,gpiooutdir); | |
|
66 | gpiosetdir(gpio2,gpiooutdir); | |
|
67 | gpiosetdir(gpio4,gpiooutdir); | |
|
68 | 68 | } |
|
69 | 69 | |
|
70 | 70 | void bsp_uart_init() |
@@ -77,10 +77,10 void bsp_GPIO_init() | |||
|
77 | 77 | { |
|
78 | 78 | gpio_t gpio1 = gpioopen(LED1);//gpioopen(LED1); //PD9 D=> 0x0300 9 => 0x0009 |
|
79 | 79 | gpio_t gpio2 = gpioopen(LED2);//gpioopen(LED2); |
|
80 |
gpiosetspeed( |
|
|
81 |
gpiosetspeed( |
|
|
82 |
gpiosetdir( |
|
|
83 |
gpiosetdir( |
|
|
80 | gpiosetspeed(gpio1,gpiohighspeed); | |
|
81 | gpiosetspeed(gpio2,gpiohighspeed); | |
|
82 | gpiosetdir(gpio1,gpiooutdir); | |
|
83 | gpiosetdir(gpio2,gpiooutdir); | |
|
84 | 84 | } |
|
85 | 85 | |
|
86 | 86 | void bsp_uart_init() |
@@ -61,8 +61,7 int bsp_FSMC_init() | |||
|
61 | 61 | for(int i=0;i<10;i++) |
|
62 | 62 | { |
|
63 | 63 | gpio_t LCD_DBx = gpioopen(LCD_DBxList[i]); |
|
64 |
LCD_DBx |
|
|
65 | gpiosetconfig(&LCD_DBx); | |
|
64 | gpiosetconfig(LCD_DBx, gpioaf, gpiohighspeed, gpiopushpulltype, gpionopulltype); | |
|
66 | 65 | GPIO_PinAFConfig(GPIOGETPORT(LCD_DBx), (uint8_t)(LCD_DBx & 0xF), GPIO_AF_FSMC); |
|
67 | 66 | } |
|
68 | 67 |
@@ -92,12 +92,12 void bsp_GPIO_init() | |||
|
92 | 92 | gpio_t gpio1 = gpioopen(LED1); |
|
93 | 93 | gpio_t gpio2 = gpioopen(LED2); |
|
94 | 94 | gpio_t gpio3 = gpioopen(LED3); |
|
95 |
gpiosetspeed( |
|
|
96 |
gpiosetspeed( |
|
|
97 |
gpiosetspeed( |
|
|
98 |
gpiosetdir( |
|
|
99 |
gpiosetdir( |
|
|
100 |
gpiosetdir( |
|
|
95 | gpiosetspeed(gpio1,gpiohighspeed); | |
|
96 | gpiosetspeed(gpio2,gpiohighspeed); | |
|
97 | gpiosetspeed(gpio3,gpiohighspeed); | |
|
98 | gpiosetdir(gpio1,gpiooutdir); | |
|
99 | gpiosetdir(gpio2,gpiooutdir); | |
|
100 | gpiosetdir(gpio3,gpiooutdir); | |
|
101 | 101 | } |
|
102 | 102 | |
|
103 | 103 | void bsp_uart_init() |
@@ -159,8 +159,7 int bsp_FSMC_init() | |||
|
159 | 159 | for(int i=0;i<43;i++) |
|
160 | 160 | { |
|
161 | 161 | gpio_t LCD_DBx = gpioopen(LCD_DBxList[i]); |
|
162 |
LCD_DBx |
|
|
163 | gpiosetconfig(&LCD_DBx); | |
|
162 | gpiosetconfig(LCD_DBx, gpioaf, gpiohighspeed, gpiopushpulltype, gpionopulltype); | |
|
164 | 163 | GPIO_PinAFConfig(GPIOGETPORT(LCD_DBx), (uint8_t)(LCD_DBx & 0xF), GPIO_AF_FSMC); |
|
165 | 164 | } |
|
166 | 165 | |
@@ -237,8 +236,7 int bsp_FSMC_init() | |||
|
237 | 236 | for(int i=0;i<22;i++) |
|
238 | 237 | { |
|
239 | 238 | gpio_t SRAM_DBx = gpioopen(SRAM_DBxList[i]); |
|
240 |
SRAM_DBx |
|
|
241 | gpiosetconfig(&SRAM_DBx); | |
|
239 | gpiosetconfig(SRAM_DBx, gpioaf, gpiohighspeed, gpiopushpulltype, gpionopulltype); | |
|
242 | 240 | GPIO_PinAFConfig(GPIOGETPORT(SRAM_DBx), (uint8_t)(SRAM_DBx & 0xF), GPIO_AF_FSMC); |
|
243 | 241 | } |
|
244 | 242 | /*-- FSMC Configuration ------------------------------------------------------*/ |
@@ -291,8 +289,7 void bsp_SD_init() | |||
|
291 | 289 | for(int i=0;i<6;i++) |
|
292 | 290 | { |
|
293 | 291 | gpio_t SDIO_DBx = gpioopen(SDIO_DBxList[i]); |
|
294 |
SDIO_DBx |
|
|
295 | gpiosetconfig(&SDIO_DBx); | |
|
292 | gpiosetconfig(SDIO_DBx, gpioaf, gpiohighspeed, gpiopushpulltype, gpionopulltype); | |
|
296 | 293 | GPIO_PinAFConfig(GPIOGETPORT(SDIO_DBx), (uint8_t)(SDIO_DBx & 0xF), GPIO_AF_SDIO); |
|
297 | 294 | } |
|
298 | 295 | } |
@@ -24,6 +24,7 | |||
|
24 | 24 | * the project file. The value BSP contains the board name, and UCMODEL contain |
|
25 | 25 | * the target architecture. |
|
26 | 26 | */ |
|
27 | #include <stdio.h> | |
|
27 | 28 | |
|
28 | 29 | int libuc_main() |
|
29 | 30 | { |
@@ -5,7 +5,8 contains( UCMODEL , simulator ) { | |||
|
5 | 5 | } |
|
6 | 6 | contains( UCMODEL , stm32f4 ) { |
|
7 | 7 | #BSP = STM32F4Eval |
|
8 | BSP = SOSmartPSU | |
|
8 | #BSP = SOSmartPSU | |
|
9 | BSP = STM32F429Discovery | |
|
9 | 10 | } |
|
10 | 11 | |
|
11 | 12 | SOURCES += \ |
@@ -29,7 +29,7 With this api you will be able to open a | |||
|
29 | 29 | A simple example to drive PA0 and read PA1. |
|
30 | 30 | \code |
|
31 | 31 | // lets open PA0 and PA1 |
|
32 | gpio_t mygpio1 gpioopen(PA0); | |
|
32 | gpio_t mygpio1 = gpioopen(PA0); | |
|
33 | 33 | gpioopen(PA1); |
|
34 | 34 | mygpio1 |= gpiohighspeed | gpiooutdir | gpiopushpulltype | gpionopulltype; |
|
35 | 35 | gpiosetconfig(mygpio1); |
@@ -69,20 +69,20 typedef uint32_t gpio_t; | |||
|
69 | 69 | * @brief GPIO speed enum |
|
70 | 70 | * |
|
71 | 71 | * Use gpiospeed_t values to configure the speed of your GPIO pin with |
|
72 |
* gpiosetspeed(gpio_t |
|
|
72 | * gpiosetspeed(gpio_t gpio,gpiospeed_t speed) function or gpiosetconfig(gpio_t gpio). | |
|
73 | 73 | * The speed values are realy platform dependant check for each target if you whant to |
|
74 | 74 | * know the meaning of each speed. |
|
75 | 75 | * Don't try to use numerical values directly! |
|
76 |
* @sa gpiosetspeed(gpio_t |
|
|
76 | * @sa gpiosetspeed(gpio_t gpio,gpiospeed_t speed),gpiosetconfig(gpio_t gpio) | |
|
77 | 77 | * |
|
78 | 78 | * \ingroup GPIO |
|
79 | 79 | */ |
|
80 | 80 | typedef enum gpiospeed_t |
|
81 | 81 | { |
|
82 |
gpiolowspeed = 0 |
|
|
83 |
gpiomediumspeed |
|
|
84 |
gpiofastspeed |
|
|
85 |
gpiohighspeed |
|
|
82 | gpiolowspeed = 0, /**< Lowest speed value*/ | |
|
83 | gpiomediumspeed, /**< Normal or medium speed value*/ | |
|
84 | gpiofastspeed , /**< Higher speed value*/ | |
|
85 | gpiohighspeed /**< Highest speed value*/ | |
|
86 | 86 | }gpiospeed_t; |
|
87 | 87 | |
|
88 | 88 | |
@@ -91,18 +91,18 typedef enum gpiospeed_t | |||
|
91 | 91 | * @brief GPIO direction enum |
|
92 | 92 | * |
|
93 | 93 | * Use gpiodir_t values to configure the direction of your GPIO pin with |
|
94 |
* gpiosetdir(gpio_t |
|
|
94 | * gpiosetdir(gpio_t gpio,gpiodir_t dir) function or gpiosetconfig(gpio_t gpio). | |
|
95 | 95 | * Don't try to use numerical values directly! |
|
96 |
* @sa gpiosetdir(gpio_t |
|
|
96 | * @sa gpiosetdir(gpio_t gpio,gpiodir_t dir),gpiosetconfig(gpio_t gpio) | |
|
97 | 97 | * |
|
98 | 98 | * \ingroup GPIO |
|
99 | 99 | */ |
|
100 | 100 | typedef enum gpiodir_t |
|
101 | 101 | { |
|
102 |
gpioindir = 0 |
|
|
103 |
gpiooutdir |
|
|
104 |
gpioaf |
|
|
105 |
gpioan |
|
|
102 | gpioindir = 0,/**< Input direction*/ | |
|
103 | gpiooutdir, /**< Output direction*/ | |
|
104 | gpioaf, /**< Alternate function such as spi, uart, ...*/ | |
|
105 | gpioan /**< Configure the pin for analogic mode*/ | |
|
106 | 106 | }gpiodir_t; |
|
107 | 107 | |
|
108 | 108 | |
@@ -111,16 +111,16 typedef enum gpiodir_t | |||
|
111 | 111 | * @brief GPIO output type enum |
|
112 | 112 | * |
|
113 | 113 | * Use gpioouttype_t values to configure the kind of output you want with |
|
114 |
* gpiosetouttype(gpio_t |
|
|
114 | * gpiosetouttype(gpio_t gpio, gpioouttype_t outtype) function or gpiosetconfig(gpio_t gpio). | |
|
115 | 115 | * Don't try to use numerical values directly! |
|
116 |
* @sa gpiosetouttype(gpio_t |
|
|
116 | * @sa gpiosetouttype(gpio_t gpio, gpioouttype_t outtype),gpiosetconfig(gpio_t gpio) | |
|
117 | 117 | * |
|
118 | 118 | * \ingroup GPIO |
|
119 | 119 | */ |
|
120 | 120 | typedef enum gpioouttype_t |
|
121 | 121 | { |
|
122 |
gpiopushpulltype = 0 |
|
|
123 |
gpioopendraintype |
|
|
122 | gpiopushpulltype = 0, /**< Pushpull output*/ | |
|
123 | gpioopendraintype /**< Open drain output*/ | |
|
124 | 124 | }gpioouttype_t; |
|
125 | 125 | |
|
126 | 126 | |
@@ -129,19 +129,27 typedef enum gpioouttype_t | |||
|
129 | 129 | * @brief GPIO pull resistor configuration enum |
|
130 | 130 | * |
|
131 | 131 | * Use gpiopulltype_t values to configure the pull resistor of your GPIO pin with |
|
132 |
* gpiosetpulltype(gpio_t |
|
|
132 | * gpiosetpulltype(gpio_t gpio,gpiopulltype_t pulltype) function or gpiosetconfig(gpio_t gpio). | |
|
133 | 133 | * Don't try to use numerical values directly! |
|
134 |
* @sa gpiosetpulltype(gpio_t |
|
|
134 | * @sa gpiosetpulltype(gpio_t gpio,gpiopulltype_t pulltype),gpiosetconfig(gpio_t gpio) | |
|
135 | 135 | * |
|
136 | 136 | * \ingroup GPIO |
|
137 | 137 | */ |
|
138 | 138 | typedef enum gpiopulltype_t |
|
139 | 139 | { |
|
140 |
gpionopulltype = 0 |
|
|
141 |
gpiopulluptype |
|
|
142 |
gpiopulldowntype |
|
|
140 | gpionopulltype = 0, | |
|
141 | gpiopulluptype, | |
|
142 | gpiopulldowntype | |
|
143 | 143 | }gpiopulltype_t; |
|
144 | 144 | |
|
145 | typedef struct | |
|
146 | { | |
|
147 | gpiodir_t direction; | |
|
148 | gpiospeed_t speed; | |
|
149 | gpioouttype_t outType; | |
|
150 | gpiopulltype_t pullType; | |
|
151 | }gpioconfig_str; | |
|
152 | ||
|
145 | 153 | #ifndef DOXYGEN_SHOULD_SKIP_THIS |
|
146 | 154 |
|
|
147 | 155 |
|
@@ -154,11 +162,11 typedef enum gpiopulltype_t | |||
|
154 | 162 | * @param gpio |
|
155 | 163 | * @return |
|
156 | 164 | * @sa gpioclose(gpio_t gpio) |
|
157 | * @ingroup GPIO | |
|
158 | 165 | * |
|
159 | 166 | * \ingroup GPIO |
|
160 | 167 | */ |
|
161 | 168 | extern gpio_t gpioopen(uint32_t gpio); |
|
169 | extern gpio_t gpioopenandconfig(uint32_t gpio, gpioconfig_str* config); | |
|
162 | 170 | /** |
|
163 | 171 | * @brief gpioclose |
|
164 | 172 | * @param gpio |
@@ -170,10 +178,17 extern void gpioclose(gpio_t gpio); | |||
|
170 | 178 | /** |
|
171 | 179 | * @brief gpiosetconfig |
|
172 | 180 | * @param gpio |
|
181 | * @param direction | |
|
182 | * @param speed | |
|
183 | * @param outType | |
|
184 | * @param pullType | |
|
173 | 185 | * |
|
174 | 186 | * \ingroup GPIO |
|
175 | 187 | */ |
|
176 | extern void gpiosetconfig(gpio_t* gpio); | |
|
188 | extern void gpiosetconfig(gpio_t gpio, gpiodir_t direction, gpiospeed_t speed, gpioouttype_t outType, gpiopulltype_t pullType); | |
|
189 | extern void gpiosetconfigstr(gpio_t gpio, gpioconfig_str *config); | |
|
190 | ||
|
191 | ||
|
177 | 192 | /** |
|
178 | 193 | * @brief gpiosetdir |
|
179 | 194 | * @param gpio |
@@ -181,38 +196,38 extern void gpiosetconfig(gpio_t* gpio); | |||
|
181 | 196 | * |
|
182 | 197 | * \ingroup GPIO |
|
183 | 198 | */ |
|
184 |
extern void gpiosetdir(gpio_t |
|
|
199 | extern void gpiosetdir(gpio_t gpio,gpiodir_t dir); | |
|
185 | 200 | /** |
|
186 | 201 | * @brief gpiosetouttype |
|
187 | 202 | * @param gpio |
|
188 | 203 | * @param outtype |
|
189 |
* @sa gpiosetconfig(gpio_t |
|
|
204 | * @sa gpiosetconfig(gpio_t gpio) | |
|
190 | 205 | * |
|
191 | 206 | * \ingroup GPIO |
|
192 | 207 | */ |
|
193 |
extern void gpiosetouttype(gpio_t |
|
|
208 | extern void gpiosetouttype(gpio_t gpio, gpioouttype_t outtype); | |
|
194 | 209 | /** |
|
195 | 210 | * @brief gpiosetpulltype |
|
196 | 211 | * @param gpio |
|
197 | 212 | * @param pulltype |
|
198 |
* @sa gpiosetconfig(gpio_t |
|
|
213 | * @sa gpiosetconfig(gpio_t gpio) | |
|
199 | 214 | * |
|
200 | 215 | * \ingroup GPIO |
|
201 | 216 | */ |
|
202 |
extern void gpiosetpulltype(gpio_t |
|
|
217 | extern void gpiosetpulltype(gpio_t gpio,gpiopulltype_t pulltype); | |
|
203 | 218 | /** |
|
204 | 219 | * @brief gpiosetspeed |
|
205 | 220 | * @param gpio |
|
206 | 221 | * @param speed |
|
207 |
* @sa gpiosetconfig(gpio_t |
|
|
222 | * @sa gpiosetconfig(gpio_t gpio) | |
|
208 | 223 | * |
|
209 | 224 | * \ingroup GPIO |
|
210 | 225 | */ |
|
211 |
extern void gpiosetspeed(gpio_t |
|
|
226 | extern void gpiosetspeed(gpio_t gpio,gpiospeed_t speed); | |
|
212 | 227 | /** |
|
213 | 228 | * @brief gpioset |
|
214 | 229 | * @param gpio |
|
215 |
* @sa gpiosetconfig(gpio_t |
|
|
230 | * @sa gpiosetconfig(gpio_t gpio) | |
|
216 | 231 | * |
|
217 | 232 | * \ingroup GPIO |
|
218 | 233 | */ |
@@ -243,20 +258,20 extern int gpiogetval(gpio_t gpio); | |||
|
243 | 258 | |
|
244 | 259 | #ifndef DOXYGEN_SHOULD_SKIP_THIS |
|
245 | 260 | |
|
246 | #define GPIOISINPUT(gpio) (((gpio) & GPIODIRMASK)==gpioindir) | |
|
247 | #define GPIOISOUTPUT(gpio) (((gpio) & GPIOSPEEDMASK)==gpiooutdir) | |
|
261 | //#define GPIOISINPUT(gpio) (((gpio) & GPIODIRMASK)==gpioindir) | |
|
262 | //#define GPIOISOUTPUT(gpio) (((gpio) & GPIOSPEEDMASK)==gpiooutdir) | |
|
248 | 263 | |
|
249 | #define GPIOISLOWSPEED(gpio) (((gpio) & GPIOSPEEDMASK)==gpiolowspeed) | |
|
250 | #define GPIOISMEDIUMSPEED(gpio) (((gpio) & GPIOSPEEDMASK)==gpiomediumspeed) | |
|
251 | #define GPIOISFASTPEED(gpio) (((gpio) & GPIOSPEEDMASK)==gpiofastspeed) | |
|
252 | #define GPIOISHIGHSPEED(gpio) (((gpio) & GPIOSPEEDMASK)==gpiohighspeeds) | |
|
264 | //#define GPIOISLOWSPEED(gpio) (((gpio) & GPIOSPEEDMASK)==gpiolowspeed) | |
|
265 | //#define GPIOISMEDIUMSPEED(gpio) (((gpio) & GPIOSPEEDMASK)==gpiomediumspeed) | |
|
266 | //#define GPIOISFASTPEED(gpio) (((gpio) & GPIOSPEEDMASK)==gpiofastspeed) | |
|
267 | //#define GPIOISHIGHSPEED(gpio) (((gpio) & GPIOSPEEDMASK)==gpiohighspeeds) | |
|
253 | 268 | |
|
254 | #define GPIOISPUSHPULL(gpio) (((gpio) & GPIOOUTTYPEMASK)==gpiopushpulltype) | |
|
255 | #define GPIOISOPENDRAIN(gpio) (((gpio) & GPIOOUTTYPEMASK)==gpioopendraintype) | |
|
269 | //#define GPIOISPUSHPULL(gpio) (((gpio) & GPIOOUTTYPEMASK)==gpiopushpulltype) | |
|
270 | //#define GPIOISOPENDRAIN(gpio) (((gpio) & GPIOOUTTYPEMASK)==gpioopendraintype) | |
|
256 | 271 | |
|
257 | #define GPIOISNOPULL(GPIO) (((gpio) & GPIOPULLTYPEMASK)==gpionopulltype) | |
|
258 | #define GPIOISPULLUP(GPIO) (((gpio) & GPIOPULLTYPEMASK)==gpiopulluptype) | |
|
259 | #define GPIOISPULLDOWN(GPIO) (((gpio) & GPIOPULLTYPEMASK)==gpiopulldowntype) | |
|
272 | //#define GPIOISNOPULL(GPIO) (((gpio) & GPIOPULLTYPEMASK)==gpionopulltype) | |
|
273 | //#define GPIOISPULLUP(GPIO) (((gpio) & GPIOPULLTYPEMASK)==gpiopulluptype) | |
|
274 | //#define GPIOISPULLDOWN(GPIO) (((gpio) & GPIOPULLTYPEMASK)==gpiopulldowntype) | |
|
260 | 275 | |
|
261 | 276 | |
|
262 | 277 | #define PA0 ((0<<8)+0) |
@@ -30,6 +30,8 extern uint32_t getCpuFreq(); | |||
|
30 | 30 | extern int setCpuFreq(uint32_t freq); |
|
31 | 31 | extern int optimizePLLcfg(uint32_t freq, uint32_t srcfreq,uint32_t PLLM,uint32_t* PLLP, uint32_t* PLLN,uint8_t* AHBPRindx); |
|
32 | 32 | extern int setPll(uint32_t freq); |
|
33 | extern void getCpuUUID(char*uuid); | |
|
34 | extern int getCpuUUIDLen(); | |
|
33 | 35 | extern void enable_FPU(); |
|
34 | 36 | extern void reset_AHB1(); |
|
35 | 37 | extern void reset_AHB2(); |
@@ -248,8 +248,8 void ili9328paintFilCirc_old(LCD_t* LCD, | |||
|
248 | 248 | for(int32_t line=-r;line<r;line++) |
|
249 | 249 | { |
|
250 | 250 | #ifdef __OPTIMIZED_MATH |
|
251 |
Val1 = (uint32_t)optimised_sqrt((float |
|
|
252 |
Val2 = (uint32_t)optimised_sqrt((float |
|
|
251 | Val1 = (uint32_t)optimised_sqrt((float)(rr - (line*line)) ); | |
|
252 | Val2 = (uint32_t)optimised_sqrt((float)(rr2 - (line*line)) ); | |
|
253 | 253 | #else |
|
254 | 254 | Val1 = sqrt( (double)(rr - ((line)*(line))) ); |
|
255 | 255 | Val2 = sqrt( (double)(rr2 - ((line)*(line))) ); |
@@ -241,8 +241,8 void ssd2119paintFilCirc_old(LCD_t* LCD, | |||
|
241 | 241 | for(int32_t line=-r;line<r;line++) |
|
242 | 242 | { |
|
243 | 243 | #ifdef __OPTIMIZED_MATH |
|
244 |
Val1 = (uint32_t)optimised_sqrt((float |
|
|
245 |
Val2 = (uint32_t)optimised_sqrt((float |
|
|
244 | Val1 = (uint32_t)optimised_sqrt((float)(rr - (line*line)) ); | |
|
245 | Val2 = (uint32_t)optimised_sqrt((float)(rr2 - (line*line)) ); | |
|
246 | 246 | #else |
|
247 | 247 | Val1 = sqrt( (double)(rr - ((line)*(line))) ); |
|
248 | 248 | Val2 = sqrt( (double)(rr2 - ((line)*(line))) ); |
@@ -119,8 +119,14 void enable_FPU() | |||
|
119 | 119 | |
|
120 | 120 | } |
|
121 | 121 | |
|
122 | void getCpuUUID(char*uuid) | |
|
123 | { | |
|
124 | } | |
|
125 | ||
|
126 | int getCpuUUIDLen() | |
|
127 | { | |
|
128 | return 0; | |
|
129 | } | |
|
122 | 130 | |
|
123 | 131 | |
|
124 | 132 | |
|
125 | ||
|
126 |
@@ -376,4 +376,16 void enable_FPU() | |||
|
376 | 376 | |
|
377 | 377 | |
|
378 | 378 | |
|
379 | void getCpuUUID(char*uuid) | |
|
380 | { | |
|
381 | volatile char* uuidreg = (char*)0x1FFF7A10; | |
|
382 | for(int i=0;i<12;i++) | |
|
383 | { | |
|
384 | uuid[i]=uuidreg[i]; | |
|
385 | } | |
|
386 | } | |
|
379 | 387 | |
|
388 | int getCpuUUIDLen() | |
|
389 | { | |
|
390 | return 96/8; | |
|
391 | } |
@@ -21,10 +21,9 | |||
|
21 | 21 | -------------------------------------------------------------------------------*/ |
|
22 | 22 | #ifndef OPTIMISED_MATH_H |
|
23 | 23 | #define OPTIMISED_MATH_H |
|
24 | #include <arm_math.h> | |
|
25 | 24 | |
|
26 |
extern float |
|
|
25 | extern float optimised_sqrt(float value); | |
|
27 | 26 | |
|
28 |
extern float optimised_sin(float |
|
|
27 | extern float optimised_sin(float x); | |
|
29 | 28 | |
|
30 | 29 | #endif |
@@ -1,4 +1,6 | |||
|
1 | 1 | #include <optimised_math.h> |
|
2 | #include <arm_math.h> | |
|
3 | ||
|
2 | 4 | float32_t optimised_sqrt(float32_t value) |
|
3 | 5 | { |
|
4 | 6 | float32_t out; |
@@ -25,8 +25,7 int dacopen(uint32_t pin) | |||
|
25 | 25 | RCC_APB1PeriphClockCmd(RCC_APB1Periph_DAC, ENABLE); |
|
26 | 26 | gpio_t DACOUT; |
|
27 | 27 | DACOUT = gpioopen(pin); |
|
28 | DACOUT |= gpioan | gpionopulltype; | |
|
29 | gpiosetconfig(&DACOUT); | |
|
28 | gpiosetconfig(DACOUT, gpioan, gpiolowspeed, gpiopushpulltype, gpionopulltype); | |
|
30 | 29 | return 0; |
|
31 | 30 | } |
|
32 | 31 |
@@ -29,285 +29,155 | |||
|
29 | 29 | |
|
30 | 30 | gpio_t gpioopen(uint32_t gpio) |
|
31 | 31 | { |
|
32 | gpio &= -1^GPIOSPEEDMASK; | |
|
33 | gpio |= gpiolowspeed; | |
|
34 | gpio &= -1^GPIODIRMASK; | |
|
35 | gpio |= gpioindir; | |
|
36 | gpio &= -1^GPIOOUTTYPEMASK; | |
|
37 | gpio |= gpiopushpulltype; | |
|
38 | gpio &= -1^GPIOPULLTYPEMASK; | |
|
39 | gpio |= gpionopulltype; | |
|
40 | gpiosetconfig(&gpio); | |
|
32 | gpiosetconfig(gpio,gpioindir,gpiolowspeed,gpiopulluptype,gpionopulltype); | |
|
41 | 33 |
|
|
42 | 34 |
|
|
43 | 35 | } |
|
44 | 36 | |
|
37 | gpio_t gpioopenandconfig(uint32_t gpio, gpioconfig_str *config) | |
|
38 | { | |
|
39 | gpiosetconfig(gpio, config->direction, config->speed, config->outType, config->pullType); | |
|
40 | RCC_AHB1PeriphClockCmd(((uint32_t)0x00000001<<GPIOPORTNUM(gpio)), ENABLE); | |
|
41 | return gpio; | |
|
42 | } | |
|
45 | 43 | |
|
46 | 44 | void gpioclose(gpio_t gpio) |
|
47 | 45 | { |
|
48 | 46 | } |
|
49 | 47 | |
|
50 | void gpiosetconfig(gpio_t* gpio) | |
|
48 | void gpiosetconfig(gpio_t gpio, gpiodir_t direction, gpiospeed_t speed, gpioouttype_t outType, gpiopulltype_t pullType) | |
|
51 | 49 | { |
|
52 | gpiosetdir(gpio, (*gpio & GPIODIRMASK)); | |
|
53 | gpiosetspeed(gpio, (*gpio & GPIOSPEEDMASK)); | |
|
54 | gpiosetouttype(gpio, (*gpio & GPIOOUTTYPEMASK)); | |
|
55 | gpiosetpulltype(gpio, (*gpio & GPIOPULLTYPEMASK)); | |
|
50 | gpiosetdir(gpio, direction); | |
|
51 | gpiosetspeed(gpio, speed); | |
|
52 | gpiosetouttype(gpio, outType); | |
|
53 | gpiosetpulltype(gpio, pullType); | |
|
56 | 54 | } |
|
57 | 55 | |
|
58 | extern void gpiosetspeed(gpio_t* gpio,gpiospeed_t speed) | |
|
56 | void gpiosetconfigstr(gpio_t gpio, gpioconfig_str* config) | |
|
59 | 57 | { |
|
60 | GPIO_TypeDef* GPIOx = GPIOGETPORT((*gpio)); | |
|
58 | gpiosetconfig(gpio, config->direction, config->speed, config->outType, config->pullType); | |
|
59 | } | |
|
60 | ||
|
61 | extern void gpiosetspeed(gpio_t gpio,gpiospeed_t speed) | |
|
62 | { | |
|
63 | GPIO_TypeDef* GPIOx = GPIOGETPORT((gpio)); | |
|
64 | uint32_t speedMask = GPIO_Speed_2MHz; | |
|
61 | 65 |
|
|
62 | 66 | { |
|
63 | 67 |
|
|
64 | if((*gpio & 0xFF)==0xFF) | |
|
68 | speedMask = GPIO_Speed_2MHz; | |
|
69 | break; | |
|
70 | case gpiomediumspeed : | |
|
71 | speedMask = GPIO_Speed_25MHz; | |
|
72 | break; | |
|
73 | case gpiofastspeed : | |
|
74 | speedMask = GPIO_Speed_50MHz; | |
|
75 | break; | |
|
76 | case gpiohighspeed : | |
|
77 | speedMask = GPIO_Speed_100MHz; | |
|
78 | break; | |
|
79 | } | |
|
80 | if((gpio & 0xFF)==0xFF) | |
|
65 | 81 | { |
|
66 | 82 |
|
|
67 | 83 | { |
|
68 | 84 |
|
|
69 |
|
|
|
70 | } | |
|
71 | } | |
|
72 | else | |
|
73 | { | |
|
74 | GPIOx->OSPEEDR &= ~(GPIO_OSPEEDER_OSPEEDR0 << ((*gpio & 0xFF) * 2)); | |
|
75 | GPIOx->OSPEEDR |= ((uint32_t)(GPIO_Speed_2MHz) << ((*gpio & 0xFF) * 2)); | |
|
76 | } | |
|
77 | *gpio &= ~GPIOSPEEDMASK; | |
|
78 | *gpio |= gpiolowspeed; | |
|
79 | break; | |
|
80 | case gpiomediumspeed : | |
|
81 | if((*gpio & 0xFF)==0xFF) | |
|
82 | { | |
|
83 | for(int i=0;i<16;i++) | |
|
84 | { | |
|
85 | GPIOx->OSPEEDR &= ~(GPIO_OSPEEDER_OSPEEDR0 << (i * 2)); | |
|
86 | GPIOx->OSPEEDR |= ((uint32_t)(GPIO_Speed_25MHz) << (i * 2)); | |
|
87 | } | |
|
88 | } | |
|
89 | else | |
|
90 | { | |
|
91 | GPIOx->OSPEEDR &= ~(GPIO_OSPEEDER_OSPEEDR0 << ((*gpio & 0xFF) * 2)); | |
|
92 | GPIOx->OSPEEDR |= ((uint32_t)(GPIO_Speed_25MHz) << ((*gpio & 0xFF) * 2)); | |
|
93 | } | |
|
94 | *gpio &= ~GPIOSPEEDMASK; | |
|
95 | *gpio |= gpiomediumspeed; | |
|
96 | break; | |
|
97 | case gpiofastspeed : | |
|
98 | if((*gpio & 0xFF)==0xFF) | |
|
99 | { | |
|
100 | for(int i=0;i<16;i++) | |
|
101 | { | |
|
102 | GPIOx->OSPEEDR &= ~(GPIO_OSPEEDER_OSPEEDR0 << (i * 2)); | |
|
103 | GPIOx->OSPEEDR |= ((uint32_t)(GPIO_Speed_50MHz) << (i * 2)); | |
|
85 | GPIOx->OSPEEDR |= ((speedMask) << (i * 2)); | |
|
104 | 86 | } |
|
105 | 87 | } |
|
106 | 88 | else |
|
107 | 89 | { |
|
108 |
|
|
|
109 |
|
|
|
110 | } | |
|
111 | *gpio &= ~GPIOSPEEDMASK; | |
|
112 | *gpio |= gpiofastspeed; | |
|
113 | break; | |
|
114 | case gpiohighspeed : | |
|
115 | if((*gpio & 0xFF)==0xFF) | |
|
116 | { | |
|
117 | for(int i=0;i<16;i++) | |
|
118 | { | |
|
119 | GPIOx->OSPEEDR &= ~(GPIO_OSPEEDER_OSPEEDR0 << (i * 2)); | |
|
120 | GPIOx->OSPEEDR |= ((uint32_t)(GPIO_Speed_100MHz) << (i * 2)); | |
|
121 | } | |
|
122 | } | |
|
123 | else | |
|
124 | { | |
|
125 | GPIOx->OSPEEDR &= ~(GPIO_OSPEEDER_OSPEEDR0 << ((*gpio & 0xFF) * 2)); | |
|
126 | GPIOx->OSPEEDR |= ((uint32_t)(GPIO_Speed_100MHz) << ((*gpio & 0xFF) * 2)); | |
|
127 | } | |
|
128 | *gpio &= ~GPIOSPEEDMASK; | |
|
129 | *gpio |= gpiohighspeed; | |
|
130 | break; | |
|
90 | GPIOx->OSPEEDR &= ~(GPIO_OSPEEDER_OSPEEDR0 << ((gpio & 0xFF) * 2)); | |
|
91 | GPIOx->OSPEEDR |= ((speedMask) << ((gpio & 0xFF) * 2)); | |
|
131 | 92 |
|
|
132 | 93 | } |
|
133 | 94 | |
|
134 | 95 | |
|
135 |
void gpiosetdir(gpio_t |
|
|
96 | void gpiosetdir(gpio_t gpio, gpiodir_t dir) | |
|
136 | 97 | { |
|
137 |
|
|
|
98 | GPIO_TypeDef* GPIOx = GPIOGETPORT((gpio)); | |
|
99 | uint32_t directionMask = GPIO_Mode_IN; | |
|
138 | 100 |
|
|
139 | 101 | { |
|
140 | 102 |
|
|
141 | if((*gpio & 0xFF)==0xFF) | |
|
142 | { | |
|
143 | for(int i=0;i<16;i++) | |
|
144 | { | |
|
145 | GPIOx->MODER &= ~(GPIO_MODER_MODER0 << (i * 2)); | |
|
146 | GPIOx->MODER |= (GPIO_Mode_OUT << (i * 2)); | |
|
147 | } | |
|
148 | } | |
|
149 | else | |
|
150 | { | |
|
151 | GPIOx->MODER &= ~(GPIO_MODER_MODER0 << ((*gpio & 0xFF) * 2)); | |
|
152 | GPIOx->MODER |= (GPIO_Mode_OUT << ((*gpio & 0xFF) * 2)); | |
|
153 | } | |
|
154 | *gpio &= ~GPIODIRMASK; | |
|
155 | *gpio |= gpiooutdir; | |
|
103 | directionMask = GPIO_Mode_OUT; | |
|
156 | 104 | break; |
|
157 | 105 |
|
|
158 | if((*gpio & 0xFF)==0xFF) | |
|
159 | { | |
|
160 | for(int i=0;i<16;i++) | |
|
161 | { | |
|
162 | GPIOx->MODER &= ~(GPIO_MODER_MODER0 << (i * 2)); | |
|
163 | GPIOx->MODER |= (GPIO_Mode_AF << (i * 2)); | |
|
164 | } | |
|
165 | } | |
|
166 | else | |
|
167 | { | |
|
168 | GPIOx->MODER &= ~(GPIO_MODER_MODER0 << ((*gpio & 0xFF) * 2)); | |
|
169 | GPIOx->MODER |= (GPIO_Mode_AF << ((*gpio & 0xFF) * 2)); | |
|
170 | } | |
|
171 | *gpio &= ~GPIODIRMASK; | |
|
172 | *gpio |= gpioaf; | |
|
106 | directionMask = GPIO_Mode_AF; | |
|
173 | 107 | break; |
|
174 | 108 |
|
|
175 | if((*gpio & 0xFF)==0xFF) | |
|
109 | directionMask = GPIO_Mode_AN; | |
|
110 | break; | |
|
111 | } | |
|
112 | if((gpio & 0xFF)==0xFF) | |
|
176 | 113 | { |
|
177 | 114 |
|
|
178 | 115 | { |
|
179 | 116 |
|
|
180 |
|
|
|
181 | } | |
|
182 | } | |
|
183 | else | |
|
184 | { | |
|
185 | GPIOx->MODER &= ~(GPIO_MODER_MODER0 << ((*gpio & 0xFF) * 2)); | |
|
186 | GPIOx->MODER |= (GPIO_Mode_AN << ((*gpio & 0xFF) * 2)); | |
|
187 | } | |
|
188 | *gpio &= ~GPIODIRMASK; | |
|
189 | *gpio |= gpioan; | |
|
190 | break; | |
|
191 | default : | |
|
192 | if((*gpio & 0xFF)==0xFF) | |
|
193 | { | |
|
194 | for(int i=0;i<16;i++) | |
|
195 | { | |
|
196 | GPIOx->MODER &= ~(GPIO_MODER_MODER0 << (i * 2)); | |
|
197 | GPIOx->MODER |= (GPIO_Mode_IN << (i * 2)); | |
|
117 | GPIOx->MODER |= (directionMask << (i * 2)); | |
|
198 | 118 | } |
|
199 | 119 | } |
|
200 | 120 | else |
|
201 | 121 | { |
|
202 |
|
|
|
203 |
|
|
|
122 | GPIOx->MODER &= ~(GPIO_MODER_MODER0 << ((gpio & 0xFF) * 2)); | |
|
123 | GPIOx->MODER |= (directionMask << ((gpio & 0xFF) * 2)); | |
|
204 | 124 | } |
|
205 | *gpio &= ~GPIODIRMASK; | |
|
206 | *gpio |= gpioindir; | |
|
207 | break; | |
|
208 | } | |
|
209 | ||
|
210 | 125 | } |
|
211 | 126 | |
|
212 | 127 | |
|
213 |
void gpiosetouttype(gpio_t |
|
|
128 | void gpiosetouttype(gpio_t gpio, gpioouttype_t outtype) | |
|
214 | 129 | { |
|
215 |
|
|
|
130 | GPIO_TypeDef* GPIOx = GPIOGETPORT((gpio)); | |
|
131 | uint16_t outTypeMask = GPIO_OType_PP; | |
|
216 | 132 |
|
|
217 | { | |
|
218 | if((*gpio & 0xFF)==0xFF) | |
|
133 | outTypeMask = GPIO_OType_OD; | |
|
134 | else | |
|
135 | outTypeMask = GPIO_OType_PP; | |
|
136 | ||
|
137 | if((gpio & 0xFF)==0xFF) | |
|
219 | 138 | { |
|
220 | 139 |
|
|
221 | 140 | { |
|
222 | 141 |
|
|
223 |
|
|
|
224 | } | |
|
225 | } | |
|
226 | else | |
|
227 | { | |
|
228 | GPIOx->OTYPER &= ~((GPIO_OTYPER_OT_0) << ((uint16_t)(*gpio & 0xFF))); | |
|
229 | GPIOx->OTYPER |= (uint16_t)(GPIO_OType_OD<<((uint16_t)(*gpio & 0xFF))); | |
|
230 | } | |
|
231 | *gpio &= ~GPIOOUTTYPEMASK; | |
|
232 | *gpio |= gpioopendraintype; | |
|
233 | } | |
|
234 | else | |
|
235 | { | |
|
236 | if((*gpio & 0xFF)==0xFF) | |
|
237 | { | |
|
238 | for(int i=0;i<16;i++) | |
|
239 | { | |
|
240 | GPIOx->OTYPER &= ~((GPIO_OTYPER_OT_0) << ((uint16_t)i)); | |
|
241 | GPIOx->OTYPER |= (uint16_t)(GPIO_OType_PP<<((uint16_t)i)); | |
|
142 | GPIOx->OTYPER |= (uint16_t)(outTypeMask<<((uint16_t)i)); | |
|
242 | 143 | } |
|
243 | 144 | } |
|
244 | 145 | else |
|
245 | 146 | { |
|
246 |
|
|
|
247 |
|
|
|
248 | } | |
|
249 | *gpio &= ~GPIOOUTTYPEMASK; | |
|
250 | *gpio |= gpiopushpulltype; | |
|
147 | GPIOx->OTYPER &= ~((GPIO_OTYPER_OT_0) << ((uint16_t)(gpio & 0xFF))); | |
|
148 | GPIOx->OTYPER |= (uint16_t)(outTypeMask<<((uint16_t)(gpio & 0xFF))); | |
|
251 | 149 | } |
|
252 | 150 | } |
|
253 | 151 | |
|
254 | 152 | |
|
255 |
void gpiosetpulltype(gpio_t |
|
|
153 | void gpiosetpulltype(gpio_t gpio,gpiopulltype_t pulltype) | |
|
256 | 154 | { |
|
257 |
|
|
|
155 | GPIO_TypeDef* GPIOx = GPIOGETPORT(gpio); | |
|
156 | uint32_t pullTypeMask=GPIO_PuPd_NOPULL; | |
|
258 | 157 |
|
|
259 | 158 | { |
|
260 | 159 |
|
|
261 | if((*gpio & 0xFF)==0xFF) | |
|
160 | pullTypeMask=GPIO_PuPd_UP; | |
|
161 | break; | |
|
162 | case gpiopulldowntype: | |
|
163 | pullTypeMask=GPIO_PuPd_DOWN; | |
|
164 | break; | |
|
165 | default : | |
|
166 | pullTypeMask=GPIO_PuPd_NOPULL; | |
|
167 | break; | |
|
168 | } | |
|
169 | if((gpio & 0xFF)==0xFF) | |
|
262 | 170 | { |
|
263 | 171 |
|
|
264 | 172 | { |
|
265 | 173 |
|
|
266 |
|
|
|
174 | GPIOx->PUPDR |= (pullTypeMask << (i * 2)); | |
|
267 | 175 | } |
|
268 | 176 | } |
|
269 | 177 | else |
|
270 | 178 | { |
|
271 |
|
|
|
272 |
|
|
|
273 | } | |
|
274 | *gpio &= ~GPIOPULLTYPEMASK; | |
|
275 | *gpio |= gpiopulluptype; | |
|
276 | break; | |
|
277 | case gpiopulldowntype: | |
|
278 | if((*gpio & 0xFF)==0xFF) | |
|
279 | { | |
|
280 | for(int i=0;i<16;i++) | |
|
281 | { | |
|
282 | GPIOx->PUPDR &= ~(GPIO_PUPDR_PUPDR0 << ((uint16_t)i * 2)); | |
|
283 | GPIOx->PUPDR |= (GPIO_PuPd_DOWN << (i * 2)); | |
|
284 | } | |
|
285 | } | |
|
286 | else | |
|
287 | { | |
|
288 | GPIOx->PUPDR &= ~(GPIO_PUPDR_PUPDR0 << ((uint16_t)(*gpio & 0xFF) * 2)); | |
|
289 | GPIOx->PUPDR |= (GPIO_PuPd_DOWN << ((*gpio & 0xFF) * 2)); | |
|
290 | } | |
|
291 | *gpio &= ~GPIOPULLTYPEMASK; | |
|
292 | *gpio |= gpiopulldowntype; | |
|
293 | break; | |
|
294 | default : | |
|
295 | if((*gpio & 0xFF)==0xFF) | |
|
296 | { | |
|
297 | for(int i=0;i<16;i++) | |
|
298 | { | |
|
299 | GPIOx->PUPDR &= ~(GPIO_PUPDR_PUPDR0 << ((uint16_t)i * 2)); | |
|
300 | GPIOx->PUPDR |= (GPIO_PuPd_NOPULL << (i * 2)); | |
|
301 | } | |
|
302 | } | |
|
303 | else | |
|
304 | { | |
|
305 | GPIOx->PUPDR &= ~(GPIO_PUPDR_PUPDR0 << ((uint16_t)(*gpio & 0xFF) * 2)); | |
|
306 | GPIOx->PUPDR |= (GPIO_PuPd_NOPULL << ((*gpio & 0xFF) * 2)); | |
|
307 | } | |
|
308 | *gpio &= ~GPIOPULLTYPEMASK; | |
|
309 | *gpio |= gpionopulltype; | |
|
310 | break; | |
|
179 | GPIOx->PUPDR &= ~(GPIO_PUPDR_PUPDR0 << ((uint16_t)(gpio & 0xFF) * 2)); | |
|
180 | GPIOx->PUPDR |= (pullTypeMask << ((gpio & 0xFF) * 2)); | |
|
311 | 181 | } |
|
312 | 182 | } |
|
313 | 183 |
@@ -103,9 +103,7 int i2csetpins(i2c_t dev, uint32_t SDA, | |||
|
103 | 103 | gpio_t SDApin,SCLpin; |
|
104 | 104 | SDApin = gpioopen(SDA); |
|
105 | 105 | SCLpin = gpioopen(SCL); |
|
106 |
|
|
|
107 | SCLpin |= gpiolowspeed | gpiooutdir | gpioopendraintype | gpionopulltype; | |
|
108 | gpiosetconfig(&SCLpin); | |
|
106 | gpiosetconfig(SCLpin, gpiooutdir, gpiolowspeed, gpioopendraintype, gpionopulltype); | |
|
109 | 107 | for(int i=0;i<32;i++) |
|
110 | 108 | { |
|
111 | 109 | gpioclr(SCLpin); |
@@ -116,9 +114,8 int i2csetpins(i2c_t dev, uint32_t SDA, | |||
|
116 | 114 | {__asm__("nop");} |
|
117 | 115 | } |
|
118 | 116 | SCLpin = gpioopen(SCL); |
|
119 |
|
|
|
120 | gpiosetconfig(&SDApin); | |
|
121 | gpiosetconfig(&SCLpin); | |
|
117 | gpiosetconfig(SDApin, gpioaf, gpiolowspeed, gpioopendraintype, gpionopulltype); | |
|
118 | gpiosetconfig(SCLpin, gpioaf, gpiolowspeed, gpioopendraintype, gpionopulltype); | |
|
122 | 119 | uint8_t gpioAFi2cx = GPIO_AF_I2C1; |
|
123 | 120 | switch(dev) |
|
124 | 121 | { |
@@ -20,8 +20,7 int pwmopen(int PWM,uint32_t pin) | |||
|
20 | 20 | int timer = PWMGETTIMNUMBER(PWM); |
|
21 | 21 | gpio_t PWMOUT; |
|
22 | 22 | PWMOUT = gpioopen(pin); |
|
23 |
PWMOUT |
|
|
24 | gpiosetconfig(&PWMOUT); | |
|
23 | gpiosetconfig(PWMOUT, gpioaf, gpiohighspeed, gpiopushpulltype, gpionopulltype); | |
|
25 | 24 | uint8_t GPIO_AF = -1; |
|
26 | 25 | if(timer==timer1 || timer==timer2)GPIO_AF=1; |
|
27 | 26 | if(timer==timer3 || timer==timer4 || timer==timer5)GPIO_AF=2; |
@@ -123,31 +123,25 int spisetpins(spi_t spidev,uint32_t MOS | |||
|
123 | 123 | if(MISOpin!=-1) |
|
124 | 124 | { |
|
125 | 125 | MISO = gpioopen(MISOpin); |
|
126 |
MISO |
|
|
127 | gpiosetconfig(&MISO); | |
|
126 | gpiosetconfig(MISO, gpioaf, gpiohighspeed, gpiopushpulltype, gpionopulltype); | |
|
128 | 127 | GPIO_PinAFConfig(GPIOGETPORT(MISO), (uint8_t)(MISO & 0xF), gpioAFspix); |
|
129 | 128 | } |
|
130 | 129 | if(MOSIpin!=-1) |
|
131 | 130 | { |
|
132 | 131 | MOSI = gpioopen(MOSIpin); |
|
133 |
MOSI |
|
|
134 | gpiosetconfig(&MOSI); | |
|
132 | gpiosetconfig(MOSI, gpioaf, gpiohighspeed, gpiopushpulltype, gpionopulltype); | |
|
135 | 133 | GPIO_PinAFConfig(GPIOGETPORT(MOSI), (uint8_t)(MOSI & 0xF), gpioAFspix); |
|
136 | 134 | } |
|
137 | ||
|
138 | 135 | if(SCKpin!=-1) |
|
139 | 136 | { |
|
140 | 137 | SCK = gpioopen(SCKpin); |
|
141 |
SCK |
|
|
142 | gpiosetconfig(&SCK); | |
|
138 | gpiosetconfig(SCK, gpioaf, gpiohighspeed, gpiopushpulltype, gpionopulltype); | |
|
143 | 139 | GPIO_PinAFConfig(GPIOGETPORT(SCK), (uint8_t)(SCK & 0xF), gpioAFspix); |
|
144 | 140 | } |
|
145 | ||
|
146 | 141 | if(SCSpin!=-1) |
|
147 | 142 | { |
|
148 | 143 | SCS = gpioopen(SCSpin); |
|
149 |
SCS |
|
|
150 | gpiosetconfig(&SCS); | |
|
144 | gpiosetconfig(SCS, gpioaf, gpiohighspeed, gpiopushpulltype, gpionopulltype); | |
|
151 | 145 | GPIO_PinAFConfig(GPIOGETPORT(SCS), (uint8_t)(SCS & 0xF), gpioAFspix); |
|
152 | 146 | _dev_->CR2 |= (1<<2); |
|
153 | 147 | } |
@@ -36,6 +36,23 int _uartstrsetpos(streamdevice* device, | |||
|
36 | 36 | int _uartstrread(streamdevice* device,void* data,int size, int n); |
|
37 | 37 | int _uartstrwrite(streamdevice* device,void* data,int size, int n); |
|
38 | 38 | |
|
39 | typedef struct _dma_pointer_ | |
|
40 | { | |
|
41 | int pos; | |
|
42 | int size; | |
|
43 | }_dma_pointer_; | |
|
44 | ||
|
45 | #ifdef UART_USES_DMA | |
|
46 | static char _uart_dma_buff[1024]; | |
|
47 | _dma_pointer_ _uart1_dma_pointer={0,0}; | |
|
48 | _dma_pointer_ _uart2_dma_pointer={0,0}; | |
|
49 | _dma_pointer_ _uart3_dma_pointer={0,0}; | |
|
50 | _dma_pointer_ _uart4_dma_pointer={0,0}; | |
|
51 | _dma_pointer_ _uart5_dma_pointer={0,0}; | |
|
52 | _dma_pointer_ _uart6_dma_pointer={0,0}; | |
|
53 | _dma_pointer_* _uart_dma_pointer_table[6]={&_uart1_dma_pointer,&_uart2_dma_pointer,&_uart3_dma_pointer,&_uart4_dma_pointer,&_uart5_dma_pointer,&_uart6_dma_pointer}; | |
|
54 | #endif | |
|
55 | ||
|
39 | 56 | streamdevice_ops UART_OPS= |
|
40 | 57 | { |
|
41 | 58 | .write = &_uartstrwrite, |
@@ -143,10 +160,8 int uartsetpins(uart_t uart,uint32_t TXp | |||
|
143 | 160 | gpio_t TX,RX,CTS,RTS; |
|
144 | 161 | TX = gpioopen(TXpin); |
|
145 | 162 | RX = gpioopen(RXpin); |
|
146 |
TX |
|
|
147 |
RX |
|
|
148 | gpiosetconfig(&TX); | |
|
149 | gpiosetconfig(&RX); | |
|
163 | gpiosetconfig(TX,gpioaf,gpiolowspeed,gpiopushpulltype,gpionopulltype); | |
|
164 | gpiosetconfig(RX,gpioaf,gpiolowspeed,gpiopushpulltype,gpionopulltype); | |
|
150 | 165 | uint8_t gpioAFuartx = GPIO_AF_USART1; |
|
151 | 166 | switch(uart) |
|
152 | 167 | { |
@@ -179,16 +194,14 int uartsetpins(uart_t uart,uint32_t TXp | |||
|
179 | 194 | if(CTSpin!=-1) |
|
180 | 195 | { |
|
181 | 196 | CTS = gpioopen(CTSpin); |
|
182 |
CTS |
|
|
183 | gpiosetconfig(&CTS); | |
|
197 | gpiosetconfig(CTS,gpioaf,gpiolowspeed,gpiopushpulltype,gpionopulltype); | |
|
184 | 198 | GPIO_PinAFConfig(GPIOGETPORT(CTS), (uint8_t)(CTS & 0xF), gpioAFuartx); |
|
185 | 199 | } |
|
186 | 200 | |
|
187 | 201 | if(RTSpin!=-1) |
|
188 | 202 | { |
|
189 | 203 | RTS = gpioopen(RTSpin); |
|
190 |
RTS |
|
|
191 | gpiosetconfig(&RTS); | |
|
204 | gpiosetconfig(RTS,gpioaf,gpiolowspeed,gpiopushpulltype,gpionopulltype); | |
|
192 | 205 | GPIO_PinAFConfig(GPIOGETPORT(RTS), (uint8_t)(RTS & 0xF), gpioAFuartx); |
|
193 | 206 | } |
|
194 | 207 | } |
@@ -356,6 +369,7 int uartsetstopbits(uart_t uart,uartstop | |||
|
356 | 369 | return -1; |
|
357 | 370 | } |
|
358 | 371 | |
|
372 | #ifdef UART_USES_DMA | |
|
359 | 373 | int uartputc(uart_t uart,char c) |
|
360 | 374 | { |
|
361 | 375 | if((uart<6)&&(uart>=0)) |
@@ -367,7 +381,19 int uartputc(uart_t uart,char c) | |||
|
367 | 381 | } |
|
368 | 382 | return -1; |
|
369 | 383 | } |
|
370 | ||
|
384 | #else | |
|
385 | int uartputc(uart_t uart,char c) | |
|
386 | { | |
|
387 | if((uart<6)&&(uart>=0)) | |
|
388 | { | |
|
389 | USART_TypeDef* _dev_ = _uart_dev_table[(int)uart]; | |
|
390 | while((_dev_->SR & (uint16_t)(1<<7))!=(uint16_t)(1<<7)); | |
|
391 | _dev_->DR = c; | |
|
392 | return 1; | |
|
393 | } | |
|
394 | return -1; | |
|
395 | } | |
|
396 | #endif | |
|
371 | 397 | char uartgetc(uart_t uart) |
|
372 | 398 | { |
|
373 | 399 | if((uart<6)&&(uart>=0)) |
General Comments 0
You need to be logged in to leave comments.
Login now