path: root/Libraries/NixieDriver/nixie_driver_process.c

#include "nixie_driver_process.h"
#include "nixie_driver_config.h"
#include "indicate_modes_task.h"
#include "light_sensor_task.h"

#include <stdint.h>

// FreeRTOS includes 
#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"
#include "semphr.h"

// - ìàññèâ äëÿ öèôð äåøèôðàòîðà
// - ìàññèâ äëÿ íîìåðà ëàìïû
// - ñ÷åò÷èê íîìåðà òåêóùåé ëàìïû
// - òàéìåð1 äëÿ âðåìåíè ãîðåíèÿ
// - òàéìåð2 äëÿ âðåìåíè çàòóõàíèÿ

#define  TUBE_HEATING_UP                        0

 
static const uint16_t tube_off_digit = 0;                                      // Ñèìâîë äëÿ äåøèôðàòîðà, ÷òîáû ëàìïà íå ãîðåëà

// Ìàññèâ çíà÷åíèé öèôð äëÿ äåøèôðàòîðà. Åñëè ñòàðøèé áàéò âïåðåä.
// È ó÷òåíî, ÷òî âñå çíà÷åíèÿ ñäâèíóòû íà 1 âëåâî
const uint16_t tube_digits [MAX_DIGITS] = {                                     // Öèôðà íà ëàìïå
                                                TUBE_DIGIT_0,                   // 0
                                                TUBE_DIGIT_1,                   // 1
                                                TUBE_DIGIT_2,                   // 2
                                                TUBE_DIGIT_3,                   // 3
                                                TUBE_DIGIT_4,                   // 4
                                                TUBE_DIGIT_5,                   // 5
                                                TUBE_DIGIT_6,                   // 6
                                                TUBE_DIGIT_7,                   // 7
                                                TUBE_DIGIT_8,                   // 8
                                                TUBE_DIGIT_9,                   // 9
                                                TUBE_DIGIT_DP1,                 // dp1
                                                TUBE_DIGIT_DP2,                 // dp2
                                                TUBE_DIGIT_EMPTY                // ëàìïà íå ãîðèò
};

// Ëàìïû íà ïëàòå èäóò ñëåâà íàïðàâî. Çíà÷åíèå ÿ÷åéêè ìàññèâà ñ ó÷åòîì, åñëè
// ñòàðøèé áàéò èäåò âïåðåä â SPI
// È ó÷òåíî, ÷òî âñå çíà÷åíèÿ ñäâèíóòû íà 1 âëåâî
static const uint16_t tube_num [ MAX_TUBES ] = {
                                                TUBE_NUM_1,                      // 1-ÿ ëàìïà
                                                TUBE_NUM_2,                      // 2-ÿ ëàìïà
                                                TUBE_NUM_3,                      // 3-ÿ ëàìïà
                                                TUBE_NUM_4,                      // 4-ÿ ëàìïà
                                                TUBE_NUM_5,                      // 5-ÿ ëàìïà
                                                TUBE_NUM_6                       // 6-ÿ ëàìïà
};


// Òåêóùèé áóôåð ñ äàííûìè-öèôðàìè íà ëàìïû
static uint16_t curr_tube_bufer [ MAX_TUBES ] = {
                                                TUBE_DIGIT_1,                   // 0
                                                TUBE_DIGIT_1,                   // 1
                                                TUBE_DIGIT_1,                   // 2
                                                TUBE_DIGIT_1,                   // 3
                                                TUBE_DIGIT_1,                   // 4
                                                TUBE_DIGIT_1                   // 5
};


// ßðêîñòü ------------------------------------------------------------------ //

// ãîðèò / íå ãîðèò
// time1 / time2
// 1      9
// 2      8
// 3      7
// 4      6
// 5      6
// 6      4
// 7      3
// 8      2
// 9      1
// 10     0

