Forum: Mikrocontroller und Digitale Elektronik STM32F3 UART Problem


STM32F3 UART Problem
von david v. (dvyhnalik)

Lesenswert?
• ▲
▼ 
Hallo ich habe ein Problem bei der Verwendung von Uart am STM32F3 Board. 
Ich möchte alle 5 Uarts verwenden und zum Testen schicke ich über alle 
Uarts eigene Zeichen, jedoch bekomme ich über Uart1 das Zeichen von Uart 
1&2. Über Uart2 bekomme ich gar nichts. Über Uart3 bekomme ich die 
Zeichen von U3&U4 über U4 wiederum nichts und bei U5 passiert ebenfalls 
nichts. Hat jemand eine Ahnung woran das liegen könnte ?

main:
1
#include <stddef.h>

2
#include "stm32f30x.h"

3
#include "stm32f30x_conf.h"

4
#include "GPIO.h"

5
#include "UART.h"

6
7
#define  max_wordlength 10

8
char send[max_wordlength];

9
int ctr=0;

10
11
int main(void)

12
13
{   USART1_Init();

14
  USART2_Init();

15
  USART3_Init();

16
  UART4_Init();

17
  UART5_Init();

18
    GPIO_CLKconfig();

19
    init_Dig_input();

20
    int x=0;

21
  while (1)

22
23
  {

24
25
    if(send[1]=='h')

26
    {

27
        USART1_String("U1 ");

28
        USART2_String("U2 ");

29
        USART3_String("U3 ");

30
        UART4_String("U4 ");

31
        UART5_String("U5 ");

32
    }

33
34
35
  }

36
37
38
39
40
41
  return 0;

42
43
}



uart.c
1
void USART1_Init(void)

2
3
{

4
5
6
      RCC->APB2RSTR |= RCC_APB2RSTR_USART1RST;//Usart1 Reset

7
      RCC->APB2RSTR &= (~RCC_APB2RSTR_USART1RST);

8
      RCC->AHBENR |= RCC_AHBENR_GPIOAEN; //GPIOA Clock Enable

9
      RCC->APB2ENR |= RCC_APB2ENR_USART1EN;//USART1 Clock Enable

10
      RCC->CFGR3 |= RCC_CFGR3_USART1SW_0;//System clock (SYSCLK) selected as USART1 clock

11
      RCC->CFGR3 &= ~RCC_CFGR3_USART1SW_1;

12
13
        GPIOA->MODER |=GPIO_MODER_MODER9_1|GPIO_MODER_MODER10_1 ;//p9(TX)&p10(RX) Alternative function mode

14
      GPIOA->OSPEEDR |= GPIO_OSPEEDER_OSPEEDR9_0|GPIO_OSPEEDER_OSPEEDR9_1| //50 MHz speed

15
                  GPIO_OSPEEDER_OSPEEDR10_0|GPIO_OSPEEDER_OSPEEDR10_1;

16
17
      GPIOA->AFR[1] |= 0x00000100|0x00000200|0x00000400| //AF7

18
               0x00000010|0x00000020|0x00000040;

19
20
21
        USART1->BRR = (SystemCoreClock / 9600);//Baudrate 9600

22
    USART1->CR1 |=  USART_CR1_UE;//Usart enable

23
    USART1->CR1 |=  USART_CR1_TE |USART_CR1_RE|USART_CR1_RXNEIE ;//Receive & Transmit enable

24
    NVIC_EnableIRQ(USART1_IRQn);

25
    //NVIC_EnableIRQ(USART1_EXTI25_IRQN);

26
27
28
}

29
30
31
void USART1_PutChar(uint8_t ch)//write a character in the Transmit Data Register

32
33
{

34
35
  while(!(USART1->ISR & USART_ISR_TXE));

36
37
  USART1->TDR = ch;

38
39
}

40
41
42
void USART1_IRQHandler (void)

43
44
{

45
46
  if(USART1->ISR & USART_ISR_RXNE){

47
48
             if(ctr<1)

49
          {

50
            send[ctr]=USART1->RDR;

51
            ctr++;

52
            //opc(send[0]);

53
          }

54
55
        else if(ctr<max_wordlength)

56
          {

57
            send[ctr]=USART1->RDR;

58
            ctr++;

59
60
61
          }

62
63
        else

64
           {

65
66
           for(ctr=0;ctr<max_wordlength;ctr++){send[ctr]=0;}

67
           ctr=0;

68
           send[ctr]=USART1->RDR;

69
           ctr++;

70
           }

71
  }

72
}

