Comunicazione seriale STM32F103 usando Hyperterminal

[strato]

Buona domenica forum,
come da titolo avrei bisogno di chiarezza riguardo la comunicazione seriale usando hyperterminal (mi è stato consigliato anche termite) tra il PC e l'evaluation board che monta l' stm32f103.
Del mondo dell'ARM purtroppo conosco ancora poco e fino ad ora ho programmato per cosi dire.. "bit a bit" vedendo quali registri usare e di quel registro quali bit alzare.
Mettiamo il caso abbia scritto tre funzioni

Codice: Seleziona tutto

serial_print(char*)
serial_read()
serial_init()

rispettivamente per scrivere una stringa,leggere una stringa ed inizializzare le porte.
Qui inizia il mio dubbio..hyperterminal dovrebbe essere l'equivalente dell'interfaccia che si ha ad esempio con il dev c?(lo schermo nero dove viene visualizzato il programma..non conosco il termine tecnico,scusatemi)
Io scrivo il mio programma,lo scarico nel micro,faccio partire hyperterminal e mi compare la stringa che ho caricato?
E come lo scrivo il main.c?Nel senso io ho quelle tre funzioni di prima,semplicemente il codice sarà

Codice: Seleziona tutto

serial_print(Hello world!)

?
Sono tentato di taggare i microcontrollisti del forum,ma è domenica e non voglio disturbare nessuno
grazie dell'attenzione

[TardoFreak]

Prima di proseguire ti invito a leggere:
- QUESTO articolo che descrive le nozioni di base per utilizzare una serial con il PIERI-PIC18.
- QUESTO articolo che illustra come sviluppare un programma appoggiandosi alla seriale ed utilizzandola per visualizzare su terminale (PC con hyperterminal) informazioni utili per il debug.
- In QUESTO thread ho messo una funzione di editor di linea che utilizza la seriale.

Penso che dopo queste tre letture (leggili tutti, ti saranno utili) potremo andare avanti cercando di capire come fare a fare le stesse cose con un Cortex-M3.

Un passo alla volta.

[strato]

Mangio e mi ci butto dentro..
Grazie immensamente TardoFreak.

[strato]

Ho trovato utilissimo il secondo articolo che mi hai linkato..cioè in sostanza penso di aver trovato tutto li ,sei un grande
Ora devo trasportare il tutto per la mia bella scheda..non vorrei approfittare..ma se butto giù un codice ti andrebbe di darci un'occhiata?

[TardoFreak]

Più che darci un' occhiata (coa ahimè improbabile) ti do qualche dritta.
Per le inizializzazioni io uso le funzioni di libreria della STM e gli esempi sono per la usart 2.
Ricordati prima di tutto di abilitare il clock della perferica della porta dove sono i pin RX e TX. Se non lo fai questa non funziona (a differenza di altri micro).

Codice: Seleziona tutto

  // Fornisce il clock alla porta che contiene RX e TX
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);

  // Fornisce il clock alla USART2
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);

Inizializzi i due pin di i/O

Codice: Seleziona tutto

  // Inizializza PA2 (TX) come uscita AF
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  GPIO_Init(GPIOA, &GPIO_InitStructure);
 
  // Inizializza PA3 (RX) come ingresso con pull-down
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD;
  GPIO_Init(GPIOA, &GPIO_InitStructure);

Inizializza la periferica

Codice: Seleziona tutto

// Configura l' USART 8 bit, 1 stop, no parità nessun controllo hardware
  USART_InitStructure.USART_BaudRate = 9600; // 9600 baud
  USART_InitStructure.USART_WordLength = USART_WordLength_8b;
  USART_InitStructure.USART_StopBits = USART_StopBits_1;
  USART_InitStructure.USART_Parity = USART_Parity_No;
  USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
  USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
  USART_Init(USART2, &USART_InitStructure);

Poi la abiliti

Codice: Seleziona tutto

// Abilita l' USART2
  USART_Cmd(USART2, ENABLE);

Per scrivere un carattere sulla seriale

Codice: Seleziona tutto

//-----------------------------------------------------------------------------------------------
char serialTxReady(void)
{
  return(USART2->SR & USART_SR_TC);
}
//-----------------------------------------------------------------------------------------------
// Scrive sulla linea seriale un carattere
int sendchar(int ch)
{
  if ('\n' == ch)
  {
    while(!(USART2->SR & USART_SR_TXE));
    USART2->DR = '\r';
  }
  while (!serialTxReady());
  USART2->DR = ch & 0x1FF;
  return ch;
}

