STM32, C++ и FreeRTOS. Разработка с нуля. Часть 105.07.2015 12:04

#include "types.h"          //Стандартные типы проекта
class iActiveObject
{
  public:              
    virtual void run(void) = 0;
    void *taskHandle;
};

   //Настройка портов ввода-вывода
   //PE.10, PE.11 - светодиоды stat3 и stat4
   //PA.4, PA.5 - светодиоды stat1 и stat 2
   //Настраиваем порты PE.10, PE.11, PA.4, PA.5 на выход, cтр.174 CD00240194.pdf
   GPIOE->MODER |=  GPIO_MODER_MODER10_0;
   GPIOE->MODER |=  GPIO_MODER_MODER11_0;
   GPIOA->MODER |=  GPIO_MODER_MODER4_0;
   GPIOA->MODER |=  GPIO_MODER_MODER5_0;

#include "types.h"            //Стандартные типы проекта tU8
#define LEDS_NUMBER    4
class cLedsDriver
{
  public:
    explicit cLedsDriver(void);
    void ledOn(const tU8 led);
    void ledOff(const tU8 led);
    void ledToggle(const tU8 led);
  private:
    static tPort ledsPort[LEDS_NUMBER];
    static const tU16 ledsPin[LEDS_NUMBER];
};

#include "ledsdriver.h"       // Определение класса и тип tLeds
#include         //Регистры STM32
#include "susuassert.h"       // for ASSERT
#include "types.h"            // для типов tPort, tU16, tU8
#include "bitutil.h"          // для макросов работы с битами 
#define LED1_PIN        GPIO_OTYPER_ODR_4
#define LED1_PORT       GPIOA
#define LED2_PIN        GPIO_OTYPER_ODR_5
#define LED2_PORT       GPIOA
#define LED3_PIN        GPIO_OTYPER_ODR_10
#define LED3_PORT       GPIOE
#define LED4_PIN        GPIO_OTYPER_ODR_11
#define LED4_PORT       GPIOE
tPort cLedsDriver::ledsPort[LEDS_NUMBER] = {LED1_PORT, LED2_PORT, LED3_PORT, LED4_PORT};
const tU16 cLedsDriver::ledsPin[LEDS_NUMBER] = {LED1_PIN, LED2_PIN, LED3_PIN, LED4_PIN};
/*******************************************************************************
* Function:  constructor
* Description: 
******************************************************************************/
cLedsDriver::cLedsDriver(void) 
{
}

/*******************************************************************************
* Function:  ledOn
* Description: Зажигает выбранный светодид
******************************************************************************/
void cLedsDriver::ledOn(const tU8 led)
{
  ASSERT(led < LEDS_NUMBER); 
  SETBIT(this->ledsPort[led]->ODR, this->ledsPin[led]);   
}

/*******************************************************************************
* Function:  ledOff
* Description: Гасит выбранный светодид
******************************************************************************/
void cLedsDriver::ledOff(const tU8 led)
{
  ASSERT(led < LEDS_NUMBER); 
  CLRBIT(this->ledsPort[led]->ODR, this->ledsPin[led]);
}
/*******************************************************************************
* Function:  ledToggle
* Description: Меняет состояние выбранного светодиода
******************************************************************************/
void cLedsDriver::ledToggle(const tU8 led)
{
  ASSERT(led < LEDS_NUMBER); 
  TOGGLEBIT(this->ledsPort[led]->ODR, this->ledsPin[led]);
}

#include "ledsdriver.h"    //для cLedsDriver
#include "iactiveobject.h"  //для iActiveObject
typedef enum 
{
  LD_led1 = 0,
  LD_led2 = 1,
  LD_led3 = 2,
  LD_led4 = 3,
  LD_none = 4
} tLeds;
class cLedsDirector: public iActiveObject
{
  public:
    explicit cLedsDirector(void);
    void run(void);      
  private:
    cLedsDriver* pLedsDriver;
};

#include "ledsdirector.h"      // Определение класса
#include "frtoswrapper.h"   // для oRTOS
#include "types.h"             // lля типов

#define LED_DELAY (tU32)500/portTICK_PERIOD_MS
/*******************************************************************************
* Function:  constructor
* Description: Создает объект класса cLedsDriver
******************************************************************************/
cLedsDirector::cLedsDirector(void)  
{
  this->pLedsDriver =  new cLedsDriver();   
}
/*******************************************************************************
* Function:  runTask
* Description: Задача управления ледами. led3 просто моргает
******************************************************************************/
void cLedsDirector::run(void)
{
  for(;;)
  {
    oRTOS.taskDelay(LED_DELAY);
    this->pLedsDriver->ledToggle(LD_led3);    
  }
}