73
void USART1_String(char*string)//write a String in the Transmit Data Register

74
75
{  int laenge=sizeof(string);

76
   int i=0;

77
  while(i<=(laenge+1)){

78
  USART1_PutChar(string[i]);

79
  i++;

80
  }

81
82
83
84
}

85
86
87
void USART2_Init(void)

88
89
{

90
91
92
      RCC->APB1RSTR |= RCC_APB1RSTR_USART2RST;//Usart2 Reset

93
      RCC->APB1RSTR &= (~RCC_APB1RSTR_USART2RST);

94
      RCC->AHBENR |= RCC_AHBENR_GPIODEN; //GPIOD Clock Enable

95
      RCC->APB1ENR |= RCC_APB1ENR_USART2EN;//USART2 Clock Enable

96
      RCC->CFGR3 |= RCC_CFGR3_USART2SW_0;//System clock (SYSCLK) selected as USART2 clock

97
      RCC->CFGR3 &= ~RCC_CFGR3_USART2SW_1;

98
99
        GPIOD->MODER |=GPIO_MODER_MODER5_1|GPIO_MODER_MODER6_1 ;//p5(TX)&p6(RX) Alternative function mode

100
      GPIOD->OSPEEDR |= GPIO_OSPEEDER_OSPEEDR5_0|GPIO_OSPEEDER_OSPEEDR5_1| //50 MHz speed

101
                  GPIO_OSPEEDER_OSPEEDR6_0|GPIO_OSPEEDER_OSPEEDR6_1;

102
103
      GPIOD->AFR[1] |= 0x00000100|0x00000200|0x00000400| //AF7

104
               0x00000010|0x00000020|0x00000040;

105
106
107
        USART2->BRR = (SystemCoreClock / 9600);//Baudrate 9600

108
    USART2->CR1 |=  USART_CR1_UE;//Usart enable

109
    USART2->CR1 |=  USART_CR1_TE |USART_CR1_RE|USART_CR1_RXNEIE ;//Receive & Transmit enable

110
    NVIC_EnableIRQ(USART2_IRQn);

111
112
113
114
}

115
116
117
void USART2_PutChar(uint8_t ch)//write a character in the Transmit Data Register

118
119
{

120
121
  while(!(USART2->ISR & USART_ISR_TXE));

122
123
  USART2->TDR = ch;

124
125
}

126
127
128
void USART2_IRQHandler (void)

129
130
{

131
132
  if(USART2->ISR & USART_ISR_RXNE){

133
134
             if(ctr<1)

135
          {

136
            send[ctr]=USART2->RDR;

137
            ctr++;

138
            //opc(send[0]);

139
          }

140
141
        else if(ctr<max_wordlength)

142
          {

143
            send[ctr]=USART2->RDR;

144
            ctr++;

145
146
147
          }

148
149
        else

150
           {

151
152
           for(ctr=0;ctr<max_wordlength;ctr++){send[ctr]=0;}

153
           ctr=0;

154
           send[ctr]=USART2->RDR;

155
           ctr++;

156
           }

157
  }

158
}

159
void USART2_String(char*string)//write a String in the Transmit Data Register

160
161
{  int laenge=sizeof(string);

162
   int i=0;

163
  while(i<=(laenge+1)){

164
  USART2_PutChar(string[i]);

165
  i++;

166
  }

167
168
169
170
}

171
172
173
174
void USART3_Init(void)

175
176
{

177
178
179
      RCC->APB1RSTR |= RCC_APB1RSTR_USART3RST;//Usart3 Reset

180
      RCC->APB1RSTR &= (~RCC_APB1RSTR_USART3RST);

181
      RCC->AHBENR |= RCC_AHBENR_GPIOBEN; //GPIOb Clock Enable

182
      RCC->APB1ENR |= RCC_APB1ENR_USART3EN;//USART3 Clock Enable

183
      RCC->CFGR3 |= RCC_CFGR3_USART3SW_0;//System clock (SYSCLK) selected as USART3 clock

184
      RCC->CFGR3 &= ~RCC_CFGR3_USART3SW_1;

185
186
        GPIOB->MODER |=GPIO_MODER_MODER10_1|GPIO_MODER_MODER11_1 ;//p10(TX)&p11(RX) Alternative function mode

187
      GPIOB->OSPEEDR |= GPIO_OSPEEDER_OSPEEDR10_0|GPIO_OSPEEDER_OSPEEDR10_1| //50 MHz speed

188
                  GPIO_OSPEEDER_OSPEEDR11_0|GPIO_OSPEEDER_OSPEEDR11_1;

189
190
      GPIOB->AFR[1] |= 0x00000700|0x00000070; //afr7

191
192
193
        USART3->BRR = (SystemCoreClock / 9600);//Baudrate 9600

194
    USART3->CR1 |=  USART_CR1_UE;//Usart enable

195
    USART3->CR1 |=  USART_CR1_TE |USART_CR1_RE|USART_CR1_RXNEIE ;//Receive & Transmit enable

196
    NVIC_EnableIRQ(USART3_IRQn);

197
198
199
200
}

