File content as of revision 215:b58b887fd367:

#include "Global.h"
struct SPI Spi;
//unsigned int Temp_AMP;
unsigned int Temp_AMP64P;
int ttt=1;
unsigned int Count_AMP, ADD_AMP, Cur_Amp;
int Znak_Amp;
int AD_Regul = 0;
int temp9,tempADC5;
int AD_MAX=0;
int k=0,l=0,r=0,n=0;//счетчики для регулировки периметра
int flagmod=0,Bdelta;
int start=10;
int dispersion=0,side=1,tempstrafe=15000;
int ADC_5_T;
unsigned int TempA;
unsigned int TempTermLM;
unsigned int conuntPLS;
int ADC5Old,ADCDIF=0;
/*int DACModReg;*/
int SinPls=0,SinMns=0;
int TSinPls=0,TSinMns=0;
 int timer=750;
int sum=0,znak=0;
 unsigned int testcount=0;
unsigned int ADC5New;
unsigned int Buff_ADC_1		[32];
unsigned int Buff_ADC_2		[32];
unsigned int Buff_ADC_3	   	[32];
unsigned int Buff_ADC_4		[32];

int RegulADC,DeltaRegul,tempDeltaRegul;



//int BuffADC_32Point	[64];		

//unsigned int Buff_ADC_5		   [255];




//unsigned int PulseADC_16Point;
//unsigned int PulseADC_32Point;
//unsigned int PulseADC_64Point;
//unsigned int PulseADC_32PointD;


//unsigned int Buff_AMP		[256];
//unsigned int Buff_AMP64P	[256];
unsigned int TypeMod=0;
unsigned int ModArraySin	  [64] = {50,55,59,64,68,73,77,81,85,88,91,94,96,98,99,99,100,99,99,98,96,94,91,88,85,81,77,73,68,64,59,55,50,45,41,36,32,27,23,19,16,12,9,7,4,2,1,1,0,1,1,2,4,7,9,12,16,19,23,27,32,36,41,45};
//unsigned int ModArrayTriangle [64];
//unsigned int ModArraySaw	  [64];
unsigned int Mod=0;                                           

