Tentando usar C ++ moderno e padrões de projeto para programação de microcontroladores

Olá!



O problema de usar C ++ em microcontroladores tem me atormentado há algum tempo. A questão era que eu honestamente não entendia como essa linguagem orientada a objetos poderia ser aplicada a sistemas embarcados. Quer dizer, como selecionar classes e com que base compor objetos, ou seja, como exatamente usar essa linguagem corretamente. Depois de algum tempo e lendo a enésima quantidade de literatura, cheguei a alguns resultados, sobre os quais gostaria de falar neste artigo. Se esses resultados têm algum valor ou não, depende do leitor. Será muito interessante para mim ler as críticas à minha abordagem para finalmente me responder à pergunta: "Como usar C ++ corretamente na programação de microcontroladores?"



Esteja avisado, este artigo conterá muitos códigos-fonte.



Neste artigo, eu, usando o exemplo do uso do USART no MK stm32 para me comunicar com o esp8266, tentarei delinear minha abordagem e suas principais vantagens. Vamos começar com o fato de que a principal vantagem de usar C ++ para mim é a capacidade de fazer desacoplamento de hardware, ou seja, faça o uso de módulos de nível superior independentes da plataforma de hardware. Isso resultará no fato de que o sistema se tornará facilmente modificável no caso de quaisquer alterações. Para isso, identifiquei três níveis de abstração do sistema:

1. HW_USART - nível de hardware, dependente de plataforma
2. MW_USART - nível médio, serve para desacoplar o primeiro e o terceiro níveis
3. APP_ESP8266 - nível de aplicação, não sabe nada sobre MK

HW_USART

O nível mais primitivo. Usei stm32f411 gem, USART # 2, também implementei suporte a DMA. A interface é implementada na forma de apenas três funções: inicializar, enviar e receber.



A função de inicialização é semelhante a esta:

bool usart2_init(uint32_t baud_rate)
{
  bool res = false;
  
  /*-------------GPIOA Enable, PA2-TX/PA3-RX ------------*/
  BIT_BAND_PER(RCC->AHB1ENR, RCC_AHB1ENR_GPIOAEN) = true;
  
  /*----------GPIOA set-------------*/
  GPIOA->MODER |= (GPIO_MODER_MODER2_1 | GPIO_MODER_MODER3_1);
  GPIOA->OSPEEDR |= (GPIO_OSPEEDER_OSPEEDR2 | GPIO_OSPEEDER_OSPEEDR3);
  constexpr uint32_t USART_AF_TX = (7 << 8);
  constexpr uint32_t USART_AF_RX = (7 << 12);
  GPIOA->AFR[0] |= (USART_AF_TX | USART_AF_RX);        
  
  /*!---------------USART2 Enable------------>!*/
  BIT_BAND_PER(RCC->APB1ENR, RCC_APB1ENR_USART2EN) = true;
  
  /*-------------USART CONFIG------------*/
  USART2->CR3 |= (USART_CR3_DMAT | USART_CR3_DMAR);
  USART2->CR1 |= (USART_CR1_TE | USART_CR1_RE | USART_CR1_UE);
  USART2->BRR = (24000000UL + (baud_rate >> 1))/baud_rate;      //Current clocking for APB1
  
  /*-------------DMA for USART Enable------------*/   
  BIT_BAND_PER(RCC->AHB1ENR, RCC_AHB1ENR_DMA1EN) = true;
  
  /*-----------------Transmit DMA--------------------*/
  DMA1_Stream6->PAR = reinterpret_cast<uint32_t>(&(USART2->DR));
  DMA1_Stream6->M0AR = reinterpret_cast<uint32_t>(&(usart2_buf.tx));
  DMA1_Stream6->CR = (DMA_SxCR_CHSEL_2| DMA_SxCR_MBURST_0 | DMA_SxCR_PL | DMA_SxCR_MINC | DMA_SxCR_DIR_0);
     
  /*-----------------Receive DMA--------------------*/
  DMA1_Stream5->PAR = reinterpret_cast<uint32_t>(&(USART2->DR));
  DMA1_Stream5->M0AR = reinterpret_cast<uint32_t>(&(usart2_buf.rx));
  DMA1_Stream5->CR = (DMA_SxCR_CHSEL_2 | DMA_SxCR_MBURST_0 | DMA_SxCR_PL | DMA_SxCR_MINC);
  
  DMA1_Stream5->NDTR = MAX_UINT16_T;
  BIT_BAND_PER(DMA1_Stream5->CR, DMA_SxCR_EN) = true;
  return res;
}

      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Não há nada de especial na função, exceto talvez que eu use máscaras de bits para reduzir o código resultante.



