/*------------------------------------------------------------------*/

/* --- STC MCU International Limited -------------------------------*/

/* --- STC 15 Series MCU A/D Conversion Demo -----------------------*/

/* --- Mobile: (86)13922805190 -------------------------------------*/

/* --- Fax: 86-755-82944243 ----------------------------------------*/
/* --- Tel: 86-755-82948412 ----------------------------------------*/

/* --- Web: www.STCMCU.com -----------------------------------------*/

/*------------------------------------------------------------------*/

#include "stc15.h"

#include < stdint.h >

#define _nop_ __asm nop __endasm;

/* Определение констант операций ADC для ADC_CONTR */

#define ADC_POWER   0x80         //бит управления питанием ADC

#define ADC_FLAG    0x10         //бит завершения преобразования ADC

#define ADC_START   0x08         //бит управления запуском ADC

#define ADC_SPEEDLL 0x00         //540 тактов

#define ADC_SPEEDL  0x20         //360 тактов

#define ADC_SPEEDH  0x40         //180 тактов

#define ADC_SPEEDHH 0x60         //90 тактов

/*----------------------------

Инициализация регистров ADC

----------------------------*/

void InitADC(uint8_t chan);

/*-----------------------------------

Получение 10-битного результата ADC

-----------------------------------*/

uint16_t getADCResult(uint8_t chan);

/*-----------------------------------

Получение 8-битного результата ADC

-----------------------------------*/

uint8_t getADCResult8(uint8_t chan);

/*---------------------------------------------------------------------*/

/* --- STC MCU International Limited ----------------------------------*/

/* --- STC 15 Series MCU A/D Conversion Demo --------------------------*/

/* --- Mobile: (86)13922805190 ----------------------------------------*/

/* --- Fax: 86-755-82944243 -------------------------------------------*/

/* --- Tel: 86-755-82948412 -------------------------------------------*/

/* --- Web: www.STCMCU.com --------------------------------------------*/

/*---------------------------------------------------------------------*/

#include "stc15.h"

#include "adc.h"

/*----------------------------

Инициализация регистров ADC

----------------------------*/

void InitADC(uint8_t chan)
{
   P1ASF |= 1 << chan;                 //разрешение функции канала ADC
   ADC_RES = 0;                        //очистка предыдущего результата
   ADC_CONTR = ADC_POWER | ADC_SPEEDLL;//включение ADC
   //Delay(2);                         // и задержка
}

/*-----------------------------------

Получение 10-битного результата ADC

-----------------------------------*/

uint16_t getADCResult(uint8_t chan)
{
   ADC_CONTR = ADC_POWER | ADC_SPEEDHH | ADC_START | chan;
   _nop_;                           //нужно подождать перед запросом
   while (!(ADC_CONTR & ADC_FLAG)); //ожидание флага завершения преобразования
   ADC_CONTR &= ~ADC_FLAG;          //закрытие ADC
   return  ADC_RES << 2 | (ADC_RESL & 0b11) ;   //возврат значения ADC
}

/*-----------------------------------

Получение 8-битного результата ADC

-----------------------------------*/

uint8_t getADCResult8(uint8_t chan)
{
   ADC_CONTR = ADC_POWER | ADC_SPEEDHH | ADC_START | chan;
   _nop_;                           //нужно подождать перед запросом
   while (!(ADC_CONTR & ADC_FLAG)); //ожидание флага завершения преобразования
   ADC_CONTR &= ~ADC_FLAG;          //закрытие ADC
   return ADC_RES;                  //возврат значения ADC
}

// DS1302 RTC IC

// http://datasheets.maximintegrated.com/en/ds/DS1302.pdf

#include "stc15.h"

#include < stdint.h >

#define _nop_ __asm nop __endasm;

#define DS_CE    P1_0

#define DS_IO    P1_1

#define DS_SCLK  P1_2

#define DS_CMD        1 << 7

#define DS_CMD_READ   1

#define DS_CMD_WRITE  0

#define DS_CMD_RAM    1 << 6

#define DS_CMD_CLOCK  0 << 6

#define DS_ADDR_SECONDS     0

#define DS_ADDR_MINUTES     1

#define DS_ADDR_HOUR        2

#define DS_ADDR_DAY         3

#define DS_ADDR_MONTH       4

#define DS_ADDR_WEEKDAY     5

#define DS_ADDR_YEAR        6

#define DS_ADDR_WP          7

#define DS_ADDR_TCSDS       8

#define DS_BURST_MODE       31

#define DS_MASK_SECONDS       0b01111111

#define DS_MASK_SECONDS_TENS  0b01110000

#define DS_MASK_SECONDS_UNITS 0b00001111

#define DS_MASK_MINUTES       0b01111111

#define DS_MASK_MINUTES_TENS  0b01110000

#define DS_MASK_MINUTES_UNITS 0b00001111

#define DS_MASK_AMPM_MODE     0b10000000

#define DS_MASK_PM            0b00100000

#define DS_MASK_HOUR12        0b00011111