void InitMOD(void)
{
     for (int i = 0; i < 64; i++ ) 
 	 { 
   	 /*if(i<32)   { ModArrayTriangle[i]=Mod; Mod+=3;}
   	 else       { ModArrayTriangle[i]=Mod; Mod-=3;}*/
     }
    
     for (int i = 0; i < 16; i++ ) 
 	 { 
     /* ModArraySaw[i]=Mod;
      Mod+=1;*/
     }
}
void Modulator(void)
{
	if(!MODFlag)
	{
	switch(TypeMod) 
		{
	    case 0: LPC_DAC->DACR = (ModArraySin		[(CountV64)&0x3f]*Gyro.ModAmp);    break;
	/*    case 1: LPC_DAC->DACR = (ModArraySaw		[CountV64]*Gyro.ModAmp);  	break;
	    case 2: LPC_DAC->DACR = (ModArrayTriangle	[(CountV64-2)&0x3f]*Gyro.ModAmp);  	break;*/
	    }
	    
	    
         

	 
	}
}
void  PLCRegul(void)
{	
    unsigned int temp, Temp_Dac_B=0,Side=0;

    static int  CountFaza; 	
    

    if(conuntPLS<30)
    {
  // Temp_Dac_B=(0xffff-Spi.DAC_B);Buff_Restored_Mod[CountV64] BuffADC_1Point[CountV255]
     /*  if( (ModArraySin[(CountV64)&0x3f]-50)>0) znak=1;
       else znak = -1;
        for (CountFaza = 0;  CountFaza <32; CountFaza++)      	SinPls +=  ((Buff_Restored_Mod[ (CountFaza - Gyro.PLC_Phase)  & 0x3f]))>>5;
        for (CountFaza = 32; CountFaza <64; CountFaza++)      	SinMns +=  ((Buff_Restored_Mod[ (CountFaza - Gyro.PLC_Phase)  & 0x3f]))>>5;*/
       /* for (CountFaza = 0;  CountFaza <32; CountFaza++)        SinPls +=  (( BuffADC_1Point[ (CountFaza - Gyro.PLC_Phase)  & 0x3f]))>>5;
        for (CountFaza = 32; CountFaza <64; CountFaza++)      	SinMns +=  (( BuffADC_1Point[ (CountFaza - Gyro.PLC_Phase)  & 0x3f]))>>5; */
        /*for (CountFaza = 0; CountFaza <64; CountFaza++) 
        {
        	if(Buff_Restored_Mod[CountFaza]>0) SinPls+=(Buff_Restored_Mod[CountFaza])>>5;
        	else SinMns+=(Buff_Restored_Mod[CountFaza])>>5;
        	sum += (Buff_Restored_Mod[CountFaza])>>5;
        }*/
      
        conuntPLS++;
     }
     else{
       		
       		TSinPls=SinPls;
       	    TSinMns=SinMns;
       		conuntPLS=0;
       		Gyro.PLC_Eror = (TSinMns+TSinPls)>>5; 
       	    sum+=Gyro.PLC_Eror ;
            sprintf((Time)," %d     %d     %d      %d\r\n",  Buff_Restored_Mod[ (CountV64 - Gyro.PLC_Phase)  & 0x3f], Buff_Restored_Mod[ (CountV64 - Gyro.PLC_Phase+1)  & 0x3f],Buff_Restored_Mod[ (CountV64 - Gyro.PLC_Phase+2)  & 0x3f], Buff_Restored_Mod[ (CountV64 - Gyro.PLC_Phase+23)  & 0x3f]);
            WriteCon(Time);
        	SinPls=0;
   			SinMns=0;
   			
   		
   	
		      /*	 if(Gyro.PLC_Eror>0) {Gyro.PLC_regul--;}
		     	 else 			   	 {Gyro.PLC_regul++;}
*/
      	
      		if(Gyro.RgConA&0x8)
				{
						Spi.DAC_B-=(Gyro.PLC_Eror>>4)*Gyro.PLC_Gain;
		      	/* if(Gyro.PLC_Eror>0) {Spi.DAC_B+=Gyro.PLC_Eror*Gyro.PLC_Gain;}
		      	 else 			   	 {Spi.DAC_B-=Gyro.PLC_Eror*Gyro.PLC_Gain;}*/
		      	}
		      	
		      	if(Gyro.PLC_Eror>0){ Gyro.PLC_Eror_count++;}
     			else {Gyro.PLC_Eror_count--;}
     			
     		    Gyro.PLC_Eror=0;
     		
	        if(Gyro.LG_Type==1)
       			{
                  if	  ( Spi.DAC_B < Gyro.HighTreshold ) Spi.DAC_B = (Gyro.ResetLevelHeat);       
      	    	  else if ( Spi.DAC_B > Gyro.DownTreshold ) Spi.DAC_B = (Gyro.ResetLevelCool);
      	    	
       	    	}
       	    else
       	        {
      			  if      ( Spi.DAC_B < 10300 )     Spi.DAC_B = 32000;            //проверка на переваливание за границу.  
      			  else if ( Spi.DAC_B > 57000 ) 	Spi.DAC_B = 32000;
      			}
      }
     
}

 
void  PLCRegul250(void)
{	
    unsigned int temp;
    static int  CountFaza; 	
    temp = MODCount;
   
       /* for (CountFaza = 0;  CountFaza <16; CountFaza++)      	SinPls+=  (Buff_Restored_Mod[ (CountFaza - Gyro.PLC_Phase)  & 0x3f]);
        for (CountFaza = 16; CountFaza <32; CountFaza++)      	SinMns-=  (Buff_Restored_Mod[ (CountFaza - Gyro.PLC_Phase)  & 0x3f]);
        for (CountFaza = 32; CountFaza <48; CountFaza++)		SinPls+=  (Buff_Restored_Mod[ (CountFaza - Gyro.PLC_Phase)  & 0x3f]);
        for (CountFaza = 48; CountFaza <64; CountFaza++)      	SinMns-=  (Buff_Restored_Mod[ (CountFaza - Gyro.PLC_Phase)  & 0x3f]);*/
  
     /*   for (CountFaza = 0; CountFaza <32; CountFaza++ )      	SinPls+=  BuffADC_64Point[ (CountFaza - Gyro.PLC_Phase)  & 0x3f];
        for (CountFaza = 32; CountFaza <64; CountFaza++)		SinMns+=  BuffADC_64Point[ (CountFaza - Gyro.PLC_Phase)  & 0x3f];*/
        Gyro.PLC_Eror = SinMns-SinPls; 
     /*  sprintf((Time)," %d %d %d %d %d\r\n",Spi.ADC5, Spi.DAC_B, SinPls, SinMns, Gyro.PLC_Eror);
         WriteCon(Time);*/
      	if(Gyro.RgConA&0x8)
			{
		      if(Gyro.PLC_Eror>0) {Spi.DAC_B+=1 * Gyro.PLC_Gain;}
		      else 				  {Spi.DAC_B-=1 * Gyro.PLC_Gain;}
		    }  
	/*	if(Gyro.PLC_Eror>0) {Gyro.PLC_Eror_count++;}
     	else 				{Gyro.PLC_Eror_count--;}*/
     
      	if      ( Spi.DAC_B < 10300 )   Spi.DAC_B = 32000;            //проверка на переваливание за границу.  
      	else if ( Spi.DAC_B > 57000 ) 	Spi.DAC_B = 32000;

   		SinPls=0;
   		SinMns=0; 
}
void  HFORegul(void)
{

 RegulADC=32767-Spi.ADC5;
 DeltaRegul+=((Gyro.HFO_ref-RegulADC));
 //tempDeltaRegul+=((Gyro.HFO_ref-RegulADC));
 //if(DeltaRegul>50)DeltaRegul=50;

 if(timer) timer--;
 else
 {
	/*sprintf((Time),"%d  %d  %d  %d  %d  %d \r\n", Gyro.HFO_Min , Spi.DAC_A,Gyro.HFO_Max,tempDeltaRegul>>10,   Spi.DAC_B, Gyro.CuruAngle);
    WriteCon(Time);
    Gyro.CuruAngle=0;*/
    //tempDeltaRegul=0;
 if(Gyro.RgConA&0x2) 
 {
 	DeltaRegul=DeltaRegul>>10;
 	tempDeltaRegul=DeltaRegul>>10;
 	Spi.DAC_A-=DeltaRegul*Gyro.HFO_Gain;
 	timer=10;
 }
 	else DeltaRegul=0;
 }
    if(Spi.DAC_A>Gyro.HFO_Min-1)	  Spi.DAC_A=Gyro.HFO_Min-2;
 	else if(Spi.DAC_A<Gyro.HFO_Max+1) Spi.DAC_A=Gyro.HFO_Max+2;
 
}               
                
         
           
