Форум РадиоКот

Код: Выделить всё

//==================
#ifndef SEVEN_SEGM_LED_IND_H

#define SEVEN_SEGM_LED_IND_H

#include "seven_segm_led_ind.h"
//==================

//==================
#include "main_def_func.h"
//==================

//==================
#define SEGM_A_DDR  DDRC
#define SEGM_A_PORT PORTC
//------------------------------------------------------------------------
#define SEGM_B_DDR  DDRC
#define SEGM_B_PORT PORTC
//------------------------------------------------------------------------
#define SEGM_C_DDR  DDRC
#define SEGM_C_PORT PORTC
//------------------------------------------------------------------------
#define SEGM_D_DDR  DDRC
#define SEGM_D_PORT PORTC
//------------------------------------------------------------------------
#define SEGM_E_DDR  DDRC
#define SEGM_E_PORT PORTC
//------------------------------------------------------------------------
#define SEGM_F_DDR  DDRC
#define SEGM_F_PORT PORTC
//------------------------------------------------------------------------
#define SEGM_G_DDR  DDRC
#define SEGM_G_PORT PORTC
//------------------------------------------------------------------------
#define SEGM_H_DDR  DDRC
#define SEGM_H_PORT PORTC
//==================

//==================
//----------------------------- Пины МК ----------------------------------
//-------------------------- Segments Outputs ----------------------------
#define S_A_OUT     6
#define S_B_OUT     7 //     A
#define S_C_OUT     3 //   F   B
#define S_D_OUT     2 //     G
#define S_E_OUT     1 //   E   C
#define S_F_OUT     5 //     D  H
#define S_G_OUT     4
#define S_H_OUT     0
//==================

//==================
#define COMM_1_DDR  DDRA
#define COMM_1_PORT PORTA
//------------------------------------------------------------------------
#define COMM_2_DDR  DDRA
#define COMM_2_PORT PORTA
//------------------------------------------------------------------------
#define COMM_3_DDR  DDRA
#define COMM_3_PORT PORTA
//------------------------------------------------------------------------
#define COMM_4_DDR  DDRA
#define COMM_4_PORT PORTA
//------------------------------------------------------------------------
#define COMM_5_DDR  DDRA
#define COMM_5_PORT PORTA
//------------------------------------------------------------------------
#define COMM_6_DDR  DDRA
#define COMM_6_PORT PORTA
//==================

//==================
//----------------------------- Пины МК ----------------------------------
//-------------------------- Commons Outputs -----------------------------
#define C_1_OUT    2
#define C_2_OUT    3
#define C_3_OUT    4
#define C_4_OUT    5
#define C_5_OUT    6
#define C_6_OUT    7
//------------------------------------------------------------------------
#define C_1        0
#define C_2        1
#define C_3        2
#define C_4        3
#define C_5        4
#define C_6        5
//==================

//==================
//------------------------- Segment numeric value ------------------------
#define S_A        0
#define S_B        1
#define S_C        2
#define S_D        3
#define S_E        4
#define S_F        5
#define S_G        6
#define S_H        7
//==================

//==================
#define ZERO      (_BV(S_A) | _BV(S_B) | _BV(S_C) | _BV(S_D) | _BV(S_E) | _BV(S_F))
#define ONE       (_BV(S_B) | _BV(S_C))
#define TWO       (_BV(S_A) | _BV(S_B) | _BV(S_D) | _BV(S_E) | _BV(S_G))
#define THREE     (_BV(S_A) | _BV(S_B) | _BV(S_C) | _BV(S_D) | _BV(S_G))
#define FOUR      (_BV(S_B) | _BV(S_C) | _BV(S_F) | _BV(S_G))
#define FIVE      (_BV(S_A) | _BV(S_C) | _BV(S_D) | _BV(S_F) | _BV(S_G))
#define SIX       (_BV(S_A) | _BV(S_C) | _BV(S_D) | _BV(S_E) | _BV(S_F) | _BV(S_G))
#define SEVEN     (_BV(S_A) | _BV(S_B) | _BV(S_C))
#define EIGHT     (_BV(S_A) | _BV(S_B) | _BV(S_C) | _BV(S_D) | _BV(S_E) | _BV(S_F) | _BV(S_G))
#define NINE      (_BV(S_A) | _BV(S_B) | _BV(S_C) | _BV(S_D) | _BV(S_F) | _BV(S_G))
#define SPACE      0