201
202
203
void USART3_PutChar(uint8_t ch)//write a character in the Transmit Data Register

204
205
{

206
207
  while(!(USART3->ISR & USART_ISR_TXE));

208
209
  USART3->TDR = ch;

210
211
}

212
213
214
void USART3_IRQHandler (void)

215
216
{

217
218
  if(USART3->ISR & USART_ISR_RXNE){

219
220
             if(ctr<1)

221
          {

222
            send[ctr]=USART3->RDR;

223
            ctr++;

224
            //opc(send[0]);

225
          }

226
227
        else if(ctr<max_wordlength)

228
          {

229
            send[ctr]=USART3->RDR;

230
            ctr++;

231
232
233
          }

234
235
        else

236
           {

237
238
           for(ctr=0;ctr<max_wordlength;ctr++){send[ctr]=0;}

239
           ctr=0;

240
           send[ctr]=USART3->RDR;

241
           ctr++;

242
           }

243
  }

244
}

245
void USART3_String(char*string)//write a String in the Transmit Data Register

246
247
{  int laenge=sizeof(string);

248
   int i=0;

249
  while(i<=(laenge+1)){

250
  USART3_PutChar(string[i]);

251
  i++;

252
  }

253
254
255
256
}

257
258
259
void UART4_Init(void)

260
261
{

262
263
264
      RCC->APB1RSTR |= RCC_APB1RSTR_UART4RST;//Uart4 Reset

265
      RCC->APB1RSTR &= (~RCC_APB1RSTR_UART4RST);

266
      RCC->AHBENR |= RCC_AHBENR_GPIOCEN; //GPIOC Clock Enable

267
      RCC->APB1ENR |= RCC_APB1ENR_UART4EN;//UART4 Clock Enable

268
      RCC->CFGR3 |= RCC_CFGR3_UART4SW_0;//System clock (SYSCLK) selected as UART4 clock

269
      RCC->CFGR3 &= ~RCC_CFGR3_UART4SW_1;

270
271
        GPIOC->MODER |=GPIO_MODER_MODER10_1|GPIO_MODER_MODER11_1 ;//p10(TX)&p11(RX) Alternative function mode

272
      GPIOC->OSPEEDR |= GPIO_OSPEEDER_OSPEEDR10_0|GPIO_OSPEEDER_OSPEEDR10_1| //50 MHz speed

273
                  GPIO_OSPEEDER_OSPEEDR11_0|GPIO_OSPEEDER_OSPEEDR11_1;

274
275
      GPIOC->AFR[1] |= 0x00000800|0x00000080; //afr8

276
277
278
        UART4->BRR = (SystemCoreClock / 9600);//Baudrate 9600

279
    UART4->CR1 |=  USART_CR1_UE;//Usart enable

280
    UART4->CR1 |=  USART_CR1_TE |USART_CR1_RE|USART_CR1_RXNEIE ;//Receive & Transmit enable

281
    NVIC_EnableIRQ(UART4_IRQn);

282
283
284
285
}

286
287
288
void UART4_PutChar(uint8_t ch)//write a character in the Transmit Data Register

289
290
{

291
292
  while(!(UART4->ISR & USART_ISR_TXE));

293
294
  UART4->TDR = ch;

295
296
}

297
298
299
void UART4_IRQHandler (void)