#define TIME_PERIOD_TCONST      (uint32_t)80                                    // Âðåìÿ ïîëíîãî ïåðèîäà ÷àñòîòû ðàáîòû ëàìï. Åäèíèöà èçìåðåíèÿ çàâèñèò îò íàñòðîéêè
                                                                                // òàéìåðà.  äàííîì ñëó÷àå òàéìåð òèêàåò ðàç â 100 ìêñ, çíà÷èò Ò = 80 => T = 80*100 = 8000ìêñ = 8ìñ
#define TIME_MIN                (uint32_t)1                                     // Ìèíèìàëüíûé øàã âðåìåíè òàéìåðà = 100 ìêñ. Ìèíèìàëüíîå âðåìÿ ãîðåíèÿ ëàìïû

// - äîáàâèòü ñîñòîÿíèÿ DARK è LIGHT 
// (ïî ñóòè ýòî òîëüêî êîìáèíàöèè TIME_ON è TIME_OFF)
#define TIME_ON                 2//5//20
#define TIME_OFF                23//22
// Âðåìÿ ïàóçû ïîñëå âêë/âûêë âñåç ëàìï ïîî÷åðåäè
#define TIME_OFF_BRIGHT         0          
#define TIME_OFF_DARK           100      

#define TIME_TEST               10000

static uint32_t time_on  = TIME_ON;                                             // Âðåìÿ ãîðåíèÿ ëàìïû
static uint32_t time_off = TIME_OFF;                                            // Âðåìÿ íà óãàñàíèå ëàìïû ( ÷òîáû îíà óñïåëà ïîãàñíóòü ïîëíîñòüþ )
static uint32_t time_off2 = TIME_OFF_DARK;
// static uint32_t time_on  = TIME_OFF;                                             
// static uint32_t time_off = TIME_ON;
// static uint32_t time_off2 = TIME_OFF_BRIGHT;

//static uint32_t coef_brightness = 1;                                            // Êîýôôèöèåíò ÿðêîñòè. Íå ìîæåò áûòü íóëåì!

// Ïåðåìåííàÿ äëÿ ïðîâåðêè ïåðâàÿ èëè âòîðàÿ ïàðà áàéò óøëà â îòïðàâêó
// Íóæíà ò.ê. íóæíî îïðàâèòü èìåííî 2 ïàðû áàéò íà äèíàì. èíäèêàöèþ
//static uint8_t first_byte;

// Äëÿ ñîõðàíåíèÿ íîìåðà ëàìïû ïðè îòïðàâêå âòîðîé ïàðû áàéò
//static uint16_t tube_nbr_second_value;

// Ñîîáùåíèÿ î÷åðåäè ÎÑÐÂ
QueueHandle_t  queue_new_value;
QueueHandle_t  queue_new_data;
static LightSensorState_t light_sensor_state;
extern QueueHandle_t  queue_light_sensor;


// Ïðîòîòèïû ôóíêöèé ôàéëà -------------------------------------------------- //
// Îòêðûòûå
void NixieDriver_SendValue ( uint8_t *value_arr );
// Çàêðûòûå
static void SwitchOnTube  ( uint8_t tube_nbr );
static void SwitchOffTube ( uint8_t tube_nbr );
// - ôóíêöèÿ íà÷àëüíîé êîíôèãóðàöèè âðåìåíè ( ÷òåíèå ÿðêîñòè èç ïàìÿòè EE )
// void NixieDriver_LoadBrightnessFromMemory ( void );                          // Ô-ÿ ÷èòàåò èç ïàìÿòè çíà÷åíèå êîýôôèöèåíòà ÿðêîñòè coef_brightness
//static void NewTimeCalculate ( uint32_t *time_on, uint32_t *time_off );
// - ô-ÿ NixieDriver_SetBrightness ( uint32_t ??? );                            // Êàêèå áóäóò ïðåäåëû è êîëè÷åñòâî óðîâíåé ÿðêîñòè?
// - ô-ÿ NixieDriver_IncreaseBrighntness ( void );                              // Óâåëè÷èòü ÿðêîñòü íà îäèí øàã ( òî åñòü óâåëè÷èòñÿ êîýô. ÿðêîñòè íà +1 )
// - ô-ÿ NixieDriver_DecreaseBrighntness ( void );                              // Óìåíüøèòü ÿðêîñòü íà îäèí øàã ( òî åñòü óìåíüøèòñÿ êîýô. ÿðêîñòè íà -1 )