#define DS_MASK_HOUR12_TENS   0b00010000

#define DS_MASK_HOUR24        0b00111111

#define DS_MASK_HOUR24_TENS   0b00110000

#define DS_MASK_HOUR_UNITS    0b00001111

#define DS_MASK_DAY           0b00111111

#define DS_MASK_DAY_TENS      0b00110000

#define DS_MASK_DAY_UNITS     0b00001111

#define DS_MASK_MONTH         0b00011111

#define DS_MASK_MONTH_TENS    0b00010000

#define DS_MASK_MONTH_UNITS   0b00001111

#define DS_MASK_WEEKDAY       0b00000111

#define DS_MASK_YEAR          0b11111111

#define DS_MASK_YEAR_TENS     0b11110000

#define DS_MASK_YEAR_UNITS    0b00001111

/*

  Примечание: биты RTC и конфигурации изначально находились

  в структурах/объединениях (structs/unions), но по некоторой

  причине выходной код sdcc слишком разросся. Это прямая попытка

  заново создать функциональность структуры/объединения путем

  явного выбора адресации бита/байта iram масками, заданными выше.

  Из-за того, что эта текущая реализация более сложная, чем

  с помощью структур/объединений, есть некая надежда вернуться

  к доступу через struct/union, если это позволит размер кода

  (может быть, это даст оптимизация sdcc?).*/

// 8051 область памяти 0x20 .. 0x2F в IRAM может быть доступна

// как биты (по адресам 0x00 .. 0x7F)

// 0x20, бит 0 это бит по адресу __bit __at (0x00),

// бит 7 это бит по адресу __bit __at (0x07), и так далее...

uint8_t __at (0x24) rtc_table[8];

// h12.tenhour в RTC по адресу 0x26, бит 4 -> => 0x26-0x20 => 0x6*8+4 => 52 => 0x34
__bit __at (0x34) H12_TH;

// h12.pm в RTC по адресу 0x26, бит 5 -> => 0x26-0x20 => 0x6*8+5 => 53 => 0x35
__bit __at (0x35) H12_PM;

// hour_12_24 в RTC по адресу 0x26, бит 7 -> => 0x26-0x20 => 0x6*8+7 => 55 => 0x37
__bit __at (0x37) H12_24;

// Конфигурация в DS1302 RAM

uint8_t __at (0x2c) cfg_table[4];

#define CFG_ALARM_HOURS_BYTE   0

#define CFG_ALARM_MINUTES_BYTE 1

#define CFG_TEMP_BYTE          2

#define CFG_ALARM_HOURS_MASK   0b11111000

#define CFG_ALARM_MINUTES_MASK 0b00111111

#define CFG_TEMP_MASK          0b00000111

// Смещение 0 => alarm_hour (7..3) / chime_on (2) / alarm_on (1) / temp_C_F (0)

// Смещение 1 => (7) не используется / (6) sw_mmdd / alarm_minute (5..0)

// Смещение 2 => chime_hour_start (7..3) / temp_offset (2..0), signed -4 / +3

// Смещение 3 => (7),(6)&(5) не используется / chime_hour_stop (4..0)

// temp_C_F в конфигурации находится по адресу 0x2c,

// бит 0 => 0x2c-0x20 => 0xc*8+0 => 96 => 0x60
__bit __at (0x60) CONF_C_F;
__bit __at (0x61) CONF_ALARM_ON;
__bit __at (0x62) CONF_CHIME_ON;
__bit __at (0x6E) CONF_SW_MMDD;

// Функции DS1302

void ds_ram_config_init();

void ds_ram_config_write();

// Чтение одного байта ds1302

uint8_t ds_readbyte(uint8_t addr);

// Чтение ds1302 пакетом 8 байт в структуру

void ds_readburst();

// Запись одного байта ds1302

void ds_writebyte(uint8_t addr, uint8_t data);

// Очистка WP, CH

void ds_init();

// Сброс даты/времени в 01/01 00:00

void ds_reset_clock();

// переключение режима часов 12/24

void ds_hours_12_24_toggle();

// инкремент часов

void ds_hours_incr();

// инкремент минут

void ds_minutes_incr();

// инкремент месяца

void ds_month_incr();

// инкремент дней

void ds_day_incr();

void ds_weekday_incr();

void ds_sec_zero();

// разбиение bcd на int

uint8_t ds_split2int(uint8_t tens_ones);

// возврат байта в кодировке bcd, полученного из целого числа

uint8_t ds_int2bcd(uint8_t integer);

// преобразование целого числа на части bcd (старшая тетрада десятки,

// младшая тетрада единицы)

uint8_t ds_int2bcd_tens(uint8_t integer);

uint8_t ds_int2bcd_ones(uint8_t integer);

// Модуль для работы с микросхемой DS1302 часов реального времени (RTC)

// http://datasheets.maximintegrated.com/en/ds/DS1302.pdf

#pragma callee_saves sendbyte,readbyte

#pragma callee_saves ds_writebyte,ds_readbyte

