/**Программа ручного и автоматического управления 
   RGB светодиодами.*/

//Подключаем необходимые библиотеки
#include "GenericHID.h"
#include <avr/iobits.h>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <util/delay.h>
#include <avr/interrupt.h>

//Определяем переменные
float red,green,yellow,blue; //Новые цвета
unsigned int tred,tgreen,tyellow,tblue;	//Исходные цвета
//Величина прибавки за шаг
float delta_red,delta_green,delta_yellow,delta_blue;     
unsigned int time; //Длительность шага
unsigned int temp1,temp2,temp3,temp4,temp5,temp6;
//Режим работы Автомат-1, ручной-2, ЦМУ-3, по времени-4, выкл=0, 
unsigned char regim;
unsigned char result;
unsigned char R1,G1,Y1,B1;        //Основные цвета
unsigned char R2,G2,Y2,B2;                  
unsigned char Rf,Gf,Yf,Bf;       //Цвет фона
unsigned char dRf,dGf,dYf,dBf;   //Для плавного включения фона 
unsigned char zmax, zmin, tim;   //Задержки
unsigned int hizat;              //Затухание старший байт
unsigned char lozat;             //Затухание младший байт
unsigned int hizatf;   //Задержка фона (плавность) старший байт  
unsigned char lozatf; //Задержка  фона (плавность) младший байт  
/** В связи с тем, что программный генератор случайных чисел при каждом новом запуске генерирует одну и ту же последовательность импульсов, мы ввели процедуру начальной установки этого генератора при помощи простейшего АЦП. Он принимает на входе шумы и наводки и выдает практически случайное число, которым мы и выполним начальную установку функции SRAND. Вкратце принцип работы этого АЦП таков. На один из входов компаратора подается линейно-нарастающее напряжение зарядки конденсатора С5, а второй вход "висит" в воздухе, т.е. на нем имеются наводки.Включается таймер и компаратор. В момент совпадения потенциалов на обоих входах компаратора таймер останавливается и его значение используется для установки SRAND.*/
//Определяем п/п прерывания компаратора.     
ISR(ANALOG_COMP_vect )   
{
  result = TCNT0;        //Загрузка значения таймера 0
  TCCR0B = 0;            //Остановим таймер         
  CLRBIT(PORTC,PC2);     //Запуск разрядки конденсатора
  srand(result);         //Инициализируем функцию SRAND
}

/**Буфер для хранения HID репорта*/
static uint8_t PrevHIDReportBuffer[GENERIC_REPORT_SIZE];

/**Интерфейс конфигурации*/
USB_ClassInfo_HID_Device_t Generic_HID_Interface =
	{
	.Config =
		{
		.InterfaceNumber              = 0,
		.ReportINEndpointNumber       = GENERIC_IN_EPNUM,
		.ReportINEndpointSize         = GENERIC_EPSIZE,
		.ReportINEndpointDoubleBank   = false,
		.PrevReportINBuffer           = PrevHIDReportBuffer,
		.PrevReportINBufferSize       = sizeof(PrevHIDReportBuffer),
		},
	};
 
 /** П/п Генерация яркости, max 255. Случайным образом выбираем цвета и если они примерно равны генерим снова*/
void generate_tagert_color(void)      
{
	do 
      {
        tred = rand() & 0xFF;
        tgreen = rand() & 0xFF;
        tyellow = rand() & 0xFF;
        tblue = rand() & 0xFF;
        temp1 = (abs(tred - tgreen));
        temp2 = (abs(tred - tyellow));
        temp3 = (abs(tred - tblue));
        temp4 = (abs(tgreen - tyellow));
        temp5 = (abs(tgreen - tblue));
        temp6 = (abs(tyellow — tblue));
/**Так как здесь наша программа может "закрутиться" надолго (относительно конечно), то введем проверку "активности шины USB, чтобы не пропустить что нибудь интересное*/
		HID_Device_USBTask(&Generic_HID_Interface);
		USB_USBTask();			
       }
	while (( temp1 < 150 ) && (temp2 < 150) && (temp3 < 150) && (temp4 < 150) && (temp5 < 150) && (temp6 < 150)); 
};

/**задержка delay_ms() на вход принимает только константу*/
void delay(unsigned int delayt) 
{
  while (delayt != 0)
  {
/**Если работает автомат, то в период задержки нужно часто опрашивать USB*/	
		HID_Device_USBTask(&Generic_HID_Interface);
		USB_USBTask();	
    _delay_ms(1);
    delayt--;
/**Если вдруг сменился режим то закончим задержку досрочно*/
	 if(regim==0 || regim==2 || regim==3)  
	  {
		return;
	  }
  };
};