#define CHAR_SPACE 10
//==================

//==================
#define MAX_LED_INDS 6
//==================

//==================
extern u08 dsp_buf [];

void clr_dsp_buf (void);
//==================

//==================
void set_proc_7_segm_ind_on (void);
void set_proc_7_segm_ind_off (void);
void proc_7_segm_ind (void);
//==================

//==================
#define HI  true
#define LOW false
//==================

//==================
void Set_Commons_Level (bool level);
void Set_Segments_Level (bool level);
//==================

//==================
void handle_commons (void);
void handle_segments (void); // 306 тактов, 19,13 мкс.
//==================

//==================
typedef struct port_pin_t
{
   volatile u08 * port;
   u08            mask;
} port_pin_t;
//==================

//==================
// Прогон

//==================

//==================
#endif
//==================

Код: Выделить всё

//==================
#include "seven_segm_led_ind.h"
//==================

//==================
struct port_pin_t __flash commons_pins [6] =
{
   {&COMM_1_PORT, _BV(C_1_OUT)},
   {&COMM_2_PORT, _BV(C_2_OUT)},
   {&COMM_3_PORT, _BV(C_3_OUT)},
   {&COMM_4_PORT, _BV(C_4_OUT)},
   {&COMM_5_PORT, _BV(C_5_OUT)},
   {&COMM_6_PORT, _BV(C_6_OUT)}
};
//==================

//==================
struct port_pin_t __flash segments_pins [8] =
{
   {&SEGM_A_PORT, _BV(S_A_OUT)},   // A
   {&SEGM_B_PORT, _BV(S_B_OUT)},   // B
   {&SEGM_C_PORT, _BV(S_C_OUT)},   // C
   {&SEGM_D_PORT, _BV(S_D_OUT)},   // D
   {&SEGM_E_PORT, _BV(S_E_OUT)},   // E
   {&SEGM_F_PORT, _BV(S_F_OUT)},   // F
   {&SEGM_G_PORT, _BV(S_G_OUT)},   // G
   {&SEGM_H_PORT, _BV(S_H_OUT)}    // H
};
//==================

//==================
u08 __flash table_7_segm_char [11] =
{
   ZERO,    ONE,
   TWO,     THREE,
   FOUR,    FIVE,
   SIX,     SEVEN,
   EIGHT,   NINE,
   SPACE,
};
//==================

//==================
soft_timer ST_PROC_7_SEGM_IND;
//------------------------------------------------------------------------
u08 dsp_buf [MAX_LED_INDS];
//------------------------------------------------------------------------
// Очистка буфера дисплея.

u08 dsp_buf [MAX_LED_INDS];

void clr_dsp_buf (void)
{
   for (u08 i = 0; i < MAX_LED_INDS; i++)
      dsp_buf [i] = CHAR_SPACE;
}
//==================

//==================
static u08 _proc_7_segm_ind;
static u08 cnt_commons;


void set_proc_7_segm_ind_on (void)
{
   _proc_7_segm_ind = 1;
}

void set_proc_7_segm_ind_off (void)
{
   _proc_7_segm_ind = 0;
}

