File content as of revision 142:7a6f68601291:

//ssdfwewedfsfds
/****************************************Copyright (c)****************************************************
**--------------File Info---------------------------------------------------------------------------------
** File name:           main.c
** Last modified Date:  2011-10-24
** Last Version:        V1.00
** Descriptions:        The main() function
**
**--------------------------------------------------------------------------------------------------------
** Created by:          Electrooptica Incorp.
** Created date:        2011-08-22
** Version:             V1.00
** Descriptions:
**--------------------------------------------------------------------------------------------------------
последнии изменения
//2016_02_03_17_47
//2016_02_06 igor
//2016_06 Dima
//2016_02_06 21:20 Kovalev_D
*********************************************************************************************************/


#include "Global.h"
//#include <math.h>
#include "Device.h"
//#include "IAP.h"
/******************************************************************************
**   Main Function  main()
******************************************************************************/
extern Device device; //Single global for all device hardware-independent algorithm
#define	IMG_START_SECTOR	0x00010000	/* Sector 16 */
#define	IMG_END_SECTOR		0x00017FFF	/* Sector 20 */

/*
#define	IMG_START_SECTOR	0x00030000//0x00010000	/* Sector 16 
#define	IMG_END_SECTOR		0x00037FFF	*/
unsigned int addres;

uint32_t Result[5];
extern uint32_t CMD_Mode;
unsigned int  secPuls;
float DACF, K_DAC;
int tempAMP;
int temp;
//unsigned int    *Add;

