Le plan de présentation est le suivant :

1) Comment relier le PC au STM32F407 par port série

a. USB/RS232 <-> RS232/UART ou USB/RS485 <-> RS485/UART ou USB/UART

MAX485
USB Interface RS485 UART
ou STM32F407
PC USB <-> RS485
équivalent

Brancher A+ sur A+ et B- sur B-

Brancher UART_TX venant du PC sur UART_RX du microcontrôleur et UART_RX allant vers le PC sur
UART_TX du microcontrôleur

b. Les broches du STM32F407 pouvant être utilisées

Voir page 60 de DM00037051_Datasheet.pdf pour trouver les pins de UART possibles (PA9 et PA10 sont
des broches possibles du USART1, mais elles ne marchent pas en raison du point suivant)

Il faut vérifier que les broches de USART (un UART avec fonctionnalités additionnelles) choisi ne sont pas
déjà utilisées sur le kit de développement

2) Comment trouver un logiciel PC pour envoyer les octets, et, surtout, le checksum qui n’est pas
une valeur ASCII
a. Drivers
b. Logiciels disponibles
c. ASCII versus hexadecimal
d. Un mot sur l’ouverture des ports série

Démo avec trois interfaces et voir sur internet!

3) Comment implémenter le port série dans le logiciel embarqué

a. Implémentation par accès bloquant, par interruption, par DMA
b. Utilisation de buffers circulaires
c. Interprétation des messages octet par octet
d. Exécution des commandes
Exemple de code:

char UartRxCB[TAILLE_DE_BUFFER_RX];
char UartTxCB[TAILLE_DE_BUFFER_RX];
int UartRxCB_WriteIndex;
int UartRxCB_ReadIndex;
int UartTxCB_WriteIndex;
int UartTxCB_ReadIndex;

void UART_ISR(void)
{
char ByteRx;

if(UART_REG_STATUS & UART_STATUS_BIT_UART_RX)

{
//UART_REG_STATUS &= ~UART_STATUS_BIT_UART_RX;
ByteRx = UART_REG_RX_BYTE;

UartRxCB[UartRxCB_WriteIndex] = ByteRx;
UartRxCB_WriteIndex++;
If(UartRxCB_WriteIndex >= sizeof(UartRxCB))
UartRxCB_WriteIndex = 0;
}

If(UART_REG_STATUS & UART_STATUS_BIT_UART_TX_READY)

{
If(UartTxCB_ReadIndex != UartTxCB_WriteIndex)
{
UART_REG_TX_BYTE = UartTxCB[UartTxCB_ReadIndex];
UartTxCB_ReadIndex++
If(UartTxCB_ReadIndex >= sizeof(UartTxCB))
UartTxCB_ ReadIndex = 0;
}
}
}

void UART_SendString(unsigned char* String, int StringLength)

{
for(i = 0; i < StringLength; i++)
{
UartTxCB[UartTxCB_WriteIndex] = String[i];
UartTxCB_ WriteIndex ++
If(UartTxCB_ WriteIndex >= sizeof(UartTxCB))
UartTxCB_ WriteIndex = 0;
}
StartUART_TransmissionIfNotAlreadyStarted();
}
void main(void)

{
char ByteToParse;
char lCommand;
char lCommandData;
InitUART();
InitLCD();

while(UartRxCB_ReadIndex != UartRxCB_WriteIndex)
{
ByteToParse = UartRxCB[UartRxCB_ReadIndex]
UartRxCB_ReadIndex++;
if(UartRxCB_ReadIndex >= sizeof(UartRxCB)
UartRxCB_ReadIndex = 0;

IsCommandReceived = Parse(ByteToParse, &lCommand, &lCommandData);

If(IsCommandReceived)
ExecuteCommand(lCommand, lCommandData);
}
}

char Parse(char ByteToParse, char* Command, char* CommandData)

{
switch(ParserState)
{
case WaitCommand:
if((ByteToParse == 0x40) || (ByteToParse == 0x41) || (ByteToParse == 0x42))
{
* Command = ByteToParse;
ParserState = WaitData;
}
Return 0;
case WaitData:
*CommandData = ByteToParse;
ParserState = WaitChecksum;
Return 0;
case WaitChecksum:
ParserState = WaitCommand;
if(*CommandData + * Command + ByteToParse == 0)
{
return 1;
}
Else
{
return 0;
}
}}