#if TUBE_HEATING_UP == 0
static uint8_t LoadNextValueToTubes ( void );
#else
static uint8_t LoadNextValueToTubes ( void );
#endif 

//static void TestLoadNewValueToClock ( void );
static void UpdateValueForClock     ( void );
static void CheckLightSensor (void);


// ----------------------------------------------------------------------------
//
// ----------------------------------------------------------------------------
void NixieDriverInitProcess  ( void )
{
   //first_byte = 0;
   
   queue_new_value = xQueueCreate ( 1, sizeof (uint8_t*) );
   configASSERT( queue_new_value );
   queue_new_data  = xQueueCreate ( 1, sizeof (DataToIndicate_t) );
   configASSERT( queue_new_value );
}


// ----------------------------------------------------------------------------
// Ô-ÿ, ðåàëèçóþùàÿ áåñïðåðûâíûé ïðîöåññ äèíàìè÷åñêîé èíäèêàöèè ëàìï Nixie
// Ô-ÿ âûçûâàåòñÿ èç ïðåðûâàíèÿ òàéìåðà, íàñòðîåííîãî íà 100 ìêñ
// ----------------------------------------------------------------------------
void ProcessNixieDriverFromISR ( void )
{
  static uint8_t  process_indic_state = 0;
  static uint32_t timer               = TIME_ON;
   static uint8_t curr_tube_num       = 0;

  timer++;
  //timer_test++;
  
#if TUBE_HEATING_UP == 0  
  
  switch ( process_indic_state )
  {
        
  case 0:
    
    if ( timer >= time_off )                                                     // Æäåì âðåìÿ ãîðåíèÿ ëàìïû
    {
       curr_tube_num = LoadNextValueToTubes ();
       SwitchOnTube ( curr_tube_num );
       timer = 0;
       process_indic_state = 1;
       /*
       if ( curr_tube_num == (MAX_TUBES - 1) )
       {
         UpdateValueForClock ();
         CheckLightSensor();

        // SwitchOffTube ( curr_tube_num );
         //process_indic_state = 2;
         //timer = 0;

       }
       */
    }
    
    break;
    
  case 1:
    
    if ( timer >= time_on )
    {
      SwitchOffTube ( curr_tube_num );
      timer = 0;
      process_indic_state = 0;

      if ( curr_tube_num == (MAX_TUBES - 1) )
       {
         UpdateValueForClock ();
         CheckLightSensor();

         SwitchOffTube ( curr_tube_num );
         process_indic_state = 2;
         timer = 0;

       }
    }
    
    break;
    
  case 2:
   
    if ( timer >= time_off2 )                                                    
    {   
       //SwitchOnTube ( curr_tube_num );
       timer = time_off;
       process_indic_state = 0;
    }
    
    break;
    
  } // end switch
  
#else
/*
  switch ( process_indic_state )
  {
    
  case 0:

    SwitchOnTube ( curr_tube_num );
    timer = 0;
    process_indic_state = 1;
    
    break;
        
  case 1:
    
    if ( timer >= time1 )                                                       // Æäåì âðåìÿ ãîðåíèÿ ëàìïû
    {
       curr_tube_num = LoadNextValueToTubes ();
       timer = 0;
       process_indic_state = 0;
    }
    
    break;
    
  } // end switch
  */
  
#endif
    
}

