forkd

Dependencies:   mbed

Fork of LGstaandart by Dmitry Kovalev

SPI.c

Committer:
Kovalev_D
Date:
2017-12-12
Revision:
225:f8fee6c586cc
Parent:
224:598aec95415f
Child:
226:4a4d5bd5fcd7

File content as of revision 225:f8fee6c586cc:

#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;
unsigned int SPIlog;
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 Buff_OUT1	[64];
int Buff_OUT	[64];
int RegulADC,DeltaRegul,tempDeltaRegul;
int count10v=0,AmpWorms,MinWorms,MaxWorms,AMPSUM,AMPSUMP,AMPSUMM,AMPSUM_DESP,AMPSUMPout,AMPSUMMout,AMPSUMout,SumDelta,PLC_EROR,PLC_Flag,HFO_Flag,HFOdelta,HFOregul,HFOSumDelta;


//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 ModArraySin32	  [32] = {50,59,68,77,85,91,96,99,100,99,96,91,85,77,68,59,50,41,32,23,16,9,4,1,0,1,4,9,16,23,32,41};
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=100;}
   	 else       { ModArrayTriangle[i]=Mod; Mod=0;}
     }
    
     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_Phase)&0x3f])*Gyro.ModAmp + Gyro.ShiftMod-32000; break;    
	 case 0: LPC_DAC->DACR = (ModArraySin		[(CountV64+Gyro.PLC_Phase)&0x3f])*Gyro.ModAmp + Gyro.ShiftMod-32000; 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: LPC_DAC->DACR = ((ModArraySin32		[(CountV31)&0x1f]+150)*Gyro.ModAmp);      		 break;ShiftMod
     	case 4: LPC_DAC->DACR = ((ModArraySin32		[(CountV31+8)&0x1f])*Gyro.ModAmp + Gyro.ShiftMod-32000); break;
   	    case 5:    		 break;
	    }
}

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  HFORegul2(void)
{
static unsigned int countHFO;
	
	 countHFO=0;
	 if(Gyro.RgConA&0x2) 
		 {
		 	if(HFO_Flag)
		 	{
 	        DeltaRegul+=(Gyro.HFO_ref-(AMPSUM>>8));
	        
	        sprintf((Time),"%d  %d  %d\r\n", AMPSUM>>8, DeltaRegul, Gyro.HFO_ref);
    	 	WriteCon(Time);
    	 	HFO_Flag=0;
    	 	AMPSUM=0;
       		}
            switch(DeltaRegul) {
            case  1: DeltaRegul=0; break;
            case -1: DeltaRegul=0; break;
           }
        	Spi.DAC_A-=(DeltaRegul>>2)*Gyro.HFO_Gain;
        	DeltaRegul=0;
		 }
 	 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);
    switch(Gyro.LG_Type) 
    {
     	case 1:  	Gyro.DeltaT = (unsigned int)(Spi.ADC2>>1); break;
     	
     	case 0:     Gyro.DeltaT = (unsigned int)(Spi.ADC4>>1); break;
	}
  
 
    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 ModFilt(void)
{
	       static int SumBuff,Delta, OldDelta;
	      
        
        
         if (count10v>=64*32)
 		  {
 		  	LoopOn
 	        count10v=0;
        
 	        for(int q=0; q<32; q++)
      	    	{
	  	    	SumBuff += BuffADC_10v[q];
	         	SumBuff -= BuffADC_10v_OLD[q+32];      	       	
	  	       	BuffADC_10v_F [q] = SumBuff;
          		}
          		
  	        for(int q=32; q<64; q++)
      	    	{
     	    	 SumBuff += BuffADC_10v[q];
         	   	 SumBuff -= BuffADC_10v[q-32];      	       	
  	       		 BuffADC_10v_F [q] = SumBuff;
          		}         	
           
 	      	for(int q=0; q<32; q++)		{AMPSUMP += BuffADC_10v_F [q];}
	      	for(int q=32; q<64; q++)	{AMPSUMM += BuffADC_10v_F [q];}
       	               
    	    for(int q=0; q<64; q++)
      	    	{
      	    	 	AMPSUM+=BuffADC_10v[q];
      	    	 	AMPSUMout+=BuffADC_10v_F[q];   	    	 	
	       	 		BuffADC_10v_OLD[q]= BuffADC_10v[q];
    	   		 	BuffADC_10v[q] =0;				
           		}
          	for(int q=0; q<64; q++)
      	    	{
      	    	 	Buff_OUT[q]=(BuffADC_10v_F[q]-(AMPSUM>>1))>>3;
           		}
           		
            /*sprintf((Time),"%d  \r\n",  Spi.DAC_A);
            WriteCon(Time);*/
          	   
       	    AMPSUMPout=AMPSUMP>>1;
       	    AMPSUMMout=AMPSUMM>>1;
       	    AMPSUMout=AMPSUM;
            
            Delta= (AMPSUMPout - AMPSUMMout);
            
           // if((Delta<(-5000000))||(Delta>5000000))Delta=0;
            
            SumDelta+=Delta;
            
            Gyro.PLC_Eror_count=SumDelta/Gyro.PLC_Gain;
            SumDelta-=Gyro.PLC_Gain*Gyro.PLC_Eror_count;
          	
          	PLC_EROR+=Gyro.PLC_Eror_count;
          	 
          	 
          	 
          	AMPSUM=AMPSUM>>6;
          	AMPSUM=AMPSUM>>3; 
        	AMPSUM=AMPSUM>>2;
        
           	AMPSUM_DESP=AMPSUM;
           	HFOdelta=(int)((Gyro.HFO_ref)-AMPSUM);
           	
           	
           	HFOSumDelta+=HFOdelta;
           	HFOregul=HFOSumDelta/(int)(Gyro.HFO_Gain);
           	
           	HFOSumDelta-=Gyro.HFO_Gain*HFOregul;
           	
	        tempDeltaRegul=HFOregul;
	        tempDeltaRegul+=HFOdelta;
	        
            HFO_Flag=1;
            PLC_Flag=1;
    	 	AMPSUMM=0;
    	 	AMPSUMP=0;
    	    AMPSUM=0;
    	    LoopOff
          }
}

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[CountV31]=(0x7fff-ADC5New)&0x7fff;

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

		
     //   Buff_Restored_Mod[CountV31] =(int)(BuffADC_1Point_64[CountV31] - ((BuffADC_128Point[CountV64])>>7));       
   //     Buff_Restored_Mod[CountV64] =(int)(BuffADC_32PointD[CountV64]*2 -  BuffADC_64Point[CountV64]);
        
   
        count10v++;
        BuffADC_10v[CountV64] += BuffADC_1Point[CountV255];
        
        ModFilt();
  
       }
            
}

