ARM - From PIC

[TardoFreak]

Domani spero di trovare il tempo per copiarti un po' di codice che ho scritto (e in parte copiato dagli esempi ) e che funziona, garantito al limone.

[pierinter]

Per l'UART ?

Già che sei così gentile... mi è arrivata questa schedina : http://www.sparkfun.com/products/10822

Secondo te come faccio a collegarmi dal computer ? nel manuale dice ci sono diversi modi per collegarsi alla schedina : o con l'UART (ma nn lo so ancora fare ) oppure creando una connessione ad hoc, ma non riesco.

[TardoFreak]

No, 'scolta,
Io ti copio un po' di funzioni per l' UART che ho scritto e che funzionano davvero.
Te le spiego, ti dico quale è il modo in cui bisogno ragionare per implementare le cose (che alla fine della fiera sono di carattere generale e vanno bene per tutto) ma non mi fare esplorare schede, please. Non ho il tempo di farlo e, a dire il vero, neanche la voglia.

Scusa la franchezza ma il negozio non può offrire altro al momento.

[pierinter]

No ci mancherebbe.
Era solo un problema di interpretazione di una parte del datasheet che non capivo , ma ci sono riuscito quindi a posto

[TardoFreak]

L' UART ... alura,
Per prima cosa dobbiamo dichiarare da qualche parte queste variabili che ci servono per l' inizializzazione. Lo dobbiamo fare perché non siamo masochisti e quindi utilizziamo la libreria standard che la ST fornisce.

Codice: Seleziona tutto

// Definizione della struttura utilizzata per l' inizializzazione delle porte di I/O
GPIO_InitTypeDef GPIO_InitStructure;
// Definizione della struttura per inizializzare l' USART
USART_InitTypeDef USART_InitStructure;

Come per le GPIO dobbiamo per prima cosa dare il clcok alla periferica.

Codice: Seleziona tutto

  // Fornisce il clock all' USART1 per metterla in funzione
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);

Configuriamo quindi i PIN (questa l' ho copiata e funziona)

Codice: Seleziona tutto

  // Configura il piedino di RX come input floating
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  GPIO_Init(GPIOA, &GPIO_InitStructure);
  /* Configura il pin TX come funzione alternativa push-pull */
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  GPIO_Init(GPIOA, &GPIO_InitStructure);

Quindi configuriamo l' UART

Codice: Seleziona tutto

// Configura l' USART 1200 baid, 8 bit, 1 stop, no parità nessun controllo hardware
  USART_InitStructure.USART_BaudRate = 1200;
  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;
  // Configura l' USART1
  USART_Init(USART1, &USART_InitStructure);

E alla fine la abilitiamo

Codice: Seleziona tutto

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

Per scrivere un carattere sulla UART1

Codice: Seleziona tutto

//-----------------------------------------------------------------------
void USART1PrintChar(char ch)
{
  // Aspetta che il registro di trasmissione sia libero
  while (USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET);
  USART_SendData(USART1,ch);
}

La ricezione la devo cercare e lo farò forse domani.

[pierinter]

mm ok, fino ad ora è tutto chiaro Grazie.

[pierinter]

Penso che la funzione per la ricezione sia questa, trovata sfogliando un po' le librerie ST :

Codice: Seleziona tutto

uint16_t USART_ReceiveData(USART_TypeDef* USARTx);


e questa è l'implementazione :

Codice: Seleziona tutto

uint16_t USART_ReceiveData(USART_TypeDef* USARTx)
{
  /* Check the parameters */
  assert_param(IS_USART_ALL_PERIPH(USARTx));
 
  /* Receive Data */
  return (uint16_t)(USARTx->DR & (uint16_t)0x01FF);
}


direi che quindi per la ricezione si potrebbe utilizzare una funzione del tipo :

Codice: Seleziona tutto

uint16_t USART1ReceiveChar
{
  //aspetto che sia disponibile qualcosa da leggere
  if (USART_GetFlagStatus(USART1,USART_FLAG_RXNE) == SET) {
             uint16_t ch=USART_ReceiveData(USART1);
             return ch;
  }
}



Più o meno credo potrebbe andare come logica ( non sto dando molta importanza ai tipi di variabile, sono ancora in fase preliminare nel cercare di capire la logica e conoscere le librerie, ad esempio il tipo 'uint16_t' non so nemmeno cosa sia e me lo dovrò andare un po' a vedere.

Che ne dici ?

[TardoFreak]

Non devi metterci un if ma un while se vuoi aspettare. E poi, visto che ricevi un carattere puoi usare un char come ritorno

Codice: Seleziona tutto

char USART1ReceiveChar(void)
{
  char ch;

  //aspetto fino a quando ci sarà un carattere disponibile da leggere
  while (USART_GetFlagStatus(USART1,USART_FLAG_RXNE) == RESET);

  // Leggo il carattere ricevuto
  ch=USART_ReceiveData(USART1);

  return (ch);
}

ATTENZIONE! E' chiaro che la funzione si "pianta" fino a quando non riceve un carattere.

[pierinter]

Si chiaro, mi pare si chiami Polling Mode se non sbaglio.
Più avanti quando prendo confidenza potre utilizzare gli interrupt in modo da rendere più efficiente il firmware, ma per ora va bene così.

Credo che nel tuo codice hai dimenticato di modificare RESET in SET.
Credo che il flag debba essere a livello alto.

Comunque ok, sono davvero interessanti queste cose, più andiamo avanti più mi prende ;)

Ora, come faccio a provare se tutto quelle che stiamo dicendo funziona ?
Ovviamente, oltre a collegarmi con un oscilloscopio per vedere la sequenza...

Intendo un modo per collegarmi al computer e vedere, in qualche modo se possibile, i byte che la schedina manda (magari dal terminale).

Credo che abbia bisogno di un adattatore TTL - USB , giusto ?
Quindi, o lo compro o me lo faccio... ma forse conviene comprarlo dato che potrebbe essere molto utile anche in futuro.

[TardoFreak]

Infatti, fino a quando il flag è a livello 0 il micro continua a stare dentro il while. Forse così ti è più chiaro

Codice: Seleziona tutto

  //aspetto fino a quando ci sarà un carattere disponibile da leggere
  while (USART_GetFlagStatus(USART1,USART_FLAG_RXNE) == RESET)
  {
    // Non fa un cavolo di niente e rimane inlooppato
  }