// ----------------------------------------------------------------------------
// Ô-ÿ ïîäãîòîâêè è çàïóñêà ïåðåäà÷è áàéò ïî SPI â ñäâèãîâûå ðåãèñòðû
// óïðàâåëåíèÿ äèíàìè÷åñêîé èíäèêàöèåé. Ïî ñóòè âêëþ÷àåò íóæíóþ ëàìïó
// Ô-ÿ ïðèíèìàåò òåêóùèé íîìåð ëàìïû, äëÿ êîòîðîé áóäåò ôîðìèðîâàòüñÿ 
// ïàêåò-êàäð
// ----------------------------------------------------------------------------
static void SwitchOnTube ( uint8_t tube_nbr )
{
  // - ñíà÷àëà îòïðàâëÿåì ïàðó áàéò ñ íîìåðîì ëàìïû
  // - çàòåì îòïðàâëÿåì ïàðó áàéò ñ íîìåðîì öèôðû

  static uint16_t temp;
  
  temp = 0;
  temp = tube_num [ tube_nbr ];                                       //(uint16_t)curr_tube_bufer [ tube_nbr ];
  temp |= curr_tube_bufer [ tube_nbr ];
  
  NIX_DRIVER_RESET_ST_PIN;

  // Ò.ê. òî÷êè íà ëàìïàõ óïðàâëÿþòñÿ íàïðÿìóþ ñ ÌÊ ÷åðåç GPIO,
  // òî íóæíî ïðîâåðÿòü âðó÷íóþ èäåò ëè â ïàêåòå òî÷êà
  // Ìàëåíüêèé íþàíñ:
  // Åñëè ìû âûñòàâèì ñèãíàë íà òî÷êè ðàíüøå, ÷åì ïåðåäàäèì ïàêåò íà âêëþ÷åíèå ëàìï ïî SPI,
  // òî ïî èäåå òî÷êè âêëþ÷àòñÿ ðàíüøå, ÷åì ïîäàñòñÿ ñèãíàë ST
  if (curr_tube_bufer [ tube_nbr ] & TUBE_DIGIT_DP1)
  {
       NIX_DRIVER_SET_TUB_DP1_PIN;
  }
  else
  {
       NIX_DRIVER_RESET_TUB_DP1_PIN;
  }

  if (curr_tube_bufer [ tube_nbr ] & TUBE_DIGIT_DP2)
  {
       NIX_DRIVER_SET_TUB_DP2_PIN;
  }
  else
  {
       NIX_DRIVER_RESET_TUB_DP2_PIN;
  }

  SPI_I2S_SendData16 ( NIX_SPIx, temp );
  SPI_I2S_ITConfig ( NIX_SPIx, SPI_I2S_IT_TXE, ENABLE );
}


// ----------------------------------------------------------------------------
// Ô-ÿ îòêëþ÷àåò ëàìïó
// ----------------------------------------------------------------------------
static void SwitchOffTube ( uint8_t tube_nbr )
{
  //static uint16_t value_to_spi1;
  //static uint16_t temp1;
  
  //value_to_spi1 = (uint16_t)tube_off_digit;
  //value_to_spi1 <<= 8;
  
  //temp1 = 0;
  //temp1 = (uint16_t)tube_num [ tube_nbr ];
  
  //value_to_spi1 |= temp1;

  //first_byte = 1;
  //tube_nbr_second_value = tube_off_digit;
  NIX_DRIVER_RESET_ST_PIN;
  
  NIX_DRIVER_RESET_TUB_DP1_PIN;
  NIX_DRIVER_RESET_TUB_DP2_PIN;
  SPI_I2S_SendData16 ( NIX_SPIx, tube_off_digit );
  SPI_I2S_ITConfig ( NIX_SPIx, SPI_I2S_IT_TXE, ENABLE );
}

// ----------------------------------------------------------------------------
// Ô-ÿ ïðîâåðÿåò íóæíî ëè çàæå÷ü òî÷êó íà èíäèêàòîðàõ ñðàçó ïîñëå îòïðàâêè 
// äâóõ áàéò ïî SPI
// Ô-ÿ âûçûâàåòÿñ èç ïðåðûâàíèÿ ïîñëå óõîäà äâóõ áàéò èç SPI
// Åñëè åñòü òî÷êà, òî çàæèãàåì åå ñ ïîìîùüþ GPIO
// ----------------------------------------------------------------------------
// void NixieDriverCheckDPPins (void)
// {
//   ;
// }


