I used HIGH frequency PWM to generate power for my electric magnet to make it attract and seperate
Then I use attach interrupt to get the time from PWM duty changed till the magnet attract and seperate is being captured by light sensor and sent back to the interrupt pin.
The error I got is when I make the PWM high, the light sensor interrupt pin doesn't react immediately but only works till the while loop function is finished.
It only works when I make the PWM over 2MHz and make duty really high.
Does anyone knows the reason? Thanks. Except that, other functions works fine.
//paramters define
#include "SPI.h"
#include <Adafruit_GFX.h>
#include <ILI9488.h>
#include <XPT2046_Touchscreen.h>
#include "pwm_lib.h"
//include "tc_lib.h"
using namespace arduino_due::pwm_lib;
//paramters define
#define PWM_PERIOD_PIN_42 42 // 100 usecs in hundredth of usecs (1e-8 secs)
#define PWM_DUTY_PIN_42 1 // 10 usec in hundredth of usecs (1e-8 secs)
#define MODEL ILI9488_18
#define CS A5
#define CS2 A6
#define DC A3
#define RST A4
#define LED A0 //if you don't need to control the LED pin,you should set it to -1 and set it to 3.3V
#define TIRQ_PIN 52
pwm<pwm_pin::PWMH1_PA19> pwm_pin42;
XPT2046_Touchscreen ts(CS2, TIRQ_PIN); // Param 2 - Touch IRQ Pin - interrupt enabled polling
//the definiens of hardware spi mode as follow:
//if the IC model is known or the modules is unreadable,you can use this constructed function
//LCDWIKI_SPI mylcd(MODEL,CS,CD,RST,LED); //model,cs,dc,reset,led
//if the IC model is not known and the modules is readable,you can use this constructed function
//LCDWIKI_SPI mylcd((pixely*2)0,480,CS,CD,RST,LED); //model,cs,dc,reset,led
ILI9488 mylcd = ILI9488(CS, DC, RST);
//define some colour values
#define BLACK 0x0000
#define BLUE 0x001F
#define RED 0xF800
#define GREEN 0x07E0
#define CYAN 0x07FF
#define MAGENTA 0xF81F
#define YELLOW 0xFFE0
#define WHITE 0xFFFF
int pwmDuty1 =21;
int pwmDutyH =25;
//For Arduino Mega 2560 only first 6 can be used as interrupt
int solenoidPort[] = {22,23,24,25,26,27,28,29,30,31}; //电磁铁信号端口号
int electricPort[] = {32,33,34,35,36,37,38,39,40,41}; //电磁铁信号端口号
int delayCounter =100;
int pwmOut01 = 42;
int pixely =18;
int pixelx =14;
int Tbutton1x=1045;
int Tbutton1y=700;
int Tbutton2x=1310;
int Tbutton2y=700;
int PWM_H_Time = 1500;
int PWM_L_Time = 400;
static unsigned long time1=0;
static unsigned long time2=0;
volatile unsigned long countrun =0;
volatile bool solenoidReleasedFailure[] = {0,0,0,0,0,0,0,0,0,0};
volatile bool solenoidEngagedFailure[] = {0,0,0,0,0,0,0,0,0,0};
volatile bool EsolenoidReleasedFailure[] = {0,0,0,0,0,0,0,0,0,0};
volatile bool EsolenoidEngagedFailure[] = {0,0,0,0,0,0,0,0,0,0};
volatile unsigned long count[] = {0,0,0,0,0,0,0,0,0,0};
volatile unsigned long countf[] = {0,0,0,0,0,0,0,0,0,0};
int yPrintPoint[]={60,90,120,150,180,210,240,270,280,300};
volatile unsigned long Rounds = 0;
volatile unsigned long Time_Run = 0;
volatile unsigned long Time_RecF[]= {0,0,0,0,0,0,0,0,0,0};
volatile unsigned long Time_RecR[]= {0,0,0,0,0,0,0,0,0,0};
volatile unsigned long Time_RecFL[]= {0,0,0,0,0,0,0,0,0,0};
volatile unsigned long Time_RecRL[]= {0,0,0,0,0,0,0,0,0,0};
volatile unsigned long ETime_RecF[]= {0,0,0,0,0,0,0,0,0,0};
volatile unsigned long ETime_RecR[]= {0,0,0,0,0,0,0,0,0,0};
volatile unsigned long ETime_RecFL[]= {0,0,0,0,0,0,0,0,0,0};
volatile unsigned long ETime_RecRL[]= {0,0,0,0,0,0,0,0,0,0};
void setup() {
//put your setup code here, to run once:
//pinMode(pwmOut01, OUTPUT);
ts.begin();
ts.setRotation(1);
mylcd.begin();
mylcd.setRotation(1);
mylcd.setTextSize(2);
pwm_pin42.start(PWM_PERIOD_PIN_42,PWM_DUTY_PIN_42);
Serial.begin(9600);
for(int i=0;i<10;i++)
{
pinMode(solenoidPort[i],INPUT);
pinMode(electricPort[i],INPUT);
}
attachInterrupt(digitalPinToInterrupt(solenoidPort[0]),ISR_Time_0F,FALLING);
attachInterrupt(digitalPinToInterrupt(solenoidPort[1]),ISR_Time_1F,FALLING);
attachInterrupt(digitalPinToInterrupt(solenoidPort[2]),ISR_Time_2F,FALLING);
attachInterrupt(digitalPinToInterrupt(solenoidPort[3]),ISR_Time_3F,FALLING);
attachInterrupt(digitalPinToInterrupt(solenoidPort[4]),ISR_Time_4F,FALLING);
attachInterrupt(digitalPinToInterrupt(solenoidPort[5]),ISR_Time_5F,FALLING);
attachInterrupt(digitalPinToInterrupt(solenoidPort[6]),ISR_Time_6F,FALLING);
attachInterrupt(digitalPinToInterrupt(solenoidPort[7]),ISR_Time_7F,FALLING);
attachInterrupt(digitalPinToInterrupt(solenoidPort[8]),ISR_Time_8F,FALLING);
attachInterrupt(digitalPinToInterrupt(solenoidPort[9]),ISR_Time_9F,FALLING);
attachInterrupt(digitalPinToInterrupt(electricPort[0]),EISR_Time_0F,FALLING);
attachInterrupt(digitalPinToInterrupt(electricPort[1]),EISR_Time_1F,FALLING);
attachInterrupt(digitalPinToInterrupt(electricPort[2]),EISR_Time_2F,FALLING);
attachInterrupt(digitalPinToInterrupt(electricPort[3]),EISR_Time_3F,FALLING);
attachInterrupt(digitalPinToInterrupt(electricPort[4]),EISR_Time_4F,FALLING);
attachInterrupt(digitalPinToInterrupt(electricPort[5]),EISR_Time_5F,FALLING);
attachInterrupt(digitalPinToInterrupt(electricPort[6]),EISR_Time_6F,FALLING);
attachInterrupt(digitalPinToInterrupt(electricPort[7]),EISR_Time_7F,FALLING);
attachInterrupt(digitalPinToInterrupt(electricPort[8]),EISR_Time_8F,FALLING);
attachInterrupt(digitalPinToInterrupt(electricPort[9]),EISR_Time_9F,FALLING);
// Setup Interrupt, will be overwriten in Loop
mylcd.fillScreen(ILI9488_BLACK);
mylcd.setCursor(70, 140);
mylcd.setTextSize(5);
mylcd.print("initializing");
delay(4000);
mylcd.setTextSize(1);
Rounds = 0;
Time_Run = 0;
for (int i =0;i<10;i++)
{
Time_RecF[i]= 0;
Time_RecR[i]= 0;
Time_RecFL[i]= 0;
Time_RecRL[i]= 0;
ETime_RecF[i]= 0;
ETime_RecR[i]= 0;
ETime_RecFL[i]= 0;
ETime_RecRL[i]= 0;
count[i] = 0;
countf[i] = 0;
}
}
#define change_duty_definition \
template<typename pwm_type> void change_duty( \
pwm_type& pwm_obj, \
uint32_t pwm_duty, \
uint32_t pwm_period \
) \
{ \
uint32_t duty=pwm_obj.get_duty()+pwm_duty; \
if(duty>pwm_period) duty=pwm_duty; \
pwm_obj.set_duty(duty); \
}
// FIX: here we instantiate the template definition
// of change_duty
change_duty_definition;
/*void PWM_init()
{
PMC->PMC_PCER1 |= PMC_PCER1_PID34; // TC7 power ON - Timer Counter 2 channel 1 IS TC7 - See page 38
PIOC->PIO_PDR |= PIO_PDR_P28; // The pin is no more driven by GPIO
PIOC->PIO_ABSR |= PIO_PC28B_TIOA7; // Periperal type B - See page 859
TC2->TC_CHANNEL[1].TC_CMR = TC_CMR_TCCLKS_TIMER_CLOCK1 // MCK/2, clk on rising edge
| TC_CMR_WAVE // Waveform mode
| TC_CMR_WAVSEL_UP_RC // UP mode with automatic trigger on RC Compare
| TC_CMR_ACPA_CLEAR // Clear TIOA7 on RA compare match -- See page 883
| TC_CMR_ACPC_SET; // Set TIOA7 on RC compare match
TC2->TC_CHANNEL[1].TC_RC = 2100; //<********************* Frequency = (Mck/2)/TC_RC Hz = 20 KHz
//TC2->TC_CHANNEL[1].TC_IER = TC_IER_CPCS; // Interrupt on RC compare match
//NVIC_EnableIRQ(TC7_IRQn);
TC2->TC_CHANNEL[1].TC_CCR = TC_CCR_SWTRG | TC_CCR_CLKEN; // Software trigger TC7 counter and enable
}
void PWM_Setduty(int n)
{
PWM_init();
TC2->TC_CHANNEL[1].TC_RA = n*21;//<******************** Duty cycle = (TC_RA/TC_RC) * 100 %
}*/
void PWM_Setduty(int n)
{
/************* Timer Counter 0 Channel 0 to generate PWM pulses thru TIOA0 ************/
PMC->PMC_PCER0 |= PMC_PCER0_PID27; // Timer Counter 0 channel 0 IS TC0, TCO power ON
PMC->PMC_PCER0 |= PMC_PCER0_PID12; // PIOB power ON, page 38
PIOB->PIO_PDR |= PIO_PDR_P25;
PIOB->PIO_ABSR |= PIO_ABSR_P25; // PB25 is driven by the TC, peripheral type B, page 858
TC0->TC_CHANNEL[0].TC_CMR = TC_CMR_TCCLKS_TIMER_CLOCK1 // MCK/2, clk on rising edge
| TC_CMR_WAVE // Waveform mode
| TC_CMR_WAVSEL_UP_RC // UP mode with automatic trigger on RC Compare
| TC_CMR_ACPA_CLEAR // Clear TIOA0 on RA compare match
| TC_CMR_ACPC_SET; // Set TIOA0 on RC compare match
TC0->TC_CHANNEL[0].TC_RC = 21; //<********************* Frequency = (Mck/2)/TC_RC = 1 MHz
//<******************** Duty cycle = (TC_RA/TC_RC) * 100 = 50 %
TC0->TC_CHANNEL[0].TC_RA = n;
TC0->TC_CHANNEL[0].TC_CCR = TC_CCR_SWTRG | TC_CCR_CLKEN; // Software trigger TC0 counter and enable
}
/*void PWM_Init()
{
//************* Timer Counter 0 Channel 0 to generate PWM pulses thru TIOA0 ************
PMC->PMC_PCER0 |= PMC_PCER0_PID27; // Timer Counter 0 channel 0 IS TC0, TCO power ON
PMC->PMC_PCER0 |= PMC_PCER0_PID12; // PIOB power ON, page 38
PIOB->PIO_PDR |= PIO_PDR_P25;
PIOB->PIO_ABSR |= PIO_ABSR_P25; // PB25 is driven by the TC, peripheral type B, page 858
TC0->TC_CHANNEL[0].TC_CMR = TC_CMR_TCCLKS_TIMER_CLOCK1 // MCK/2, clk on rising edge
| TC_CMR_WAVE // Waveform mode
| TC_CMR_WAVSEL_UP_RC // UP mode with automatic trigger on RC Compare
| TC_CMR_ACPA_CLEAR // Clear TIOA0 on RA compare match
| TC_CMR_ACPC_SET; // Set TIOA0 on RC compare match
TC0->TC_CHANNEL[0].TC_RC = 21; //<********************* Frequency = (Mck/2)/TC_RC = 1 MHz
//<******************** Duty cycle = (TC_RA/TC_RC) * 100 = 50 %
TC0->TC_CHANNEL[0].TC_CCR = TC_CCR_SWTRG | TC_CCR_CLKEN; // Software trigger TC0 counter and enable
TC0->TC_CHANNEL[0].TC_RA = 0;
}*/
void loop()
{
switch (ts.loopStatus)
{
case 0:
mainProgram();
break;
case 1:
pSetting();
break;
case 2:
prefresh();
break;
default:
mylcd.setCursor(70, 140);
mylcd.setTextSize(5);
mylcd.setTextColor(ILI9488_RED);
mylcd.print("Invalid Input");
}
}
void mainProgram()
{
Serial.print("Position......................1");
Serial.println(millis());
while(ts.loopStatus ==0)
{
LCDdisplay();
//start the LCD
//Rounds + to record the loop circles
Rounds++;
//Assign all 6 of the interrupt pin to the sensor, use it trigger time Calculation ISR when sensor Outage signal falling
attachInterrupt(digitalPinToInterrupt(solenoidPort[0]),ISR_Time_0F,FALLING);
attachInterrupt(digitalPinToInterrupt(solenoidPort[1]),ISR_Time_1F,FALLING);
attachInterrupt(digitalPinToInterrupt(solenoidPort[2]),ISR_Time_2F,FALLING);
attachInterrupt(digitalPinToInterrupt(solenoidPort[3]),ISR_Time_3F,FALLING);
attachInterrupt(digitalPinToInterrupt(solenoidPort[4]),ISR_Time_4F,FALLING);
attachInterrupt(digitalPinToInterrupt(solenoidPort[5]),ISR_Time_5F,FALLING);
attachInterrupt(digitalPinToInterrupt(solenoidPort[6]),ISR_Time_6F,FALLING);
attachInterrupt(digitalPinToInterrupt(solenoidPort[7]),ISR_Time_7F,FALLING);
attachInterrupt(digitalPinToInterrupt(solenoidPort[8]),ISR_Time_8F,FALLING);
attachInterrupt(digitalPinToInterrupt(solenoidPort[9]),ISR_Time_9F,FALLING);
//attachInterrupt(digitalPinToInterrupt(electricPort[0]),EISR_Time_0F,FALLING);
//attachInterrupt(digitalPinToInterrupt(electricPort[1]),EISR_Time_1F,FALLING);
//attachInterrupt(digitalPinToInterrupt(electricPort[2]),EISR_Time_2F,FALLING);
//attachInterrupt(digitalPinToInterrupt(electricPort[3]),EISR_Time_3F,FALLING);
//attachInterrupt(digitalPinToInterrupt(electricPort[4]),EISR_Time_4F,FALLING);
//attachInterrupt(digitalPinToInterrupt(electricPort[5]),EISR_Time_5F,FALLING);
//attachInterrupt(digitalPinToInterrupt(electricPort[6]),EISR_Time_6F,FALLING);
//attachInterrupt(digitalPinToInterrupt(electricPort[7]),EISR_Time_7F,FALLING);
//attachInterrupt(digitalPinToInterrupt(electricPort[8]),EISR_Time_8F,FALLING);
//attachInterrupt(digitalPinToInterrupt(electricPort[9]),EISR_Time_9F,FALLING);
//Mark all failure flag as true, then mark false in the interrupt function. The leftover are the interrupt pin that didn't trigger the Falling Interrupt function
for(int j=0; j<10; j++)
{
solenoidEngagedFailure[j]=1;
EsolenoidEngagedFailure[j]=1;//励磁失效置1
}
//Record time right before changing the magnet
Time_Run = millis();
pwm_pin42.set_duty(pwmDutyH);
//PWM_Setduty(12); //设置激励电压 0.75*24 = 18 24V代表电源模块输入电压
time1=millis();
time2=millis();
while((time2-time1)<delayCounter)
{
while (countrun < 50000)
{
countrun++;
}
time2=millis();
countrun=0;
}
pwm_pin42.set_duty(pwmDuty1);
//PWM_Setduty(8); //设置保持电压 0.25*24 = 6
time1=millis();
time2=millis();
countrun=0;
while ((time2-time1)<PWM_H_Time)
{
while (countrun < 50000)
{
countrun++;
}
time2=millis();
countrun =0;
if (ts.loopStatus !=0)
{
break;
}
}
countrun=0;
//Assign all 6 of the interrupt pin to the sensor, use it trigger time Calculation ISR when sensor Outage signal Rising
attachInterrupt(digitalPinToInterrupt(solenoidPort[0]),ISR_Time_0R,RISING);
attachInterrupt(digitalPinToInterrupt(solenoidPort[1]),ISR_Time_1R,RISING);
attachInterrupt(digitalPinToInterrupt(solenoidPort[2]),ISR_Time_2R,RISING);
attachInterrupt(digitalPinToInterrupt(solenoidPort[3]),ISR_Time_3R,RISING);
attachInterrupt(digitalPinToInterrupt(solenoidPort[4]),ISR_Time_4R,RISING);
attachInterrupt(digitalPinToInterrupt(solenoidPort[5]),ISR_Time_5R,RISING);
attachInterrupt(digitalPinToInterrupt(solenoidPort[6]),ISR_Time_6R,RISING);
attachInterrupt(digitalPinToInterrupt(solenoidPort[7]),ISR_Time_7R,RISING);
attachInterrupt(digitalPinToInterrupt(solenoidPort[8]),ISR_Time_8R,RISING);
attachInterrupt(digitalPinToInterrupt(solenoidPort[9]),ISR_Time_9R,RISING);
attachInterrupt(digitalPinToInterrupt(electricPort[0]),EISR_Time_0R,RISING);
attachInterrupt(digitalPinToInterrupt(electricPort[1]),EISR_Time_1R,RISING);
attachInterrupt(digitalPinToInterrupt(electricPort[2]),EISR_Time_2R,RISING);
attachInterrupt(digitalPinToInterrupt(electricPort[3]),EISR_Time_3R,RISING);
attachInterrupt(digitalPinToInterrupt(electricPort[4]),EISR_Time_4R,RISING);
attachInterrupt(digitalPinToInterrupt(electricPort[5]),EISR_Time_5R,RISING);
attachInterrupt(digitalPinToInterrupt(electricPort[6]),EISR_Time_6R,RISING);
attachInterrupt(digitalPinToInterrupt(electricPort[7]),EISR_Time_7R,RISING);
attachInterrupt(digitalPinToInterrupt(electricPort[8]),EISR_Time_8R,RISING);
attachInterrupt(digitalPinToInterrupt(electricPort[9]),EISR_Time_9R,RISING);
//Mark all failure flag as true, then mark false in the interrupt function. The leftover are the interrupt pin that didn't trigger the Rising Interrupt function
for(int j=0; j<10; j++)
{
solenoidReleasedFailure[j]=1;
EsolenoidReleasedFailure[j]=1;//电磁铁释放失效置1
}
//Record time right before changing the magnet
Time_Run = millis();
//analogWrite(pwmOut01, LOW);
pwm_pin42.set_duty(1);
time1=millis();
time2=millis();
while((time2-time1)<delayCounter)
{
while (countrun < 50000)
{
countrun++;
}
time2=millis();
countrun=0;
}
countrun =0;
pwm_pin42.set_duty(1);
//PWM_Setduty(1); //设置最小电压
time1=millis();
time2=millis();
while ((time2-time1)<PWM_L_Time)
{
while (countrun < 50000)
{
countrun++;
}
time2=millis();
countrun=0;
if (ts.loopStatus !=0)
{
break;
}
}
countrun =0;
//if no Falling and Rising failure, count++
for(int j=0; j<10; j++)
{
if(solenoidEngagedFailure[j]==0 && solenoidReleasedFailure[j]==0)
{
count[j]++;
}
else
{
countf[j]++;
}
}
}
}
void pSetting()
{
mylcd.fillScreen(ILI9488_BLACK);
while (ts.loopStatus ==1)
{
if (ts.vPWM_H_Time==1)
{
PWM_H_Time++;
ts.vPWM_H_Time=0;
}
else if (ts.vPWM_H_Time==-1)
{
PWM_H_Time--;
ts.vPWM_H_Time=0;
}
if (ts.vPWM_L_Time==1)
{
PWM_L_Time++;
ts.vPWM_L_Time=0;
}
else if (ts.vPWM_L_Time==-1)
{
PWM_L_Time--;
ts.vPWM_L_Time=0;
}
if (ts.pwmDuty==1)
{
pwmDuty1++;
ts.pwmDuty=0;
}
else if (ts.pwmDuty==-1)
{
pwmDuty1--;
ts.pwmDuty=0;
}
//Serial.println(ts.xraw);
//Serial.println(ts.yraw);
mylcd.setTextSize(5);
mylcd.setCursor(70, 30);
mylcd.print("<");
mylcd.setCursor(380, 30);
mylcd.print(">");
mylcd.setCursor(70, 110);
mylcd.print("<");
mylcd.setCursor(380, 110);
mylcd.print(">");
mylcd.setCursor(70, 190);
mylcd.print("<");
mylcd.setCursor(380, 190);
mylcd.print(">");
mylcd.setCursor(300, 270);
mylcd.print("RETURN");
mylcd.setTextSize(3);
mylcd.setCursor(140, 0);
mylcd.print("Attract Time");
mylcd.setCursor(140, 90);
mylcd.print("Release Time");
mylcd.setCursor(170, 180);
mylcd.print("PWM Duty");
mylcd.setCursor(230, 30);
mylcd.fillRect(230,30,120,30,ILI9488_BLACK);
mylcd.print(PWM_H_Time);
mylcd.setCursor(230, 120);
mylcd.fillRect(230,120,120,30,ILI9488_BLACK);
mylcd.print(PWM_L_Time);
mylcd.fillRect(230,210,120,30,ILI9488_BLACK);
mylcd.setCursor(230, 210);
mylcd.print(pwmDuty1);
}
prefresh();
}
void prefresh()
{
mylcd.fillScreen(ILI9488_BLACK);
mylcd.setCursor(70, 140);
mylcd.setTextSize(5);
mylcd.setTextColor(ILI9488_RED);
mylcd.setCursor(70, 140);
mylcd.print("Refreshing");
delay(300);
mylcd.setTextColor(ILI9488_GREEN);
mylcd.setCursor(70, 140);
mylcd.print("Refreshing");
delay(300);
mylcd.setTextColor(ILI9488_BLUE);
mylcd.setCursor(70, 140);
mylcd.print("Refreshing");
delay(300);
Rounds = 0;
for (int i =0;i<10;i++)
{
Time_RecF[i]= 0;
Time_RecR[i]= 0;
Time_RecFL[i]= 0;
Time_RecRL[i]= 0;
ETime_RecF[i]= 0;
ETime_RecR[i]= 0;
ETime_RecFL[i]= 0;
ETime_RecRL[i]= 0;
count[i] = 0;
countf[i] = 0;
solenoidReleasedFailure[i] = 0;
solenoidEngagedFailure[i] = 0;
EsolenoidReleasedFailure[i] = 0;
EsolenoidEngagedFailure[i] = 0;
}
ts.loopStatus = 0;
}
void LCDdisplay()
{
mylcd.fillRect(54,0,70,pixely,ILI9488_BLACK);
mylcd.fillRect(0,pixely*4,480,pixely*11,ILI9488_BLACK);
//Every character Pixel is x->12, y->18 for size 2
//LCD Resolution 480x320
mylcd.setTextColor(ILI9488_WHITE);
mylcd.setTextSize(3);
mylcd.setCursor(40, 270);
mylcd.print("SETTING");
mylcd.setCursor(300, 270);
mylcd.print("REFRESH");
mylcd.setTextSize(2);
mylcd.setCursor(56, pixely+10);
mylcd.print("Attract Time");
mylcd.setCursor(248, pixely+10);
mylcd.print("Release Time");
mylcd.setTextSize(1);
mylcd.setCursor(324, 6);
mylcd.print("Time Unit: m/s Pin: L&E");
mylcd.setCursor(0, 6);
mylcd.print("Rounds:");
mylcd.setCursor(54, 6);
mylcd.println(Rounds);
mylcd.setCursor(0, pixely*3);
mylcd.print("Pin"); // Name
mylcd.setCursor(36, pixely*3);
mylcd.print("LSensor");
mylcd.setCursor(90, pixely*3);
mylcd.print("PeakV");
mylcd.setCursor(138, pixely*3);
mylcd.print("ESensor");
mylcd.setCursor(186, pixely*3);
mylcd.print("PeakV");
mylcd.setCursor(228, pixely*3);
mylcd.print("LSensor");
mylcd.setCursor(276, pixely*3);
mylcd.print("PeakV");
mylcd.setCursor(324, pixely*3);
mylcd.print("ESensor");
mylcd.setCursor(372, pixely*3);
mylcd.print("PeakV");
mylcd.setCursor(408, pixely*3);
mylcd.println("pass");
mylcd.setCursor(450, pixely*3);
mylcd.println("fail");
for(int j=0; j<10; j++)
{
if(j%2==1)
{
mylcd.setTextColor(ILI9488_RED);
}
else
{
mylcd.setTextColor(ILI9488_GREEN);
}
if (Time_RecF[j]>Time_RecFL[j])
{
Time_RecFL[j] = Time_RecF[j];
}
if (Time_RecR[j]>Time_RecRL[j])
{
Time_RecRL[j] = Time_RecR[j];
}
if (ETime_RecF[j]>ETime_RecFL[j])
{
ETime_RecFL[j] = ETime_RecF[j];
}
if (ETime_RecR[j]>ETime_RecRL[j])
{
ETime_RecRL[j] = ETime_RecR[j];
}
mylcd.setCursor(0, (pixely*j)+(pixely*4));
mylcd.print(solenoidPort[j]);
mylcd.print("&");
mylcd.print(electricPort[j]);// number
mylcd.setCursor(36, (pixely*j)+(pixely*4));
if (solenoidEngagedFailure[j]==0)
mylcd.print(Time_RecF[j]); // Falling Reaction Time
else
mylcd.print("n/a");
mylcd.setCursor(90, (pixely*j)+(pixely*4));
mylcd.print(Time_RecFL[j]); // Falling Reaction Time
mylcd.setCursor(138, (pixely*j)+(pixely*4));
if (EsolenoidEngagedFailure[j]==0)
mylcd.print(ETime_RecF[j]); // Falling Reaction Time
else
mylcd.print("n/a");
mylcd.setCursor(186, (pixely*j)+(pixely*4));
mylcd.print(ETime_RecFL[j]); // Falling Reaction Time
mylcd.setCursor(228, (pixely*j)+(pixely*4));
if (solenoidReleasedFailure[j]==0)
mylcd.print(Time_RecR[j]);// Rising Reaction Time
else
mylcd.print("n/a");
mylcd.setCursor(276, (pixely*j)+(pixely*4));
mylcd.print(Time_RecRL[j]);// Rising Reaction Time
mylcd.setCursor(324, (pixely*j)+(pixely*4));
if (EsolenoidReleasedFailure[j]==0)
mylcd.print(ETime_RecR[j]);// Rising Reaction Time
else
mylcd.print("n/a");
mylcd.setCursor(372, (pixely*j)+(pixely*4));
mylcd.print(ETime_RecRL[j]);// Rising Reaction Time
mylcd.setCursor(408, (pixely*j)+(pixely*4));
mylcd.print(count[j]);
mylcd.setCursor(450, (pixely*j)+(pixely*4));
mylcd.print(countf[j]);
}
}
//All the interrupt triggered to change flag and get reaction time
void ISR_Time_0F(void)
{
Time_RecF[0] = millis()- Time_Run;
solenoidEngagedFailure[0]=0;
}
void ISR_Time_0R(void)
{
Time_RecR[0] = millis()- Time_Run;
solenoidReleasedFailure[0]=0;
}
void ISR_Time_1F(void)
{
Time_RecF[1] = millis()- Time_Run;
solenoidEngagedFailure[1]=0;
}
void ISR_Time_1R(void)
{
Time_RecR[1] = millis()- Time_Run;
solenoidReleasedFailure[1]=0;
}
void ISR_Time_2F(void)
{
Time_RecF[2] = millis()- Time_Run;
solenoidEngagedFailure[2]=0;
}
void ISR_Time_2R(void)
{
Time_RecR[2] = millis()- Time_Run;
solenoidReleasedFailure[2]=0;
}
void ISR_Time_3F(void)
{
Time_RecF[3] = millis()- Time_Run;
solenoidEngagedFailure[3]=0;
}
void ISR_Time_3R(void)
{
Time_RecR[3] = millis()- Time_Run;
solenoidReleasedFailure[3]=0;
}
void ISR_Time_4F(void)
{
Time_RecF[4] = millis()- Time_Run;
solenoidEngagedFailure[4]=0;
}
void ISR_Time_4R(void)
{
Time_RecR[4] = millis()- Time_Run;
solenoidReleasedFailure[4]=0;
}
void ISR_Time_5F(void)
{
Time_RecF[5] = millis()- Time_Run;
solenoidEngagedFailure[5]=0;
}
void ISR_Time_5R(void)
{
Time_RecR[5] = millis()- Time_Run;
solenoidReleasedFailure[5]=0;
}
void ISR_Time_6F(void)
{
Time_RecF[6] = millis()- Time_Run;
solenoidEngagedFailure[6]=0;
}
void ISR_Time_6R(void)
{
Time_RecR[6] = millis()- Time_Run;
solenoidReleasedFailure[6]=0;
}
void ISR_Time_7F(void)
{
Time_RecF[7] = millis()- Time_Run;
solenoidEngagedFailure[7]=0;
}
void ISR_Time_7R(void)
{
Time_RecR[7] = millis()- Time_Run;
solenoidReleasedFailure[7]=0;
}
void ISR_Time_8F(void)
{
Time_RecF[8] = millis()- Time_Run;
solenoidEngagedFailure[8]=0;
}
void ISR_Time_8R(void)
{
Time_RecR[8] = millis()- Time_Run;
solenoidReleasedFailure[8]=0;
}
void ISR_Time_9F(void)
{
Time_RecF[9] = millis()- Time_Run;
solenoidEngagedFailure[9]=0;
}
void ISR_Time_9R(void)
{
Time_RecR[9] = millis()- Time_Run;
solenoidReleasedFailure[9]=0;
}
void EISR_Time_0F(void)
{
ETime_RecF[0] = millis()- Time_Run;
EsolenoidEngagedFailure[0]=0;
}
void EISR_Time_0R(void)
{
ETime_RecR[0] = millis()- Time_Run;
EsolenoidReleasedFailure[0]=0;
}
void EISR_Time_1F(void)
{
ETime_RecF[1] = millis()- Time_Run;
EsolenoidEngagedFailure[1]=0;
}
void EISR_Time_1R(void)
{
ETime_RecR[1] = millis()- Time_Run;
EsolenoidReleasedFailure[1]=0;
}
void EISR_Time_2F(void)
{
ETime_RecF[2] = millis()- Time_Run;
EsolenoidEngagedFailure[2]=0;
}
void EISR_Time_2R(void)
{
ETime_RecR[2] = millis()- Time_Run;
EsolenoidReleasedFailure[2]=0;
}
void EISR_Time_3F(void)
{
ETime_RecF[3] = millis()- Time_Run;
EsolenoidEngagedFailure[3]=0;
}
void EISR_Time_3R(void)
{
ETime_RecR[3] = millis()- Time_Run;
EsolenoidReleasedFailure[3]=0;
}
void EISR_Time_4F(void)
{
ETime_RecF[4] = millis()- Time_Run;
EsolenoidEngagedFailure[4]=0;
}
void EISR_Time_4R(void)
{
ETime_RecR[4] = millis()- Time_Run;
EsolenoidReleasedFailure[4]=0;
}
void EISR_Time_5F(void)
{
ETime_RecF[5] = millis()- Time_Run;
EsolenoidEngagedFailure[5]=0;
}
void EISR_Time_5R(void)
{
ETime_RecR[5] = millis()- Time_Run;
EsolenoidReleasedFailure[5]=0;
}
void EISR_Time_6F(void)
{
ETime_RecF[6] = millis()- Time_Run;
EsolenoidEngagedFailure[6]=0;
}
void EISR_Time_6R(void)
{
ETime_RecR[6] = millis()- Time_Run;
EsolenoidReleasedFailure[6]=0;
}
void EISR_Time_7F(void)
{
ETime_RecF[7] = millis()- Time_Run;
EsolenoidEngagedFailure[7]=0;
}
void EISR_Time_7R(void)
{
ETime_RecR[7] = millis()- Time_Run;
EsolenoidReleasedFailure[7]=0;
}
void EISR_Time_8F(void)
{
ETime_RecF[8] = millis()- Time_Run;
EsolenoidEngagedFailure[8]=0;
}
void EISR_Time_8R(void)
{
ETime_RecR[8] = millis()- Time_Run;
EsolenoidReleasedFailure[8]=0;
}
void EISR_Time_9F(void)
{
ETime_RecF[9] = millis()- Time_Run;
EsolenoidEngagedFailure[9]=0;
}
void EISR_Time_9R(void)
{
ETime_RecR[9] = millis()- Time_Run;
EsolenoidReleasedFailure[9]=0;
}