void proc_7_segm_ind (void)
{
   switch (_proc_7_segm_ind)
   {
      case 0:
         break;

      case 1:
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
//--------------------------- Segments -----------------------------------
         set_bit (SEGM_A_DDR, S_A_OUT);
         set_bit (SEGM_B_DDR, S_B_OUT);
         set_bit (SEGM_C_DDR, S_C_OUT);
         set_bit (SEGM_D_DDR, S_D_OUT);
         set_bit (SEGM_E_DDR, S_E_OUT);
         set_bit (SEGM_F_DDR, S_F_OUT);
         set_bit (SEGM_G_DDR, S_G_OUT);
         set_bit (SEGM_H_DDR, S_H_OUT);
//--------------------------- Commons ------------------------------------
         set_bit (COMM_1_DDR, C_1_OUT);
         set_bit (COMM_2_DDR, C_2_OUT);
         set_bit (COMM_3_DDR, C_3_OUT);
         set_bit (COMM_4_DDR, C_4_OUT);
         set_bit (COMM_5_DDR, C_5_OUT);
         set_bit (COMM_6_DDR, C_6_OUT);

         Set_Commons_Level (HI);
         Set_Segments_Level (LOW);

         dsp_buf [0] = 1;
         dsp_buf [1] = 2;
         dsp_buf [2] = 3;
         dsp_buf [3] = 4;
         dsp_buf [4] = 5;
         dsp_buf [5] = 6;
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
         cnt_commons = 0;
         set_soft_timer (ST_PROC_7_SEGM_IND, 1, 1);
         _proc_7_segm_ind = 2;
         break;

      case 2:
         if (handle_soft_timer (ST_PROC_7_SEGM_IND))
         {
            handle_commons ();
            handle_segments ();

            if (++cnt_commons >= MAX_LED_INDS) cnt_commons = 0;
         }
         break;

      default:
         break;
   }
}
//==================

//==================
static bool commons_level;
//------------------------------------------------------------------------
void Set_Commons_Level (bool level)
{
   commons_level = level;
}
//------------------------------------------------------------------------
void handle_commons (void)
{
   u08 a = tab_bv [cnt_commons];

   volatile u08 *p;

   for (u08 i = 0; i < MAX_LED_INDS; i++, a >>= 1)
   {
      p = commons_pins [i] .port;

      if (commons_level == HI)
      {
         if (a & (1<<0))
            *p |= commons_pins [i] .mask;
         else
            *p &= (~commons_pins [i] .mask);
      }
      else
      {
         if (a & (1<<0))
            *p &= (~commons_pins [i] .mask);
         else
            *p |= commons_pins [i] .mask;
      }
   }
}
//==================

//==================
static bool segments_level;
//------------------------------------------------------------------------
void Set_Segments_Level (bool level)
{
   segments_level = level;
}
//------------------------------------------------------------------------
void handle_segments (void)
{
   u08 a = table_7_segm_char [dsp_buf [cnt_commons]];

   volatile u08 *p;

   for (u08 i = 0; i < 8; i++, a >>= 1)
   {
      p = segments_pins[i].port;

      if (segments_level == HI)
      {
         if (a & (1<<0))
            *p |= segments_pins [i] .mask;
         else
            *p &= (~segments_pins [i] .mask);
      }
      else
      {
         if (a & (1<<0))
            *p &= (~segments_pins [i] .mask);
         else
            *p |= segments_pins [i] .mask;
      }
   }
}
//==================

Код: Выделить всё

void handle_commons (void)
{
   u08 a = tab_bv [cnt_commons];

   volatile u08 *p;

   if (commons_level == HI)
   {
      for (u08 i = 0; i < MAX_LED_INDS; i++, a >>= 1)
      {
         p = commons_pins [i] .port;

         if (a & (1<<0))
            *p |= commons_pins [i] .mask;
         else
            *p &= (~commons_pins [i] .mask);
      }
   }
   else
   {
      for (u08 i = 0; i < MAX_LED_INDS; i++, a >>= 1)
      {
         p = commons_pins [i] .port;

         if (a & (1<<0))
            *p &= (~commons_pins [i] .mask);
         else
            *p |= commons_pins [i] .mask;
      }
   }
}

void handle_segments (void)
{
   u08 a = table_7_segm_char [dsp_buf [cnt_commons]];

   volatile u08 *p;

   if (segments_level == HI)
   {
      for (u08 i = 0; i < 8; i++, a >>= 1)
      {
         p = segments_pins[i].port;

         if (a & (1<<0))
            *p |= segments_pins [i] .mask;
         else
            *p &= (~segments_pins [i] .mask);
      }
   }
   else
   {
      for (u08 i = 0; i < 8; i++, a >>= 1)
      {
         p = segments_pins[i].port;

         if (a & (1<<0))
            *p &= (~segments_pins [i] .mask);
         else
            *p |= segments_pins [i] .mask;
      }
   }
}