Easyelectronics.ru

void   G_LcdPutStringUserFonts(uint8_t x   ,uint16_t y   ,const FONT_INFO*   Fonts   ,const char* str   )
{

   uint16_t VideoRamPtr,VideoRamPtrStore;
   uint8_t StartLine, StartLineOffset;

   FONT_CHAR_INFO*   char_info;
   uint8_t*   fontdata;

   xSemaphoreTake(VideoRamMutex, portMAX_DELAY);
   while (*str)
   {
      uint8_t ch = *str++;
      if (ch == ' ')
      {
         y += Fonts->spacePixels;
         continue;
      }
      if(ch >= 192)   //Кириллица
      {
         char_info = (FONT_CHAR_INFO*)(Fonts->charInfoCyr);
         fontdata = (uint8_t*)(Fonts->dataCyr);
         ch -= 192;
      }
      else
      {
         char_info = (FONT_CHAR_INFO*)(Fonts->charInfo);
         fontdata = (uint8_t*)(Fonts->data);
         ch -= Fonts->startChar;
      }
      if(VideoRamPtr && ((VideoRamPtr%G_LCD_WIDTH) + char_info[ch].widthBits) >= G_LCD_WIDTH)      //Не влазим в текущую строку, идем на следующую
      {
         y = 0;
         x+=Fonts->charInfo[0].heightBits;
      }
      StartLine = x / G_LCD_HW_HEIGHT_LINE;            //определяем начальную строку
      StartLineOffset = x % G_LCD_HW_HEIGHT_LINE;      //сдвиг вниз от начальной строки

      VideoRamPtr = StartLine*WG_LCD_WIDTH + y;      //Определяем, с какого байта начинаем писать в видеобуфер
      if (VideoRamPtr>= 1024) VideoRamPtr -= 1024;

      for (uint8_t i = 0; i < char_info[ch].widthBits; i++ )   //следим за шириной символа, инфу берем из базы
      {

         uint8_t LineCnt = Fonts->heightPages;
         if(StartLineOffset) LineCnt++;

         for (uint16_t l = 0; l < LineCnt; l++)
         {
            VideoRamPtrStore = VideoRamPtr;
            if ((VideoRamPtr + l*128) >= 1024) VideoRamPtr = VideoRamPtr + l*128 - 1024;

            if (!l) VideoRam[VideoRamPtr] |= (*(fontdata + char_info[ch].offset + i + l * char_info[ch].widthBits)) << StartLineOffset;
            else
            {
               if (StartLineOffset)
               {
                  //Выводим остаток от предыдущей строчки
                  VideoRam[VideoRamPtr + l * G_LCD_WIDTH] |= (*(fontdata + char_info[ch].offset + i + (l-1) * char_info[ch].widthBits)) >> (G_LCD_HW_HEIGHT_LINE-StartLineOffset);
                  if (l < Fonts->heightPages) // выводим следующую
                  {
                     VideoRam[VideoRamPtr + l * G_LCD_WIDTH] |= (*(fontdata + char_info[ch].offset + i + l * char_info[ch].widthBits)) << StartLineOffset;
                  }
               }
               else
               {
                  VideoRam[VideoRamPtr + l * G_LCD_WIDTH] |= (*(fontdata + char_info[ch].offset + i + l * char_info[ch].widthBits));
               }
            }
         }
         VideoRamPtr = VideoRamPtrStore + 1;
      }
      y += char_info[ch].widthBits + 1;
   }
   xSemaphoreGive(VideoRamMutex);
}


