431 lines
9.8 KiB
C++
Executable File
431 lines
9.8 KiB
C++
Executable File
#include <SPI.h>
|
|
|
|
#define ON 1
|
|
#define OFF 0
|
|
#define TIMREADA2D 0
|
|
#define TIMCLICKRELAY 1
|
|
#define TIMFLASHEDISONLED 2
|
|
#define TIMWRITED2A 3
|
|
#define TIMREADDIGS 4
|
|
|
|
void AnalogIn(void);
|
|
void AnalogOut(void);
|
|
void FlashEdisonLED(void);
|
|
void Relays(void);
|
|
void ReadDigitals(void);
|
|
void Timers(void);
|
|
|
|
unsigned int anout1; // Analog output value 1 - 0xFFFF (0 - 20mA)
|
|
unsigned int anout2; // Analog output value 2 - 0xFFFF (0 - 20mA)
|
|
unsigned int anin1; // Analog output value 1 - 0xFFFF (0-20mA, 0-10V, 0-5V)
|
|
unsigned int anin2; // Analog output value 2 - 0xFFFF (0-20mA, 0-10V, 0-5V)
|
|
unsigned int anin3; // Analog output value 3 - 0xFFFF (0-20mA, 0-10V, 0-5V)
|
|
unsigned int anin4; // Analog output value 4 - 0xFFFF (0-20mA, 0-10V, 0-5V)
|
|
|
|
// unsigned char edisonled; // flag for led on edison cannot use since messes with SPI
|
|
unsigned char redled; // flag for red status led
|
|
unsigned char greenled; // flag for green status led
|
|
unsigned char relay1, relay2, relay3, relay4, relay5, relay6; // Flags for control of relays
|
|
unsigned char digin1, digin2, digin3, digin4, digin5, digin6, digin7, digin8; // Flags show dig input state
|
|
unsigned long oldticker;
|
|
unsigned int ticker; // Millisecond counter
|
|
unsigned int timers[10];
|
|
|
|
void setup()
|
|
{
|
|
anout1 = 0;
|
|
anout2 = 0;
|
|
relay1 = 0;
|
|
relay2 = 0;
|
|
relay3 = 0;
|
|
relay4 = 0;
|
|
relay5 = 0;
|
|
relay6 = 0;
|
|
redled = 0;
|
|
greenled = 0;
|
|
pinMode(0, OUTPUT); // Relay 1
|
|
pinMode(1, OUTPUT); // Relay 2
|
|
pinMode(2, OUTPUT); // Relay 3
|
|
pinMode(3, OUTPUT); // Relay 4
|
|
pinMode(4, OUTPUT); // Relay 5
|
|
pinMode(5, OUTPUT); // Relay 6
|
|
pinMode(6, OUTPUT); // D2A CS
|
|
pinMode(8, OUTPUT); // Red board LED
|
|
pinMode(9, OUTPUT); // Green board LED
|
|
pinMode(11, OUTPUT); // SPI Out data
|
|
pinMode(12, INPUT); // SPI In data
|
|
pinMode(13, OUTPUT); // SPI CLK & Board LED)
|
|
pinMode(A5, INPUT);
|
|
pinMode(A0, OUTPUT); // Channel select LSB
|
|
pinMode(A1, OUTPUT); // Channel select 2nd bit
|
|
pinMode(A2, OUTPUT); // Channel select MSB
|
|
pinMode(A3, INPUT); // Result from reading digital inputs
|
|
|
|
|
|
// SPISettings settingsA(2000000, MSBFIRST, SPI_MODE1);
|
|
// SPI.beginTransaction(SPISettings(14000000, MSBFIRST, SPI_MODE0));
|
|
SPI.begin();
|
|
SPI.setBitOrder(MSBFIRST);
|
|
Serial.begin(9600);
|
|
pinMode(SS, OUTPUT);
|
|
}
|
|
|
|
void Relays(void)
|
|
{
|
|
if (relay1 == 1)
|
|
digitalWrite(0, HIGH);
|
|
else
|
|
digitalWrite(0, LOW);
|
|
if (relay2 == 1)
|
|
digitalWrite(1, HIGH);
|
|
else
|
|
digitalWrite(1, LOW);
|
|
if (relay3 == 1)
|
|
digitalWrite(2, HIGH);
|
|
else
|
|
digitalWrite(2, LOW);
|
|
if (relay4 == 1)
|
|
digitalWrite(3, HIGH);
|
|
else
|
|
digitalWrite(3, LOW);
|
|
if (relay5 == 1)
|
|
digitalWrite(4, HIGH);
|
|
else
|
|
digitalWrite(4, LOW);
|
|
if (relay6 == 1)
|
|
digitalWrite(5, HIGH);
|
|
else
|
|
digitalWrite(5, LOW);
|
|
}
|
|
|
|
void LEDs(void)
|
|
{
|
|
if (redled == 1)
|
|
digitalWrite(8, HIGH);
|
|
else
|
|
digitalWrite(8, LOW);
|
|
if (greenled == 1)
|
|
digitalWrite(9, HIGH);
|
|
else
|
|
digitalWrite(9, LOW);
|
|
}
|
|
|
|
|
|
void Timers(void)
|
|
{
|
|
unsigned char x;
|
|
unsigned long milli;
|
|
milli = millis();
|
|
if (milli == oldticker)
|
|
return;
|
|
oldticker = milli;
|
|
ticker++;
|
|
for (x=0; x<10;x++)
|
|
{
|
|
if(timers[x] > 0) timers[x]--;
|
|
}
|
|
// anout1++;
|
|
}
|
|
|
|
|
|
void AnalogOut(void)
|
|
{
|
|
static unsigned char x = 8;
|
|
static unsigned char diff;
|
|
|
|
unsigned char val;
|
|
unsigned int val16;
|
|
unsigned int incomingByte;
|
|
if (timers[TIMWRITED2A])
|
|
return;
|
|
anout1++;
|
|
// SPI.beginTransaction(2000000, MSBFIRST, SPI_MODE1);
|
|
digitalWrite(6, LOW);
|
|
val = 16; // Chan A
|
|
SPI.transfer(x);
|
|
if (diff == 1) x++;
|
|
if (diff == 2) x--;
|
|
diff = 0;
|
|
val16 = anout1;
|
|
val16 = val16 >> 8;
|
|
val = val16 & 0xFF;
|
|
SPI.transfer(0);
|
|
// SPI.transfer(val);
|
|
val = anout1 & 0xFF;
|
|
SPI.transfer(val);
|
|
// SPI.transfer(0);
|
|
|
|
/*
|
|
Serial.print(x);
|
|
Serial.print("\n");
|
|
|
|
if (Serial.available() > 0)
|
|
{
|
|
incomingByte = Serial.read();
|
|
if (incomingByte == '.') diff = 1;
|
|
if (incomingByte == ',') diff = 2;
|
|
if (incomingByte == ' ') diff = 0;
|
|
}
|
|
*/
|
|
timers[TIMWRITED2A] = 100;
|
|
digitalWrite(6, HIGH);
|
|
|
|
}
|
|
|
|
void AnalogIn(void)
|
|
{
|
|
unsigned char a,b,c;
|
|
unsigned int x;
|
|
static unsigned char chan = 0;
|
|
if (timers[TIMREADA2D])
|
|
return;
|
|
|
|
switch(chan)
|
|
{
|
|
case 0:
|
|
{
|
|
digitalWrite(A0, LOW); // Need to set up mux for each A2D like the relays
|
|
digitalWrite(A1, LOW);
|
|
digitalWrite(A2, LOW);
|
|
a = SPI.transfer(0);
|
|
b = SPI.transfer(0);
|
|
c = SPI.transfer(0);
|
|
/* Serial.print(a);
|
|
Serial.print(",");
|
|
Serial.print(b);
|
|
Serial.print(",");
|
|
Serial.print(c);
|
|
Serial.print(",");
|
|
*/ if (c == 13) // 13 good reading, 45 overrange, anything else A2D not ready
|
|
{
|
|
x = (unsigned int) a * 256;
|
|
x = x + b;
|
|
if (x >= 32767) // wrong ref fix
|
|
{ // wrong ref fix
|
|
x = x - 32767; // wrong ref fix
|
|
x = x * 2; // wrong ref fix
|
|
} // wrong ref fix
|
|
}
|
|
else
|
|
x = 0;
|
|
anin1 = x;
|
|
break;
|
|
}
|
|
|
|
case 1:
|
|
{
|
|
digitalWrite(A0, HIGH); // Need to set up mux for each A2D like the relays
|
|
digitalWrite(A1, LOW);
|
|
digitalWrite(A2, LOW);
|
|
a = SPI.transfer(0);
|
|
b = SPI.transfer(0);
|
|
c = SPI.transfer(0);
|
|
if (c == 13) // 13 good reading, 45 overrange, anything else A2D not ready
|
|
{
|
|
x = (unsigned int) a * 256;
|
|
x = x + b;
|
|
if (x >= 32767) // wrong ref fix
|
|
{ // wrong ref fix
|
|
x = x - 32767; // wrong ref fix
|
|
x = x * 2; // wrong ref fix
|
|
} // wrong ref fix
|
|
else
|
|
x = 0;
|
|
anin2 = x;
|
|
break;
|
|
}
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
digitalWrite(A0, LOW); // Need to set up mux for each A2D like the relays
|
|
digitalWrite(A1, HIGH);
|
|
digitalWrite(A2, LOW);
|
|
a = SPI.transfer(0);
|
|
b = SPI.transfer(0);
|
|
c = SPI.transfer(0);
|
|
if (c == 13) // 13 good reading, 45 overrange, anything else A2D not ready
|
|
{
|
|
x = (unsigned int) a * 256;
|
|
x = x + b;
|
|
if (x >= 32767) // wrong ref fix
|
|
{ // wrong ref fix
|
|
x = x - 32767; // wrong ref fix
|
|
x = x * 2; // wrong ref fix
|
|
} // wrong ref fix
|
|
}
|
|
else
|
|
x = 0;
|
|
anin3 = x;
|
|
break;
|
|
}
|
|
|
|
case 3:
|
|
{
|
|
digitalWrite(A0, HIGH); // Need to set up mux for each A2D like the relays
|
|
digitalWrite(A1, HIGH);
|
|
digitalWrite(A2, LOW);
|
|
a = SPI.transfer(0);
|
|
b = SPI.transfer(0);
|
|
c = SPI.transfer(0);
|
|
if (c == 13) // 13 good reading, 45 overrange, anything else A2D not ready
|
|
{
|
|
x = (unsigned int) a * 256;
|
|
x = x + b;
|
|
if (x >= 32767) // wrong ref fix
|
|
{ // wrong ref fix
|
|
x = x - 32767; // wrong ref fix
|
|
x = x * 2; // wrong ref fix
|
|
} // wrong ref fix
|
|
}
|
|
else
|
|
x = 0;
|
|
anin4 = x;
|
|
break;
|
|
}
|
|
|
|
default: ;
|
|
}
|
|
|
|
chan++;
|
|
if(chan > 3)
|
|
chan = 0;
|
|
|
|
Serial.print(anin1);
|
|
Serial.print(",");
|
|
Serial.print(anin2);
|
|
Serial.print(",");
|
|
Serial.print(anin3);
|
|
Serial.print(",");
|
|
Serial.print(anin4);
|
|
Serial.print("\n");
|
|
timers[TIMREADA2D] = 1000;
|
|
}
|
|
|
|
|
|
void ReadDigitals(void)
|
|
{
|
|
if (timers[TIMREADDIGS])
|
|
return;
|
|
digitalWrite(A0, LOW);
|
|
digitalWrite(A1, LOW);
|
|
digitalWrite(A2, LOW);
|
|
if (digitalRead(A3))
|
|
digin1 = 0;
|
|
else
|
|
digin1 = 1;
|
|
|
|
digitalWrite(A0, HIGH);
|
|
digitalWrite(A1, LOW);
|
|
if (digitalRead(A3))
|
|
digin2 = 0;
|
|
else
|
|
digin2 = 1;
|
|
|
|
digitalWrite(A0, LOW);
|
|
digitalWrite(A1, HIGH);
|
|
if (digitalRead(A3))
|
|
digin3 = 0;
|
|
else
|
|
digin3 = 1;
|
|
|
|
digitalWrite(A0, HIGH);
|
|
digitalWrite(A1, HIGH);
|
|
if (digitalRead(A3))
|
|
digin4 = 0;
|
|
else
|
|
digin4 = 1;
|
|
|
|
digitalWrite(A0, LOW);
|
|
digitalWrite(A1, LOW);
|
|
digitalWrite(A2, HIGH);
|
|
if (digitalRead(A3))
|
|
digin5 = 0;
|
|
else
|
|
digin5 = 1;
|
|
|
|
digitalWrite(A0, HIGH);
|
|
digitalWrite(A1, LOW);
|
|
if (digitalRead(A3))
|
|
digin6 = 0;
|
|
else
|
|
digin6 = 1;
|
|
|
|
digitalWrite(A0, LOW);
|
|
digitalWrite(A1, HIGH);
|
|
if (digitalRead(A3))
|
|
digin7 = 0;
|
|
else
|
|
digin7 = 1;
|
|
digitalWrite(A0, HIGH);
|
|
digitalWrite(A1, HIGH);
|
|
if (digitalRead(A3))
|
|
digin8 = 0;
|
|
else
|
|
digin8 = 1;
|
|
|
|
timers[TIMREADDIGS] = 500;
|
|
Serial.print(digin1);
|
|
Serial.print(", ");
|
|
Serial.print(digin2);
|
|
Serial.print(", ");
|
|
Serial.print(digin3);
|
|
Serial.print(", ");
|
|
Serial.print(digin4);
|
|
Serial.print(", ");
|
|
Serial.print(digin5);
|
|
Serial.print(", ");
|
|
Serial.print(digin6);
|
|
Serial.print(", ");
|
|
Serial.print(digin7);
|
|
Serial.print(", ");
|
|
Serial.print(digin8);
|
|
Serial.print(", ");
|
|
Serial.print("\n");
|
|
}
|
|
|
|
|
|
|
|
|
|
void loop() // the loop function runs over and over again forever
|
|
{
|
|
AnalogIn();
|
|
ReadDigitals();
|
|
LEDs();
|
|
Timers();
|
|
Relays();
|
|
AnalogOut();
|
|
|
|
anout1++;
|
|
|
|
if (timers[TIMCLICKRELAY] == 0)
|
|
{
|
|
if (relay1)
|
|
{
|
|
relay1 = 0;
|
|
relay2 = 1;
|
|
relay3 = 0;
|
|
relay4 = 1;
|
|
relay5 = 0;
|
|
relay6 = 1;
|
|
redled = 1;
|
|
greenled = 0;
|
|
}
|
|
else
|
|
{
|
|
relay1 = 1;
|
|
relay2 = 0;
|
|
relay3 = 1;
|
|
relay4 = 0;
|
|
relay5 = 1;
|
|
relay6 = 0;
|
|
redled = 0;
|
|
greenled = 1;
|
|
}
|
|
timers[TIMCLICKRELAY] = 5000;
|
|
}
|
|
}
|
|
|
|
|
|
|