Модернизируем твёрдотельный лазер без регистрации и смс

//----------------------------------------------------------------------------------------------------
//подключаемые библиотеки
//----------------------------------------------------------------------------------------------------
#include "based.h"
#include "mt16s2d.h"

//----------------------------------------------------------------------------------------------------
//константы
//----------------------------------------------------------------------------------------------------

//----------------------------------------------------------------------------------------------------
//глобальные переменные
//----------------------------------------------------------------------------------------------------
extern char String[STRING_BUFFER_SIZE];//строка
volatile bool FireEnabled=false;//разрешение на вспышку

//****************************************************************************************************
//макроопределения
//****************************************************************************************************

//****************************************************************************************************
//порты обмена данными в режиме ведущего
//****************************************************************************************************

#define MISO_DDR      DDRB
#define MISO_PORT     PORTB
#define MISO_PIN      PINB
#define MISO          4

#define MOSI_DDR      DDRB
#define MOSI_PORT     PORTB
#define MOSI_PIN      PINB
#define MOSI          3

#define SCK_DDR      DDRB
#define SCK_PORT     PORTB
#define SCK_PIN      PINB
#define SCK          5

#define RW_DDR      DDRD
#define RW_PORT     PORTD
#define RW_PIN      PIND
#define RW          6

//****************************************************************************************************
//сигнал включения вспышки
//****************************************************************************************************

#define FIRE_DDR      DDRB
#define FIRE_PORT     PORTB
#define FIRE          2

//****************************************************************************************************
//сигнал включения зарядки
//****************************************************************************************************

#define CHARGING_DDR      DDRC
#define CHARGING_PORT     PORTC
#define CHARGING          5

//****************************************************************************************************
//включение лазера
//****************************************************************************************************

#define LASER_ENABLED_DDR      DDRC
#define LASER_ENABLED_PORT     PORTC
#define LASER_ENABLED_PIN      PINC
#define LASER_ENABLED          3


//----------------------------------------------------------------------------------------------------
//прототипы функций
//----------------------------------------------------------------------------------------------------
void InitAVR(void);//инициализация контроллера
uint16_t GetData(void);//считать данные

void MOSI_Hi(void);//выставить высокий уровень на выходе MOSI
void MOSI_Lo(void);//выставить низкий уровень на выходе MOSI
void SCK_Hi(void);//выставить высокий уровень на выходе SCK
void SCK_Lo(void);//выставить низкий уровень на выходе SCK
bool GetMISOState(void);//получить значение уровня на входе MISO
void FireEnable(void);//произвести вспышку
void FireDisable(void);//отключить вспышку
void ChargingEnable(void);//произвести зарядку
void ChargingDisable(void);//отключить зарядку
bool IsLaserEnabled(void);//получить, включён ли лазер

//----------------------------------------------------------------------------------------------------
//основная функция программы
//----------------------------------------------------------------------------------------------------
int main(void)
{ 
 InitAVR();
 _delay_ms(500);
 MT16S2D_Init();
 float fire_u=0; 
 _delay_ms(100);
 MT16S2D_SetTextUpLine("Вольтметр лазера");
 MT16S2D_SetTextDownLine("Ожидаю ответ МК1");
 
 ChargingDisable();
 FireDisable();
 
 while(1)
 {
  uint16_t value=GetData();
  float v=2.56*value/1023;//напряжение на измерительном резисторе
  const float r_measure=13000;//измерительный резистор
  const float r_ballast=10200000;//балластный резистор
  
  const float FIRE_U=800;//напряжение готовности к вспышке
  
  float i=v/r_measure;//ток в цепи
  float u=i*(r_measure+r_ballast);
  //фильтр даёт существенную задержку, поэтому показания для готовности к вспышке фильтруем иначе
  fire_u=0.5*fire_u+0.5*u;
  if (fire_u>FIRE_U)
  {
   cli();  
   FireEnabled=true;
   sei();
  }
  else
  {
   cli();  
   FireEnabled=false;
   sei();
  }
  u=fire_u;
  
  sprintf(String,"U,В:%i",(int)(u));
  MT16S2D_SetTextUpLine(String);
  const float c=2000E-6;//ёмкость батареи конденсаторов
  uint32_t e=(uint32_t)(c*u*u/2);
  sprintf(String,"E,Дж:%i",(int)e);
  MT16S2D_SetTextDownLine(String);
  _delay_ms(50);
 }
 return(0);
}
//****************************************************************************************************
//****************************************************************************************************
//общие функции
//****************************************************************************************************
//****************************************************************************************************