#define LEDSDIRECTOR_STACK_SIZE configMINIMAL_STACK_SIZE
#define LEDSDIRECTOR_PRIORITY (tU32)2
// Не охота было заморачиваться с синглтоном, сделал oRTOS глобальным объектом
// можно было конечно сделать сRTOS статическим, но че-то тоже заморочек много
// зато просто, все равно всем нужен 
cRTOS oRTOS;
....
void main(void)
{  
  cLedsDirector *pLedsDirector = new cLedsDirector();
  oRTOS.taskCreate(pLedsDirector, LEDSDIRECTOR_STACK_SIZE, LEDSDIRECTOR_PRIORITY, "Leds"); 
  oRTOS.startScheduler();
}

#include "types.h"            //Стандартные типы проекта для tU16 и tU8
#define BUTTONS_NUMBER    2
typedef enum
{
  BS_buttonNotPressed = 0,
  BS_buttonPressed = 1
} tButtonState;
class cButtonsDriver
{
  public:
    explicit  cButtonsDriver();
    tButtonState getButtonState(const tU8 button);
  private:
    static tPort buttonsPort[BUTTONS_NUMBER];
    static const tU16 buttonsPin[BUTTONS_NUMBER];
    static const tBoolean buttonsTrigger[BUTTONS_NUMBER]; 
};

#include "buttonsdriver.h"    // Определение класса и тип tLeds
#include         //Регистры STM32
#include "susuassert.h"       //for ASSERT
#include "types.h"            //для типов tPort, tU16, tU8
#define BUTTON1_PIN         GPIO_OTYPER_IDR_13
#define BUTTON1_PORT        GPIOC
#define BUTTON2_PIN         GPIO_OTYPER_IDR_0
#define BUTTON2_PORT        GPIOA
tPort cButtonsDriver::buttonsPort[BUTTONS_NUMBER] = {BUTTON1_PORT, BUTTON2_PORT};
const tU16 cButtonsDriver::buttonsPin[BUTTONS_NUMBER] = {BUTTON1_PIN, BUTTON2_PIN};
// первая кнопка нажата, когда во входном регистре 0, вторая когда 1
const tBoolean cButtonsDriver::buttonsTrigger[BUTTONS_NUMBER]  =  {FALSE, TRUE}; 
/*******************************************************************************
* Function:  constructor
* Description: 
******************************************************************************/
cButtonsDriver::cButtonsDriver()
{
}
/*******************************************************************************
* Function:  getButtonState
* Description: Возвращает состояние кнопки, нажата или нет
******************************************************************************/
tButtonState cButtonsDriver::getButtonState(const tU8 button)
{
  tButtonState eState = BS_buttonNotPressed;  
  ASSERT(button < BUTTONS_NUMBER); 
  //У нас кнопки работают по разному, одна подтянута к 1, вторая к 0,
  //Поэтому тут танцы с бубном, вначале смотрим состояние копки, а потом
  //чтобы не городить много ифов и кейзов просто через массив состояний кнопки
  //с помощью исключаещего или определяем её нажати.  
  tBoolean isLogicalZero = !(this->buttonsPort[button]->IDR & 
                             this->buttonsPin[button]);
  if(isLogicalZero ^ this->buttonsTrigger[button])
  {
    eState = BS_buttonPressed;
  }  
  return eState;   
}

#include "types.h"            //Стандартные типы проекта tU32
#include "iactiveobject.h"    //для iActiveObject
#include "buttonsdriver.h"    //для cButtonsDriver
#include "frtosWrapper.h"     // для tTaskHandle
typedef enum 
{
  BT_button1 = 0,
  BT_button2 = 1,
  BT_none = 2
} tButtons;
class cButtonsController: public iActiveObject
{
  public:
    explicit  cButtonsController(const tTaskHandle *pTaskToNotify, 
                                 const tU32 countOfNotifiedTask);
    tButtons  getPressedButton(void) const { return pressedButton; };
    void run(void);
  private:
    cButtonsDriver* pButtonsDriver;
    tButtons getButton(void);
    tButtons pressedButton;
    const tTaskHandle *pTaskToNotify;
    tU32 countOfNotifiedTask;    
};