#include "ds1302.h"

#define MAGIC_HI  0x5A

#define MAGIC_LO  0xA5

void ds_ram_config_init()
{
   uint8_t i,j;
   // проверка magic-байтов, чтобы определить, была ли ранее записана ram
   if ( (ds_readbyte( DS_CMD_RAM >> 1 | 0x00) != MAGIC_LO
      || ds_readbyte( DS_CMD_RAM >> 1 | 0x01) != MAGIC_HI) )
   {
      // если нет, то нужно инициализировать конфигурацию ram значениями
      // по умолчанию
      ds_writebyte( DS_CMD_RAM >> 1 | 0x00, MAGIC_LO);
      ds_writebyte( DS_CMD_RAM >> 1 | 0x01, MAGIC_HI);
      // ОПТИМИЗАЦИЯ: генерировать ljmp в ds_ram_config_write
      ds_ram_config_write();
      return;
   }
   
   // чтение конфигурации ram
   // ОПТИМИЗАЦИЯ: условие завершения цикла !=4 даст код меньше, чем < 4 
   // ОПТИМИЗАЦИЯ: было cfg_table[i] = ds_readbyte(DS_CMD_RAM >> 1 | (i+2));
   //              использование второй переменной вместо DS_CMD_RAM>>1 | (i+2)
   //              дает код меньшего размера
   j=DS_CMD_RAM>>1|2;
   for (i=0; i!=4; i++)
      cfg_table[i] = ds_readbyte(j++);
}

void ds_ram_config_write()
{
   uint8_t i,j;
   j=DS_CMD_RAM>>1|2;
   for (i=0; i!=4; i++)
      ds_writebyte(j++, cfg_table[i]);
}

void sendbyte(uint8_t b)
{
   b;
   __asm
   push  ar7
   mov   a,dpl
   mov   r7,#8

00001$:
   nop
   nop
   rrc   a
   mov   _P1_1,c
   setb  _P1_2
   nop
   nop
   clr   _P1_2
   djnz  r7,00001$
   pop   ar7
   __endasm;
}

uint8_t readbyte()
{
   __asm
   push  ar7
   mov   a,#0
   mov   r7,#8

00002$:
   nop
   nop
   mov   c,_P1_1
   rrc   a
   setb  _P1_2
   nop
   nop
   clr   _P1_2
   djnz  r7,00002$
   mov   dpl,a
   pop   ar7
   __endasm;
}

uint8_t ds_readbyte(uint8_t addr)
{
   // чтение одного байта из ds1302
   uint8_t b;
   b = DS_CMD | DS_CMD_CLOCK | addr << 1 | DS_CMD_READ;
   DS_CE = 0;
   DS_SCLK = 0;
   DS_CE = 1;
   // отправка байта команды
   sendbyte(b);
   // чтение байта
   b=readbyte();
   DS_CE = 0;
   return b;
}

void ds_readburst()
{
   // чтение ds1302 пакетом 8 байт
   uint8_t j, b;
   b = DS_CMD | DS_CMD_CLOCK | DS_BURST_MODE << 1 | DS_CMD_READ;
   DS_CE = 0;
   DS_SCLK = 0;
   DS_CE = 1;
   // отправка байта команды
   sendbyte(b);
   // чтение байт
   for (j=0; j!=8; j++) 
      rtc_table[j] = readbyte();
   DS_CE = 0;
}

void ds_writebyte(uint8_t addr, uint8_t data)
{
   // запись одного байта в ds1302
   uint8_t b = 0;
   b = DS_CMD | DS_CMD_CLOCK | addr << 1 | DS_CMD_WRITE;
   DS_CE = 0;
   DS_SCLK = 0;
   DS_CE = 1;
   // отправка байта команды
   sendbyte(b);
   // отправка байта данных
   sendbyte(data);
   DS_CE = 0;
}

void ds_init()
{
   uint8_t b = ds_readbyte(DS_ADDR_SECONDS);
   ds_writebyte(DS_ADDR_WP, 0);        // очистка WP
   b &= ~(0b10000000);
   ds_writebyte(DS_ADDR_SECONDS, b);   // очистка CH
}

// Сброс даты и времени

void ds_reset_clock()
{
   ds_writebyte(DS_ADDR_MINUTES, 0x00);
   ds_writebyte(DS_ADDR_HOUR,  DS_MASK_AMPM_MODE|0x07);
   ds_writebyte(DS_ADDR_MONTH, 0x01);
   ds_writebyte(DS_ADDR_DAY,   0x01);
}

