Dmitry Kovalev
/
LGstaandart
Important changes to repositories hosted on mbed.com
Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.
To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.
It is also possible to export all your personal repositories from the account settings page.
Fork of
LG2
by 
Dmitry Kovalev
SPI.c
- Committer:
- Kovalev_D
- Date:
- 2017-11-20
- Revision:
- 222:7de7b3bf3a1d
- Parent:
- 221:53b256368ca1
- Child:
- 224:598aec95415f
File content as of revision 222:7de7b3bf3a1d:
#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,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*8)
{
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;
AMPSUMMout=AMPSUMM;
AMPSUMout=AMPSUM;
Delta= (AMPSUMPout - AMPSUMMout);
SumDelta+=Delta;
Gyro.PLC_Eror_count=SumDelta/Gyro.PLC_Gain;
SumDelta-=Gyro.PLC_Gain*Gyro.PLC_Eror_count;
AMPSUM=AMPSUM>>6;
AMPSUM=AMPSUM>>3;
AMPSUM_DESP=AMPSUM;
HFOdelta=(int)((Gyro.HFO_ref)-AMPSUM);
PLC_EROR=Gyro.PLC_Eror_count;
HFOSumDelta+=HFOdelta;
HFOregul=HFOSumDelta/(int)(Gyro.HFO_Gain);
HFOSumDelta-=Gyro.HFO_Gain*HFOregul;
tempDeltaRegul=HFOregul;
HFO_Flag=1;
PLC_Flag=1;
AMPSUMM=0;
AMPSUMP=0;
AMPSUM=0;
}
}
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/10;
}
else if(Spi.DAC_B > Gyro.DownTreshold )
{
Spi.DAC_B = (Gyro.ResetLevelHeat);
Gyro.PLCDelay = GyroP.Str.PLCDelay/10;
}
}
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) ;
}
}