/** Главная программа */
int main(void)
{
/** Настройка АЦП и генерация начальной установки SRAND. После срабатывания этого блока будет произведена начальная установка генератора случайных чисел случайным числом (вот такой каламбур).*/ 

 ACSR = 0x0B;       // Разрешение работы и прерывания компаратора
 DDRC=(1<<DDC2);    // Настройка линии заряда/разряда как выход
 sei();
 TCCR0B = 2;        // Запуск таймера 0 с предделением на 8
 SETBIT(PORTC,PC2); // Включение режима заряда конденсатора
 _delay_ms(200);

/** Начальная установка контроллера. */

cli();
	SetupHardware();
	LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
	result=0;   // Флаг окончания процедуры подключения к USB
	sei();
	regim=1;      //Флаг режима (1 - автомат)
	hizat=1000;
	hizatf=1000;


  
/** Главный, непрерывный цикл.*/
main:
		for (;;)
	{
// Опрашиваем USB максимально часто.	  
		HID_Device_USBTask(&Generic_HID_Interface);
		USB_USBTask();
/**----------------- Выключим светодиоды ------------------*/		
     if (regim==0)
      {
	       OCR1AL=0;
	       OCR1BL=0;
        OCR1CL=0;
		  OCR0B=0;
      };
/**------------------ Ручной режим -----------------------*/
	 if (regim==2)            
	  {
	    OCR1AL=R1;
	    OCR1BL=G1;
	    OCR0B=Y1;
	    OCR1CL=B1;
	  };		
/**---------- Режим Автоматический и По времени ----------*/	
	if (regim==1 || regim==4) 
	 {
//Генерируем начальный цвет
   generate_tagert_color();  
// С вероятностью 0,4 (32767) вышибаем один цвет
 if (rand() < 13100)     
  {  
   do
   {
    temp4 = rand() & 0x0F ; //Определяем, какой цвет будем гасить
   }
   while ((temp4 == 0) || (temp4 > 4));
//Красный		  
   if (temp4 == 1)    
    {                   
     do
      {
       temp4 = rand() & 0x0FFF;
      }
     while ((temp4 == 0) || (temp4 > 3276));
     tred = ceil((float)(temp4 / 32767) * tred);
    };
// Зеленый
	  if (temp4 == 2)   
    {
     do
      {
        temp4 = rand() & 0x0FFF;
      }
     while ((temp4 == 0) || (temp4 > 3276));
     tgreen = ceil((float)(temp4 / 32767) * tgreen);
    };
// Желтый
	  if (temp4 == 3)   
    {
     do
      {
        temp4 = rand() & 0x0FFF;
      }
     while ((temp4 == 0) || (temp4 > 3276));
     tyellow = ceil((float)(temp4 / 32767) * tyellow);
    };
// Синий
	  if (temp4 == 4)    
    {
     do
      {
        temp4 = rand() & 0x0FFF;
      }
     while ((temp4 == 0) || (temp4 > 3276));
     tblue = ceil((float)(temp4 / 32767) * tblue);
    };
   }; 
//Находим значение прибавки. доходим до нужного цвета за 255 шагов
       delta_red = (float)(tred - red) / 255;
       delta_green = (float)(tgreen - green) / 255;
       delta_yellow = (float)(tyellow - yellow) / 255;
       delta_blue = (float)(tblue - blue) / 255;
	   
/**Выбор времени задержки. Если от РС нет данных, то устанавливаем задержки по умолчанию, а если есть, то пользуемся принятыми. Этот блок работает в режиме Автомат */
      if (zmax==0 || zmin==0)
        {     
		    zmax=39;
			zmin=5;
        };
	      do
        {
          time = rand() & 0x00FF;
        }
       while ((time < zmin) || (time > zmax)); 	  
		  
/**Если включен режим По времени, то установим время изменения цвета, которое пришло из РС */ 
      if (regim==4) time=tim;
//Продолжим программу. Установим цвета для вывода и выдадим их 	
		do 
       {
        if (tred != ceil(red))
		   {
		    red = red + delta_red;
		   };
        if (tgreen != ceil(green))
         {
          green = green + delta_green;
		   };	
        if (tyellow != ceil(yellow))
         {
          yellow = yellow + delta_yellow;
		   };	
        if (tblue != ceil(blue))
		   {
		     blue = blue + delta_blue;
		   };
      OCR1CL = ceil(blue);  
		OCR1BL = ceil(green);  
		OCR1AL = ceil(red);
      OCR0B = ceil(yellow);
//Чуток ожидаем (это скорость изменения цвета).
      delay(time);
/**Если вдруг включили режим ЦМУ, то досрочно выходим из Автомата. Это сделано для более быстрого переключения режимов.*/
	     if(regim==3) goto main;
     }
  while ((tred != ceil(red)) || (tgreen != ceil(green)) || (tyellow != ceil(yellow)) || (tblue != ceil(blue)));
//В режиме Автомат задержим установленные цвета.
   if (regim==1) delay(time * 255); 
//В режиме По времени ничего задерживать не нужно.
	  if(regim==4) goto main;
 };    
/**------------ Конец автоматического режима -------------------*/
	  
/**-------------------- Режим ЦМУ -----------------------------*/
	 if (regim==3)
	  {
//Если музыки нет, включить фон
	    if((R1==0) && (G1==0) && (Y1==0) && (B1==0)) goto pause;
/**Определим соотношения предыдущей и вновь принятой яркости и примем решение, как нам ее изменить.*/
//Красный канал	  
//Если новое значение больше ранее установленного	    
if (R2<R1)
 {
  do
	  {
//Поднимаем яркость от ранее установленной до вновь принятой
	    OCR1AL=R2;
	    R2=R2+1;
	  } 	
	 while (R2>R1);
	};
//Если новое значение меньше ранее установленного	 
	if (R2>R1)
  {
	  do
	   {
/**Снижаем яркость до вновь принятой с задержкой.(Параметр затухание)*/ 
	    OCR1AL=R2;
	    R2=R2-1;
		_delay_us(hizat);
	   } 	
	   while (R2<R1);
	 };
	//И если значения равны то ничего не меняем.
   if (R2==R1)
     {
		 OCR1AL=R1;
	    };
//Зеленый канал	(все аналогично красному).	  
	 if (G2<G1)
   {
	   do
	    {
	     OCR1BL=G2;
		G2=G2+1;
	    }	
	   while (G2>G1);
	  };
	 if (G2>G1)
   {
	   do
	   {
	     OCR1BL=G2;
		G2=G2-1;
		_delay_us(hizat);
	   }	
	   while (G2<G1);
	  };		
	 if (G2==G1)
   {
	    OCR1BL=G1;
	  };
//Желтый канал		  
	if (Y2<Y1)
  {
	  do
	   {
	    OCR0B=Y2;
	    Y2=Y2+1;
	   }	
	   while (Y2>Y1);
	  };
	 if (Y2>Y1)
   {
	   do
	    {
	     OCR0B=Y2;
		Y2=Y2-1;
		_delay_us(hizat);
	    }	
	   while (Y2<Y1);
	  };		
	 if (Y2==Y1)
   {
	    OCR0B=Y1;
	  };
//Синий канал
  if (B2<B1)
   {
    do
	   {
	     OCR1CL=B2;
		B2=B2+1;
	   }	
	   while (B2>B1);
	  };
	 if (B2>B1)
   {
	   do
	    {
	     OCR1CL=B2;
		B2=B2-1;
		_delay_us(hizat);
	    }	
	   while (B2<B1);
	  };		
	 if (B2==B1)
   {
	    OCR1CL=B1;
	  };
//--------------------- Пауза ---------------------------------
pause:
        if((R1==0) && (G1==0) && (Y1==0) && (B1==0))
/**Включим плавненько фон. Аналогично вышеописанному. Если Значение яркости фона < того, что было до этого, то досчитываем яркость фона без задержки, а если >, то снижаем яркость с задержкой*/
 		 {
 //Красненький		 
            if((Rf>0) && (R1=Rf))
            {  	   
			   OCR1AL=R1;
			};
            if((Rf>0) && (R1>Rf))
            {  	   
             while(R1>Rf)
			  {
			   OCR1AL=R1;
               R1=R1-1;  			 
			   _delay_us(hizatf);
			  }
			};
            if((Rf>0) && (R1<Rf))
            {  	   
             while(R1<Rf)
			  {
			   OCR1AL=R1;
               R1=R1+1;  			 
			   _delay_us(hizatf);
			  }
			};
//Зелененький			
            if((Gf>0) && (G1=Gf))
            {  	   
			   OCR1BL=G1;
			};
            if((Gf>0) && (G1>Gf))
            {  	   
             while(G1>Gf)
			  {
			   OCR1BL=G1;
               G1=G1-1;  			 
			   _delay_us(hizatf);
			  }
			};
            if((Gf>0) && (G1<Gf))
            {  	   
             while(G1<Gf)
			  {
			   OCR1BL=G1;
               G1=G1+1;  			 
			   _delay_us(hizatf);
			  }
			};
//Желтенький			
            if((Yf>0) && (Y1=Yf))
            {  	   
			   OCR0B=Y1;
			};
            if((Yf>0) && (Y1>Yf))
            {  	   
             while(Y1>Yf)
			  {
			   OCR0B=Y1;
               Y1=Y1-1;  			 
			   _delay_us(hizatf);
			  }
			};
            if((Yf>0) && (Y1<Yf))
            {  	   
             while(Y1<Yf)
			  {
			   OCR0B=Y1;
               Y1=Y1+1;  			 
			   _delay_us(hizatf);
			  }
			};
//Синенький			
            if((Bf>0) && (B1=Bf))
            {  	   
			   OCR1CL=B1;
			};
            if((Bf>0) && (B1>Bf))
            {  	   
             while(B1>Bf)
			  {
			   OCR1CL=B1;
               B1=B1-1;  			 
			   _delay_us(hizatf);
			  }
			};
            if((Bf>0) && (B1<Bf))
            {  	   
             while(B1<Bf)
			  {
			   OCR1CL=B1;
               B1=B1+1;  			 
			   _delay_us(hizatf);
			  }
			};					
         }; 	  		  
      };
	}
}
/**Конфигурируем контроллер*/
void SetupHardware(void)
{
//Настройка выводов PWM на выход
  PORTC=0x00;
  PORTB=0x00;
  PORTD=0x00;
  DDRC=0x60;
  DDRB=0x80;
  DDRD=0x11;
//Настроим таймер1 для PWM
  TCCR1A=0xA9;
  TCCR1B=0x01;
//Настроим таймер0 для PWM
  TCCR0A=0x21;
  TCCR0B=0x01;  
//Сбросим регистры PWM
  OCR1AL=0;
  OCR1BL=0;
  OCR1CL=0;
  OCR0B=0;
//Выключим "собаку" 
	MCUSR &= ~(1 << WDRF);
	wdt_disable();
//Никаких делителей
	clock_prescale_set(clock_div_1);

//Инициализация контрольного светодиода и шины USB
	LEDs_Init();
 USB_Init();
}