// Spi.DAC_B-=ADCDIF>>6;
        
void ADS_Acum(void)
{
    Spi.ADC_NewData = 0;
   // Gyro.Termo 	= (unsigned int)(((Spi.ADC1>>1) +  Gyro.Tmp_OffsetT4) *  Gyro.Tmp_scaleT4);
    Gyro.Termo 	= (unsigned int)(Spi.ADC1>>1);
    Gyro.IN1_Accum	+=  Spi.ADC2;
    Gyro.IN2_Accum	+=  Spi.ADC3;
   // Gyro.DeltaT = (unsigned int)(((Spi.ADC4>>1) +  Gyro.Tmp_OffsetT5) *  Gyro.Tmp_scaleT5);
    Gyro.DeltaT = (unsigned int)(Spi.ADC4>>1);
 
    TempA = (0xffff - Spi.ADC5);  		// перевернем знак  и умножим на два (было 32000...0 стало 0 ...32000 /*сдвиг(<<1) стало 0 ...64000*/)
    Gyro.TermLM = Spi.ADC1; 
    Gyro.ADF_Accum += TempA;
    Gyro.ADS_Accum += TempA;
   /// Gyro.ADS_AccumTermLM+=TempTermLM;
    Gyro.ADF_Count ++;
    Gyro.ADS_Count ++;
    Gyro.ADM_Count ++;
     /*   sprintf((Time),"%d %d\r\n",((Gyro.In1>>1) - 0x4fff),(Spi.DAC_B-0x4fff));
        WriteCon(Time);*/
    if (Gyro.ADM_Count > 255) {	
         Gyro.In1 =  Gyro.IN1_Accum>>8;
   		 Gyro.In2 =  Gyro.IN2_Accum>>8;
   		 Gyro.IN1_Accum=0;
   		 Gyro.IN2_Accum=0;
    	 Gyro.ADM_Count=0;

    	}   
    if (Gyro.ADF_Count > 15) {					// если прошло 16 тактов виброподвеса
        Gyro.AD_Fast = Gyro.ADF_Accum << 11;	//обновляем данные и приводим в один масштаб
        Gyro.ADF_Count = 0;//
        Gyro.ADF_Accum = 0;
        Gyro.ADF_NewData = 1;
    }
    if (Gyro.ADS_Count > 255) {					// если прошло 256 тактов виброподвеса
        Gyro.AD_Slow = Gyro.ADS_Accum << 7;		//обновляем данные и приводим в один масштаб
     //   Gyro.TermLM = Gyro.ADS_AccumTermLM << 3;
        Gyro.ADS_Count = 0;
        Gyro.ADS_Accum = 0;
        Gyro.ADS_AccumTermLM=0;
        Gyro.ADS_NewData = 1;
	}
}
void SPI_Exchange(void)  // новая функция чтения, в нецй не должно быть ничего лишнего
{
   
    unsigned int DummySPI;
    //unsigned int ADC5Dif;
    ADC5New = LPC_SSP0->DR;// Чтение АЦП
    //Spi.ADC5_Accum += LPC_SSP0->DR;
    Spi.ADC4_Accum += LPC_SSP0->DR;
    Spi.ADC3_Accum += LPC_SSP0->DR;
    Spi.ADC2_Accum += LPC_SSP0->DR;
    Spi.ADC1_Accum += LPC_SSP0->DR;
    Spi.ADC5_Accum += ADC5New;	       

    while (LPC_SSP0->SR & RX_SSP_notEMPT) 	
    {
    DummySPI = LPC_SSP0->DR;   //если буфер SPI не пуст.//очистить буфер.
    }
    DAC_OutPut();
    if (CountV31 == 0) {						// просто фильтруем по 32 точкам.
         										// выставояем бит, что есть новы данные
        Spi.ADC1 = Spi.ADC1_Accum >> 5;			// подгоотавливаем данные (в той эе сетке) те 	 ADC1  0..65535
        Spi.ADC2 = Spi.ADC2_Accum >> 5;
        Spi.ADC3 = Spi.ADC3_Accum >> 5;
        Spi.ADC4 = Spi.ADC4_Accum >> 5;
        Spi.ADC5 = Spi.ADC5_Accum >> 5;
        Spi.ADC1_Accum  = 0;				    // сбрасывкем аккамулятор
        Spi.ADC2_Accum  = 0;
        Spi.ADC3_Accum  = 0;
        Spi.ADC4_Accum  = 0;
        Spi.ADC5_Accum  = 0;
        Spi.ADC_NewData = 1;

       }
        if(Time1Hz>6)
        {    
        BuffADC_1Point[CountV255]=ADC5New;//(0x7fff-ADC5New)&0x7fff;

        ADC_64Point += BuffADC_1Point[CountV255];
        ADC_64Point -= BuffADC_1Point[(CountV255 - 64) & 0xff];						// заполнение буфера накопленых приращений за 64 тактов
        BuffADC_64Point[CountV64] = ADC_64Point;

           
           
        ADC_32PointD += BuffADC_1Point[CountV255];  
        ADC_32PointD -= BuffADC_1Point[(CountV255 - 32) & 0xff]; 							// заполнение буфера накопленых приращений за 32 тактов
        ADC_32PointD += BuffADC_1Point[(CountV255 - 64) & 0xff];  
        ADC_32PointD -= BuffADC_1Point[(CountV255 - 96) & 0xff]; 
        BuffADC_32PointD[CountV64] =  ADC_32PointD;

       
        ADC_16Point += BuffADC_1Point[CountV255];  
        ADC_16Point -= BuffADC_1Point[(CountV255 - 16) & 0xff];
        BuffADC_16Point	[CountV64] =  ADC_16Point; 

            
        Buff_Restored_Mod[CountV64] =(int)(BuffADC_32PointD[CountV64] -  BuffADC_64Point[CountV64]);
        
        
        
       /* if( (ModArraySin[(CountV64)&0x3f]-50)>0) znak=1;
        else znak = -1;*/
        if (CountV64<32)      	SinPls +=  (Buff_Restored_Mod[ (CountV64 - Gyro.PLC_Phase)  & 0x3f]/*znak*/)>>5;
        else  					SinMns +=  (Buff_Restored_Mod[ (CountV64 - Gyro.PLC_Phase)  & 0x3f]/*znak*/)>>5;
        }
      
	      /*if(Gyro.LogMod)
	      {
	      	sprintf((Time),"%i\r\n", Buff_Restored_Mod[CountV64]);
            WriteCon(Time);
	      }*/
      
       
     // BuffADC_64Point[CountV64]=ADC5New;
      //  Buff_ADC_5[CountV255] = (0x7fff-ADC5New)<<2;
   
        
}