void  HFORegul(void)
{
static unsigned int countHFO;
	
	 countHFO=0;
	
	 if(Gyro.RgConA&0x2) 
		 {
		   	if(HFO_Flag)
		   	{
		   /*	switch(HFOregul){
		   
	case  1:  HFOregul=0; break;
 	case -1:  HFOregul=0; break;
	  	case  2:  HFOregul=1; break;
	   	case -2:  HFOregul=1; break; 	
		   	
		   	
		   	}*/

		    Spi.DAC_A -= HFOregul;
		   	HFO_Flag=0;
        	DeltaRegul=0;
        	}
		 }
		
 	 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;
 	
}     


void  PLCRegul(void)

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


 	 if(Gyro.RgConA&0x8)
		{
		if(PLC_Flag)
			{  
	  	  	 	PLC_Flag=0;
	  	  	 	if   (Gyro.PLCDelay)
	  	  	 	{

	  	  	 	}
	  	  	 	else Spi.DAC_B+=(Gyro.PLC_Eror_count);
	  	  		
	  	  		
			}
   		 }   
   		Gyro.PLC_Eror_count=0;  		 	
  if(Gyro.LG_Type==1)
 	{
   		if(Spi.DAC_B > Gyro.HighTreshold ) 
   		{
   			Spi.DAC_B = (Gyro.ResetLevelCool);  
   			Gyro.PLCDelay			= GyroP.Str.PLCDelay; 
   		}     
   else if(Spi.DAC_B < Gyro.DownTreshold ) 
    	{
    		Spi.DAC_B = (Gyro.ResetLevelHeat);
    		Gyro.PLCDelay			= GyroP.Str.PLCDelay; 
    	}
    }
  else
    {
    	if      ( Spi.DAC_B < 10300 )	Spi.DAC_B = 32000;            //проверка на переваливание за границу.  
      	else if ( Spi.DAC_B > 57000 )	Spi.DAC_B = 32000;
    }     
}

 


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