Então, a função de envio se parece com isto:

bool usart2_write(const uint8_t* buf, uint16_t len)
{
   bool res = false;
   static bool first_attempt = true;
   
   /*!<-----Copy data to DMA USART TX buffer----->!*/
   memcpy(usart2_buf.tx, buf, len);
   
   if(!first_attempt)
   {
     /*!<-----Checking copmletion of previous transfer------->!*/
     while(!(DMA1->HISR & DMA_HISR_TCIF6)) continue;
     BIT_BAND_PER(DMA1->HIFCR, DMA_HIFCR_CTCIF6) = true;
   }
   
   first_attempt = false;
   
   /*!<------Sending data to DMA------->!*/
   BIT_BAND_PER(DMA1_Stream6->CR, DMA_SxCR_EN) = false;
   DMA1_Stream6->NDTR = len;
   BIT_BAND_PER(DMA1_Stream6->CR, DMA_SxCR_EN) = true;
   
   return res;
}

      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

A função tem uma muleta, na forma da variável first_attempt, que ajuda a determinar se é o primeiro envio via DMA ou não. Por que isso é necessário? O fato é que verifiquei se o envio anterior ao DMA foi bem-sucedido ou não ANTES de enviar, não DEPOIS. Fiz isso para que, depois de enviar os dados, não seja estúpido esperar a conclusão, mas executar códigos úteis neste momento.



Então, a função de recepção se parece com isto:

uint16_t usart2_read(uint8_t* buf)
{
   uint16_t len = 0;
   constexpr uint16_t BYTES_MAX = MAX_UINT16_T; //MAX Bytes in DMA buffer
   
   /*!<---------Waiting until line become IDLE----------->!*/
   if(!(USART2->SR & USART_SR_IDLE)) return len;
   /*!<--------Clean the IDLE status bit------->!*/
   USART2->DR;
   
   /*!<------Refresh the receive DMA buffer------->!*/
   BIT_BAND_PER(DMA1_Stream5->CR, DMA_SxCR_EN) = false;
   len = BYTES_MAX - (DMA1_Stream5->NDTR);
   memcpy(buf, usart2_buf.rx, len);
   DMA1_Stream5->NDTR = BYTES_MAX;
   BIT_BAND_PER(DMA1->HIFCR, DMA_HIFCR_CTCIF5) = true;
   BIT_BAND_PER(DMA1_Stream5->CR, DMA_SxCR_EN) = true;
   
   return len;
}

      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

A peculiaridade dessa função é que não sei de antemão quantos bytes devo receber. Para indicar os dados recebidos, eu verifico a flag IDLE, então, se o estado IDLE for fixo, eu limpo a flag e leio os dados do buffer. Se o estado IDLE não for fixo, a função simplesmente retornará zero, ou seja, nenhum dado.



Neste ponto, proponho terminar com um nível baixo e ir diretamente para C ++ e padrões.

MW_USART

Aqui, implementei a classe USART abstrata básica e apliquei o padrão "protótipo" para criar descendentes (as classes USART1 e USART2 concretas). Não descreverei a implementação do padrão de protótipo, pois ele pode ser encontrado no primeiro link do Google, mas darei imediatamente o código-fonte e explicarei a seguir.