unsigned int status;
unsigned int Para;
int main (void)
{
int ttemp;

unsigned int TempA;
SystemInit1();  // Инициализация контроллера: установка тактовых частот
addres = 0x10000;


    //FlashDMA_Init(); 		  // Загрузка параметров с флэш
    SystemCoreClockUpdate1(); // расчет тактовой частоты процессора перед инициализацией UART - 100MHz



    GLD_Init();
    ///////////старый UART
//    UARTInit();				  // инициализация  UART0 на скорость 38400.
//    UART1_Init();             // инициализация  UART1 на скорость 38400.


      UART_InitSet (0, 921600, 0x03);  // надо проверить, мож чо с ногам
   // UART_InitSet (1, 921600, 0x03);
      UART_InitSet (1, 115200, 0x03);
    
    ////////////
    //DAC_ADC_Exchange_Init();  // инициализация  обмена АЦП и ЦАП.

    IntLatch_Init();		  // инициализация внутренней защелки.
    ExtLatch_Init();		  // инициализация внешней защелки.
    LoadFlashParam(FromFLASH); 	//загрузка параметров.

   // open_all_loops();                          //#define open_all_loops()			RgConA   = 0	(Основной регистр управления устройства (0 - включить, 1 - отключить)).
  //  Output.Str.HF_reg = Device_blk.Str.HF_min; //HFO output voltage = максивальное напряжение на ГВЧ.
    init_PLC();                                //Инициализация СРП(регулировка периметра)
    init_Dither_reg();                         //инициализация вибропривода
  //  RgConB = RATE_VIBRO_1; // дополнительный регистр управления = разность вибросчетчиков после фильтра скольз.среднего(#define RATE_VIBRO_1	0x0001)
 //   close_all_loops();

    Out_G_photo(200,200);        //запись в буфер мастера принятые от функции данные (60,60) и установка флага старта передачи и занятой шины.

    WriteCon1("\n\r ...GL start programm uart ACK.... ");
    WriteCon("\n\r ...GL start programm uart Tech.... ");
    sprintf(Time,"\r\nCompiled: %s %s.",__DATE__,  __TIME__ );                 //Подготовка даты и времени компиляции
    WriteCon(Time);

Gyro.PLC_Error2Mode = 10;  // начальная задержка (неработает СРП)

    while ( 1 ) { //основной цикл.
  
     	G_Photo_Exchange();	
        Concol ();				// Проврка 0 консоли  (вход и выход)
        Concol1 ();		        // Проврка 0 консоли  (вход и выход)
        Read_CMD();	
        if (OutBufConCount)  OutBufConCount--;
        if (OutBufCon1Count)  OutBufCon1Count--;
        
        if (ReadCon (Time)) {
/////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
//////////////////////Выбор FlashMod///////////////////////////
////////////////////////////////////////////////////////////////

            if (Time[0] == 'B') {
                Gyro.FlashMod=1;
            }  
             if (Time[0] == 'W') {
                Gyro.FlashMod=2;
            }
            if (Time[0] == 'R') {
                Gyro.FlashMod=3;
            }

         
///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////

            if (Time[0] == 'H') { // если ввели буквц h то выдать подсказку. сделанно через принф ОЧЕНЬ плохо в работе не использовать
                sprintf(Time,"\r\nCompiled: %s %s.",__DATE__,  __TIME__ );                 //Подготовка даты и времени компиляции
                WriteCon(Time);
                sprintf(Time,"--%d.%3.d.%2.d.",Time1Hz,Time1K,Time100K);                 //Временно выдачпа временни из трех чисел
                WriteCon(Time);
            }
            if (Time[0] == 'D') {
                Gyro.Discharg = StartDischarg;
            }
            if (Time[0] == 'L') {
                Gyro.BackLight = StartBackLight;
            }
            
             if (Time[0] == 'F') {		// выдача технологическая
                sprintf(Time,"\r\n");
                WriteCon(Time);
                sprintf((Time)," <%07d>   <%07d>",Gyro.F_ras,Param2);
                WriteCon(Time);
            }   
            
             if (Time[0] == 'q') {		// внешняя защелка
                Gyro.EXT_Latch=1;
            }   
          if (Time[0] == '1') {		// выдача технологическая
                sprintf(Time,"\r\n");
                WriteCon(Time);
                for (int i = 0; i < 32; i++ )sprintf((Time + i * 9)," <%05d> ",Buff_1Point[i]);
                WriteCon(Time);
            }
            
               if (Time[0] == '2') {		// выдача технологическая
                sprintf(Time,"\r\n");
                WriteCon(Time);
                for (int i = 0; i < 32; i++ )sprintf((Time + i * 9)," <%05d> ",    Buff_8Point[i]);
                WriteCon(Time);
            }
                if (Time[0] == '3') {		// выдача технологическая
                sprintf(Time,"\r\n");
                WriteCon(Time);
                for (int i = 0; i < 32; i++ )sprintf((Time + i * 9)," <%05d> ",    Buff_16Point[i]);
                WriteCon(Time);
            }
            
             if (Time[0] == '4') {		// выдача технологическая
                sprintf(Time,"\r\n");
                WriteCon(Time);
                for (int i = 0; i < 32; i++ )sprintf((Time + i * 9)," <%05d> ",    Buff_16PointD[i]);
                WriteCon(Time);
            }
 


                      if (Time[0] == 'z') {		// выдача технологическая
                sprintf(Time,"\r\n");
                WriteCon(Time);
           
                  for (int i = 0; i < 32; i++ ) 
                  { 
                  ttemp=(Buff_16PointD[i]);
                  if (ttemp < 0) WriteCon("1"); else WriteCon("0");
                  }
       
            }
           
            
              if (Time[0] == '5') {		// выдача технологическая
                sprintf(Time,"\r\n");
                WriteCon(Time);
                for (int i = 0; i < 32; i++ )sprintf((Time + i * 9)," <%05d> ",Buff_32Point[i]);
                WriteCon(Time);
            }
           
              if (Time[0] == '6') {		// выдача технологическая
                sprintf(Time,"\r\n");
                WriteCon(Time);
                for (int i = 0; i < 32; i++ )sprintf((Time + i * 9)," <%05d> ",Buff_Restored_sin[i]);
                WriteCon(Time);
            }       
            
            
            
                if (Time[0] == 'c') {		// выдача технологическая
                sprintf(Time,"\r\n");
                WriteCon(Time);
                sprintf((Time)," <%07d> <%07d> <%07d> <%07d>", Gyro.F_ras,Gyro.F_ras/16, Gyro.Cnt_Pls, Gyro.Cnt_Mns);
                WriteCon(Time);
            }   
            
            
            
           if (Time[0] == '7') {		// выдача технологическая
                sprintf(Time,"\r\n");
                WriteCon(Time);
                for (int i = 0; i < 32; i++ )sprintf((Time + i * 10)," <%07d> ",Buff_AMP64P[i]-(Buff_AMP[i]));
                WriteCon(Time);
            }
               if (Time[0] == '9') {		// выдача технологическая
                sprintf(Time,"\r\n");
                WriteCon(Time);
                for (int i = 0; i < 32; i++ )sprintf((Time)," <%07d> ",Gyro.Frq);
                WriteCon(Time);
            }
            
            if (Time[0] == 'p') {		// выдача технологическая
                sprintf(Time,"\r\n");
                WriteCon(Time);
                for (int i = 0; i < 32; i++ )sprintf((Time)," <%07d> ",Cur_Amp);
                WriteCon(Time);
            }
             if (Time[0] == 'm') {		// выдача технологическая
               sprintf(Time,"\r\n");
               WriteCon(Time);
             //  sprintf((Time),"Cur_Amp  <%07d> ",	Cur_Amp);  	WriteCon(Time);              
           //    sprintf((Time),"Znak_Amp  <%07d> ",	Znak_Amp);  	WriteCon(Time);
            //   sprintf((Time),"AD_Regul  <%07d> ",	AD_Regul);  	WriteCon(Time);
               
                sprintf((Time),"PLC_Delta  <%07d> ",	Gyro.PLC_Delta);  	    WriteCon(Time);
                sprintf((Time),"PLC_DeltaADD  <%07d> ",	Gyro.PLC_DeltaADD);  	WriteCon(Time);
  //         	printf((Time),"AD_Regul  <%07d> ",	Delta);  	WriteCon(Time);               
              
//               sprintf((Time),"Spi.DAC_B  <%07d> ",Spi.DAC_B);  WriteCon(Time);*/
//               sprintf((Time),"MaxAmp  <%07d> ", MaxAmp);  WriteCon(Time);
 //              sprintf((Time),"CaunAddPlus  <%07d> ", CaunAddPlus);  WriteCon(Time);
 //              sprintf((Time),"CaunAddMin  <%07d> ",  CaunAddMin);  WriteCon(Time);
//               sprintf((Time)," Gyro.Amp <%07d> ",amp);  WriteCon(Time);

            }
          if (Time[0] == 'V') {		// выдача технологическая
            //    Gyro.Frq+=65000;
            Spi.DAC_B += 200;
            
            }
          if (Time[0] == 'v') {		// выдача технологическая
              //Gyro.Frq-=65000;
               Spi.DAC_B -= 200;
            }
       /*     
         if (Time[0] == 'Y') {		// выдача технологическая
              Log=1;
            }*/
            
            
            
       ////////////////////////////////////////////////////////////////////////////////   
                      /*Запись лога настройки частоты*/
            if (Time[0] == 'y')   Gyro.LogHZ=1;           //включит передачу
            if (Time[0] == 'u')   Gyro.StrayHZ_flag = 1;  //LPC_TIM1->MR0+1000  вносим помеху        
            if (Time[0] == 'i')   Gyro.StrayHZ_flag = 0;  //LPC_TIM1->MR0       убираем помеху  
            if (Time[0] == 'o')   Gyro.LogHZ=0;           //Отключить передачу
       ////////////////////////////////////////////////////////////////////////////////////     
                      /*Запись лога настройки периметра*/
            if (Time[0] == 'g')   Gyro.LogPLC=1;           //включит передачу
            if (Time[0] == 'h')   Gyro.StrayPLC_flag = 1;  //LPC_TIM1->MR0+1000  вносим помеху
            if (Time[0] == 'j')   Gyro.StrayPLC_flag = 0;  
            if (Time[0] == 'b')   Gyro.StrayPLC_flag = 3;  //LPC_TIM1->MR0-1000  вносим помеху
            if (Time[0] == 'n')   Gyro.StrayPLC_flag = 2;  //LPC_TIM1->MR0       убираем помеху  
            if (Time[0] == 'k')   Gyro.LogPLC=0;           //Отключить передачу
           
      //////////////////////////////////////////////////////////////////////////////////////     
            
  
                if (Time[0] == '8') {		// выдача технологическая
                sprintf(Time,"\r\n");
                WriteCon(Time);
            //  for (int i = 0; i < 32; i++ )sprintf((Time + i * 9)," <%05d> ",Buff_AMP64P[i]-(Buff_AMP[i]*2));
                  for (int i = 0; i < 32; i++ ) 
                  { 
                  ttemp=(Buff_AMP64P[i]-(Buff_AMP[i]));
                  if (ttemp < 0) WriteCon("1"); else WriteCon("0");
                  }
            //   WriteCon(Time);
            }
            
                 if (Time[0] == 'b') {		// выдача технологическая
                sprintf(Time,"\r\n");
                WriteCon(Time);
           
                  for (int i = 0; i < 32; i++ ) 
                  { 
                  ttemp=(Buff_Restored_sin[i]);
                  if (ttemp < 0) WriteCon("1"); else WriteCon("0");
                  }
       
            }
           
                 if (Gyro.PLC_Error2Mode) {		// выдача технологическая
                sprintf(Time,"\r\nPLC_Error2Mode");
                WriteCon(Time);
                }
            
        }
        
    
          
        Event_100KHz();
        Event_1KHz();
        Event_500Hz();
        Event_1Hz();
        
        Event_Vibro();
        
	 switch(Gyro.ModeOut) {
     case 1:
            if(Gyro.Rate1_Event==1)CMD_Rate();
     break;  
     case 2:
            if(Gyro.Rate2_Event==1)CMD_Rate2();
     break;   
     case 3:
            if(Gyro.Delta500_Event==1)CMD_Delta_500Hz();
     break;   
     case 4:
            if(Gyro.EXT_Latch==1){CMD_Delta_Ext();}
     break;       		   		
     } 
	if (Spi.ADC_NewData == 1)  // был приход новых данных по ацп сдесь сделать обработку информации и подготовку для выдачи делается 1 раз за вибро
	{
// можно апихнкть в функцию
		Spi.ADC_NewData = 0;	
		Gyro.Termo 	= Spi.ADC1;
		Gyro.In1   	= Spi.ADC2;
		Gyro.In2   	= Spi.ADC3;
		Gyro.DeltaT = Spi.ADC4;
		TempA = (0x7fff - Spi.ADC5) << 1;  		// перевернем знак  и умножим на два (бало 32000...0 стало 0 ...64000)

		Gyro.ADF_Accum += TempA;
		Gyro.ADS_Accum += TempA;
		Gyro.ADF_Count ++;
		Gyro.ADS_Count ++;

		if (Gyro.ADF_Count > 15)					// если прошло 16 тактов виброподвеса
		{
			Gyro.AD_Fast = Gyro.ADF_Accum << 12;	//обновляем данные и приводим в один масштаб
			Gyro.ADF_Count = 0;
			Gyro.ADF_Accum = 0;
			Gyro.ADF_NewData = 1;
		}
		if (Gyro.ADS_Count > 255)					// если прошло 256 тактов виброподвеса
		{
			Gyro.AD_Slow = Gyro.ADS_Accum << 8;		//обновляем данные и приводим в один масштаб
			Gyro.ADS_Count = 0;
			Gyro.ADS_Accum = 0;
			Gyro.ADS_NewData = 1;
		}
	}
	



	if (Gyro.ADF_NewData == 1)  // был приход новых данных После быстрого фильтра AD
	{
		Gyro.ADF_NewData = 0;
	}// можно запихнкть в функцию
	
	if (Gyro.ADS_NewData == 1)  // был приход новых данных После Медленного фильтра AD
	{

		Gyro.ADS_NewData = 0;
		PlcRegul();//Расчет	
		
	

	}// можно запихнкть в функцию
	
    if(Gyro.VibroFrqRegulF == 1)		//Регулеровка частоты виброподвеса
    {
    	  Gyro.VibroFrqRegulF = 0;
    	  VibroFrqRegul();
    }

    if(Gyro.VibroAMPRegulF == 1)		//Регулеровка Амплитуды виброподвеса
    {
    	  Gyro.VibroAMPRegulF = 0;
    	  VibroAMPRegul();
    }
    if(Gyro.VibroNoiseF == 1)			//регулеровка ошумления, наверно нужно объеденить с регулеровкой ампитуды
    {
    	  Gyro.VibroNoiseF = 0;
    	  CalcAmpN();
    }

    if(Gyro.VibroOutF== 1)				// установка ног в регисторе тоже подумать , зачем отделный флаг? наверно
    {
    	  Gyro.VibroOutF = 0;
    	  VibroOut();				//Чтение ADS_SPI
    }
    
    if( (Gyro.LogHZ == 1)&&(CountV31==0))				// установка ног в регисторе тоже подумать , зачем отделный флаг? наверно
    {
    	 
    	 // Gyro.Test_time1++;
    	/*  if(Gyro.Test_time1==4)
    	  {*/
    	  sprintf((Time),"%d \r\n",LPC_TIM1->MR0);
          WriteCon(Time);
        //  Gyro.Test_time++;
         /* Gyro.Test_time1=0;
          }*/
          
    }
   //&Gyro.Firmware_Version
/////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////Работа с Flash//////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////
 if(Gyro.FlashMod == 1)		
 {    		   
 	
 	/*	Prepare Sectors to be flashed */
    NVIC_DisableIRQ(TIMER1_IRQn);
    NVIC_DisableIRQ(TIMER2_IRQn);
 	NVIC_DisableIRQ(TIMER3_IRQn);
 	NVIC_DisableIRQ(EINT3_IRQn);
//SCB->VTOR = 0x00A000;


SystemInitDef();
vIAP_ReinvokeISP();
} 


 if(Gyro.FlashMod == 2)			
    {
   
    NVIC_DisableIRQ(TIMER1_IRQn);
    NVIC_DisableIRQ(TIMER2_IRQn);
 	NVIC_DisableIRQ(TIMER3_IRQn);
 	NVIC_DisableIRQ(EINT3_IRQn);
 
  SystemInitDef();
 
  	
  	
   WriteCon("\r\n Start Prepare Sectors");
   if(u32IAP_PrepareSectors(18, 21) == IAP_STA_CMD_SUCCESS)
   {
   	WriteCon("\r\nPrepare Sectors OK");
   	WriteCon("\r\n Start Erase");
   	
    u32IAP_EraseSectors(IMG_START_SECTOR, IMG_END_SECTOR);
   
    WriteCon("\r\n AND Erase");
   }
   else WriteCon("\r\nPrepare Sectors ERROR");  
SystemInit1(); 
Gyro.FlashMod = 0;
//boot_jump(addres); 
  }
    
    
    
  
  /*
#define IAP_STA_CMD_SUCCESS                                 0
#define IAP_STA_INVALID_COMMAND                             1
#define IAP_STA_SRC_ADDR_ERROR                              2
#define IAP_STA_DST_ADDR_ERROR                              3
#define IAP_STA_SRC_ADDR_NOT_MAPPED                         4
#define IAP_STA_DST_ADDR_NOT_MAPPED                         5
#define IAP_STA_COUNT_ERROR                                 6
#define IAP_STA_INVALID_SECTOR                              7
#define IAP_STA_SECTOR_NOT_BLANK                            8
#define IAP_STA_SECTOR_NOT_PREPARED_FOR_WRITE_OPERATION     9
#define IAP_STA_COMPARE_ERROR                               10
#define IAP_STA_BUSY                                        11
#define IAP_STA_INVALD_PARAM                                12
*/  
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
if(Gyro.FlashMod == 3)			
    {
 
 ReadFlash();
  //  SystemInitDef();
//  *status=(unsigned int*)addres;
    /*NVIC_DisableIRQ(TIMER1_IRQn);
    NVIC_DisableIRQ(TIMER2_IRQn);
 	NVIC_DisableIRQ(TIMER3_IRQn);
 	NVIC_DisableIRQ(EINT3_IRQn);*/
    Gyro.FlashMod = 0;
//     memdump(addres,4);
//     addres+=0x10;
//    p   = (unsigned int *)((unsigned int)base & ~(unsigned int)0x3);
   // WriteCon(*addres);
  //      status=*addres;
   // SystemInit1();  
    //  WriteCon(status);  
   //   addres+=0x10;
   
    }




}//while
}//main

/******************************************************************************
**                            End Of File
******************************************************************************/