void   G_LcdPutBitMap(uint8_t x0   ,uint16_t y0   ,uint8_t sizex   ,uint16_t sizey   ,char* data   )
{

   uint16_t VideoRamPtr,VideoRamPtrStore;
   uint8_t StartLine, StartLineOffset;


   xSemaphoreTake(VideoRamMutex, portMAX_DELAY);

   StartLine = x0 / G_LCD_HW_HEIGHT_LINE;            //определяем начальную строку
   StartLineOffset = x0 % G_LCD_HW_HEIGHT_LINE;      //сдвиг вниз от начальной строки

   VideoRamPtr = StartLine*WG_LCD_WIDTH + y0;      //Определяем, с какого байта начинаем писать в видеобуфер
   if (VideoRamPtr>= 1024) VideoRamPtr -= 1024;

   for (uint8_t i = 0; i < sizey; i++ )         //следим за шириной символа, инфу берем из базы
   {

      uint8_t LineCnt = sizex/8;
      if(StartLineOffset) LineCnt++;

      for (uint16_t l = 0; l < LineCnt; l++)
      {
         VideoRamPtrStore = VideoRamPtr;
         if ((VideoRamPtr + l*128) >= 1024) VideoRamPtr = VideoRamPtr + l*128 - 1024;

         if (!l) VideoRam[VideoRamPtr] |= (*(data + i + l * sizey)) << StartLineOffset;
         else
         {
            if (StartLineOffset)
            {
               //Выводим остаток от предыдущей строчки
               VideoRam[VideoRamPtr + l * G_LCD_WIDTH] |= (*(data + i + (l-1) * sizey)) >> (G_LCD_HW_HEIGHT_LINE-StartLineOffset);
               if (l < (sizex/8)) // выводим следующую
               {
                  VideoRam[VideoRamPtr + l * G_LCD_WIDTH] |= (*(data + i + l * sizey)) << StartLineOffset;
               }
            }
            else
            {
               VideoRam[VideoRamPtr + l * G_LCD_WIDTH] |= (*(data + i + l * sizey));
            }
         }
      }
      VideoRamPtr = VideoRamPtrStore + 1;
   }
   xSemaphoreGive(VideoRamMutex);
}

/* структура координаты X-Y */
typedef struct {
   uint16_t x;
   uint16_t y;
}coord_t;

/* код векторного объекта */
enum vectobjcode{objpoint, objline, objrectangle, objfillrectangle, objcircle, forceupdate = 0xF};

/* структура параметров векторного объекта */
typedef struct {
   coord_t h_coord;         // координаты начальн.точки
   coord_t e_coord;          // координаты конечн.точки
   uint8_t vectobjcode :4;      // код векторного объекта
   uint8_t overlay_mode :4;   // режим наложения
}vectobj_t ;

/*** Дескрипторы RTOS ***/
TaskHandle_t xFrameComposer_Handle = NULL,      
          xTaskVectorGraph_Handle = NULL,   
          xTaskDisplayDrv_Handle = NULL;      
QueueHandle_t xQueueCommandVectorGraph = NULL;   

  /*-- Создание задач и очередей --------------*/

   //------- Задача компоновщика кадра ---------
   error = xTaskCreate(prvTask_FrameComposer,   //
            "FrameComposer",               //
            configMINIMAL_STACK_SIZE,      // размер стека задачи
            NULL,                     //
            (tskIDLE_PRIORITY + 1),         // приоритет задачи
            &xFrameComposer_Handle);         // дескриптор задачи
   while(error == pdFAIL) { }

   //------- Очередь для команд векторной графики ---
#define NUM_COMMANDS   5
   xQueueCommandVectorGraph = xQueueCreate(NUM_COMMANDS, sizeof(vectobj_t));

   //------- Задача отрисовки векторной графики -
   error = xTaskCreate(prvTask_VectorGraphics,   //
            "VectorGraph",               //
            configMINIMAL_STACK_SIZE,      // размер стека задачи
            NULL,                     //
            (tskIDLE_PRIORITY + 1),         // приоритет задачи
            &xTaskVectorGraph_Handle);      // дескриптор задачи
   while(error == pdFAIL) { }

   //------- Задача драйвер дисплея ------------
   error = xTaskCreate(prvTask_DisplayDrv,      //
            "DispDrv",                  //
            configMINIMAL_STACK_SIZE,      // размер стека задачи
            NULL,                     //
            (tskIDLE_PRIORITY + 2),         // приоритет задачи
            &xTaskDisplayDrv_Handle);      // дескриптор задачи
   while(error == pdFAIL) { }

/*-----------------------------------------------
* @brief:   Компоновщик кадра дисплея.
*          Формирует и передает через очередь задания для
*          модуля векторной графики.
* @param:   *pvParameters
* @retval:   нет
*/
static void Cmd_DrawLine(uint16_t, uint16_t, uint16_t, uint16_t, uint8_t);