//----------------------------------------------------------------------------------------------------
//инициализация контроллера
//----------------------------------------------------------------------------------------------------
void InitAVR(void)
{
 cli(); 
 //настраиваем порты
 DDRB=0;
 DDRD=0; 
 DDRC=0;
 
 RW_DDR|=(1<<RW); 
 MOSI_DDR|=(1<<MOSI);
 SCK_DDR|=(1<<SCK);
 MISO_DDR&=0xff^(1<<MISO);
 
 FIRE_DDR|=(1<<FIRE);
 CHARGING_DDR|=(1<<CHARGING);
 LASER_ENABLED_DDR&=0xff^(1<<LASER_ENABLED);

 //задаём состояние портов
 PORTB=0x00;
 PORTD=0x00;
 PORTC=0x00;
 
 RW_PORT&=0xff^(1<<RW); 
 
 LASER_ENABLED_PORT|=(1<<LASER_ENABLED);//подтяжка входа разрешения работы лазера 
 
 //настраиваем таймер T0
 TCCR0=((0<<CS02)|(1<<CS01)|(0<<CS00));//выбран режим деления тактовых импульсов на 8
 TCNT0=0;//начальное значение таймера
 TIMSK=(1<<TOIE0);//прерывание по переполнению таймера (таймер T0 восьмибитный)
 
 
 sei(); 
}
//----------------------------------------------------------------------------------------------------
//считать данные
//----------------------------------------------------------------------------------------------------
uint16_t GetData(void)
{ 
 //отправляем сигнал, пока не получим 32 единицы после ноля
 uint8_t counter=0;
 bool zero=false;
 while(1)
 {
  SCK_Hi();
  _delay_ms(1);
  bool state=GetMISOState();
  SCK_Lo();
  _delay_ms(1); 
  if (zero==false)
  {
   counter=0;  
   if (state==false) zero=true;
   continue;
  } 
  if (state==true) counter++;//считаем единицы
  else//ошибка
  {
   counter=0;
   zero=false;
   continue;
  }
  if (counter==32) break;
 }
 //принимаем данные
 uint16_t mask=(1<<0);
 uint16_t value=0;
 for(int16_t n=0;n<sizeof(uint16_t)*8;n++,mask<<=1)
 {
  SCK_Hi();
  _delay_ms(1);
  bool state=GetMISOState();
  SCK_Lo();
  _delay_ms(1);
  if (state==true) value|=mask; 
 }
 return(value);
}

//----------------------------------------------------------------------------------------------------
//выставить высокий уровень на выходе MOSI
//----------------------------------------------------------------------------------------------------
void MOSI_Hi(void)
{
 MOSI_PORT|=(1<<MOSI);
}
//----------------------------------------------------------------------------------------------------
//выставить низкий уровень на выходе MOSI
//----------------------------------------------------------------------------------------------------
void MOSI_Lo(void)
{
 MOSI_PORT&=0xff^(1<<MOSI);
}

//----------------------------------------------------------------------------------------------------
//выставить высокий уровень на выходе SCK
//----------------------------------------------------------------------------------------------------
void SCK_Hi(void)
{
 SCK_PORT|=(1<<SCK);
}
//----------------------------------------------------------------------------------------------------
//выставить низкий уровень на выходе SCK
//----------------------------------------------------------------------------------------------------
void SCK_Lo(void)
{
 SCK_PORT&=0xff^(1<<SCK);
}

//----------------------------------------------------------------------------------------------------
//получить значение уровня на входе MISO
//----------------------------------------------------------------------------------------------------
bool GetMISOState(void)
{
 if (MISO_PIN&(1<<MISO)) return(true);
 return(false);
}
//----------------------------------------------------------------------------------------------------
//включить вспышку
//----------------------------------------------------------------------------------------------------
void FireEnable(void)
{
 FIRE_PORT|=(1<<FIRE);
}
//----------------------------------------------------------------------------------------------------
//отключить вспышку
//----------------------------------------------------------------------------------------------------
void FireDisable(void)
{
 FIRE_PORT&=0xff^(1<<FIRE);
}
//----------------------------------------------------------------------------------------------------
//произвести зарядку
//----------------------------------------------------------------------------------------------------
void ChargingEnable(void)
{
 CHARGING_PORT|=(1<<CHARGING);
}
//----------------------------------------------------------------------------------------------------
//отключить зарядку
//----------------------------------------------------------------------------------------------------
void ChargingDisable(void)
{
 CHARGING_PORT&=0xff^(1<<CHARGING);
}
//----------------------------------------------------------------------------------------------------
//получить, включён ли лазер
//----------------------------------------------------------------------------------------------------
bool IsLaserEnabled(void)
{
 if (LASER_ENABLED_PIN&(1<<LASER_ENABLED)) return(false);
 return(true);
}
//----------------------------------------------------------------------------------------------------
//обработчик вектора прерывания таймера T0 (8-ми разрядный таймер) по переполнению
//----------------------------------------------------------------------------------------------------
ISR(TIMER0_OVF_vect)
{
 //частота таймера 488 Гц (период 0,002048 секунды).

 TCNT0=0;
 static uint16_t counter=0; 
 
 if (counter>0)
 {
  counter--;
  return;
 }
 
 typedef enum 
 {
  MODE_WAIT,
  MODE_CHARGING, 
  MODE_FIRE,
  MODE_WAIT_FIRE
 } MODE; 
 
 static MODE mode=MODE_WAIT; 
 
 if (mode==MODE_WAIT)
 {
  FireDisable();
  if (IsLaserEnabled()==true) 
  {
   mode=MODE_CHARGING; 
   ChargingEnable();
   counter=300;//для напряжения 800 В нужно поставить 300
   //125 =550 В
   //250 =730 В
   //350 =860 В
   
   //U=1240*(1-exp(-t/295)), где t- время в тактах таймера
   return;
  }
 }
 
 if (mode==MODE_CHARGING)
 { 
  //if (FireEnabled==true)
  {
   ChargingDisable();
   mode=MODE_FIRE;
   counter=5;
   return;
  }
 }
 
 if (mode==MODE_FIRE)
 {
  FireEnable();
  counter=10;
  mode=MODE_WAIT_FIRE;
  return;
 } 
 
 if (mode==MODE_WAIT_FIRE)
 {
  FireDisable();
  if (FireEnabled==false)
  {
   mode=MODE_WAIT; 
   counter=5;
   return;
  }
  counter=10;
  mode=MODE_FIRE;
  return;
 } 
}