RTOS - UART

Nesse lab iremos trabalhar com comunicação UART (aquela do terminal / printf). Praticando RTOS (queue)

Lab

Início

Esse código exemplo já possui a comunicação UART configurada pela função (configure_console), essa função configura a utilização do periférico USART1 operando em modo de comunicação serial assíncrona. Os pinos TX e RX da comunicação serial são conectados ao EDGB, chip responsável pela gravação e debug do kit de desenvolvimento SAME70-XPLD.

A comunicação UART é um protocolo de comunicação muito utilizado para comunicação entre dois dispositivos (Machine-to-Machine, é utilizado por exemplo no arduino para a gravação e debug (print), é utilizado por diversos equipamentos para comunicação e configuração (impressoras térmicas, máquinas de cartão de crédito, GPP, sensores de biometria, ...).

Essa função configura o periférico USART1 para operar como stdio do nosso código C, toda vez que invocamos a função printf a saída dos caracteres é enviada para o periférico e é serializado por ele.

Vamos adicionar uma nova função (USART1_init) que faz praticamente a mesma coisa, porém configura a interrupção desse periférico. A interrupção ativada é para o recebimento de dados pela serial (US_IER_RXRDY), toda vez que um novo dado é recebido pela serial, o handler USART1_Handler é chamado.

Preparando exemplo

Adicione as funções USART1_init, usart1_puts e o handler USART1_Handler ao exemplo.

static void USART1_init(void){
  /* Configura USART1 Pinos */
  sysclk_enable_peripheral_clock(ID_PIOB);
  sysclk_enable_peripheral_clock(ID_PIOA);
  pio_set_peripheral(PIOB, PIO_PERIPH_D, PIO_PB4); // RX
  pio_set_peripheral(PIOA, PIO_PERIPH_A, PIO_PA21); // TX
  MATRIX->CCFG_SYSIO |= CCFG_SYSIO_SYSIO4;

  /* Configura opcoes USART */
  const sam_usart_opt_t usart_settings = {
      .baudrate       = 115200,
      .char_length    = US_MR_CHRL_8_BIT,
      .parity_type    = US_MR_PAR_NO,
      .stop_bits    = US_MR_NBSTOP_1_BIT    ,
      .channel_mode   = US_MR_CHMODE_NORMAL
  };

  /* Ativa Clock periferico USART0 */
  sysclk_enable_peripheral_clock(ID_USART1);

  stdio_serial_init(CONF_UART, &usart_settings);

  /* Enable the receiver and transmitter. */
  usart_enable_tx(USART1);
  usart_enable_rx(USART1);

  /* map printf to usart */
  ptr_put = (int (*)(void volatile*,char))&usart_serial_putchar;
  ptr_get = (void (*)(void volatile*,char*))&usart_serial_getchar;

  /* ativando interrupcao */
  usart_enable_interrupt(USART1, US_IER_RXRDY);
  NVIC_SetPriority(ID_USART1, 4);
  NVIC_EnableIRQ(ID_USART1);
}

void USART1_Handler(void){
  uint32_t ret = usart_get_status(USART1);

  BaseType_t xHigherPriorityTaskWoken = pdTRUE;
  char c;

  // Verifica por qual motivo entrou na interrupçcao?
  // RXRDY ou TXRDY

  //  Dados disponível para leitura
  if(ret & US_IER_RXRDY){
      usart_serial_getchar(USART1, &c);
      printf("%c", c);

  // -  Transmissoa finalizada
  } else if(ret & US_IER_TXRDY){

  }
}

A função usart1_puts envia uma string para a serial pelo periférico USART1.

uint32_t usart1_puts(uint8_t *pstring){
    uint32_t i ;

    while(*(pstring + i))
        if(uart_is_tx_empty(USART1))
            usart_serial_putchar(USART1, *(pstring+i++));
}

Edite o main para chamarmos a função USART1_init no lugar do configure_console:

int main(void)
{
    /* Initialize the SAM system */
    sysclk_init();
    board_init();

    /* Initialize the console uart */
-   configure_console();
+   USART1_init();

Lab

Agora com o exemplo preparado vamos implementar o firmware que foi desenvolvido em aula.

O usuário pode modificar os LEDs (recurso) de duas maneiras diferentes: enviando uma mensagem pela UART (terminal) ou apertando os botões da placa. Os botões e a UART servem como 'produtores' de comandos que serão processados por uma tarefa específica.

A vantagem desse formato é:

• a flexibilidade de criação de novos produtores (é fácil adicionar por exemplo uma segunda uart, ou uma outra comunicação), basta enviar os dados na fila de comandos;
• o isolamento entre diferentes partes do firmware.

Dicas

A seguir algumas dicas de como fazer o seu código.

xQueueChar

Deve ser uma fila de caracteres, especificar um tamanho que caiba os comandos.

int main(void){
/* Initialize the SAM system */
sysclk_init();
board_init();

// Criar a fila aqui!
//    |
//    v

USART1_init();

USART1_handler

Irá receber um caracter da uart e colocar ele na fila xQueueChar

  //  Dados disponível para leitura
  if(ret & US_IER_RXRDY){
      usart_serial_getchar(USART1, &c);
      printf("%c", c);

task_uartRX

Ficará lendo a fila xQueueChar e montando uma string interna, quando detectado um \n envia a string para a fila xQueueCommand.

xQueueCommand

Uma fila de strings que representam comandos, você deve criar o seu protocolo de comandos. O comando deve ser capaz de inverter o valor dos leds.

• led 3 toggle: Inverte led 3
• led 1 toggle: Inverte led 1

task_execute

Tarefa que fica lendo a fila de comandos xQueueCommand e realizando os comandos que são enviados por ela.

task_led1, task_led2

Tarefas que controlam individualmente cada LED da placa OLED

B

Diagrama do firmware de como seria esse código caso a parte do LCD touch (task_lcd e task_mxt) fosse inserida nele, entrando como um novo produtor.

A

Comandos: led x on e led x off

• led 1 on: Acende led 1
• led 2 off: Apaga led 2