#pragma once
#include <stdint.h>
#include <vector>
#include <map>

/*!<========Enumeration of USART=======>!*/
enum class USART_NUMBER : uint8_t
{
  _1,
  _2
};


class USART; //declaration of basic USART class

using usart_registry = std::map<USART_NUMBER, USART*>; 


/*!<=========Registry of prototypes=========>!*/
extern usart_registry _instance; //Global variable - IAR Crutch
#pragma inline=forced 
static usart_registry& get_registry(void) { return _instance; }

/*!<=======Should be rewritten as========>!*/
/*
static usart_registry& get_registry(void) 
{ 
  usart_registry _instance;
  return _instance; 
}
*/

/*!<=========Basic USART classes==========>!*/
class USART
{
private:
protected:   
  static void add_prototype(USART_NUMBER num, USART* prot)
  {
    usart_registry& r = get_registry();
    r[num] = prot;
  }
  
  static void remove_prototype(USART_NUMBER num)
  {
    usart_registry& r = get_registry();
    r.erase(r.find(num));
  }
public:
  static USART* create_USART(USART_NUMBER num)
  {
    usart_registry& r = get_registry();
    if(r.find(num) != r.end())
    {
      return r[num]->clone();
    }
    return nullptr;
  }
  virtual USART* clone(void) const = 0;
  virtual ~USART(){}
  
  virtual bool init(uint32_t baudrate) const = 0;
  virtual bool send(const uint8_t* buf, uint16_t len) const = 0;
  virtual uint16_t receive(uint8_t* buf) const = 0;
};

/*!<=======Specific class USART 1==========>!*/
class USART_1 : public USART
{
private:
  static USART_1 _prototype;
  
  USART_1() 
  {  
    add_prototype( USART_NUMBER::_1, this);
  }
public:
 
 virtual USART* clone(void) const override final 
 {
   return new USART_1;
 }
 
 virtual bool init(uint32_t baudrate) const override final;
 virtual bool send(const uint8_t* buf, uint16_t len) const override final;
 virtual uint16_t receive(uint8_t* buf) const override final;
};

/*!<=======Specific class USART 2==========>!*/
class USART_2 : public USART
{
private:
  static USART_2 _prototype;
  
  USART_2() 
  {  
    add_prototype( USART_NUMBER::_2, this);
  }
public:
 
 virtual USART* clone(void) const override final 
 {
   return new USART_2;
 }
 
 virtual bool init(uint32_t baudrate) const override final;
 virtual bool send(const uint8_t* buf, uint16_t len) const override final;
 virtual uint16_t receive(uint8_t* buf) const override final;
};


      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Primeiro, o arquivo é enumerado como classe USART_NUMBER com todos os USARTs disponíveis, para minha pedra existem apenas dois deles. Em seguida, vem a declaração direta da classe base USART . Em seguida, vem a declaração do contêiner e de todos os protótipos std :: map <USART_NUMBER, USART *> e seu registro, que é implementado como um singleton por Mayers.



Aqui encontrei um recurso do IAR ARM, a saber, o fato de que ele inicializa variáveis ​​estáticas duas vezes, no início do programa e imediatamente após entrar em main. Portanto, reescrevi o singleton um pouco, substituindo a variável _instance estática por uma global. Idealmente, sua aparência é descrita no comentário.



Em seguida, a classe base USART é declarada , onde métodos para adicionar um protótipo, excluir um protótipo e criar um objeto são definidos (já que o construtor das classes herdadas é declarado como privado para restringir o acesso).



Um método de clone puramente virtual também é declarado , e métodos puramente virtuais de inicialização, envio e recebimento.



Afinal, herdamos classes concretas, onde definimos métodos puramente virtuais descritos acima.



Cito o código para definir os métodos abaixo:

#include "MW_USART.h"
#include "HW_USART.h"

usart_registry _instance; //Crutch for IAR

