File content as of revision 217:15cd8752bb6c:

#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;
 unsigned int testcount=0,faza, fazaFlag=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;     
int znak;                                              

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)
{
	switch(TypeMod) 
		{
	    case 0: LPC_DAC->DACR = (ModArraySin		[(CountV64-Gyro.PLC_Gain)&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;
	    case 3: LPC_DAC->DACR = (ModArrayTriangle	[(CountV64-2)&0x3f]*Gyro.ModAmp);  	break;
   	    case 4:   	break;
	    }
}
void  PLCRegul(void)

{
static unsigned int Flag_64=0, count;	    
static int  CountFaza,Sin;

        		for (CountFaza = 0;  CountFaza <64; CountFaza++)   
        		{ 
        			Sin=(ModArraySin[CountFaza] - 50);
        			if(Sin < 0) znak = -1;
        			else znak = 1;
        			BuffADC_znak[CountFaza] =  znak;
        	    }
		if(Flag_64)
			{
       		for (CountFaza = 0;  CountFaza <32; CountFaza++)   
        		{ 
       			SinPls+=  ((Buff_Restored_Mod[(CountFaza - Gyro.PLC_Phase) & 0x3f])*BuffADC_znak[CountFaza]);
        		}
        	for (CountFaza = 32;  CountFaza <64; CountFaza++)   
        		{
       			SinMns-=   ((Buff_Restored_Mod[(CountFaza - Gyro.PLC_Phase) & 0x3f])*BuffADC_znak[CountFaza]);
        		}
        	
      			    
      			    if(count>128)
      			    {
      			    count=0;
      			    Gyro.PLC_Eror_count = (SinMns+SinPls)>>7; 
       				/*sprintf((Time)," %d      %d       %d       %d  \r\n",SinPls>>7,(SinMns>>7), Gyro.PLC_Eror_count,Gyro.PLC_Phase);
       		 		WriteCon(Time);*/
       		 	    SinPls=0;
       		 	    SinMns=0;
       		 	    if(Gyro.RgConA&0x8)
					{
       		 		  Spi.DAC_B-=Gyro.PLC_Eror_count>>1;
       		 	 	 }
       		 	    }
       		 	    else count++;
      			
      	    Flag_64=0; 
      	    }
       else Flag_64++;
      
      


  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)
{
static unsigned int countHFO;
	 if(countHFO<128)
	 {
	 RegulADC=(32767-Spi.ADC5);
 	 DeltaRegul+=((Gyro.HFO_ref-RegulADC));
	 countHFO++;
 	 }
 	else
	 {
	 countHFO=0;
	 if(Gyro.RgConA&0x2) 
		 {
		 	
		 	DeltaRegul=DeltaRegul>>17;
		 	
		 	sprintf((Time)," %d  %d \r\n",DeltaRegul,DeltaRegul>>16);
       		WriteCon(Time);

		 	tempDeltaRegul=DeltaRegul>>16;
		 	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]  =(0x7fff-ADC5New)&0x7fff;
        BuffADC_1Point_64[CountV64]=(0x7fff-ADC5New)&0x7fff;


        ADC_64Point += BuffADC_1Point[CountV255];
        ADC_64Point -= BuffADC_1Point[(CountV255 - 128) & 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]*2 -  BuffADC_64Point[CountV64]);
        Buff_Restored_Mod[CountV64] =(int)(BuffADC_1Point_64[CountV64] - ((BuffADC_64Point[CountV64])>>7));



     // SinPls +=  (Buff_Restored_Mod[ (CountV64 - Gyro.PLC_Phase)  & 0x3f]/*znak*/)>>5;
    //  SinMns +=  (Buff_Restored_Mod[ (CountV64 - Gyro.PLC_Phase)  & 0x3f]/*znak*/)>>5;
        }       
}

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);
    }
}