Dmitry Kovalev
forkd
Fork of
LGstaandart
by 
Dmitry Kovalev
Diff: SPI.c
- Revision:
- 197:7a05523bf588
- Parent:
- 196:f76dbc081e63
- Child:
- 198:fb22ba6aad54
- Child:
- 201:76f4123bf22a
- Child:
- 205:775d54fdf646
--- a/SPI.c Fri Sep 23 05:34:50 2016 +0000
+++ b/SPI.c Wed Oct 19 10:55:05 2016 +0000
@@ -11,6 +11,7 @@
int k=0,l=0,r=0,n=0;//счетчики для регулировки периметра
int flagmod=0,Bdelta;
int start=10;
+int dispersion=0,side=1,tempstrafe=15000;
unsigned int Temp_ADC_2;
unsigned int Temp_ADC_3;
unsigned int Temp_ADC_4;
@@ -18,14 +19,90 @@
unsigned int TempA;
unsigned int TempTermLM;
+int ADC5Old,ADCDIF=0;
+int DACModReg;
+int SinPls=0,SinMns=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];
-unsigned int Buff_ADC_5 [256];
+
+unsigned int Buff_ADC_5 [512];
+unsigned int BuffADC_16Point [64];
+unsigned int BuffADC_32Point [64];
+unsigned int BuffADC_64Point [64];
+unsigned int BuffADC_32PointD [64];
+unsigned int Buff_Restored_Mod [64];
+
+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 < 64; i++ )
+ {
+ ModArraySaw[i]=Mod;
+ Mod+=2;
+ }
+}
+void Modulator(void)
+{
+ switch(TypeMod)
+ {
+ case 0: LPC_DAC->DACR = (ModArraySin [CountV64]*Gyro.ModAmp); break;
+ case 1: LPC_DAC->DACR = (ModArraySaw [CountV64]*Gyro.ModAmp); break;
+ case 2: LPC_DAC->DACR = (ModArrayTriangle [CountV64]*Gyro.ModAmp); break;
+ }
+}
+void PLCRegul(void)
+{
+
+ if (CountV64 == 0)
+ {
+ for (int i = 0; i < 32; i++ )
+ {
+ SinPls+= BuffADC_64Point[i];
+ }
+ for (int i = 32; i < 64; i++ )
+ {
+ SinMns+= BuffADC_64Point[i];
+ }
+ ADCDIF = SinPls - SinMns;
+ // Spi.DAC_B-=ADCDIF>>6;
+
+ if(ADCDIF>0) Spi.DAC_B-=3;
+ else Spi.DAC_B+=3;
+
+ if ( Spi.DAC_B < 15300 ) Spi.DAC_B = 32000; //проверка на переваливание за границу.
+ else if ( Spi.DAC_B > 53000 ) Spi.DAC_B = 32000;
+/*
+ sprintf((Time),"%d %d %d %d %d \r\n", SinPls, SinMns, ADCDIF, ADCDIF>>5, Spi.DAC_B);//выдаем в терминал для постройки граффика регулировки периметра.
+ WriteCon(Time);
+ */
+ SinPls=0;
+ SinMns=0;
+ }
+}
+
void ADS_Acum(void)
{
@@ -56,25 +133,38 @@
Gyro.ADS_Count = 0;
Gyro.ADS_Accum = 0;
Gyro.ADS_AccumTermLM=0;
- Gyro.ADS_NewData = 1;
-
+ Gyro.ADS_NewData = 1;
}
}
void SPI_Exchange(void) // новая функция чтения, в нецй не должно быть ничего лишнего
{
unsigned int DummySPI;
- Spi.ADC5_Accum += LPC_SSP0->DR; // Чтение АЦП
+
+ //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;
+
+
+ // ADC5Dif = (ADC5New) - (ADC5Old);
+ // ADC5Old=ADC5New;
+
+ /*
+sprintf((Time)," %d\r\n", (Buff_Restored_Mod[CountV64]));
+WriteCon(Time);
+ */
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;
@@ -86,7 +176,52 @@
Spi.ADC4_Accum = 0;
Spi.ADC5_Accum = 0;
Spi.ADC_NewData = 1;
+
}
+
+
+
+
+ BuffADC_64Point[CountV64]=ADC5New;
+ Buff_ADC_5[CountV255] = (0x7fff-ADC5New)<<2;
+ PLCRegul();
+
+
+
+/*
+ PulseADC_16Point += Buff_ADC_5[CountV255];
+ PulseADC_16Point -= Buff_ADC_5[(CountV255-16)& 0xff]; // заполнение буфера накопленых приращений за 16 тактов
+ BuffADC_16Point[CountV64] = (Pulse_16Point);
+
+ PulseADC_32Point += Buff_ADC_5[CountV255];
+ PulseADC_32Point -= Buff_ADC_5[(CountV255-32)& 0xff ]; // заполнение буфера накопленых приращений за 32 тактов
+ BuffADC_32Point[CountV64] = (PulseADC_32Point );
+
+ PulseADC_32PointD += Buff_ADC_5[CountV255];
+ PulseADC_32PointD -= Buff_ADC_5[(CountV255-32)& 0xff]; // заполнение буфера накопленых приращений за 32 тактов Двойныз
+ PulseADC_32PointD += Buff_ADC_5[(CountV255-48)& 0xff]; //
+ PulseADC_32PointD -= Buff_ADC_5[(CountV255-64)& 0xff]; //
+ BuffADC_32PointD[CountV64] = PulseADC_32PointD ;
+ */
+ /* PulseADC_64Point += (Buff_ADC_5[CountV255]);
+ PulseADC_64Point -= Buff_ADC_5[(CountV255-64) & 0xff]; // заполнение буфера накопленых приращений за два 64 тактов
+ BuffADC_64Point[CountV64] = (PulseADC_64Point);*/
+ //ADCDIF += BuffADC_64Point[CountV64];
+ /// Buff_Restored_Mod[CountV64] = BuffADC_32PointD[CountV64] - BuffADC_64Point[CountV64];
+
+ /* if(ADC5Old>3)
+ {
+ sprintf((Time),"%d %d \r\n", BuffADC_64Point[CountV64], Buff_Restored_Mod[CountV64]);
+ WriteCon(Time);
+ ADC5Old=0;
+ }
+ else ADC5Old++;
+ */
+ // BackLightOFF
+
+ // ADCDIF += BuffADC_64Point[CountV64]/*>>5*/;
+ /* sprintf((Time),"%d %d\r\n", ADC5New, PulseADC_64Point);
+ WriteCon(Time);*/
}
@@ -97,16 +232,24 @@
//////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////смотрим все моды/////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
- if( (Gyro.PLC_Lern<1092)&&(Gyro.PLC_Error2Mode != 0))//пробигаем по нескольким значениям цап(60*0х3с=0хВВ8) для определения максимальной амплитуды.
+ 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 += 0x3c;
- if(AD_MAX < Gyro.AD_Slow) AD_MAX = Gyro.AD_Slow;
- sprintf((Time),"%d %d %d %d \r\n",Gyro.TermLM, Spi.DAC_B, Gyro.AD_Slow, AD_MAX);
- WriteCon(Time);
+ Spi.DAC_B += tempstrafe*side;
+ if(side>0)side=(-1);
+ else side = 1;
+ tempstrafe-=40;
+ dispersion=0;
}
- else {Gyro.ModJump=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);
}
@@ -120,7 +263,7 @@
int templm=0;
int PLC_In;
int tempDac;
- if(0<start<=5)
+ if(start<=5)
{
if(ttt)
{// +25 С°
@@ -136,6 +279,7 @@
else if((start==0))
{
+
PLC_In = Gyro.AD_Slow; //выбираем даные для фильтрации
Gyro.PLC_Delta = PLC_In - Gyro.PLC_Old; //узнаем приращение
Gyro.PLC_DeltaADD = Gyro.PLC_Delta * Gyro.PLC_ADC_DOld; //приращение с учетом знака (и количества) прошлого приращения
@@ -152,26 +296,41 @@
if(Gyro.Ktermo)Spi.DAC_B += 0x3c; //добовляем в значение цапа 60
else Spi.DAC_B -= 0x3c;
if(AD_MAX < PLC_In){AD_MAX = PLC_In;} //если максимальная амплитуда меньше текущей записываем новую максимальную амплитуду.
- else if ((AD_MAX>PLC_In)&&(AD_MAX>1500800000)) r++; //если текущая амплитуда меньше максимально найденной то инкрементируем счетчик.
+ else if ((AD_MAX>PLC_In)&&(AD_MAX>1550800000)) r++; //если текущая амплитуда меньше максимально найденной то инкрементируем счетчик.
if (r>10)
{
- Gyro.PLC_Lern=150;
+ Gyro.PLC_Lern=151;
Gyro.PLC_Error2Mode=3;
} //если текущая амплитуда меньше максимально найденной в течении 5 тактов то выходим из поиска
- Gyro.CuruAngle = 0; //не считаем угол пока ищем максивальную амплитуду.
- } //работает только первые ~30-40 секунд (37 сек).
+ Gyro.CuruAngle = 0; //не считаем угол пока ищем максивальную амплитуду.
+ } //работает только первые ~30-40 секунд (37 сек).
if (Gyro.PLC_Lern<160) Gyro.PLC_Lern++;
if(AD_MAX < PLC_In) {AD_MAX = PLC_In; l=0;} //обновление максимального значения амплитуды обнуление счетчика малого понижения амплитуды.
else l++; //инкрементируем счетчик малого понижения желаемой амплитуды (максимальной замеченной)
- if((l > 100)&&(Gyro.PLC_Error2Mode == 0)) {AD_MAX -= 2107200;k=15;l=0;} //если счетчик малого понижения амплитуды больше 100(аммплитуда не обновлялась 100 раз). m
- if ((k == 15)&&(Gyro.PLC_Lern > 150)) Spi.DAC_B += 75; //после уменьшения максимальной амплитуды двигаем шевелем цап
- else if((k == 1)&&(Gyro.PLC_Lern > 150)) {Spi.DAC_B -= 75; k=0;l=0;} //для быстрог поиска новог максимума.
+ if((l > 300)&&(Gyro.PLC_Error2Mode == 0)) {AD_MAX -= 2107200;k=15;l=0;} //если счетчик малого понижения амплитуды больше 100(аммплитуда не обновлялась 100 раз). m
+ if ((k == 15)&&(Gyro.PLC_Lern > 150)) Spi.DAC_B += 75; //после уменьшения максимальной амплитуды двигаем шевелем цап
+ else if((k == 1)&&(Gyro.PLC_Lern > 150)) {Spi.DAC_B -= 75; k=0;l=0;} //для быстрог поиска новог максимума.
if(k>0)k--;
Gyro.PlC_MaxD=(unsigned int)(AD_MAX-PLC_In); //ищем разницу между желаемой и действительной амплитудами.
-
+ if(Gyro.ModJump==1) { ///прыжок с моды на моду. (-->)
+ Gyro.OldCuruAngle = Gyro.CuruAngle;
+ Gyro.ModJump=0;
+ Spi.DAC_B += 4300;
+ Gyro.PLC_Error2Mode=1;
+ Gyro.StopCuruAngle=2;
+ }
+
+ if(Gyro.ModJump==2) { ///прыжок с моды на моду. (<--)
+ Gyro.OldCuruAngle = Gyro.CuruAngle;
+ Gyro.ModJump=0;
+ Spi.DAC_B -= 5250;
+ Gyro.PLC_Error2Mode=1;
+ Gyro.StopCuruAngle=2;
+ }
+
if(Gyro.RgConA&0x8) { // если контур регулирования замкнут
if ( Gyro.PLC_Error2Mode > 0) { Gyro.PLC_Error2Mode --; Gyro.PLC_ADC_DOld = 0;} // если ошибка(нахожление в двух модовом)
else if ( Gyro.PLC_DeltaADD > 0) { Gyro.PLC_ADC_DOld = 1;}
@@ -181,70 +340,58 @@
else {Gyro.PLC_Error2Mode = 1; Gyro.PLC_DeltaADD = 0;}
///прыжок с моды на моду.
-/*
- if(Gyro.ModJump==1) { ///прыжок с моды на моду. (-->)
- Gyro.ModJump=0;
- Spi.DAC_B += 12500;
- Gyro.PLC_Error2Mode=4;
- }
- if(Gyro.ModJump==2) { ///прыжок с моды на моду. (<--)
- Gyro.ModJump=0;
- Spi.DAC_B -= 12500;
- Gyro.PLC_Error2Mode=4;
- } */
-
-
+
+
+
tempADC5=0x7fff-Spi.ADC5;
// контур замкнут включен лазер
if((Gyro.RgConA&0x8) && (tempADC5>1000))
- {
- if(Gyro.PlC_MaxD>(50<<17)) { //3 режим регулирования
+ {
+ if(Gyro.PlC_MaxD>(50<<17)) { // 3 режим регулирования
tempDac=(unsigned int)(Gyro.PlC_MaxD>>19);
- if(tempDac>600) {tempDac=600;} //ограничение на регулирование если очень большая разница амплитуд
- Spi.DAC_B += Gyro.PLC_ADC_DOld * tempDac; //новое значение в цап (±1 * значение регулировки)
- tempDac = Gyro.PLC_ADC_DOld * tempDac; //используется только для выдачи
+ if(tempDac>600) tempDac=600; //ограничение на регулирование если очень большая разница амплитуд
+ Spi.DAC_B += Gyro.PLC_ADC_DOld * tempDac; //новое значение в цап (±1 * значение регулировки)
+ tempDac = Gyro.PLC_ADC_DOld * tempDac; //используется только для выдачи
flagmod=3;
-
}
- else if(Gyro.PlC_MaxD>(20<<17)) { // 2 режим регулирования
+ else if(Gyro.PlC_MaxD>(12<<17)) { // 2 режим регулирования
tempDac=(unsigned int)(Gyro.PlC_MaxD>>19);
Spi.DAC_B += Gyro.PLC_ADC_DOld * (tempDac);
- tempDac = Gyro.PLC_ADC_DOld * (tempDac); //используется только для выдачи
+ tempDac = Gyro.PLC_ADC_DOld * (tempDac); //используется только для выдачи
flagmod=2;
}
- else if(Gyro.PlC_MaxD<(4<<17)) { //режим если дельта равна 0;Gyro.ModJump
- tempDac=1;
+ /* else if(Gyro.PlC_MaxD<(2<<17)) { //режим если дельта равна 0;Gyro.ModJump
+ tempDac=2;
Spi.DAC_B += Gyro.PLC_ADC_DOld * tempDac;
flagmod=0;
- }
+ } */
else {
- tempDac=(unsigned int)(Gyro.PlC_MaxD>>19); // 1 режим регулирования
+ tempDac=2; // 1 режим регулирования
Spi.DAC_B += Gyro.PLC_ADC_DOld *tempDac;
tempDac = Gyro.PLC_ADC_DOld * tempDac;
flagmod=1;
}
- }
+ }
- if ( Spi.DAC_B < 18300 ) {Spi.DAC_B = 32000; Gyro.PLC_Error2Mode = 5; Gyro.PLC_DeltaADD = 0;} //проверка на переваливание за границу.
+ if ( Spi.DAC_B < 15300 ) {Spi.DAC_B = 32000; Gyro.PLC_Error2Mode = 5; Gyro.PLC_DeltaADD = 0;} //проверка на переваливание за границу.
else if ( Spi.DAC_B > 53000) {Spi.DAC_B = 32000; Gyro.PLC_Error2Mode = 5; Gyro.PLC_DeltaADD = 0;}
}
-
+ if(Gyro.StopCuruAngle) {Gyro.CuruAngle = Gyro.OldCuruAngle; Gyro.StopCuruAngle--;}
///////////////////////
//////////лог//////////
///////////////////////
if(Gyro.LogPLC==1) {
// LoopOn
- sprintf((Time),"%d %d %d %d %d %d %d %d \r\n",Gyro.CuruAngle, Gyro.tempdelta, Gyro.tempdelta2, Spi.DAC_B, tempDac, AD_MAX, PLC_In, Gyro.Termo);//выдаем в терминал для постройки граффика регулировки периметра.
+ sprintf((Time),"%d %d %d %d %d %d %d %d %d \r\n",Gyro.CuruAngle, Gyro.Frq, Gyro.MaxAmp, Spi.DAC_B, tempDac, flagmod, AD_MAX, PLC_In, Gyro.Termo);//выдаем в терминал для постройки граффика регулировки периметра.
Gyro.CuruAngle=0;
Gyro.tempdelta=0;
Gyro.tempdelta2=0;
WriteCon(Time);
- // LoopOff
-
+ // LoopOff
}
}
@@ -351,12 +498,13 @@
void DAC_OutPut(void)//выдача в цапы
{
+ 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 = WRITE_DAC0; //e.команда для ЦАП_0 передавать.
LPC_SSP0->DR = (Spi.DAC_A); //e. передача 12 бит
} else { //если такт четный.
LPC_SSP0->DR = WRITE_DAC1 ; //e.команда для ЦАП_1 передавать.