/*!<========Initialization of global static USART value==========>!*/
USART_1 USART_1::_prototype = USART_1();
USART_2 USART_2::_prototype = USART_2();

/*!<======================UART1 functions========================>!*/
bool USART_1::init(uint32_t baudrate) const
{
 bool res = false;
 //res = usart_init(USART1, baudrate);  //Platform depending function
 return res;
}

bool USART_1::send(const uint8_t* buf, uint16_t len) const
{
  bool res = false;
  
  return res;
}

uint16_t USART_1::receive(uint8_t* buf) const
{
  uint16_t len = 0;
  
  return len;
}
 
/*!<======================UART2 functions========================>!*/
bool USART_2::init(uint32_t baudrate) const
{
 bool res = false;
 res = usart2_init(baudrate);   //Platform depending function
 return res;
}

bool USART_2::send(const uint8_t* buf, const uint16_t len) const
{
  bool res = false;
  res = usart2_write(buf, len); //Platform depending function
  return res;
}

uint16_t USART_2::receive(uint8_t* buf) const
{
  uint16_t len = 0;
  len = usart2_read(buf);       //Platform depending function
  return len;
}

      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Aqui estão implementados NÃO métodos fictícios apenas para USART2, pois eu o uso para me comunicar com esp8266. Consequentemente, o preenchimento pode ser qualquer, também pode ser implementado usando ponteiros para funções que obtêm seu valor com base no chip atual.



Agora, proponho ir ao nível de APP e ver por que tudo isso era necessário.

APP_ESP8266

Eu defino a classe base para o ESP8266 de acordo com o padrão "singleton". Nele eu defino um ponteiro para a classe USART * base .

class ESP8266
{
private:
  ESP8266(){}
  ESP8266(const ESP8266& root) = delete;
  ESP8266& operator=(const ESP8266&) = delete;
  
  /*!<---------USART settings for ESP8266------->!*/
  static constexpr auto USART_BAUDRATE = ESP8266_USART_BAUDRATE;
  static constexpr USART_NUMBER ESP8266_USART_NUMBER = USART_NUMBER::_2;
  USART* usart;
  
  static constexpr uint8_t LAST_COMMAND_SIZE = 32;
  char last_command[LAST_COMMAND_SIZE] = {0};
  bool send(uint8_t const *buf, const uint16_t len = 0);
  
  static constexpr uint8_t ANSWER_BUF_SIZE = 32;
  uint8_t answer_buf[ANSWER_BUF_SIZE] = {0};
  
  bool receive(uint8_t* buf);
  bool waiting_answer(bool (ESP8266::*scan_line)(uint8_t *));
  
  bool scan_ok(uint8_t * buf);
  bool if_str_start_with(const char* str, uint8_t *buf);
public:  
  bool init(void);
  
  static ESP8266& Instance()
  {
    static ESP8266 esp8266;
    return esp8266;
  }
};

      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Há também uma variável constexpr que armazena o número do USART usado. Agora, para alterar o número USART, precisamos apenas alterar seu valor! A ligação ocorre na função de inicialização:

bool ESP8266::init(void)
{
  bool res = false;
  
  usart = USART::create_USART(ESP8266_USART_NUMBER);
  usart->init(USART_BAUDRATE);
  
  const uint8_t* init_commands[] = 
  {
    "AT",
    "ATE0",
    "AT+CWMODE=2",
    "AT+CIPMUX=0",
    "AT+CWSAP=\"Tortoise_assistant\",\"00000000\",5,0",
    "AT+CIPMUX=1",
    "AT+CIPSERVER=1,8888"
  };
  
  for(const auto &command: init_commands)
  {
    this->send(command);
    while(this->waiting_answer(&ESP8266::scan_ok)) continue;
  }  
  
  return res;
}

      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Linha usart = USART :: create_USART (ESP8266_USART_NUMBER); associa nossa camada de aplicativo a um módulo USART específico.



Em vez de conclusões, apenas expresso a esperança de que o material seja útil para alguém. Obrigado por ler!