void ds_hours_12_24_toggle()
{
   uint8_t hours,b;
   if (H12_24)
   {  // 12h->24h
      // часы в формате 12h (1-11am 12pm 1-11pm 12am)
      hours=ds_split2int(rtc_table[DS_ADDR_HOUR]&DS_MASK_HOUR12);
      if (hours==12)
      {
         if (!H12_PM) hours=0;
      }
      else
      {
         if (H12_PM) hours+=12;
      }// в 24h формат
      b = ds_int2bcd(hours);  // очистка бита hour_12_24 bit
   }
   else
   {  // 24h->12h
      // часы в формате 24h (0-23, 0-11=>am , 12-23=>pm)
      hours = ds_split2int(rtc_table[DS_ADDR_HOUR]&DS_MASK_HOUR24);
      b = DS_MASK_AMPM_MODE; 
      if (hours >= 12) { hours-=12; b|=0x20; }  // pm
      if (hours == 0) { hours=12; }             //12am
      b |= ds_int2bcd(hours);
   }
   ds_writebyte(DS_ADDR_HOUR,b);
}

// инкремент часов

void ds_hours_incr()
{
   uint8_t hours, b = 0;
   if (!H12_24)
   {
      // 24-часовой формат
      hours = ds_split2int(rtc_table[DS_ADDR_HOUR]&DS_MASK_HOUR24);
      if (hours < 23)
         hours++;
      else
         hours = 00;
      b = ds_int2bcd(hours);  // бит 7 = 0
   }
   else
   {
      // 12-часовой формат
      hours = ds_split2int(rtc_table[DS_ADDR_HOUR]&DS_MASK_HOUR12);
      if (hours < 12)
         hours++;
      else
      {
         hours = 1;
         H12_PM=!H12_PM;
      }
      b = (H12_PM?(DS_MASK_AMPM_MODE|DS_MASK_PM):DS_MASK_AMPM_MODE)|ds_int2bcd(hours);
   }
   ds_writebyte(DS_ADDR_HOUR, b);
}

// инкремент минут

void ds_minutes_incr()
{
   uint8_t minutes = ds_split2int(rtc_table[DS_ADDR_MINUTES]&DS_MASK_MINUTES);
   if (minutes < 59)
      minutes++;
   else
      minutes = 1;
   ds_writebyte(DS_ADDR_MINUTES, ds_int2bcd(minutes));
}

// инкремент месяца

void ds_month_incr()
{
   uint8_t month = ds_split2int(rtc_table[DS_ADDR_MONTH]&DS_MASK_MONTH);
   if (month < 12)
      month++;
   else
      month = 1;
   ds_writebyte(DS_ADDR_MONTH, ds_int2bcd(month));
}

// инкремент дней

void ds_day_incr()
{
   uint8_t day = ds_split2int(rtc_table[DS_ADDR_DAY]&DS_MASK_DAY);
   if (day < 31)
      day++;
   else
      day = 1;
   ds_writebyte(DS_ADDR_DAY, ds_int2bcd(day));
}

void ds_weekday_incr()
{
   uint8_t day = rtc_table[DS_ADDR_WEEKDAY];
   if (day < 7)
      day++;
   else
      day=1;
   ds_writebyte(DS_ADDR_WEEKDAY, day);
   rtc_table[DS_ADDR_WEEKDAY] = day;   // полезно ?
}

void ds_sec_zero()
{
   rtc_table[DS_ADDR_SECONDS]=0;
   ds_writebyte(DS_ADDR_SECONDS,0);
}

uint8_t ds_split2int(uint8_t tens_ones)
{
   return (tens_ones>>4) * 10 + (tens_ones&0xF);
}

// вернет байт в кодировке bcd, полученный из целого числа

uint8_t ds_int2bcd(uint8_t integer)
{
   return integer / 10 << 4 | integer % 10;
}

uint8_t ds_int2bcd_tens(uint8_t integer)
{
   return integer / 10 % 10;
}

uint8_t ds_int2bcd_ones(uint8_t integer)
{
   return integer % 10;
}

// Функции для управления 4-разрядным цифровым

// семисегментным светодиодным (LED) индикатором

#include < stdint.h >

// индексы для ledtable[]

#define LED_a   0xa

#define LED_b   0xb

#define LED_c   0xc

#define LED_d   0xd

#define LED_e   0xe

#define LED_f   0xf

#define LED_BLANK  0x10

#define LED_DASH   0x11

#define LED_h   0x12

#define LED_dp  0x13

const uint8_t __at (0x1000) ledtable[] =

{
    // таблица для генерации цифр
    // dp,g,f,e,d,c,b,a
    0b11000000, // was 0b00111111, // 0
    0b11111001, //     0b00000110, // 1
    0b10100100, //     0b01011011, // 2
    0b10110000, //     0b01001111, // 3
    0b10011001, //     0b01100110, // 4
    0b10010010, //     0b01101101, // 5
    0b10000010, //     0b01111101, // 6
    0b11111000, //     0b00000111, // 7
    0b10000000, //     0b01111111, // 8
    0b10011000, //     0b01100111, // 9
    0b10001000, //     0b01110111, // A
    0b10000011, //     0b01111100, // b
    0b11000110, //     0b00111001, // C
    0b10100001, //     0b01011110, // d
    0b10000110, //     0b01111001, // E
    0b10001110, //     0b01110001, // F
    0b11111111, //     0b00000000, // 0x10 - ' '
    0b10111111, //     0b01000000, // 0x11 - '-'
    0b10001011, //     0b01110100, // 0x12 - 'h'
    0b01111111, //     0b10000000, // 0x13 - '.'
};