// ----------------------------------------------------------------------------
// Ô-ÿ ïðîâåðÿåò ïåðâûå ëè 2 áàéòà îòïðàâëåíû ïî SPI
// Ô-ÿ âûçûâàåòñÿ èç ïðåðûâàíèÿ NIX_SPIx_IRQHandler
// ----------------------------------------------------------------------------
// uint8_t NixieDriverProcessCheckIsFirstByte (void)
// {
//     //return first_byte;
//     return 0;
// }


// ----------------------------------------------------------------------------
// Ô-ÿ îòïðàâëÿåò âòîðóþ ïàðó áàéò ñî çíà÷åíèåì öèôð
// ----------------------------------------------------------------------------
// void NixieDriverProcessSendSecondByte ( void )
// {
//     first_byte = 0;
//     SPI_I2S_SendData16 ( NIX_SPIx, tube_nbr_second_value );
// }


#if TUBE_HEATING_UP == 1
// ----------------------------------------------------------------------------
// Âðåìåííàÿ ô-ÿ äëÿ ïðîãðåâà êàæäîé ëàìïû ïî êàæäîìó êàòîäó
// ----------------------------------------------------------------------------
static uint8_t LoadNextValueToTubes ( void )
{
  static uint8_t curr_tube_num  = 0;
  static uint8_t curr_digit     = 0;
  
  if ( curr_digit == 10 )
  {    
    if ( curr_tube_num == 5 )
    {
       curr_tube_num = 0;
    }
    else
    {
       curr_tube_num++;
       if ( curr_tube_num == 1 ) { curr_tube_num++; }
    }
    curr_digit = 0;
  }

  curr_tube_bufer [ curr_tube_num ] = tube_digits [ curr_digit ];
  curr_digit++;

  return curr_tube_num;
}

#else

static uint8_t LoadNextValueToTubes ( void )
{
  static uint8_t curr_tube_num  = 5;

  if ( curr_tube_num == 5 )
  {
    curr_tube_num = 0;
    //NIX_TEST_PIN_PB11_TOGGLE;
  }
  else
  {
    curr_tube_num++;
  }
  
  return curr_tube_num;
}

#endif


// ----------------------------------------------------------------------------
// Ô-ÿ ïðîâåðêè è ðàñ÷åòà íîâîãî çíà÷åíèÿ ÿðêîñòè äëÿ äèíàìè÷åñêîé èíäèêàöèè
// ëàìï
// ----------------------------------------------------------------------------
//static void NewTimeCalculate ( uint32_t *time_on, uint32_t *time_off )
//{
////   uint32_t time_check;
////  
////   time_on = TIME_MIN*coef_brightness;
////   
////   if ( time_on > TIME_PERIOD_TCONST ) { return; }
//   
//}


// ----------------------------------------------------------------------------
// Òåñòîâàÿ ô-ÿ ïåðåáèðàåò ïîñëåäîâàòåëüíî âñå öèôðû îäíîâðåìåííî íà êàæäîì 
// èíäèêàòîðå
// ----------------------------------------------------------------------------
//static void TestLoadNewValueToClock ( void )
//{
//  static uint8_t digit_num = 0;
//  
//  //curr_tube_bufer [] = tube_digits [];
//  // Çóãðóæàåì â êàæäóþ ëàìïó îäíî è òî æå çíà÷åíèå
//  for ( uint8_t tube_num = 0; tube_num < MAX_TUBES; tube_num++ )
//  {
//    curr_tube_bufer [tube_num] = tube_digits [digit_num];
//  }
//  digit_num++;
//  
//  if ( digit_num == MAX_DIGITS ) 
//  {
//    digit_num = 0;
//  }
//}


// ----------------------------------------------------------------------------
// Îáíîâëåíèÿ çíà÷åíèÿ âûâîäèìîãî íà èíäèêàòîðû
// Ô-ÿ âûçûâàåòñÿ èç ô-èè ProcessNixieDriverFromISR () ïîñëå âûâîäà îäíîãî 
// öèêëà ( òî åñòü 6-òè èíäèêàòîðîâ )
// ----------------------------------------------------------------------------