Per la ricezione io ho usato una routine sotto interrupt ti scrivo al volo la funzione per leggere un carattere. L' ho scritta al volo ma non l' ho provata. Prendila come spunto (poi magari funziona )

Codice: Seleziona tutto

int readCh(void)
{
  // Attende la presenza di un carattere
  while (!(USART2->SR & USART_SR_RXNE));
  // Read one byte from the receive data register
  return USART2->DR & 0xff;
}

[strato]

Ecco adesso tocchiamo un punto a me dolente...al momento io non dovrei usare librerie ma vedere autonomamente i registri che devo abilitare e scrivermi io le funzioni, non sarei nemmeno capace di usarle perché non l'ho mai fatto quindi mi viene piu naturale operare cosi..ovviamente in questo modo per scrivere un programma che accende due led ci impiego un infinità.
Infatti se noti ti sto scrivendo all'una di notte

Io penso che nel momento in cui le cose si facciano piu serie il professore mia dia il "permesso" di usare le librerie..non lo so questo.

Ti faccio vedere il codice (senza andare a vedere nello specifico se i bit dei registri so corretti..perché richiederebbe leggere il datasheet apposito ed è una rottura di palle che onestamente non mi sento di chiederti)
dimmi se a grandi linee è corretto il ragionamento.

Codice: Seleziona tutto

#include "global.h"
char ricevuta[30];
//La funzione stampa(invia) su seriale una stringa.
void serialprint(const char *parola)
{
   int j=0;
   
  while(*(parola+j)!='\0')
   {
    USART1_DR=*(parola+j); //invio carattere per carattere.
      
    while(!(USART1_SR&0x80));//Vedo se il flag in trasmissione TE nel registro USART_SR è alto così da capire se posso trasmettere
    j++;
   }   
}


//La funzione legge(riceve) da seriale una stringa e restituisce il puntatore alla stringa letta.
char* serialread()
{
   int i=0;
      
   do
   {
      while(!(USART1_SR&0x20)); //Vedo se il flag in ricezione RE nel registro USART_SR è alto così da capire se posso ricevere
      ricevuta[i]=USART1_DR;
      i++;
   }
   while( ricevuta[i-1] != '\n' ); //il carattere di 'a capo' viene considerato fine stringa
   
   ricevuta[i-1]='\0'; // metto il tappo alla stringa che sto costruendo!
   
   return ricevuta;
}


//La funzione setta i registri del processore per attivare l'USART1.
void serialopen()
{
   RCC=(RCC | 0x4004);//Abilito USART1 e PA nel registro RCC_APB2ENR
   
   USART1_CR1=(USART1_CR1 | 0x200C);//Abilito l'USART,la Trasmissione e la Ricezione della seriale.
   
   USART1_BRR=0x341;//Stabilisco la velocita di comunicazione a 9600 baudrate
   
   CRH_PA=(CRH_PA & 0xFFFFF00F);
   CRH_PA=(CRH_PA | 0x4A0);//Rx e Tx sono collegate fisicamente rispettivamente a PA[10] e PA[9]. Quindi imposto PA[10] come floating Input e PA[9] come Output, max speed 2 MHz (Alternate function output Push-pull).
   
}

int main()
{
   serialprint(hello world!);
   return 0;
}

nell'header file global.h ho messo tutte le define dei registri che ho usato.

Se ,mettiamo il caso, il programma è corretto io dovrei adesso mandarlo al micro ed in seguito aprire hyperterminal e nella schermata vedermi comparire "hello world!" ?

grazie ancora TardoFreak (:

[strato]

Buona sera EY
Dopo un po' di sangue buttato sono riuscito a fare quello che dovevo fare [(sincronizzare due micro tramite seriale ) se vi può interessare posso postare il codice] e ringrazio ancora di cuore TardoFreak che inconsciamente mi ha aiutato con quel suo articolo sulla seriale.
Adesso devo cambiare micro,sempre ARM ma non so ancora quale, devo attendere nuove direttive dal prof.
Con la speranza che ci siate sempre qui a dare una mano ai piu deboli ,AMEN.