// Некоторые буквенные символы abc .. def

const uint8_t __at (0x1100) ledtable2[]  =

{
    0b11000000, // was 0b00111111, // 0
    0b11001111, //     0b00000110, // 1
    0b10100100, //     0b01011011, // 2
    0b10000110, //     0b01001111, // 3
    0b10001011, //     0b01100110, // 4
    0b10010010, //     0b01101101, // 5
    0b10010000, //     0b01111101, // 6
    0b11000111, //     0b00000111, // 7
    0b10000000, //     0b01111111, // 8
    0b10000011, //     0b01100111, // 9
    0b10000001, //     0b01110111, // A
    0b10011000, //     0b01111100, // b
    0b11110000, //     0b00111001, // C
    0b10001100, //     0b01011110, // d
    0b10110000, //     0b01111001, // E
    0b10110001, //     0b01110001, // F
    0b11111111, //     0b00000000, // 0x10 - ' '
    0b10111111, //     0b01000000, // 0x11 - '-'
    0b10011001, //     0b01110100, // 0x12 - 'h'
    0b01111111, //     0b10000000, // 0x13 - '.'
};

uint8_t tmpbuf[4];
__bit   dot0;
__bit   dot1;
__bit   dot2;
__bit   dot3;

uint8_t dbuf[4];

#define clearTmpDisplay() { dot0=0; dot1=0; dot2=0; dot3=0; tmpbuf[0]=tmpbuf[1]=tmpbuf[2]=tmpbuf[3]=LED_BLANK; }

#define filldisplay(pos,val,dp) { tmpbuf[pos]=(uint8_t)(val); if (dp) dot##pos=1;}

#define dotdisplay(pos,dp) { if (dp) dot##pos=1;}

#define updateTmpDisplay() { uint8_t tmp; \

                        tmp=ledtable[tmpbuf[0]]; if (dot0) tmp&=0x7F; dbuf[0]=tmp; \

                        tmp=ledtable[tmpbuf[1]]; if (dot1) tmp&=0x7F; dbuf[1]=tmp; \

                        tmp=ledtable[tmpbuf[3]]; if (dot3) tmp&=0x7F; dbuf[3]=tmp; \

                        tmp=ledtable2[tmpbuf[2]]; if (dot2) tmp&=0x7F; dbuf[2]=tmp; }

// STC15F204EA DIY LED Clock

// Copyright 2016, Jens Jensen

// Можно применить STC15F404AS

#include "stc15.h"

#include < stdint.h >

#include < stdio.h >

#include "adc.h"

#include "ds1302.h"

#include "led.h"

#define FOSC    11059200

// Очистка сторожевого таймера (WDT, Watch Dog Timer)

#define WDT_CLEAR()    (WDT_CONTR |= 1 << 4)

// Псевдонимы для выходов управления реле и пищалки.

// Реле использовалось для инидикации состояния

// главного цикла main.

#define RELAY   P1_4

#define BUZZER  P1_5

// Каналы АЦП для сенсоров:

#define ADC_LIGHT 6

#define ADC_TEMP  7

// Псевдонимы для кнопок:

#define SW2     P3_0

#define S2      1

#define SW1     P3_1

#define S1      0

// Состояния режима клавиатуры:

enum keyboard_mode {
   K_NORMAL,
   K_WAIT_S1,
   K_WAIT_S2,
   K_SET_HOUR,
   K_SET_MINUTE,
   K_SET_HOUR_12_24,
   K_SEC_DISP,
   K_TEMP_DISP,
   K_DATE_DISP,
   K_DATE_SWDISP,
   K_SET_MONTH,
   K_SET_DAY,
   K_WEEKDAY_DISP,
   K_DEBUG
};

// Состояния режима дисплея:

enum display_mode {
   M_NORMAL,
   M_SET_HOUR_12_24,
   M_SEC_DISP,
   M_TEMP_DISP,
   M_DATE_DISP,
   M_WEEKDAY_DISP,
   M_DEBUG
};

/* ------------------------------------------------------------------------- */

void _delay_ms(uint8_t ms)
{
   // i,j выбраны для тактовой частоты fosc=11.0592 МГц с помощью осциллографа.
   // Инструментарий stc-isp дает неточные результаты (может быть, для C51 
   // в отличие sdcc?).
   // max 255 мс
   uint8_t i, j;
   do
   {
      i = 4;
      j = 240;
      do
      {
         while (--j);
      } while (--i);
   } while (--ms);
}

// Глобальные переменные:

uint8_t  count;      // раньше было uint16, но 8 бит достаточно

uint16_t temp;       // значение сенсора температуры

uint8_t  lightval;   // значение сенсора освещенности

volatile uint8_t displaycounter;

volatile uint8_t _100us_count;

volatile uint8_t _10ms_count;