// - âíèìàíèå! íóæíî ñäåëàòü äâà áóôåðà, èç êîòîðûõ â ïðåðûâàíèè áåðóòñÿ
//   äàííûå íà ïåðåäà÷ó â ëàìïû â SPI. Ýòî íóæíî, ÷òîáû íå òðàòèòü âðåìÿ íà 
//   çàïîëíåíèå äàííûõ áóôåðà. Ñäåëàòü ôëàã èëè ñåìàôîð. Ïîêà èç îäíîãî
//   áóôåðà äàííûå óõîäÿò, òî â äðóãîé çàïîëíÿþò íîâûå äàííûå. À êîãäà îíè 
//   çàïîëíÿòñÿ, òî ïðîñòî ïîìåíÿòü óêàçàòåëü íà ìàññèâ.

// - ñäåëàòü çàùèòó îò âûõîäà çà ãðàíèöû ìàññèâà tube_digits [10] 
//   (íå áîëüøå 10)

static void UpdateValueForClock ( void )
{
  // - ïðîâåðÿåì ñîîáùåíèå î÷åðåäè ñ íîâûìè äàííûìè äëÿ îòîáðàæåíèÿ
  //   åñëè åñòü, òî çàïîëíÿåì áóôåð curr_tube_bufer [] íîâûìè çíà÷åíèÿìè
  //uint8_t *value_arr;
  DataToIndicate_t data_struct;
  
//  if ( pdPASS == xQueueReceive ( queue_new_value, &value_arr, 0 ) )
//  {
//     for ( uint8_t tube_num = 0; tube_num < MAX_TUBES; tube_num++ )
//     {
//       curr_tube_bufer [tube_num] = tube_digits [ value_arr [tube_num] ];
//     }
//  }


  if ( pdPASS == xQueueReceive ( queue_new_data, &data_struct, 0 ) )
  {
     curr_tube_bufer [0] = tube_digits [ data_struct.indic_1 ];
     curr_tube_bufer [1] = tube_digits [ data_struct.indic_2 ];
     curr_tube_bufer [2] = tube_digits [ data_struct.indic_3 ];
     curr_tube_bufer [3] = tube_digits [ data_struct.indic_4 ];
     curr_tube_bufer [4] = tube_digits [ data_struct.indic_5 ];
     curr_tube_bufer [5] = tube_digits [ data_struct.indic_6 ];
     
  }
  
}


// ----------------------------------------------------------------------------
//
// ----------------------------------------------------------------------------
static void CheckLightSensor (void)
{
  //LightSensorState_t light_sensor_state;
  if ( pdPASS == xQueueReceive ( queue_light_sensor, &light_sensor_state, 0 ) )
  {
     if (light_sensor_state == LIGHT_SENSOR_STATE_LIGHT )
     {
       time_on = TIME_OFF;
       time_off = TIME_ON;
       time_off2 = TIME_OFF_BRIGHT;//TIME_OFF_DARK;
     }
     else
     {
       time_on = TIME_ON;
       time_off = TIME_OFF;
       time_off2 = TIME_OFF_DARK;//TIME_OFF_BRIGHT;
     }
  }
}


// ----------------------------------------------------------------------------
// Ô-ÿ êëàäåò ñîîáùåíèå â î÷åðåäü ÎÑ è ïåðåäàåò óêàçàòåëü íà ìàññèâ ñ äàííûìè
// Ðàçìåð ìàññèâà âñåãäà 6 (êîëè÷åñòâî ëàìï)
// ----------------------------------------------------------------------------
void NixieDriver_SendValue ( uint8_t *value_arr )
{
   xQueueSend ( queue_new_value, &value_arr, 0 );
}

//void NixieDriver_SendValue2 ( uint8_t *value_arr )
//{
//   xQueueSend ( queue_new_value, &value_arr, 0 );
//}