void ShowMod(void)//технологическая функция для просмотра в ориджине мод на всем диапазпне цап
{
	
    //////////////////////////////////////////////////////////////////////////////////////////////////
    //////////////////////////////////смотрим все моды/////////////////////////////////////////////////
    ///////////////////////////////////////////////////////////////////////////////////////////////////
    if(dispersion>5)
    {
      if( (Gyro.PLC_Lern<60000)&&(Gyro.PLC_Error2Mode >1))//пробигаем по нескольким значениям цап(60*0х3с=0хВВ8) для определения максимальной амплитуды.
        {
          Gyro.PLC_Error2Mode--;
          Gyro.PLC_Lern++;
          Spi.DAC_B += tempstrafe*side;
          if(side>0)side=(-1);
          else side = 1;
          tempstrafe-=40;
          dispersion=0;
        } 
      else {Gyro.LogPLC=0;}  
      }
      else dispersion++;
      sprintf((Time),"%d %d %d %d \r\n", Gyro.CuruAngle, Spi.DAC_B, Gyro.AD_Slow, Gyro.Termo);
      Gyro.CuruAngle=0;
      WriteCon(Time);
}
void ShowMod2(void)//технологическая функция для просмотра в ориджине мод на всем диапазпне цап
{
	if(dispersion>3)
    {
	unsigned int step = 50, ENDMOD=65400;
	sprintf((Time),"%d %d %d %d     %d   %d   %d\r\n", Gyro.CuruAngle, Spi.DAC_B, Gyro.AD_Slow, Spi.ADC5, 0xfFFf-Spi.ADC1, Spi.ADC1, Gyro.Termo);
    Gyro.CuruAngle=0;
    WriteCon(Time);
	Spi.DAC_B+=step;
	if(Spi.DAC_B>ENDMOD)
		{
		// Gyro.LogMod=0;
		 PlcON
		 Spi.DAC_B = 48000;
		}
	dispersion=0;
	}
	else dispersion++;
}
void DAC_OutPut(void)//выдача в цапы
{
  	if(Gyro.RgConA&0x10)	Modulator();
    LPC_SSP0->DR=0x5555;
    LPC_SSP0->DR=0x5555;
    LPC_SSP0->DR=0x5555;

    if (CountV31 & 1) 
    {                      	//если нечетный такт то
        LPC_SSP0->DR = WRITE_DAC0;   			//e.команда для ЦАП_0 передавать.
        LPC_SSP0->DR = (Spi.DAC_A);         	//e. передача 12 бит
    } 
    else 
    { //если такт четный.
        LPC_SSP0->DR = WRITE_DAC1 ; //e.команда для ЦАП_1 передавать.
        LPC_SSP0->DR = (Spi.DAC_B);
    }
}