uint8_t dmode = M_NORMAL;        // состояние режима дисплея

uint8_t kmode = K_NORMAL;        // состояние режима клавиатуры

uint8_t smode,lmode;

volatile __bit  display_colon;   // мигание двоеточия
__bit  flash_01;
__bit  flash_23;
__bit  beep = 1;

volatile __bit  S1_LONG;

volatile __bit  S1_PRESSED;

volatile __bit  S2_LONG;

volatile __bit  S2_PRESSED;

volatile uint8_t debounce[2];    // буфер подавления дребезга контактов

volatile uint8_t switchcount[2];

#define SW_CNTMAX 80

void timer0_isr() __interrupt 1 __using 1
{
   // Обработчик прервания (ISR) обновления дисплея.
   // За 1 проход обрабатывается одна цифра.
   uint8_t digit = displaycounter % 4;
   // Выключение всех цифр, установка уровней лог. 1.
   P3 |= 0x3C;
   // Автоподстройка яркости: пропускается несколько тактов
   if (displaycounter % lightval < 4 )
   {
      // заполнение цифр
      P2 = dbuf[digit];
      // включение выбранной цифры установкой лог. 0
      P3 &= ~(0x4 << digit);  
   }
   displaycounter++;
   // делитель: для получения интервалов 10 мс
   if (++_100us_count == 100)
   {
      _100us_count = 0;
      _10ms_count++;
      // код для мигания двоеточия, 500 мс
      if (_10ms_count == 50)
      {
         display_colon = !display_colon;
         _10ms_count = 0;
      }
      // чтение кнопок с подавлением дребезга:
      // инкремент счетчика, если контакты замкнуты
      if ((debounce[0]) == 0x00)
      {
         // удержание как минимум на 8 тиков
         S1_PRESSED = 1;
         switchcount[0]++;
      }
      else
      {
         // кнопка отпущена, или дребезг, сброс состояния
         S1_PRESSED = 0; 
         switchcount[0] = 0;
      }
      if ((debounce[1]) == 0x00)
      {
         // удержание как минимум на 8 тиков
         S2_PRESSED = 1;
         switchcount[1]++;
      }
      else
      {
         // кнопка отпущена, или дребезг, сброс состояния
         S2_PRESSED = 0;
         switchcount[1] = 0;
      }
      // код подавления дребезга
      if (switchcount[0] > SW_CNTMAX)
         {switchcount[0] = SW_CNTMAX; S1_LONG=1;}
      if (switchcount[1] > SW_CNTMAX)
         {switchcount[1] = SW_CNTMAX; S2_LONG=1;}
      // чтение состояния кнопок в смещающееся 8-битное окно
      debounce[0] = (debounce[0] << 1) | SW1;
      debounce[1] = (debounce[1] << 1) | SW2;
   }
}

//Интервал таймера 100 мкс на частоте 11.0592 МГц

void Timer0Init(void)
{
   TL0 = 0xA4;TH0 = 0xFF;  //Начальное значение таймера
   TF0 = 0;                //Очистка флага TF0
   TR0 = 1;                //Запуск в работу Timer0
   ET0 = 1;                //Разрешение прерывания от Timer0
   EA = 1;                 //Глобальное разрешение прерываний
}

#define getkeypress(a) a##_PRESSED

int8_t gettemp(uint16_t raw) {
   // Формула для преобразования значения АЦП, подключенного
   // к терморезистору ntc (Negative Temperature Coeff,
   // терморезистор с отрицательным коэффициентом)
   // в приблизительное значение градусов Цельсия:
   return 76 - raw * 64 / 637;
}

/*********************************************/

