Dmitry Kovalev
forkd
Fork of
LG2
by 
Dmitry Kovalev
SPI.c
- Committer:
- Kovalev_D
- Date:
- 2018-01-05
- Revision:
- 227:2774b56bfab0
- Parent:
- 226:4a4d5bd5fcd7
File content as of revision 227:2774b56bfab0:
#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;
int PLC_ERR_DAC,PLC_ERR_DAC_F;
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 count10HFO=0, count10v=0, AmpWorms,MinWorms,MaxWorms,AMPSUM,AMPSUMP,AMPSUMM,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;
unsigned int HFO_AVR;
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 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)*100)*0.0122)-27300);
//Gyro.Termo =
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)*100)*0.0122)-27300); 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 HFOFilt(void)
{
/* HFO_AVR+=(BuffADC_10v[CountV64]>>4);
HFO_AVR-=(BuffADC_10v[CountV64 - 32]>>4);
*/
HFOdelta=(int)((Gyro.HFO_ref)-(BuffADC_128Point[CountV64]>>7));
HFOSumDelta+=HFOdelta;
HFOregul=HFOSumDelta/(int)(Gyro.HFO_Gain);
HFOSumDelta-=Gyro.HFO_Gain*HFOregul;
tempDeltaRegul += HFOregul;
AMPSUM=0;
HFO_Flag=1;
}
void PLCFilt(void)
{
static int SumBuff,Delta, OldDelta;
if (count10v>=64*32)
{
C_PLC_F++;
C_PLC_F = C_PLC_F & 0xf;
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);*/
AMPSUM=AMPSUM>>6;
AMPSUM=AMPSUM>>3;
AMPSUM=AMPSUM>>3;
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;
BuffPLC_FILT[C_PLC_F] = Gyro.PLC_Eror_count;
if(Time1Hz>10)
{
PLC_ERR_DAC_F += BuffPLC_FILT[C_PLC_F];
PLC_ERR_DAC_F -= BuffPLC_FILT[(C_PLC_F-8)&0xf];
}
PLC_ERR_DAC = PLC_ERR_DAC_F>>3;
PLC_Flag=1;
AMPSUMM=0;
AMPSUMP=0;
// LoopOff
}
}
void ModFilt(void)
{
PLCFilt();
if(PLC_Flag)
{
HFOSumDelta=0;
}
else HFOFilt();
}
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++;
count10HFO++;
BuffADC_10v[CountV64] += BuffADC_1Point[CountV255];
// BuffADC_10HFO[CountV64] += BuffADC_1Point[CountV255];
ModFilt();
}
}
void HFORegul(void)
{
static unsigned int countHFO;
countHFO=0;
if(Gyro.RgConA&0x2)
{
if(HFO_Flag)
{
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)
{
if (Gyro.PLCDelay)
{
}
else
{
/* if(Gyro.PLC_Eror_count>600) Gyro.PLC_Eror_count=0;
else if(Gyro.PLC_Eror_count<(-600)) Gyro.PLC_Eror_count=0;*/
Spi.DAC_B+=PLC_ERR_DAC;
}
}
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;
}
}
if(PLC_Flag)
{
/*sprintf((Time),"%d %d %d\r\n", PLC_ERR_DAC, Spi.DAC_B, Spi.DAC_A);
WriteCon(Time);*/
PLC_ERR_DAC=0;
PLC_Flag=0;
}
}
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) ;
}
}