#include "buttonscontroller.h" // Определение класса
#include "susuassert.h"       // для ASSERT
#include "types.h"            // для типов tPort, tU16, tU8
#include "bitutil.h"          // для макросов работы с битами  
#define BUTTON_TASK_DELAY   (tU32) 50/portTICK_PERIOD_MS
#define NEXT_PRESS_DELAY    (tU32) 500/portTICK_PERIOD_MS 
/*******************************************************************************
* Function:  constructor
* Description: Инициализируем список задач для нотификации и количество задач
*              для нотификации. А также создаем драйвер кнопок.
******************************************************************************/
cButtonsController::cButtonsController(const tTaskHandle *pTaskToNotify, 
                                       const tU32 countOfNotifiedTask)
{
  ASSERT(pTaskToNotify != NULL);  
  this->pButtonsDriver =  new cButtonsDriver();
  this->pTaskToNotify = pTaskToNotify;
  this->countOfNotifiedTask = countOfNotifiedTask;  
}
/*******************************************************************************
* Function:  run
* Description: Определеяет нажатие кнопок и посылает нотификацию нужным 
*              нужным задачам
******************************************************************************/
void cButtonsController::run(void)
{
   tRtosStatus eStatus = RS_fail;
   tButtons eButtonPreviousState = BT_none;
   tButtons  eButtonCurrentState = BT_none;
   const tTaskHandle *pTaskHandle;
   tU32 i = 0;
   for(;;)
   {
     eButtonPreviousState = this->getButton();
     if (eButtonPreviousState != BT_none)
     {
       //еще раз проверяем для антибребезга
       oRTOS.taskDelay(BUTTON_TASK_DELAY);
       eButtonCurrentState = this->getButton();
       if (eButtonPreviousState == eButtonCurrentState)
       {
         pTaskHandle = this->pTaskToNotify;
         i = 0;
         //пробегаем по списку задач, которые нужно оповестить и оповещаем их
         while ((pTaskHandle != NULL) && (i != countOfNotifiedTask))
         {
           eStatus = oRTOS.taskNotify(*(pTaskHandle), (tU32)eButtonCurrentState, 
                                      eSetValueWithOverwrite);
           if(eStatus == RS_fail) 
           {
             ;//Обработка ошибки
           }           
           pTaskHandle++;
           i++;
         }
         //следующее нажатие будет определяться только после задержки  в 0.5 сек
         oRTOS.taskDelay(NEXT_PRESS_DELAY);
       }
     }
     oRTOS.taskDelay(BUTTON_TASK_DELAY);
   }
}
/*******************************************************************************
* Function:  getPressedButton
* Description: Определеяет какая из конопок нажата
******************************************************************************/
tButtons cButtonsController::getButton(void)
{
  tButtons eButton =  BT_none;
  if (BS_buttonPressed == this->pButtonsDriver->getButtonState(BT_button1))
  {
    eButton = BT_button1;    
  }
  else if (BS_buttonPressed == this->pButtonsDriver->getButtonState(BT_button2))
  {
    eButton = BT_button2;    
  }
  this->pressedButton = eButton;
  return eButton;
}

#include           // Регистры STM2
#include "ledsdirector.h"       // Для класса cLedsDirector
#include "buttonscontroller.h"  // Для класса cButtonsController
#include "types.h"              // Для типов проекта
#include "frtoswrapper.h"       // для cRtos
#define LEDS_TASK_HANDLE_INDEX          0
#define BUTTON_TASKS_NOTYFIED_NUM       1
#define LEDSDIRECTOR_STACK_SIZE configMINIMAL_STACK_SIZE
#define LEDSDIRECTOR_PRIORITY (tU32)2
#define BUTTONSCONTROLLER_STACK_SIZE 256//configMINIMAL_STACK_SIZE
#define BUTTONSCONTROLLER_PRIORITY (tU32)3
// Не охота было заморачиваться с синглтоном, сделал oRTOS глобальным объектом
// можно было конечно сделать сRTOS статическим, но че-то тоже заморочек много
// зато просто, все равно всем нужен :)
cRTOS oRTOS;
..
void main( void )
{  
  //задача ButtonControllera должна оповещать другие задачи о нажатии
  //на кнопку, и передавать её значение. Для этого заводим массив указателей на 
  //задачи, которые надо оповещать
  static tTaskHandle tasksToNotifyFromButton[BUTTON_TASKS_NOTYFIED_NUM];
  cLedsDirector *pLedsDirector = new cLedsDirector();
  oRTOS.taskCreate(pLedsDirector, LEDSDIRECTOR_STACK_SIZE, LEDSDIRECTOR_PRIORITY, "Leds"); 
  tasksToNotifyFromButton[LEDS_TASK_HANDLE_INDEX] = pLedsDirector->taskHandle;
  cButtonsController *pButtonsController =  new cButtonsController(tasksToNotifyFromButton, BUTTON_TASKS_NOTYFIED_NUM);
  oRTOS.taskCreate(pButtonsController, BUTTONSCONTROLLER_STACK_SIZE, BUTTONSCONTROLLER_PRIORITY, "Buttons");   
  oRTOS.startScheduler();
}