/** USB функции, не разъясняю, пишем на веру, как есть */
void EVENT_USB_Device_Connect(void)
{
	LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
}
void EVENT_USB_Device_Disconnect(void)
{
	LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
}
void EVENT_USB_Device_ConfigurationChanged(void)
{
	  bool ConfigSuccess = true;
       ConfigSuccess&=HID_Device_ConfigureEndpoints(&Generic_HID_Interface);
   USB_Device_EnableSOFEvents();
   LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY :  LEDMASK_USB_ERROR);
}
void EVENT_USB_Device_ControlRequest(void)
{
	HID_Device_ProcessControlRequest(&Generic_HID_Interface);
}
void EVENT_USB_Device_StartOfFrame(void)
{
	HID_Device_MillisecondElapsed(&Generic_HID_Interface);
}

/** Функция передачи данных хосту. Можно передать 8 байт. */
bool CALLBACK_HID_Device_CreateHIDReport
                           (USB_ClassInfo_HID_Device_t* 
                            const HIDInterfaceInfo,
                            uint8_t* const ReportID,
                            const uint8_t ReportType,
                            void* ReportData,
                            uint16_t* const ReportSize)
{
	uint8_t *ReportData_u8 = (uint8_t *)ReportData;

//Выдача на РС позиции цветов и времени задержки 
	ReportData_u8[0] = red;
	ReportData_u8[1] = green;
	ReportData_u8[2] = yellow;
	ReportData_u8[3] = blue;
	ReportData_u8[4] = time;
// Выдача на РС версии котроллера.
	ReportData_u8[5] = SW_H;
	ReportData_u8[6] = SW_L;
//Просто пустой байт
	ReportData_u8[7] = 0;
	*ReportSize = GENERIC_REPORT_SIZE;
	result=1;
	return true;
}