300
301
{

302
303
  if(UART4->ISR & USART_ISR_RXNE){

304
305
             if(ctr<1)

306
          {

307
            send[ctr]=UART4->RDR;

308
            ctr++;

309
            //opc(send[0]);

310
          }

311
312
        else if(ctr<max_wordlength)

313
          {

314
            send[ctr]=UART4->RDR;

315
            ctr++;

316
          }

317
318
        else

319
           {

320
321
           for(ctr=0;ctr<max_wordlength;ctr++){send[ctr]=0;}

322
           ctr=0;

323
           send[ctr]=UART4->RDR;

324
           ctr++;

325
           }

326
  }

327
}

328
void UART4_String(char*string)//write a String in the Transmit Data Register

329
330
{  int laenge=sizeof(string);

331
   int i=0;

332
  while(i<=(laenge+1)){

333
  UART4_PutChar(string[i]);

334
  i++;

335
  }

336
337
338
339
}

340
341
342
void UART5_Init(void)

343
344
{

345
346
347
      RCC->APB1RSTR |= RCC_APB1RSTR_UART5RST;//Uart5 Reset

348
      RCC->APB1RSTR &= (~RCC_APB1RSTR_UART5RST);

349
      RCC->AHBENR |= RCC_AHBENR_GPIOCEN; //GPIOC Clock Enable

350
      RCC->AHBENR |= RCC_AHBENR_GPIODEN; //GPIOD Clock Enable

351
      RCC->APB1ENR |= RCC_APB1ENR_UART5EN;//UART5 Clock Enable

352
      RCC->CFGR3 |= RCC_CFGR3_UART5SW_0;//System clock (SYSCLK) selected as UART5 clock

353
      RCC->CFGR3 &= ~RCC_CFGR3_UART5SW_1;

354
355
        GPIOC->MODER |=GPIO_MODER_MODER12_1 ;//p10(TX)&p11(RX) Alternative function mode

356
      GPIOC->OSPEEDR |= GPIO_OSPEEDER_OSPEEDR12_0|GPIO_OSPEEDER_OSPEEDR10_1;//50MHz

357
      GPIOC->AFR[1] |= 0x00000800|0x00000080; //afr8

358
359
        GPIOD->MODER |=GPIO_MODER_MODER2_1;//p10(TX)&p11(RX) Alternative function mode

360
      GPIOD->OSPEEDR |= GPIO_OSPEEDER_OSPEEDR2_0|GPIO_OSPEEDER_OSPEEDR2_1;//50MHz

361
      GPIOD->AFR[1] |= 0x00000800|0x00000080; //afr8

362
363
364
        UART5->BRR = (SystemCoreClock / 9600);//Baudrate 9600

365
    UART5->CR1 |=  USART_CR1_UE;//Usart enable

366
    UART5->CR1 |=  USART_CR1_TE |USART_CR1_RE|USART_CR1_RXNEIE ;//Receive & Transmit enable

367
    NVIC_EnableIRQ(UART5_IRQn);

368
369
370
371
}

372
void UART5_PutChar(uint8_t ch)//write a character in the Transmit Data Register

373
374
{

375
376
  while(!(UART5->ISR & USART_ISR_TXE));

377
378
  UART5->TDR = ch;

379
380
}

381
382
383
void UART5_IRQHandler (void)

384
385
{

386
387
  if(UART5->ISR & USART_ISR_RXNE){

388
389
             if(ctr<1)

390
          {

391
            send[ctr]=UART5->RDR;

392
            ctr++;

393
            //opc(send[0]);

394
          }

395
396
        else if(ctr<max_wordlength)

397
          {

398
            send[ctr]=UART5->RDR;

399
            ctr++;

400
401
402
          }

403
404
        else

405
           {

406
407
           for(ctr=0;ctr<max_wordlength;ctr++){send[ctr]=0;}

408
           ctr=0;

409
           send[ctr]=UART5->RDR;

410
           ctr++;

411
           }

412
  }

413
}

414
void UART5_String(char*string)//write a String in the Transmit Data Register

415
416
{  int laenge=sizeof(string);

417
   int i=0;

418
  while(i<=(laenge+1)){

419
  UART5_PutChar(string[i]);

420
  i++;

421
  }

422
423
424
425
}


  


  




  

    Beitrag melden Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Markierten Text zitieren Antwort Antwort mit Zitat
  








    

    

       Thread beobachten

      |
         Seitenaufteilung abschalten

    

        


Bitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.



  Bestehender Account

  


  
  

  
    

      

        
          
        
        
          
        
      

      

        
          
        
        
          
        
      

    


    
    
    





  Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!

  Mit Google-Account einloggen
  





  Noch kein Account? Hier anmelden.