void prvTask_FrameComposer(void *pvParameters)
{
   for (;;)
   {
      /* надо нарисовать 4 горизонтальные линии */
      Cmd_DrawLine(10, 20, 100, 20, 1);   // первая гориз.линия
      Cmd_DrawLine(10, 40, 100, 40, 1);   // вторая гориз.линия
      Cmd_DrawLine(10, 60, 100, 60, 1);   // третья гориз.линия
      Cmd_DrawLine(10, 80, 100, 80, 1);   // четвертая гориз.линия
      ForceUpdate();

      vTaskSuspend(xFrameComposer_Handle);// остановлен компоновщик кадра
   }
}//----------------------------------------------
/*-----------------------------------------------
* @brief:   Формирование задания для построения объекта "линия".
*          Заполняет структуру параметров и через очередь посылает
*          задание в модуль веторной графики.
* @param:   координаты начальной и конечной точки, режим наложения
* @retval:   нет
*/
static void Cmd_DrawLine(uint16_t xh, uint16_t yh, uint16_t xe, uint16_t ye, uint8_t overlay)
{
   vectobj_t obj_params;
   obj_params.vectobjcode = objline;   // код векторного объекта
   obj_params.overlay_mode = overlay;   // режим наложения
   obj_params.h_coord.x = xh;         // коорд. начальной точки
   obj_params.h_coord.y = yh;         //
   obj_params.e_coord.x = xe;         // коорд. конечной точки
   obj_params.e_coord.y = ye;         //

   /* команда с параметрами отправляется через очередь*/
   xQueueSend(xQueueCommandVectorGraph, &obj_params, portMAX_DELAY);

}//----------------------------------------------

/* Для остальных векторных объектов - аналогично */

/*-----------------------------------------------
* @brief:   Задача модуля векторной графики
*          Принимает из очереди задания от компоновщика кадра,
*          по коду команды определяет тип векторного объекта и
*          вызывает функцию просчета объекта в соотв. с его парам.
* @param:   *pvParameters
* @retval:   нет
*/
static void VectObjLine(vectobj_t *);
static void VectObjPoint(vectobj_t *);

void prvTask_VectorGraphics(void *pvParameters)
{
   static vectobj_t obj_params;

/*-- Функционал задачи ---------- ----------------------------*/
   for (;;)
   {
      /* Задание принимается из очереди */
      xQueueReceive(xQueueCommandVectorGraph, &obj_params, portMAX_DELAY);

      /* По коду объекта вызывается соотв. ф-ция расчета */
      switch(obj_params.vectobjcode){
      //......................
      case objpoint:
         VectObjPoint(&obj_params);
         break;
      //......................
      case objline:
         VectObjLine(&obj_params);
         break;
      //......................
      case objrectangle:
         break;
      //......................
      case objfillrectangle:
         break;
      //......................
      case objcircle:
         break;
      //......................
      case forceupdate:
         /* запуск задачи-драйвера дисплея */
         vTaskResume(xTaskDisplayDrv_Handle);
         break;
      }
   }
}//----------------------------------------------
/*-----------------------------------------------
* @brief:   Расчет векторного объекта "точка".
* @param:   *pvParameters
* @retval:   нет
*/
static void VectObjPoint(vectobj_t *params)
{
   uint8_t *ptr_gram = gram;

   ptr_gram += params->h_coord.x;
   /* и т.д. */
}//----------------------------------------------
/*-----------------------------------------------
* @brief:   Расчет векторного объекта "линия".
* @param:   *pvParameters
* @retval:   нет
*/
static void VectObjLine(vectobj_t *params)
{
   uint8_t *ptr_gram = gram;

   ptr_gram += params->h_coord.x;
   /* и т.д. */
}//----------------------------------------------

/* для остальных объектов - аналогично */

/*-----------------------------------------------
* @brief:   Задача Драйвер дисплея
* @param:   *pvParameters
* @retval:   нет
*/
static void Send_to_DisplayInterface(uint8_t);
static void ClearDisplayRAM(void);
static void DisplayPowerOn(void);

void prvTask_DisplayDrv(void *pvParameters)
{
   static uint8_t *ptr_gram = gram;      // указатель на gram

/*-- Действия, выполняемые только при первом запуске задачи --*/
   ClearDisplayRAM();                  // очистка памяти дисплея
   DisplayPowerOn();                  // включение дисплея
   vTaskSuspend(xTaskDisplayDrv_Handle);   // остановка задачи

/*-- Функционал задачи ---------- ----------------------------*/
   for (;;)
   {
      ptr_gram = gram;               // на начало gram

      /* передача видеобуфера в интерфейс дисплея */
      do{
         Send_to_DisplayInterface(*ptr_gram++);
      }while(ptr_gram < (gram + 100));

      /* остановка задачи */
      vTaskSuspend(xTaskDisplayDrv_Handle);
   }
}//----------------------------------------------

/* Конкретная реализация зависит от конкретного МК и дисплея */