/** Функция приема данных от хоста. Можно принять 16 байт*/
void CALLBACK_HID_Device_ProcessHIDReport
                        (USB_ClassInfo_HID_Device_t* 
                         const HIDInterfaceInfo,
                         const uint8_t ReportID,
                         const uint8_t ReportType,
                         const void* ReportData,
                         const uint16_t ReportSize)
{
	uint8_t *ReportData_u8 = (uint8_t *)ReportData;
	
// Получим новые значения	
	R1=ReportData_u8[0];  //Основные цвета
	G1=ReportData_u8[1];
	Y1=ReportData_u8[2];
	B1=ReportData_u8[3];
	Rf=ReportData_u8[4];  //Цвета фоновой подсветки
	Gf=ReportData_u8[5];
	Yf=ReportData_u8[6];
	Bf=ReportData_u8[7];
	regim=ReportData_u8[8];    //Режим работы
	zmax=ReportData_u8[9];     //Макс. задержка
	zmin=ReportData_u8[10];    //Мин. задержка
	tim=ReportData_u8[11];     //Задержка перелива
	hizat=ReportData_u8[12];   //Затухание Hi
	lozat=ReportData_u8[13];   //Затухание Lo
	hizatf=ReportData_u8[14];  //Плавность включения фона Hi
	lozatf=ReportData_u8[15];  //Плавность включения фона Lo

//Определим значения задержек затухания цветов и фона
 hizat=hizat*256+lozat;	
	hizatf=hizatf*256+lozatf;
}