int main()
{
   // НАСТРОЙКА
   // установка выводов фоторезистора и терморезистора в режим выхода
   // с открытым коллектором:
   P1M1 |= (1 << 6) | (1 << 7);
   P1M0 |= (1 << 6) | (1 << 7);
   
   // инициализация RTC (микросхема часов реального времени DS1302):
   ds_init();
   // инициализация/чтение конфигурации ram:
   ds_ram_config_init();
   
   // Раскомментируйте, чтобы сбросить минуты и часы в 0.
   // Использовалось для отладки, сейчас это не нужно.
   //ds_reset_clock();    
    
   Timer0Init();  // настройка таймера для обновления дисплея и чтения кнопок
    
   // ГЛАВНЫЙ ЦИКЛ
   while(1)
   {
      RELAY = 0;
      _delay_ms(100);
      RELAY = 1;
      // Часто запускаемый опрос АЦП:
      if ((count % 4) == 0)
      {
         // автоподстройка яркости цифр путем деления диапазона АЦП на 8 шагов:
         lightval = getADCResult8(ADC_LIGHT) >> 3;
         temp = gettemp(getADCResult(ADC_TEMP))
              + (cfg_table[CFG_TEMP_BYTE]&CFG_TEMP_MASK)
              - 4;
         // установка нижнего порога подстройки яркости индикатора:
         if (lightval < 4) 
            lightval = 4;
      }
      ds_readburst();   // чтение RTC
      // Дерево принятия решений при опросе клавиатуры:
      switch (kmode)
      {
      case K_SET_HOUR:
         flash_01 = !flash_01;
         if (! flash_01)
         {
            if (getkeypress(S2)) ds_hours_incr();
            if (getkeypress(S1)) kmode = K_SET_MINUTE;
         }
         break;
      case K_SET_MINUTE:
         flash_01 = 0;
         flash_23 = !flash_23;
         if (! flash_23)
         {
            if (getkeypress(S2)) ds_minutes_incr();
            if (getkeypress(S1)) kmode = K_SET_HOUR_12_24;
         }
         break;
      case K_SET_HOUR_12_24:
         dmode=M_SET_HOUR_12_24;
         if (getkeypress(S2)) ds_hours_12_24_toggle();
         if (getkeypress(S1)) kmode = K_NORMAL;
          break;
              
      case K_TEMP_DISP:
         dmode=M_TEMP_DISP;
         if (getkeypress(S1))
         {
            uint8_t offset=cfg_table[CFG_TEMP_BYTE]&CFG_TEMP_MASK;
            offset++; offset&=CFG_TEMP_MASK;
            cfg_table[CFG_TEMP_BYTE]=(cfg_table[CFG_TEMP_BYTE]&~CFG_TEMP_MASK)|offset;
         }
         if (getkeypress(S2)) kmode = K_DATE_DISP;
         break;
                        
      case K_DATE_DISP:
         dmode=M_DATE_DISP;
         if (getkeypress(S1))
         {
            kmode=K_WAIT_S1;
            lmode=CONF_SW_MMDD?K_SET_DAY:K_SET_MONTH;
            smode=K_DATE_SWDISP;
         }
         if (getkeypress(S2)) kmode = K_WEEKDAY_DISP;                        
         break;
      case K_DATE_SWDISP:
         CONF_SW_MMDD=!CONF_SW_MMDD;
         kmode=K_DATE_DISP;
         break;
      case K_SET_MONTH:
         flash_01 = !flash_01;
         if (! flash_01)
         {
            if (getkeypress(S2))
            {
               ds_month_incr();
            }
            if (getkeypress(S1))
            {
               flash_01 = 0; kmode = CONF_SW_MMDD?K_DATE_DISP:K_SET_DAY;
            }
         }
         break;
      case K_SET_DAY:
         flash_23 = !flash_23;
         if (! flash_23)
         {
            if (getkeypress(S2))
            {
               ds_day_incr();
            }
            if (getkeypress(S1))
            {
               flash_23 = 0; kmode = CONF_SW_MMDD?K_SET_MONTH:K_DATE_DISP;
            }
         }
         break;
              
      case K_WEEKDAY_DISP:
         dmode=M_WEEKDAY_DISP;
         if (getkeypress(S1)) ds_weekday_incr();
         if (getkeypress(S2)) kmode = K_NORMAL;
         break;
      case K_DEBUG:
         dmode=M_DEBUG;
         if (count>100) kmode = K_NORMAL;
         if (S1_PRESSED||S2_PRESSED) count=0;
         break;
      case K_SEC_DISP:
         dmode=M_SEC_DISP;
         if (getkeypress(S1) || (count>100)) { kmode = K_NORMAL; }
         if (getkeypress(S2)) { ds_sec_zero(); }
         break;
      case K_WAIT_S1:
         count=0;
         if (!S1_PRESSED)
         {
            if (S1_LONG) {S1_LONG=0; kmode=lmode;}
            else  {kmode=smode;}
         }
         break;
      case K_WAIT_S2:
         count=0;
         if (!S2_PRESSED)
         {
            if (S2_LONG) {S2_LONG=0; kmode=lmode;}
            else  {kmode=smode;}
         }
         break;
      case K_NORMAL:          
      default:
         flash_01 = 0;
         flash_23 = 0;
         dmode=M_NORMAL;
         if (S1_PRESSED)
         {
            kmode = K_WAIT_S1; lmode=K_SET_HOUR; smode=K_SEC_DISP;
         }
         //if (S2_PRESSED)
         //{
         //   kmode = K_WAIT_S2; lmode=K_DEBUG;smode=K_TEMP_DISP;
         //}
         if (S2_PRESSED) { kmode = K_TEMP_DISP; }
      };
      // Выполнение дерева отображения:
      clearTmpDisplay();
      switch (dmode)
      {
      case M_NORMAL:
         if (flash_01)
         {
            dotdisplay(1,display_colon);
         }
         else
         {
            if (!H12_24)
            {
               // десятки часов
               filldisplay(0,
                           (rtc_table[DS_ADDR_HOUR]>>4)&(DS_MASK_HOUR24_TENS>>4),
                           0);
            }
            else
            {
               // десятки часов для случая включенного режима AMPM,
               // когда '1' только когда включено H12_TH
               if (H12_TH)
                  filldisplay(0, 1, 0);
            }
            filldisplay(1,
                        rtc_table[DS_ADDR_HOUR]&DS_MASK_HOUR_UNITS,
                        display_colon);
         }
         if (flash_23)
         {
            // точка в разряде 3, если режим AMPM и PM=1
            dotdisplay(2,display_colon);
            dotdisplay(3,H12_24&H12_PM);
         }
         else
         {
            // десятки минут
            filldisplay(2,
                        (rtc_table[DS_ADDR_MINUTES]>>4)&(DS_MASK_MINUTES_TENS>>4),
                        display_colon);
            // минуты
            filldisplay(3,
                        rtc_table[DS_ADDR_MINUTES]&DS_MASK_MINUTES_UNITS,
                        H12_24 & H12_PM);
         }
         break;
      case M_SET_HOUR_12_24:
         if (!H12_24)
         {
            filldisplay(1, 2, 0);
            filldisplay(2, 4, 0);
         }
         else
         {
            filldisplay(1, 1, 0);
            filldisplay( 2, 2, 0);                  
         }
         filldisplay(3, LED_h, 0);
         break;
      case M_SEC_DISP:
         dotdisplay(0,display_colon);
         dotdisplay(1,display_colon);
         filldisplay(2,(rtc_table[DS_ADDR_SECONDS]>>4)&(DS_MASK_SECONDS_TENS>>4),0);
         filldisplay(3,rtc_table[DS_ADDR_SECONDS]&DS_MASK_SECONDS_UNITS,0);
         break;
      case M_DATE_DISP:
         if (flash_01)
         {
            dotdisplay(1,1);
         }
         else
         {
            if (!CONF_SW_MMDD)
            {
               // десятки месяца (операция &MASK_TENS бесполезна, поскольку
               // старшие биты читаются как '0')
               filldisplay(0, rtc_table[DS_ADDR_MONTH]>>4, 0);
               filldisplay(1, rtc_table[DS_ADDR_MONTH]&DS_MASK_MONTH_UNITS, 1);
            }
            else
            {
               // десятки месяца (операция &MASK_TENS бесполезна, поскольку
               // старшие биты читаются как '0')
               filldisplay(2, rtc_table[DS_ADDR_MONTH]>>4, 0);
               filldisplay( 3, rtc_table[DS_ADDR_MONTH]&DS_MASK_MONTH_UNITS, 0);
            }
         }
         if (!flash_23)
         {
            if (!CONF_SW_MMDD)
            {
               // десятки дней (операция &MASK_TENS бесполезна)
               filldisplay(2, rtc_table[DS_ADDR_DAY]>>4, 0);
               // дни
               filldisplay(3, rtc_table[DS_ADDR_DAY]&DS_MASK_DAY_UNITS, 0);
            }
            else
            {
               // десятки дней (операция &MASK_TENS бесполезна)
               filldisplay( 0, rtc_table[DS_ADDR_DAY]>>4, 0);
               // дни
               filldisplay( 1, rtc_table[DS_ADDR_DAY]&DS_MASK_DAY_UNITS, 1);
            }
         }
         break;
      case M_WEEKDAY_DISP:
         filldisplay(1, LED_DASH, 0);
         // день недели (операция &MASK_UNITS бесполезна, потому что
         // старшие биты читаются как '0')
         filldisplay(2, rtc_table[DS_ADDR_WEEKDAY], 0);
         filldisplay(3, LED_DASH, 0);
         break;
      case M_TEMP_DISP:
         filldisplay(0, ds_int2bcd_tens(temp), 0);
         filldisplay(1, ds_int2bcd_ones(temp), 0);
         filldisplay(2, CONF_C_F ? LED_f : LED_c, 1);
         // -- температура определена как uint16, она не может быть < 0
         // if (temp < 0) filldisplay( 3, LED_DASH, 0);
         break;
      case M_DEBUG:
         filldisplay( 0, switchcount[0]>>4, S1_LONG);
         filldisplay( 1, switchcount[0]&15, S1_PRESSED);
         filldisplay( 2, switchcount[1]>>4, S2_LONG);
         filldisplay( 3, switchcount[1]&15, S2_PRESSED);
         break;
      }
      __critical { updateTmpDisplay(); }
      // сохранение конфигурации ram
      ds_ram_config_write(); 
      
      if (S1_PRESSED || S2_PRESSED && ! (S1_LONG || S2_LONG))
      {
         // попытка ослабить чрезмерно длинное нажатие кнопок
         _delay_ms(100);
      }
      // сброс при долгом нажатии кнопок, когда кнопка отпущена
      if (! S1_PRESSED && S1_LONG)
      {
         S1_LONG = 0;
      }
      if (! S2_PRESSED && S2_LONG)
      {
         S2_LONG = 0;
      }
      count++;
      WDT_CLEAR();
   }
}

/* ------------------------------------------------------------------------- */

make clean
make

c:\temp\stc_diyclock-master>make eeprom
sed -ne '/:..1/ { s/1/0/2; p }' main.hex > eeprom.hex
sed: -e expression #2, char 21: Extra characters after command