Compare commits
3 Commits
Production
...
TruehemeV_
| Author | SHA1 | Date | |
|---|---|---|---|
|
5bb6d90735 | ||
|
|
c415b1ffa3 | ||
|
|
ebbec00b9a |
616
HPOS-V0.ino
616
HPOS-V0.ino
@@ -1,616 +0,0 @@
|
||||
#include "ADS1X15.h"
|
||||
#include <SPI.h>
|
||||
#include <Wire.h>
|
||||
//BLOOD
|
||||
//DEV_7
|
||||
//int LED1_dac = 406;
|
||||
//int LED2_dac = 160;
|
||||
//int LED3_dac = 218;
|
||||
//int LED4_dac = 248;
|
||||
|
||||
//DEV_8
|
||||
//int LED1_dac = 340;
|
||||
//int LED2_dac = 144;
|
||||
//int LED3_dac = 502;
|
||||
//int LED4_dac = 190;
|
||||
|
||||
//DEV_7
|
||||
int LED1_dac = 3096;
|
||||
int LED2_dac = 1900;
|
||||
int LED3_dac = 3532;
|
||||
int LED4_dac = 3980;
|
||||
|
||||
int LED1_unstable_samples = 20;
|
||||
int LED2_unstable_samples = 20;
|
||||
int LED3_unstable_samples = 20;
|
||||
int LED4_unstable_samples = 20;
|
||||
int LED1_sample_size = 50;
|
||||
int LED2_sample_size = 50;
|
||||
int LED3_sample_size = 50;
|
||||
int LED4_sample_size = 50;
|
||||
|
||||
const int PIN_CS_DAC1 = 10;
|
||||
const int PIN_CS_DAC2 = 9;
|
||||
const int GAIN_1 = 0x1;
|
||||
const int GAIN_2 = 0x0;
|
||||
|
||||
const int PD1G1 = 6;
|
||||
const int PD1G2 = 8;
|
||||
const int PD2G1 = 9;
|
||||
const int PD2G2 = 7;
|
||||
|
||||
const int LEDR = A0;
|
||||
const int LEDB = A2;
|
||||
const int LEDG = A1;
|
||||
|
||||
ADS1115 ADS(0x48);
|
||||
|
||||
int loopcounter = 0;
|
||||
unsigned long long intensity_storage = 0;
|
||||
int temp_counter = 0;
|
||||
|
||||
//long long data_storage=0;
|
||||
float avg_storage = 0;
|
||||
float avg_green = 0;
|
||||
float avg_blue = 0;
|
||||
float old_green = 0;
|
||||
float old_blue = 0;
|
||||
int flag = 0;
|
||||
|
||||
int split_counter = 0;
|
||||
int intensity_display = 1;
|
||||
int plotter = 0;
|
||||
|
||||
int moving_average_array[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
|
||||
int sorting_array[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
|
||||
int moving_average = 0;
|
||||
int j = 0;
|
||||
int temp_sort = 0;
|
||||
int unstable_samples = 20;
|
||||
int number_of_readings = 50;
|
||||
int skip = 0;
|
||||
|
||||
float average_readings = 0;
|
||||
float avg_LED1B = 0;
|
||||
float avg_LED2B = 0;
|
||||
float avg_LED3B = 0;
|
||||
float avg_LED4B = 0;
|
||||
float avg_LED1S = 0;
|
||||
float avg_LED2S = 0;
|
||||
float avg_LED3S = 0;
|
||||
float avg_LED4S = 0;
|
||||
|
||||
void setup()
|
||||
{
|
||||
Serial.begin(9600);
|
||||
pinMode(PIN_CS_DAC1, OUTPUT);
|
||||
pinMode(PIN_CS_DAC2, OUTPUT);
|
||||
|
||||
pinMode(PD1G1, OUTPUT);
|
||||
pinMode(PD1G2, OUTPUT);
|
||||
pinMode(PD2G1, OUTPUT);
|
||||
pinMode(PD2G2, OUTPUT);
|
||||
pinMode(LEDR, OUTPUT);
|
||||
pinMode(LEDG, OUTPUT);
|
||||
pinMode(LEDB, OUTPUT);
|
||||
digitalWrite(LEDR, LOW);
|
||||
digitalWrite(LEDG, HIGH);
|
||||
digitalWrite(LEDB, HIGH);
|
||||
SPI.begin();
|
||||
SPI.setClockDivider(SPI_CLOCK_DIV2);
|
||||
ADS.begin();
|
||||
}
|
||||
|
||||
void setOutput(byte channel, byte gain, byte shutdown, unsigned int val, int DACselect)
|
||||
{
|
||||
byte lowByte = val & 0xff;
|
||||
byte highByte = ((val >> 8) & 0xff) | channel << 7 | gain << 5 | shutdown << 4;
|
||||
if (DACselect == 1)
|
||||
{
|
||||
PORTB &= 0xfb;
|
||||
SPI.transfer(highByte);
|
||||
SPI.transfer(lowByte);
|
||||
PORTB |= 0x4;
|
||||
}
|
||||
else
|
||||
{
|
||||
PORTB &= 0xfd;
|
||||
SPI.transfer(highByte);
|
||||
SPI.transfer(lowByte);
|
||||
PORTB |= 0x2;
|
||||
}
|
||||
}
|
||||
|
||||
float detector(int unstable_samples, int number_of_readings, int detector_select, int PD1G1_gain_set, int PD1G2_gain_set, int PD2G1_gain_set, int PD2G2_gain_set)
|
||||
{
|
||||
if (PD1G1_gain_set == 0)
|
||||
{
|
||||
digitalWrite(PD1G1, LOW);
|
||||
}
|
||||
else
|
||||
{
|
||||
digitalWrite(PD1G1, HIGH);
|
||||
}
|
||||
if (PD1G2_gain_set == 0)
|
||||
{
|
||||
digitalWrite(PD1G2, LOW);
|
||||
}
|
||||
else
|
||||
{
|
||||
digitalWrite(PD1G2, HIGH);
|
||||
}
|
||||
if (PD2G1_gain_set == 0)
|
||||
{
|
||||
digitalWrite(PD2G1, LOW);
|
||||
}
|
||||
else
|
||||
{
|
||||
digitalWrite(PD2G1, HIGH);
|
||||
}
|
||||
if (PD2G2_gain_set == 0)
|
||||
{
|
||||
digitalWrite(PD2G2, LOW);
|
||||
}
|
||||
else
|
||||
{
|
||||
digitalWrite(PD2G2, HIGH);
|
||||
}
|
||||
memset (moving_average_array, 0, 10);
|
||||
temp_counter = 0;
|
||||
skip = 0;
|
||||
intensity_storage = 0;
|
||||
int16_t detector_val = 0;
|
||||
for (int i = 0; i < unstable_samples + number_of_readings; i += 1)
|
||||
{
|
||||
int16_t val_0 = ADS.readADC(0);
|
||||
int16_t val_1 = ADS.readADC(1);
|
||||
int16_t val_2 = ADS.readADC(2);
|
||||
int16_t val_3 = ADS.readADC(3);
|
||||
if (detector_select == 1)
|
||||
{
|
||||
detector_val = val_0;
|
||||
}
|
||||
else
|
||||
{
|
||||
detector_val = val_1;
|
||||
}
|
||||
moving_average_array[i % 10] = detector_val;
|
||||
for (int j = 0; j < 10; j++)
|
||||
{
|
||||
sorting_array[j] = moving_average_array[j];
|
||||
}
|
||||
if (i >= unstable_samples)
|
||||
{
|
||||
for (int j = 0; j < 6; j++)
|
||||
{
|
||||
for (int k = 0; k < (9 - j); k++)
|
||||
{
|
||||
if (sorting_array[k] > sorting_array[k + 1])
|
||||
{
|
||||
temp_sort = sorting_array[k];
|
||||
sorting_array[k] = sorting_array[k + 1];
|
||||
sorting_array[k + 1] = temp_sort;
|
||||
}
|
||||
}
|
||||
}
|
||||
moving_average = (sorting_array[4] / 2) + (sorting_array[5] / 2);
|
||||
if ((detector_val > (moving_average * 0.9)) and (detector_val < (moving_average * 1.1)))
|
||||
{
|
||||
intensity_storage += detector_val;
|
||||
temp_counter++;
|
||||
}
|
||||
else
|
||||
{
|
||||
skip++;
|
||||
}
|
||||
}
|
||||
if (intensity_display == 1)
|
||||
{
|
||||
}
|
||||
}
|
||||
setOutput(1, GAIN_1, 1, 0, 1);
|
||||
setOutput(0, GAIN_1, 1, 0, 1);
|
||||
setOutput(1, GAIN_1, 1, 0, 2);
|
||||
setOutput(0, GAIN_1, 1, 0, 2);
|
||||
average_readings = intensity_storage / temp_counter;
|
||||
return average_readings;
|
||||
}
|
||||
|
||||
void loop()
|
||||
{
|
||||
ADS.setGain(0);
|
||||
loopcounter = 0;
|
||||
avg_storage = 0;
|
||||
split_counter = 0;
|
||||
if (Serial.available()) {
|
||||
char data = Serial.read();
|
||||
|
||||
if (data == 'B') {
|
||||
|
||||
startTask1();
|
||||
}
|
||||
|
||||
else if (data == 'S') {
|
||||
startTask2();
|
||||
}
|
||||
|
||||
else if (data == 'P') { //Check if the received character is 1
|
||||
Serial.print("RESULT"); Serial.println(" "); Serial.print("LB1 "); Serial.println(avg_LED1B); Serial.print("LB2 "); Serial.println(avg_LED2B);
|
||||
Serial.print("LB3 "); Serial.println(avg_LED3B); Serial.print("LB4 "); Serial.println(avg_LED4B);
|
||||
Serial.print("LS1 "); Serial.println(avg_LED1S); Serial.print("LS2 "); Serial.println(avg_LED2S); Serial.print("LS3 "); Serial.println(avg_LED3S);
|
||||
Serial.print("LS4 "); Serial.println(avg_LED4S); Serial.println("REND");
|
||||
|
||||
delay(100);
|
||||
}
|
||||
|
||||
else if (data == 'D') { //Check if the received character is 1
|
||||
startTask3();
|
||||
}
|
||||
|
||||
else if (data == 'C') { //Check if the received character is 1
|
||||
startTask4();
|
||||
}
|
||||
|
||||
else if (data == 'I') { //Check if the received character is 1
|
||||
Serial.println("SNS HCV-000-3008 SNE");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
void startTask1() {
|
||||
Serial.println("#BS");
|
||||
digitalWrite(LEDB, HIGH);
|
||||
digitalWrite(LEDR, HIGH);
|
||||
digitalWrite(LEDG, LOW);
|
||||
|
||||
setOutput(1, GAIN_1, 1, 0, 1);
|
||||
setOutput(0, GAIN_1, 1, 0, 1);
|
||||
setOutput(1, GAIN_1, 1, 0, 2);
|
||||
setOutput(0, GAIN_1, 1, 0, 2);
|
||||
delay(100);
|
||||
setOutput(1, GAIN_1, 1, 0, 1);
|
||||
setOutput(0, GAIN_1, 1, 0, 1);
|
||||
setOutput(1, GAIN_1, 1, 0, 2);
|
||||
setOutput(0, GAIN_1, 1, 0, 2);
|
||||
//Serial.println("LED1 is ON");
|
||||
setOutput(0, GAIN_1, 1, LED1_dac, 1);
|
||||
delay(100);
|
||||
avg_LED1B = detector(LED1_unstable_samples, LED1_sample_size, 1, 0, 0, 0, 0);
|
||||
//Serial.print("Average LED1 intensity :"); Serial.println(avg_LED1);
|
||||
delay(1000);
|
||||
|
||||
|
||||
|
||||
setOutput(1, GAIN_1, 1, 0, 1);
|
||||
setOutput(0, GAIN_1, 1, 0, 1);
|
||||
setOutput(1, GAIN_1, 1, 0, 2);
|
||||
setOutput(0, GAIN_1, 1, 0, 2);
|
||||
setOutput(1, GAIN_1, 1, LED2_dac, 1);
|
||||
delay(100);
|
||||
avg_LED2B = detector(LED2_unstable_samples, LED2_sample_size, 1, 0, 0, 0, 0);
|
||||
//Serial.print("Average LED2 intensity :"); Serial.println(avg_LED2);
|
||||
delay(1000);
|
||||
|
||||
|
||||
|
||||
setOutput(1, GAIN_1, 1, 0, 1);
|
||||
setOutput(0, GAIN_1, 1, 0, 1);
|
||||
setOutput(1, GAIN_1, 1, 0, 2);
|
||||
setOutput(0, GAIN_1, 1, 0, 2);
|
||||
|
||||
setOutput(0, GAIN_1, 1, LED3_dac, 2);
|
||||
delay(100);
|
||||
avg_LED3B = detector(LED3_unstable_samples, LED3_sample_size, 1, 1, 0, 0, 0);
|
||||
//Serial.print("Average LED3 intensity :"); Serial.println(avg_LED3);
|
||||
delay(1000);
|
||||
|
||||
|
||||
|
||||
setOutput(1, GAIN_1, 1, 0, 1);
|
||||
setOutput(0, GAIN_1, 1, 0, 1);
|
||||
setOutput(1, GAIN_1, 1, 0, 2);
|
||||
setOutput(0, GAIN_1, 1, 0, 2);
|
||||
setOutput(1, GAIN_1, 1, LED4_dac, 2);
|
||||
delay(100);
|
||||
avg_LED4B = detector(LED4_unstable_samples, LED4_sample_size, 1, 0, 0, 0, 0);
|
||||
//Serial.print("Average LED4 intensity :"); Serial.println(avg_LED4);
|
||||
|
||||
delay(100);
|
||||
|
||||
// Serial.print("LED1B : "); Serial.print(avg_LED1B); Serial.print("\t"); Serial.print("LED2B : "); Serial.print(avg_LED2B); Serial.print("\t"); Serial.print("LED3B : "); Serial.print(avg_LED3B); Serial.print("\t"); Serial.print("LED4B : "); Serial.println(avg_LED4B);
|
||||
digitalWrite(LEDG, HIGH);
|
||||
digitalWrite(LEDB, LOW);
|
||||
digitalWrite(LEDR, HIGH);
|
||||
Serial.println("#BC");
|
||||
}
|
||||
|
||||
|
||||
|
||||
void startTask2() {
|
||||
Serial.println("#SS");
|
||||
setOutput(1, GAIN_1, 1, 0, 1);
|
||||
setOutput(0, GAIN_1, 1, 0, 1);
|
||||
setOutput(1, GAIN_1, 1, 0, 2);
|
||||
setOutput(0, GAIN_1, 1, 0, 2);
|
||||
delay(100);
|
||||
setOutput(1, GAIN_1, 1, 0, 1);
|
||||
setOutput(0, GAIN_1, 1, 0, 1);
|
||||
setOutput(1, GAIN_1, 1, 0, 2);
|
||||
setOutput(0, GAIN_1, 1, 0, 2);
|
||||
digitalWrite(LEDB, HIGH);
|
||||
digitalWrite(LEDG, LOW);
|
||||
digitalWrite(LEDR, HIGH);
|
||||
// digitalWrite(LED1, HIGH);
|
||||
// digitalWrite(LED2, LOW);
|
||||
// digitalWrite(LED3, LOW);
|
||||
// digitalWrite(LED4, LOW);
|
||||
//Serial.println("LED1 is ON");
|
||||
setOutput(0, GAIN_1, 1, LED1_dac, 1);
|
||||
delay(100);
|
||||
avg_LED1S = detector(LED1_unstable_samples, LED1_sample_size, 1, 0, 0, 0, 0);
|
||||
// Serial.print("Average LED1 intensity :"); Serial.println(avg_LED1);
|
||||
delay(1000);
|
||||
|
||||
|
||||
|
||||
setOutput(1, GAIN_1, 1, 0, 1);
|
||||
setOutput(0, GAIN_1, 1, 0, 1);
|
||||
setOutput(1, GAIN_1, 1, 0, 2);
|
||||
setOutput(0, GAIN_1, 1, 0, 2);
|
||||
setOutput(1, GAIN_1, 1, LED2_dac, 1);
|
||||
delay(100);
|
||||
avg_LED2S = detector(LED2_unstable_samples, LED2_sample_size, 1, 0, 0, 0, 0);
|
||||
//Serial.print("Average LED2 intensity :"); Serial.println(avg_LED2);
|
||||
delay(1000);
|
||||
|
||||
|
||||
|
||||
setOutput(1, GAIN_1, 1, 0, 1);
|
||||
setOutput(0, GAIN_1, 1, 0, 1);
|
||||
setOutput(1, GAIN_1, 1, 0, 2);
|
||||
setOutput(0, GAIN_1, 1, 0, 2);
|
||||
setOutput(0, GAIN_1, 1, LED3_dac, 2);
|
||||
delay(100);
|
||||
avg_LED3S = detector(LED3_unstable_samples, LED3_sample_size, 1, 1, 0, 0, 0);
|
||||
// Serial.print("Average LED3 intensity :"); Serial.println(avg_LED3);
|
||||
delay(1000);
|
||||
|
||||
|
||||
|
||||
setOutput(1, GAIN_1, 1, 0, 1);
|
||||
setOutput(0, GAIN_1, 1, 0, 1);
|
||||
setOutput(1, GAIN_1, 1, 0, 2);
|
||||
setOutput(0, GAIN_1, 1, 0, 2);
|
||||
// digitalWrite(LED1, LOW);
|
||||
// digitalWrite(LED2, LOW);
|
||||
// digitalWrite(LED3, LOW);
|
||||
// digitalWrite(LED4, HIGH);
|
||||
//Serial.println("LED4 is ON");
|
||||
setOutput(1, GAIN_1, 1, LED4_dac, 2);
|
||||
delay(100);
|
||||
avg_LED4S = detector(LED4_unstable_samples, LED4_sample_size, 1, 0, 0, 0, 0);
|
||||
//Serial.print("Average LED4 intensity :"); Serial.println(avg_LED4);
|
||||
|
||||
delay(100);
|
||||
|
||||
//Serial.print("LED1S : "); Serial.print(avg_LED1S); Serial.print("\t"); Serial.print("LED2S : "); Serial.print(avg_LED2S); Serial.print("\t"); Serial.print("LED3S : "); Serial.print(avg_LED3S); Serial.print("\t"); Serial.print("LED4S : "); Serial.println(avg_LED4S);
|
||||
digitalWrite(LEDG, HIGH);
|
||||
digitalWrite(LEDR, LOW);
|
||||
digitalWrite(LEDB, HIGH);
|
||||
Serial.println("#SC");
|
||||
}
|
||||
|
||||
void startTask3() {
|
||||
|
||||
ADS.setGain(0);
|
||||
loopcounter = 0;
|
||||
avg_storage = 0;
|
||||
split_counter = 0;
|
||||
|
||||
|
||||
setOutput(1, GAIN_1, 1, 0, 1);
|
||||
setOutput(0, GAIN_1, 1, 0, 1);
|
||||
setOutput(1, GAIN_1, 1, 0, 2);
|
||||
setOutput(0, GAIN_1, 1, 0, 2);
|
||||
Serial.println("LED1 is ON");
|
||||
delay(1000);
|
||||
for (int i = 100; i < 1200; i += 300)
|
||||
{
|
||||
setOutput(0, GAIN_1, 1, i, 1);
|
||||
delay(50);
|
||||
int16_t val_0 = ADS.readADC(0);
|
||||
Serial.print(val_0); Serial.print("__"); Serial.println(i);
|
||||
|
||||
}
|
||||
//setOutput(0, GAIN_1, 1, LED1_dac, 1);
|
||||
//delay(100);
|
||||
//avg_LED1=detector(LED1_unstable_samples, LED1_sample_size, 1, 0, 0, 0, 0);
|
||||
//Serial.print("Average LED1 intensity :");Serial.println(avg_LED1);
|
||||
delay(1000);
|
||||
|
||||
|
||||
setOutput(1, GAIN_1, 1, 0, 1);
|
||||
setOutput(0, GAIN_1, 1, 0, 1);
|
||||
setOutput(1, GAIN_1, 1, 0, 2);
|
||||
setOutput(0, GAIN_1, 1, 0, 2);
|
||||
Serial.println("LED2 is ON");
|
||||
delay(1000);
|
||||
for (int i = 100; i < 1200; i += 300)
|
||||
{
|
||||
setOutput(1, GAIN_1, 1, i, 1);
|
||||
delay(50);
|
||||
int16_t val_0 = ADS.readADC(0);
|
||||
Serial.print(val_0); Serial.print("__"); Serial.println(i);
|
||||
|
||||
}
|
||||
//setOutput(1, GAIN_1, 1, LED2_dac, 1);
|
||||
//delay(100);
|
||||
//avg_LED2=detector(LED2_unstable_samples, LED2_sample_size, 1, 0, 0, 0, 0);
|
||||
//Serial.print("Average LED2 intensity :");Serial.println(avg_LED2);
|
||||
delay(1000);
|
||||
|
||||
|
||||
|
||||
setOutput(1, GAIN_1, 1, 0, 1);
|
||||
setOutput(0, GAIN_1, 1, 0, 1);
|
||||
setOutput(1, GAIN_1, 1, 0, 2);
|
||||
setOutput(0, GAIN_1, 1, 0, 2);
|
||||
Serial.println("LED3 is ON");
|
||||
delay(1000);
|
||||
for (int i = 100; i < 1200; i += 300)
|
||||
{
|
||||
setOutput(0, GAIN_1, 1, i, 2);
|
||||
delay(50);
|
||||
int16_t val_0 = ADS.readADC(0);
|
||||
Serial.print(val_0); Serial.print("__"); Serial.println(i);
|
||||
|
||||
}
|
||||
//setOutput(0, GAIN_1, 1, LED3_dac, 2);
|
||||
//delay(100);
|
||||
//avg_LED3=detector(LED3_unstable_samples, LED3_sample_size, 1, 0, 0, 0, 0);
|
||||
//Serial.print("Average LED3 intensity :");Serial.println(avg_LED3);
|
||||
delay(1000);
|
||||
|
||||
|
||||
|
||||
setOutput(1, GAIN_1, 1, 0, 1);
|
||||
setOutput(0, GAIN_1, 1, 0, 1);
|
||||
setOutput(1, GAIN_1, 1, 0, 2);
|
||||
setOutput(0, GAIN_1, 1, 0, 2);
|
||||
Serial.println("LED4 is ON");
|
||||
delay(1000);
|
||||
for (int i = 100; i < 1200; i += 300)
|
||||
{
|
||||
setOutput(1, GAIN_1, 1, i, 2);
|
||||
delay(50);
|
||||
int16_t val_0 = ADS.readADC(0);
|
||||
Serial.print(val_0); Serial.print("__"); Serial.println(i);
|
||||
|
||||
}
|
||||
setOutput(1, GAIN_1, 1, 0, 1);
|
||||
setOutput(0, GAIN_1, 1, 0, 1);
|
||||
setOutput(1, GAIN_1, 1, 0, 2);
|
||||
setOutput(0, GAIN_1, 1, 0, 2);
|
||||
}
|
||||
void startTask4() {
|
||||
|
||||
ADS.setGain(0);
|
||||
loopcounter = 0;
|
||||
avg_storage = 0;
|
||||
split_counter = 0;
|
||||
setOutput(1, GAIN_1, 1, 0, 1);
|
||||
setOutput(0, GAIN_1, 1, 0, 1);
|
||||
setOutput(1, GAIN_1, 1, 0, 2);
|
||||
setOutput(0, GAIN_1, 1, 0, 2);
|
||||
delay(100);
|
||||
flag = 0;
|
||||
setOutput(1, GAIN_1, 1, 0, 1);
|
||||
setOutput(0, GAIN_1, 1, 0, 1);
|
||||
setOutput(1, GAIN_1, 1, 0, 2);
|
||||
setOutput(0, GAIN_1, 1, 0, 2);
|
||||
delay(1000);
|
||||
Serial.println("LED1 is ON");
|
||||
for (int i = 0; i < 500; i += 2)
|
||||
{
|
||||
setOutput(0, GAIN_1, 1, i, 1);
|
||||
delay(500);
|
||||
int16_t val_0 = ADS.readADC(0);
|
||||
Serial.print(val_0); Serial.print("__"); Serial.println(i);
|
||||
if ((val_0 > 22000) && (flag == 0))
|
||||
{
|
||||
LED1_dac = i;
|
||||
flag = 1;
|
||||
}
|
||||
}
|
||||
setOutput(0, GAIN_1, 1, LED1_dac, 1);
|
||||
// delay(100);
|
||||
// avg_LED1=detector(LED1_unstable_samples, LED1_sample_size, 1, 1, 0, 0, 0);
|
||||
// Serial.print("Average LED1 intensity :");Serial.println(avg_LED1);
|
||||
// delay(1000);
|
||||
|
||||
|
||||
flag = 0;
|
||||
setOutput(1, GAIN_1, 1, 0, 1);
|
||||
setOutput(0, GAIN_1, 1, 0, 1);
|
||||
setOutput(1, GAIN_1, 1, 0, 2);
|
||||
setOutput(0, GAIN_1, 1, 0, 2);
|
||||
delay(1000);
|
||||
Serial.println("LED2 is ON");
|
||||
for (int i = 0; i < 500; i += 2)
|
||||
{
|
||||
setOutput(1, GAIN_1, 1, i, 1);
|
||||
delay(500);
|
||||
int16_t val_0 = ADS.readADC(0);
|
||||
Serial.print(val_0); Serial.print("__"); Serial.println(i);
|
||||
if ((val_0 > 22000) && (flag == 0))
|
||||
{
|
||||
LED2_dac = i;
|
||||
flag = 1;
|
||||
}
|
||||
}
|
||||
//setOutput(1, GAIN_1, 1, LED2_dac, 1);
|
||||
//delay(100);
|
||||
//avg_LED2=detector(LED2_unstable_samples, LED2_sample_size, 1, 0, 0, 0, 0);
|
||||
//Serial.print("Average LED2 intensity :");Serial.println(avg_LED2);
|
||||
delay(1000);
|
||||
|
||||
|
||||
flag = 0;
|
||||
setOutput(1, GAIN_1, 1, 0, 1);
|
||||
setOutput(0, GAIN_1, 1, 0, 1);
|
||||
setOutput(1, GAIN_1, 1, 0, 2);
|
||||
setOutput(0, GAIN_1, 1, 0, 2);
|
||||
delay(1000);
|
||||
Serial.println("LED3 is ON");
|
||||
digitalWrite(PD1G1, HIGH);
|
||||
for (int i = 100; i < 700; i += 2)
|
||||
{
|
||||
setOutput(0, GAIN_1, 1, i, 2);
|
||||
delay(500);
|
||||
int16_t val_0 = ADS.readADC(0);
|
||||
Serial.print(val_0); Serial.print("__"); Serial.println(i);
|
||||
if ((val_0 > 22000) && (flag == 0))
|
||||
{
|
||||
LED3_dac = i;
|
||||
flag = 1;
|
||||
}
|
||||
}
|
||||
setOutput(0, GAIN_1, 1, LED3_dac, 2);
|
||||
delay(100);
|
||||
// avg_LED3=detector(LED3_unstable_samples, LED3_sample_size, 1, 1, 0, 0, 0);
|
||||
// Serial.print("Average LED3 intensity :");Serial.println(avg_LED3);
|
||||
delay(1000);
|
||||
digitalWrite(PD1G1, LOW);
|
||||
|
||||
|
||||
flag = 0;
|
||||
setOutput(1, GAIN_1, 1, 0, 1);
|
||||
setOutput(0, GAIN_1, 1, 0, 1);
|
||||
setOutput(1, GAIN_1, 1, 0, 2);
|
||||
setOutput(0, GAIN_1, 1, 0, 2);
|
||||
delay(1000);
|
||||
Serial.println("LED4 is ON");
|
||||
for (int i = 0; i < 500; i += 2)
|
||||
{
|
||||
setOutput(1, GAIN_1, 1, i, 2);
|
||||
delay(500);
|
||||
int16_t val_0 = ADS.readADC(0);
|
||||
Serial.print(val_0); Serial.print("__"); Serial.println(i);
|
||||
if ((val_0 > 22000) && (flag == 0))
|
||||
{
|
||||
LED4_dac = i;
|
||||
flag = 1;
|
||||
}
|
||||
}
|
||||
// setOutput(1, GAIN_1, 1, LED4_dac, 2);
|
||||
//delay(100);
|
||||
//avg_LED4=detector(LED4_unstable_samples, LED4_sample_size, 1, 0, 0, 0, 0);
|
||||
//Serial.print("Average LED4 intensity :");Serial.println(avg_LED4);
|
||||
|
||||
delay(1000);
|
||||
Serial.print("LED1 DAC :"); Serial.print(LED1_dac); Serial.print("\t"); Serial.print("LED2 DAC :"); Serial.print(LED2_dac); Serial.print("\t"); Serial.print("LED3 DAC :"); Serial.print(LED3_dac); Serial.print("\t"); Serial.print("LED4 DAC :"); Serial.println(LED4_dac);
|
||||
delay(5000);
|
||||
}
|
||||
@@ -1,542 +0,0 @@
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
/////////////////////////////////////////////////////////////////////TRUEHEME CODE V0.0.3///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
#include "ADS1X15.h"
|
||||
#include <SPI.h>
|
||||
#include <Wire.h>
|
||||
|
||||
int LED_sequence[] = {1,2,3,4};
|
||||
int LED_dac[] = {1640,1680,2104,2088};
|
||||
String Device_ID = "SNS HCV-000-3010 SNE"; //Device ID
|
||||
String Firmware_version_Auto=__FILE__;
|
||||
String Firmware_version = "TruehemeV0.0.3";
|
||||
int LED_unstable_samples[] = {20,20,20,20};
|
||||
int LED_sample_size[] = {50,50,50,50};
|
||||
int LED_DS_threshold[] = {22000,22000,22000,22000};
|
||||
int LED_settling_time[] = {10000,10000,10000,10000};
|
||||
int extra_delay_per_LED =10000;
|
||||
int LED_reading_delay[] = {0,0,0,0};
|
||||
int DAC_Sweep_start_limit[] = {1000,1000,1000,1000};
|
||||
int DAC_Sweep_end_limit[] = {4000,4000,4000,4000};
|
||||
int DacSweep_gain_combinations[] = {0,0,0,0};
|
||||
|
||||
int incr=8; //DAC sweep increment
|
||||
int del=500; //DAC delay
|
||||
int appmode=1;
|
||||
int moving_average_activation=0;
|
||||
int raw_ADC_print=1;
|
||||
int limit_printer=1;
|
||||
long limit_average_storage=0;
|
||||
|
||||
int Blank_gain_combinations[] = {0,0,0,0};
|
||||
int Sample_gain_combinationsG1[] = {0,0,0,0};
|
||||
int Sample_gain_combinationsG2[] = {1,1,1,1};
|
||||
int Sample_gain_combinationsG3[] = {2,2,2,2};
|
||||
int Sample_gain_combinationsG4[] = {4,4,4,4};
|
||||
int Sample_gain_combinationsG5[] = {8,8,8,8};
|
||||
|
||||
///////////////////////////////////////////DO NOT CHANGE ANY VALUES BELOW //////////////////////////////////////////////////////////////////////////////////////////////
|
||||
const int PIN_CS_DAC1 = 10;
|
||||
const int PIN_CS_DAC2 = 9;
|
||||
const int GAIN_1 = 0x1;
|
||||
const int GAIN_2 = 0x0;
|
||||
|
||||
const int PD1G1 = 6;
|
||||
const int PD1G2 = 8;
|
||||
const int PD2G1 = 9;
|
||||
const int PD2G2 = 7;
|
||||
|
||||
const int LEDR = A0;
|
||||
const int LEDB = A2;
|
||||
const int LEDG = A1;
|
||||
|
||||
ADS1115 ADS(0x48);
|
||||
///////////////////////////////////////////DO NOT CHANGE ANY VALUES ABOVE //////////////////////////////////////////////////////////////////////////////////////////////
|
||||
const char compile_date[] = __DATE__ " " __TIME__;
|
||||
int loopcounter = 0;
|
||||
unsigned long long intensity_storage = 0;
|
||||
int temp_counter = 0;
|
||||
|
||||
float avg_storage = 0;
|
||||
float avg_green = 0;
|
||||
float avg_blue = 0;
|
||||
float old_green = 0;
|
||||
float old_blue = 0;
|
||||
|
||||
int split_counter = 0;
|
||||
int intensity_display = 1;
|
||||
int plotter = 0;
|
||||
|
||||
int moving_average_array[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
|
||||
int sorting_array[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
|
||||
int moving_average = 0;
|
||||
int j = 0;
|
||||
int temp_sort = 0;
|
||||
int skip = 0;
|
||||
|
||||
float average_readings = 0;
|
||||
float avg_blank[]={0,0,0,0};
|
||||
float avg_sample[]={0,0,0,0};
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
void setup()
|
||||
{
|
||||
Serial.begin(9600);
|
||||
pinMode(PIN_CS_DAC1, OUTPUT);
|
||||
pinMode(PIN_CS_DAC2, OUTPUT);
|
||||
pinMode(PD1G1, OUTPUT);
|
||||
pinMode(PD1G2, OUTPUT);
|
||||
pinMode(PD2G1, OUTPUT);
|
||||
pinMode(PD2G2, OUTPUT);
|
||||
pinMode(LEDR, OUTPUT);
|
||||
pinMode(LEDG, OUTPUT);
|
||||
pinMode(LEDB, OUTPUT);
|
||||
digitalWrite(LEDR, LOW);
|
||||
digitalWrite(LEDG, HIGH);
|
||||
digitalWrite(LEDB, HIGH);
|
||||
SPI.begin();
|
||||
SPI.setClockDivider(SPI_CLOCK_DIV2);
|
||||
ADS.begin();
|
||||
if(appmode==0)
|
||||
{
|
||||
Serial.print("Initial DAC Settings: ");
|
||||
for (int i =0; i<4;i++)
|
||||
{
|
||||
Serial.print("\t");Serial.print(LED_dac[i]);
|
||||
}
|
||||
Serial.println();
|
||||
}
|
||||
if(appmode==0)
|
||||
{
|
||||
Serial.print("Process: Setup End; Timestamp: ");Serial.println(millis());
|
||||
}
|
||||
}
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
void all_LEDs_turnoff()
|
||||
{
|
||||
setOutput(GAIN_1, 0, 1); //LED 1
|
||||
setOutput(GAIN_1, 0, 2); //LED 2
|
||||
setOutput(GAIN_1, 0, 3); //LED 3
|
||||
setOutput(GAIN_1, 0, 4); //LED 4
|
||||
}
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
void secondary_gain_select(int gain_combo)
|
||||
{
|
||||
bool gain_choice1=bitRead(gain_combo, 0);
|
||||
bool gain_choice2=bitRead(gain_combo, 1);
|
||||
bool gain_choice3=bitRead(gain_combo, 2);
|
||||
bool gain_choice4=bitRead(gain_combo, 3);
|
||||
digitalWrite(PD1G1, gain_choice1);
|
||||
digitalWrite(PD1G2, gain_choice2);
|
||||
digitalWrite(PD2G1, gain_choice3);
|
||||
digitalWrite(PD2G2, gain_choice4);
|
||||
if(appmode==0)
|
||||
{
|
||||
Serial.print("Gains Used\t G1:");Serial.print(gain_choice1);Serial.print("\t G2:");Serial.print(gain_choice2);Serial.print("\t G3:");Serial.print(gain_choice3);Serial.print("\t G4:");Serial.println(gain_choice4);
|
||||
}
|
||||
}
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
//void setOutput(byte channel, byte gain, byte shutdown, unsigned int val, int DACselect)
|
||||
void setOutput(byte gain, unsigned int val, int LEDselect)
|
||||
{
|
||||
byte channel=0;
|
||||
byte shutdown=1;
|
||||
if(LEDselect%2==0)
|
||||
{
|
||||
channel=1;
|
||||
}
|
||||
else
|
||||
{
|
||||
channel=0;
|
||||
}
|
||||
byte lowByte = val & 0xff;
|
||||
byte highByte = ((val >> 8) & 0xff) | channel << 7 | gain << 5 | shutdown << 4;
|
||||
if (LEDselect <= 2)
|
||||
{
|
||||
PORTB &= 0xfb;
|
||||
SPI.transfer(highByte);
|
||||
SPI.transfer(lowByte);
|
||||
PORTB |= 0x4;
|
||||
}
|
||||
else
|
||||
{
|
||||
PORTB &= 0xfd;
|
||||
SPI.transfer(highByte);
|
||||
SPI.transfer(lowByte);
|
||||
PORTB |= 0x2;
|
||||
}
|
||||
}
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
int setDAC_LED()
|
||||
{
|
||||
int LED_flags[]={0,0,0,0};
|
||||
int flags_combined=0;
|
||||
if(appmode==0)
|
||||
{
|
||||
Serial.println("#DAC Sweep Start");
|
||||
}
|
||||
all_LEDs_turnoff();
|
||||
delay(1000);
|
||||
////////////////////////////////////////FIRST FORLOOP TO DISCARD STARTS/////////////////////////////////////////////////
|
||||
for (int i=3000;i<4096;i+=incr)
|
||||
{
|
||||
setOutput(GAIN_1, i, 1);
|
||||
delay(del);
|
||||
int16_t val_0 = ADS.readADC(0);
|
||||
if((val_0>24000))
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
all_LEDs_turnoff();
|
||||
delay(1000);
|
||||
////////////////////////////////////////FIRST FORLOOP TO DISCARD ENDS/////////////////////////////////////////////////
|
||||
//for (int j=0;j<sizeof(LED_sequence);j++)
|
||||
for (int j=0;j<4;j++)
|
||||
{
|
||||
all_LEDs_turnoff();
|
||||
secondary_gain_select(DacSweep_gain_combinations[j]);
|
||||
for (int i=DAC_Sweep_start_limit[j];i<DAC_Sweep_end_limit[j];i+=incr)
|
||||
{
|
||||
setOutput(GAIN_1, i, LED_sequence[j]);
|
||||
delay(del);
|
||||
int16_t val_0 = ADS.readADC(0);
|
||||
if((val_0>LED_DS_threshold[j])&&(LED_flags[j]==0))
|
||||
{
|
||||
LED_dac[j]=i;
|
||||
LED_flags[j]=1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
all_LEDs_turnoff();
|
||||
if (appmode==0)
|
||||
{
|
||||
Serial.print("LED ");Serial.print(j+1);Serial.print(" DACsweep Completed");Serial.print("\t");Serial.print("NEW DAC VALUE : ");Serial.println(LED_dac[j]);
|
||||
}
|
||||
delay(1000);
|
||||
}
|
||||
all_LEDs_turnoff();
|
||||
flags_combined=(LED_flags[3]*1)+(LED_flags[2]*10)+(LED_flags[1]*100)+(LED_flags[0]*1000);
|
||||
if(appmode==0)
|
||||
{
|
||||
Serial.println("#DAC Sweep End");
|
||||
}
|
||||
return flags_combined;
|
||||
}
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
float detector(int unstable_samples, int number_of_readings, int detector_select, int gain_combo, int settling_time, int reading_delay)
|
||||
{
|
||||
if(appmode==0)
|
||||
{
|
||||
Serial.print("Process: Detector Start for any one LED; Timestamp: ");Serial.println(millis());
|
||||
}
|
||||
secondary_gain_select(gain_combo);
|
||||
memset (moving_average_array, 0, 10);
|
||||
temp_counter = 0;
|
||||
skip = 0;
|
||||
intensity_storage = 0;
|
||||
int16_t detector_val = 0;
|
||||
if (moving_average_activation==1)
|
||||
{
|
||||
for (int i = 0; i < unstable_samples + number_of_readings; i += 1)
|
||||
{
|
||||
int16_t val_0 = ADS.readADC(0);
|
||||
int16_t val_1 = ADS.readADC(1);
|
||||
if (detector_select == 1)
|
||||
{
|
||||
detector_val = val_0;
|
||||
}
|
||||
else
|
||||
{
|
||||
detector_val = val_1;
|
||||
}
|
||||
moving_average_array[i % 10] = detector_val;
|
||||
for (int j = 0; j < 10; j++)
|
||||
{
|
||||
sorting_array[j] = moving_average_array[j];
|
||||
}
|
||||
if (i >= unstable_samples)
|
||||
{
|
||||
for (int j = 0; j < 6; j++)
|
||||
{
|
||||
for (int k = 0; k < (9 - j); k++)
|
||||
{
|
||||
if (sorting_array[k] > sorting_array[k + 1])
|
||||
{
|
||||
temp_sort = sorting_array[k];
|
||||
sorting_array[k] = sorting_array[k + 1];
|
||||
sorting_array[k + 1] = temp_sort;
|
||||
}
|
||||
}
|
||||
}
|
||||
moving_average = (sorting_array[4] / 2) + (sorting_array[5] / 2);
|
||||
if ((detector_val > (moving_average * 0.9)) and (detector_val < (moving_average * 1.1)))
|
||||
{
|
||||
intensity_storage += detector_val;
|
||||
temp_counter++;
|
||||
}
|
||||
else
|
||||
{
|
||||
skip++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
int start_time=millis();
|
||||
int current_time=millis();
|
||||
int lower_limit=0;
|
||||
int upper_limit=0;
|
||||
limit_average_storage=0;
|
||||
while((current_time-start_time)<settling_time)
|
||||
{
|
||||
int16_t val_0 = ADS.readADC(detector_select-1);
|
||||
if(raw_ADC_print==1)
|
||||
{
|
||||
Serial.println(val_0);
|
||||
}
|
||||
current_time=millis();
|
||||
}
|
||||
delay(extra_delay_per_LED);
|
||||
for (int i=0;i<number_of_readings;i++)
|
||||
{
|
||||
delay(reading_delay);
|
||||
int16_t val_0 = ADS.readADC(detector_select-1);
|
||||
if(raw_ADC_print==1)
|
||||
{
|
||||
if(limit_printer==1)
|
||||
{
|
||||
Serial.println(val_0);
|
||||
}
|
||||
else
|
||||
{
|
||||
Serial.println(val_0);
|
||||
}
|
||||
}
|
||||
intensity_storage+=val_0;
|
||||
temp_counter++;
|
||||
}
|
||||
}
|
||||
all_LEDs_turnoff();
|
||||
average_readings = intensity_storage/temp_counter;
|
||||
if(appmode==0)
|
||||
{
|
||||
Serial.print("Skipped samples: ");Serial.println(skip);
|
||||
Serial.print("Process: Detector Start for any one LED; Timestamp: ");Serial.println(millis());
|
||||
}
|
||||
return average_readings;
|
||||
}
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
void loop()
|
||||
{
|
||||
ADS.setGain(0);
|
||||
loopcounter = 0;
|
||||
avg_storage = 0;
|
||||
split_counter = 0;
|
||||
if (Serial.available())
|
||||
{
|
||||
char data = Serial.read();
|
||||
if (data == 'C')
|
||||
{
|
||||
Serial.println("#CS");
|
||||
int flags=setDAC_LED();
|
||||
if(flags!=1111)
|
||||
{
|
||||
if(appmode==0)
|
||||
{
|
||||
Serial.println("Unable to reach 24000 for atleast one LED");
|
||||
}
|
||||
}
|
||||
Serial.print("LED1_DAC: ");Serial.println(LED_dac[0]);
|
||||
Serial.print("LED2_DAC: ");Serial.println(LED_dac[1]);
|
||||
Serial.print("LED3_DAC: ");Serial.println(LED_dac[2]);
|
||||
Serial.print("LED4_DAC: ");Serial.println(LED_dac[3]);
|
||||
Serial.println("#CC");
|
||||
}
|
||||
if (data == 'B')
|
||||
{
|
||||
startTask1();
|
||||
}
|
||||
else if ((data == 'S')||(data == 'T')||(data == 'U')||(data == 'V')||(data == 'W'))
|
||||
{
|
||||
if(data == 'S')
|
||||
{
|
||||
startTask2(1);
|
||||
}
|
||||
else if(data == 'T')
|
||||
{
|
||||
startTask2(2);
|
||||
}
|
||||
else if(data == 'U')
|
||||
{
|
||||
startTask2(3);
|
||||
}
|
||||
else if(data == 'V')
|
||||
{
|
||||
startTask2(4);
|
||||
}
|
||||
else if(data == 'W')
|
||||
{
|
||||
startTask2(5);
|
||||
}
|
||||
}
|
||||
else if (data == 'D')
|
||||
{
|
||||
startTask3();
|
||||
}
|
||||
else if (data == 'I')
|
||||
{
|
||||
Serial.println(Device_ID);
|
||||
}
|
||||
else if (data == 'R')
|
||||
{
|
||||
int dac_print=0;
|
||||
for (int i=1;i<5;i++)
|
||||
{
|
||||
Serial.print("LED");Serial.print(i);Serial.print(" DAC : ");Serial.println
|
||||
(LED_dac[i-1]);
|
||||
}
|
||||
}
|
||||
else if (data == 'F')
|
||||
{
|
||||
Serial.print("Firmware Version : ");Serial.println(Firmware_version);
|
||||
Serial.print("Firmware Version Autoloaded: ");Serial.println(Firmware_version_Auto);
|
||||
Serial.print("Date and Time of Firmware Upload : ");Serial.println(compile_date);
|
||||
}
|
||||
else if (data == 'P')
|
||||
{
|
||||
Serial.print("RESULT"); Serial.println(" "); Serial.print("LB1 "); Serial.println(avg_blank[0]); Serial.print("LB2 "); Serial.println(avg_blank[1]);
|
||||
Serial.print("LB3 "); Serial.println(avg_blank[2]); Serial.print("LB4 "); Serial.println(avg_blank[3]);
|
||||
Serial.print("LS1 "); Serial.println(avg_sample[0]); Serial.print("LS2 "); Serial.println(avg_sample[1]); Serial.print("LS3 "); Serial.println(avg_sample[2]);
|
||||
Serial.print("LS4 "); Serial.println(avg_sample[3]); Serial.println("REND");
|
||||
delay(100);
|
||||
}
|
||||
}
|
||||
}
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
void startTask1()
|
||||
{
|
||||
if(appmode==0)
|
||||
{
|
||||
Serial.print("Process: Buffer start; Timestamp: ");Serial.println(millis());
|
||||
}
|
||||
all_LEDs_turnoff();
|
||||
delay(100);
|
||||
all_LEDs_turnoff();
|
||||
Serial.println("#BS");
|
||||
for (int i=0;i<4;i++)
|
||||
{
|
||||
setOutput(GAIN_1, LED_dac[i], LED_sequence[i]);
|
||||
delay(100);
|
||||
avg_blank[i] = detector(LED_unstable_samples[i], LED_sample_size[i], 1, Blank_gain_combinations[i], LED_settling_time[i], LED_reading_delay[i]);
|
||||
all_LEDs_turnoff();
|
||||
delay(1000);
|
||||
}
|
||||
if (appmode==0)
|
||||
{
|
||||
Serial.print(millis());Serial.print("\t");Serial.print("LED1B : "); Serial.print(avg_blank[0]); Serial.print("\t"); Serial.print("LED2B : "); Serial.print(avg_blank[1]); Serial.print("\t"); Serial.print("LED3B : "); Serial.print(avg_blank[2]); Serial.print("\t"); Serial.print("LED4B : "); Serial.println(avg_blank[3]);
|
||||
}
|
||||
Serial.println("#BC");
|
||||
if(appmode==0)
|
||||
{
|
||||
Serial.print("Process: Buffer end; Timestamp: ");Serial.println(millis());
|
||||
}
|
||||
}
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
void startTask2(int selector)
|
||||
{
|
||||
if(appmode==0)
|
||||
{
|
||||
Serial.print("Process: Sample start; Timestamp: ");Serial.println(millis());
|
||||
}
|
||||
int Sample_gain_combinations[]={0,0,0,0};
|
||||
if(selector==1)
|
||||
{
|
||||
Sample_gain_combinations[0]=Sample_gain_combinationsG1[0];
|
||||
Sample_gain_combinations[1]=Sample_gain_combinationsG1[1];
|
||||
Sample_gain_combinations[2]=Sample_gain_combinationsG1[2];
|
||||
Sample_gain_combinations[3]=Sample_gain_combinationsG1[3];
|
||||
}
|
||||
if(selector==2)
|
||||
{
|
||||
Sample_gain_combinations[0]=Sample_gain_combinationsG2[0];
|
||||
Sample_gain_combinations[1]=Sample_gain_combinationsG2[1];
|
||||
Sample_gain_combinations[2]=Sample_gain_combinationsG2[2];
|
||||
Sample_gain_combinations[3]=Sample_gain_combinationsG2[3];
|
||||
}
|
||||
if(selector==3)
|
||||
{
|
||||
Sample_gain_combinations[0]=Sample_gain_combinationsG3[0];
|
||||
Sample_gain_combinations[1]=Sample_gain_combinationsG3[1];
|
||||
Sample_gain_combinations[2]=Sample_gain_combinationsG3[2];
|
||||
Sample_gain_combinations[3]=Sample_gain_combinationsG3[3];
|
||||
}
|
||||
if(selector==4)
|
||||
{
|
||||
Sample_gain_combinations[0]=Sample_gain_combinationsG4[0];
|
||||
Sample_gain_combinations[1]=Sample_gain_combinationsG4[1];
|
||||
Sample_gain_combinations[2]=Sample_gain_combinationsG4[2];
|
||||
Sample_gain_combinations[3]=Sample_gain_combinationsG4[3];
|
||||
}
|
||||
if(selector==5)
|
||||
{
|
||||
Sample_gain_combinations[0]=Sample_gain_combinationsG5[0];
|
||||
Sample_gain_combinations[1]=Sample_gain_combinationsG5[1];
|
||||
Sample_gain_combinations[2]=Sample_gain_combinationsG5[2];
|
||||
Sample_gain_combinations[3]=Sample_gain_combinationsG5[3];
|
||||
}
|
||||
all_LEDs_turnoff();
|
||||
delay(100);
|
||||
all_LEDs_turnoff();
|
||||
Serial.print("#SS");Serial.println(selector);
|
||||
for (int i=0;i<4;i++)
|
||||
{
|
||||
setOutput(GAIN_1, LED_dac[i], LED_sequence[i]);
|
||||
delay(100);
|
||||
avg_sample[i] = detector(LED_unstable_samples[i], LED_sample_size[i], 1, Sample_gain_combinations[i],LED_settling_time[i], LED_reading_delay[i]);
|
||||
all_LEDs_turnoff();
|
||||
delay(1000);
|
||||
}
|
||||
if (appmode==0)
|
||||
{
|
||||
Serial.print(millis());Serial.print("\t");Serial.print("LED1S : "); Serial.print(avg_sample[0]); Serial.print("\t"); Serial.print("LED2S : "); Serial.print(avg_sample[1]); Serial.print("\t"); Serial.print("LED3S : "); Serial.print(avg_sample[2]); Serial.print("\t"); Serial.print("LED4S : "); Serial.println(avg_sample[3]);
|
||||
}
|
||||
Serial.print("#SC");Serial.println(selector);
|
||||
if(appmode==0)
|
||||
{
|
||||
Serial.print("Process: Sample end; Timestamp: ");Serial.println(millis());
|
||||
}
|
||||
}
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
void startTask3()
|
||||
{
|
||||
if(appmode==0)
|
||||
{
|
||||
Serial.print("Process: Diagnostics start; Timestamp: ");Serial.println(millis());
|
||||
}
|
||||
int reading_delay=500;
|
||||
int reading_increment=128;
|
||||
all_LEDs_turnoff();
|
||||
Serial.println("#DS");
|
||||
for (j=0;j<4;j++)
|
||||
{
|
||||
delay(1000);
|
||||
for (int i = 0; i <=4096; i += reading_increment)
|
||||
{
|
||||
setOutput(GAIN_1, i, LED_sequence[j]);
|
||||
delay(reading_delay);
|
||||
int16_t val_0 = ADS.readADC(0);
|
||||
Serial.print("LED:");Serial.print(j+1);Serial.print("__DAC:");Serial.print(i);Serial.print("__ADC:");Serial.println(val_0);
|
||||
}
|
||||
delay(1000);
|
||||
}
|
||||
Serial.println("#DC");
|
||||
all_LEDs_turnoff();
|
||||
delay(1000);
|
||||
if(appmode==0)
|
||||
{
|
||||
Serial.print("Process: Diagnostics end; Timestamp: ");Serial.println(millis());
|
||||
}
|
||||
}
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
764
TruehemeV0.1.3.ino
Normal file
764
TruehemeV0.1.3.ino
Normal file
@@ -0,0 +1,764 @@
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
/////////////////////////////////////////////////////////////////////TRUEHEME CODE V0.1.3 - BETA Version (Tested)/////////////////////////////////////////////////////////////////////
|
||||
//////////NEW Changes: All LED warmup function Added; Limit Switch added;EEPROM storage of DAC values; Stray light sensing; Turing on any one LED///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
#include "ADS1X15.h"
|
||||
#include <EEPROM.h>
|
||||
#include <SPI.h>
|
||||
#include <Wire.h>
|
||||
/////////////////////////////////////////////////////////////////////PLEASE UPDATE DEVICE ID BEFORE UPLOADING TO ANY DEVICE/////////////////////////////////////////////////////////////////
|
||||
String Device_ID = "SNS HCV-001-0012 SNE"; // Device ID
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
const int LED_available[] = {1,2,3,4}; // List of LEDs available. All Variables with 4 columns (other than ones controlling the LED turning ON sequence) must be filled in this order
|
||||
int LED_sequence[] = {1,2,3,4}; // LED turning ON sequence
|
||||
int Detector_sequence[] = {1,1,1,1}; // Detector sequence (if hardware supports dual pathlength)
|
||||
int LED_dac[] = {1792,2304,2040,1920}; // Preset DAC values for the device
|
||||
int LED_sample_size[] = {50,50,50,50}; // No. of ADC readings to use for Average ADC calculation
|
||||
int LED_DS_threshold[] = {22000,18000,18000,22000}; // DAC sweep upperlimit for each LED
|
||||
int LED_settling_time[] = {20000,20000,20000,20000}; // Settling time given to each LED
|
||||
int ADC_reading_delay[] = {0,0,0,0}; // Delay for each ADC reading while averaging
|
||||
int led_warmup_DAC[] = {3000,3000,3000,3000}; // DAC value at which all the LEDs will be powered during LED warmup
|
||||
int DAC_Sweep_start_limit[] = {1000,1000,1000,1000}; // Lower limit for DAC sweep
|
||||
int DAC_Sweep_end_limit[] = {4000,4000,4000,4000}; // Upper limit for DAC sweep
|
||||
int DacSweep_gain_combinations[] = {0,0,0,0}; // Gain to be used for DAC sweep
|
||||
|
||||
int incr=8; // DAC sweep increment
|
||||
int del=1000; // Delay between each interval of the DAC sweep
|
||||
int appmode=1; // if =1, it removes most of the unwanted serial prints
|
||||
int raw_ADC_print=0; // if =1, it will serialprint raw ADC values (even during LED warmup and settling)
|
||||
int timestamp_printer=0; // if =1, will print timestamp at regular intervals
|
||||
int limit_switch_active=0; // If there is a limit switch in the device, make it 1
|
||||
|
||||
int Blank_gain_combinations[] = {0,0,0,0}; // Programmable gain to be used while blanking
|
||||
int Sample_gain_combinations[5][4] = {{0,0,0,0},{1,1,1,1},{2,2,2,2},{4,4,4,4},{8,8,8,8}}; // Programmable gain to be used while taking sample readings
|
||||
|
||||
///////////////////////////////////////////DO NOT CHANGE ANY VALUES BELOW //////////////////////////////////////////////////////////////////////////////////////////////
|
||||
const int PIN_CS_DAC1 = 10; // Chip select pin for DAC 1
|
||||
const int PIN_CS_DAC2 = 9; // Chip select pin for DAC 2
|
||||
const int GAIN_1 = 0x1; // DAC 1X gain (output between 0 - 2.048 Volts)
|
||||
const int GAIN_2 = 0x0; // DAC 2X gain (output between 0 - 4.096 Volts)
|
||||
|
||||
const int PD1G1 = 6; // Programmable gain resistor _______ohm
|
||||
const int PD1G2 = 8; // Programmable gain resistor _______ohm
|
||||
const int PD2G1 = 5; // Programmable gain resistor _______ohm
|
||||
const int PD2G2 = 7; // Programmable gain resistor _______ohm
|
||||
|
||||
const int LEDR = A2; // Red indicator LED
|
||||
const int LEDB = A0; // Blue indicator LED
|
||||
const int LEDG = A1; // Green indicator LED
|
||||
|
||||
const int Limit_Switch = 2; // Limit switch for cuvette sensing
|
||||
const int Buzzer_pin = 3; // Buzzer connection for alert
|
||||
|
||||
ADS1115 ADS(0x48);
|
||||
///////////////////////////////////////////DO NOT CHANGE ANY VALUES ABOVE //////////////////////////////////////////////////////////////////////////////////////////////
|
||||
const char compile_date[] = __DATE__ " " __TIME__; //Stores date and time when the firmware was uploaded on the arduino
|
||||
String Firmware_location_Auto=__FILE__; //Stores location of the firmware on the computer used for uploading
|
||||
String Firmware_version_Auto=__FILE__; //Stores the firmware version uploaded
|
||||
int DAC_lower_limit[]= {0,0,0,0};
|
||||
int DAC_upper_limit[]= {4096,4096,4096,4096};
|
||||
unsigned long long intensity_storage = 0;
|
||||
int temp_counter = 0;
|
||||
const int detector_settling_time=2000;
|
||||
const int detector_settling_time_DACsweep=1000;
|
||||
|
||||
float avg_storage = 0;
|
||||
float avg_green = 0;
|
||||
float avg_blue = 0;
|
||||
float old_green = 0;
|
||||
float old_blue = 0;
|
||||
int initialRGBstate=0;
|
||||
|
||||
int split_counter = 0;
|
||||
int intensity_display = 1;
|
||||
int plotter = 0;
|
||||
|
||||
int j = 0;
|
||||
|
||||
float average_readings = 0;
|
||||
float avg_blank[]={0,0,0,0};
|
||||
float avg_air_blank[]={0,0,0,0};
|
||||
float avg_sample[]={0,0,0,0};
|
||||
int LED_on_status[]={0,0,0,0};
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
void setup()
|
||||
{
|
||||
Serial.begin(9600);
|
||||
pinMode(PIN_CS_DAC1, OUTPUT);
|
||||
pinMode(PIN_CS_DAC2, OUTPUT);
|
||||
pinMode(PD1G1, OUTPUT);
|
||||
pinMode(PD1G2, OUTPUT);
|
||||
pinMode(PD2G1, OUTPUT);
|
||||
pinMode(PD2G2, OUTPUT);
|
||||
pinMode(LEDR, OUTPUT);
|
||||
pinMode(LEDG, OUTPUT);
|
||||
pinMode(LEDB, OUTPUT);
|
||||
pinMode(Limit_Switch, INPUT);
|
||||
pinMode(Buzzer_pin, OUTPUT);
|
||||
digitalWrite(LEDR, LOW);
|
||||
digitalWrite(LEDG, HIGH);
|
||||
digitalWrite(LEDB, HIGH);
|
||||
SPI.begin();
|
||||
SPI.setClockDivider(SPI_CLOCK_DIV2);
|
||||
ADS.begin();
|
||||
if(appmode==0)
|
||||
{
|
||||
Serial.print("Initial DAC Settings: ");
|
||||
for (int i =0; i<4;i++)
|
||||
{
|
||||
Serial.print("\t");Serial.print(LED_dac[i]);
|
||||
}
|
||||
Serial.println();
|
||||
}
|
||||
if(appmode==0)
|
||||
{
|
||||
Serial.print("Process: Setup End; Timestamp: ");Serial.println(millis());
|
||||
}
|
||||
}
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
void buzzer(int mode)
|
||||
{
|
||||
if(mode==1)
|
||||
{
|
||||
tone(Buzzer_pin, 2730, 1000);
|
||||
}
|
||||
else if (mode==2)
|
||||
{
|
||||
tone(Buzzer_pin, 2730, 5000);
|
||||
}
|
||||
}
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
void all_LEDs_turnoff()
|
||||
{
|
||||
setOutput(GAIN_1, 0, 1); //LED 1
|
||||
setOutput(GAIN_1, 0, 2); //LED 2
|
||||
setOutput(GAIN_1, 0, 3); //LED 3
|
||||
setOutput(GAIN_1, 0, 4); //LED 4
|
||||
}
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
void secondary_gain_select(int gain_combo)
|
||||
{
|
||||
bool gain_choice1=bitRead(gain_combo, 0);
|
||||
bool gain_choice2=bitRead(gain_combo, 1);
|
||||
bool gain_choice3=bitRead(gain_combo, 2);
|
||||
bool gain_choice4=bitRead(gain_combo, 3);
|
||||
digitalWrite(PD1G1, gain_choice1);
|
||||
digitalWrite(PD1G2, gain_choice2);
|
||||
digitalWrite(PD2G1, gain_choice3);
|
||||
digitalWrite(PD2G2, gain_choice4);
|
||||
if(appmode==0)
|
||||
{
|
||||
Serial.print("Gains Used\t G1:");Serial.print(gain_choice1);Serial.print("\t G2:");Serial.print(gain_choice2);Serial.print("\t G3:");Serial.print(gain_choice3);Serial.print("\t G4:");Serial.println(gain_choice4);
|
||||
}
|
||||
}
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
void setOutput(byte gain, unsigned int val, int LEDselect)
|
||||
{
|
||||
byte channel=0;
|
||||
byte shutdown=1;
|
||||
if(LEDselect%2==0)
|
||||
{
|
||||
channel=1;
|
||||
}
|
||||
else
|
||||
{
|
||||
channel=0;
|
||||
}
|
||||
byte lowByte = val & 0xff;
|
||||
byte highByte = ((val >> 8) & 0xff) | channel << 7 | gain << 5 | shutdown << 4;
|
||||
if (LEDselect <= 2)
|
||||
{
|
||||
PORTB &= 0xfb;
|
||||
SPI.transfer(highByte);
|
||||
SPI.transfer(lowByte);
|
||||
PORTB |= 0x4;
|
||||
}
|
||||
else
|
||||
{
|
||||
PORTB &= 0xfd;
|
||||
SPI.transfer(highByte);
|
||||
SPI.transfer(lowByte);
|
||||
PORTB |= 0x2;
|
||||
}
|
||||
}
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
void indicator_LED(char statusLED)
|
||||
{
|
||||
digitalWrite(LEDR,LOW);
|
||||
digitalWrite(LEDG,LOW);
|
||||
digitalWrite(LEDB,LOW);
|
||||
digitalWrite(LEDR,(statusLED=='R'));
|
||||
digitalWrite(LEDG,(statusLED=='G'));
|
||||
digitalWrite(LEDB,(statusLED=='B'));
|
||||
/*
|
||||
if(statusLED=='R')
|
||||
{
|
||||
digitalWrite(LEDR,HIGH);
|
||||
digitalWrite(LEDG,LOW);
|
||||
digitalWrite(LEDB,LOW);
|
||||
//Serial.println("RED");
|
||||
}
|
||||
else if(statusLED=='G')
|
||||
{
|
||||
digitalWrite(LEDR,LOW);
|
||||
digitalWrite(LEDG,HIGH);
|
||||
digitalWrite(LEDB,LOW);
|
||||
//Serial.println("G");
|
||||
}
|
||||
else if(statusLED=='B')
|
||||
{
|
||||
digitalWrite(LEDR,LOW);
|
||||
digitalWrite(LEDG,LOW);
|
||||
digitalWrite(LEDB,HIGH);
|
||||
//Serial.println("B");
|
||||
}
|
||||
else
|
||||
{
|
||||
digitalWrite(LEDR,LOW);
|
||||
digitalWrite(LEDG,LOW);
|
||||
digitalWrite(LEDB,LOW);
|
||||
}
|
||||
*/
|
||||
}
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
int setDAC_LED()
|
||||
{
|
||||
int LED_flags[]={0,0,0,0};
|
||||
int flags_combined=0;
|
||||
if(appmode==0)
|
||||
{
|
||||
Serial.println("#DAC Sweep Start");
|
||||
}
|
||||
all_LEDs_turnoff();
|
||||
delay(1000);
|
||||
////////////////////////////////////////FIRST FORLOOP TO DISCARD STARTS/////////////////////////////////////////////////
|
||||
for (int i=3000;i<4096;i+=incr)
|
||||
{
|
||||
setOutput(GAIN_1, i, 1);
|
||||
delay(del);
|
||||
int16_t val_0 = ADS.readADC(0);
|
||||
if((val_0>24000))
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
all_LEDs_turnoff();
|
||||
delay(1000);
|
||||
////////////////////////////////////////FIRST FORLOOP TO DISCARD ENDS/////////////////////////////////////////////////
|
||||
for (int j=0;j<4;j++)
|
||||
{
|
||||
all_LEDs_turnoff();
|
||||
secondary_gain_select(DacSweep_gain_combinations[j]);
|
||||
for (int i=DAC_Sweep_start_limit[j];i<DAC_Sweep_end_limit[j];i+=incr)
|
||||
{
|
||||
setOutput(GAIN_1, i, j+1);
|
||||
delay(del);
|
||||
int16_t val_0 = ADS.readADC(0);
|
||||
if((val_0>LED_DS_threshold[j])&&(LED_flags[j]==0))
|
||||
{
|
||||
LED_dac[j]=i;
|
||||
LED_flags[j]=1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
all_LEDs_turnoff();
|
||||
if (appmode==0)
|
||||
{
|
||||
Serial.print("LED ");Serial.print(j+1);Serial.print(" DACsweep Completed");Serial.print("\t");Serial.print("NEW DAC VALUE : ");Serial.println(LED_dac[j]);
|
||||
}
|
||||
delay(1000);
|
||||
}
|
||||
all_LEDs_turnoff();
|
||||
flags_combined=(LED_flags[3]*1)+(LED_flags[2]*10)+(LED_flags[1]*100)+(LED_flags[0]*1000);
|
||||
if(appmode==0)
|
||||
{
|
||||
Serial.println("#DAC Sweep End");
|
||||
}
|
||||
return flags_combined;
|
||||
}
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
void eeprom_DAC_write()
|
||||
{
|
||||
int led_dac_split[]= {0,0,0,0,0,0,0,0};
|
||||
Serial.println("#WS");
|
||||
led_dac_split[0] = LED_dac[0]/100;
|
||||
led_dac_split[1] = LED_dac[0]-(led_dac_split[0]*100);
|
||||
led_dac_split[2] = LED_dac[1]/100;
|
||||
led_dac_split[3] = LED_dac[1]-(led_dac_split[2]*100);
|
||||
led_dac_split[4] = LED_dac[2]/100;
|
||||
led_dac_split[5] = LED_dac[2]-(led_dac_split[4]*100);
|
||||
led_dac_split[6] = LED_dac[3]/100;
|
||||
led_dac_split[7] = LED_dac[3]-(led_dac_split[6]*100);
|
||||
if(appmode==0)
|
||||
{
|
||||
Serial.print(led_dac_split[0]);Serial.print("\t");Serial.println(led_dac_split[1]);
|
||||
Serial.print(led_dac_split[2]);Serial.print("\t");Serial.println(led_dac_split[3]);
|
||||
Serial.print(led_dac_split[4]);Serial.print("\t");Serial.println(led_dac_split[5]);
|
||||
Serial.print(led_dac_split[6]);Serial.print("\t");Serial.println(led_dac_split[7]);
|
||||
}
|
||||
for (int i=0;i<8; i++)
|
||||
{
|
||||
EEPROM.write(i, led_dac_split[i]);
|
||||
}
|
||||
Serial.println("#WC");
|
||||
}
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
void eeprom_DAC_read()
|
||||
{
|
||||
int led_dac_split[]= {0,0,0,0,0,0,0,0};
|
||||
Serial.println("#RS");
|
||||
for(int i=0;i<8;i++)
|
||||
{
|
||||
led_dac_split[i] = EEPROM.read(i);
|
||||
}
|
||||
for(int i=0;i<4;i++)
|
||||
{
|
||||
LED_dac[i] = (led_dac_split[i*2]*100)+led_dac_split[(i*2)+1];
|
||||
}
|
||||
if(appmode==0)
|
||||
{
|
||||
Serial.print(led_dac_split[0]);Serial.print("\t");Serial.println(led_dac_split[1]);
|
||||
Serial.print(led_dac_split[2]);Serial.print("\t");Serial.println(led_dac_split[3]);
|
||||
Serial.print(led_dac_split[4]);Serial.print("\t");Serial.println(led_dac_split[5]);
|
||||
Serial.print(led_dac_split[6]);Serial.print("\t");Serial.println(led_dac_split[7]);
|
||||
Serial.print(LED_dac[0]);Serial.print("\t");Serial.print(LED_dac[1]);Serial.print("\t");Serial.print(LED_dac[2]);Serial.print("\t");Serial.println(LED_dac[3]);
|
||||
}
|
||||
Serial.println("#RC");
|
||||
}
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
void LED_warmup(int warmup_time)
|
||||
{
|
||||
int warmup_start=millis();
|
||||
int current_time=millis();
|
||||
while((current_time-warmup_start)<warmup_time)
|
||||
{
|
||||
setOutput(GAIN_1, led_warmup_DAC[0], 1);
|
||||
setOutput(GAIN_1, led_warmup_DAC[1], 2);
|
||||
setOutput(GAIN_1, led_warmup_DAC[2], 3);
|
||||
setOutput(GAIN_1, led_warmup_DAC[3], 4);
|
||||
current_time=millis();
|
||||
}
|
||||
all_LEDs_turnoff();
|
||||
}
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
float ten_ADC_averager(int detector_select, int reading_delay)
|
||||
{
|
||||
long temp_storage=0;
|
||||
float temp_average_storage=0;
|
||||
for (int i=0;i<10;i++)
|
||||
{
|
||||
delay(reading_delay);
|
||||
int16_t val_0 = ADS.readADC(detector_select-1);
|
||||
if(raw_ADC_print==1)
|
||||
{
|
||||
Serial.println(val_0);
|
||||
}
|
||||
temp_storage+=val_0;
|
||||
}
|
||||
temp_average_storage=temp_storage/10;
|
||||
return temp_average_storage;
|
||||
}
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
float detector(int number_of_readings, int detector_select, int gain_combo, int settling_time, int reading_delay)
|
||||
{
|
||||
if((appmode==0)&&(timestamp_printer==1))
|
||||
{
|
||||
Serial.print("Process: Detector Start for any one LED; Timestamp: ");Serial.println(millis());
|
||||
}
|
||||
secondary_gain_select(gain_combo);
|
||||
temp_counter = 0;
|
||||
intensity_storage = 0;
|
||||
int16_t detector_val = 0;
|
||||
int start_time=millis();
|
||||
int current_time=millis();
|
||||
int lower_limit=0;
|
||||
int upper_limit=0;
|
||||
//limit_average_storage=0;
|
||||
while((current_time-start_time)<settling_time)
|
||||
{
|
||||
int16_t val_0 = ADS.readADC(detector_select-1);
|
||||
if(raw_ADC_print==1)
|
||||
{
|
||||
Serial.println(val_0);
|
||||
}
|
||||
current_time=millis();
|
||||
}
|
||||
for (int i=0;i<(number_of_readings/10);i++)
|
||||
{
|
||||
intensity_storage+=ten_ADC_averager(detector_select, reading_delay);
|
||||
temp_counter++;
|
||||
}
|
||||
all_LEDs_turnoff();
|
||||
average_readings = intensity_storage/temp_counter;
|
||||
if(appmode==0)
|
||||
{
|
||||
if (timestamp_printer==1)
|
||||
{
|
||||
Serial.print("Process: Detector Start for any one LED; Timestamp: ");Serial.println(millis());
|
||||
}
|
||||
}
|
||||
return average_readings;
|
||||
}
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
int limit_switch_check()
|
||||
{
|
||||
int switch_state = digitalRead(Limit_Switch);
|
||||
return switch_state;
|
||||
}
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
void loop()
|
||||
{
|
||||
ADS.setGain(0);
|
||||
all_LEDs_turnoff();
|
||||
avg_storage = 0;
|
||||
split_counter = 0;
|
||||
if(initialRGBstate==0)
|
||||
{
|
||||
indicator_LED('R');
|
||||
initialRGBstate=1;
|
||||
}
|
||||
if (Serial.available())
|
||||
{
|
||||
char data = Serial.read();
|
||||
if ((data == 'C')||(data == 'D'))
|
||||
{
|
||||
if(data == 'C')
|
||||
{
|
||||
Serial.println("#CS");
|
||||
int flags=setDAC_LED();
|
||||
if(flags!=1111)
|
||||
{
|
||||
if(appmode==0)
|
||||
{
|
||||
Serial.println("Unable to reach MAX ADC Limit for atleast one LED");
|
||||
}
|
||||
}
|
||||
Serial.print("LED1_DAC: ");Serial.println(LED_dac[0]);
|
||||
Serial.print("LED2_DAC: ");Serial.println(LED_dac[1]);
|
||||
Serial.print("LED3_DAC: ");Serial.println(LED_dac[2]);
|
||||
Serial.print("LED4_DAC: ");Serial.println(LED_dac[3]);
|
||||
Serial.println("#CC");
|
||||
buzzer(1);
|
||||
}
|
||||
else if(data == 'D')
|
||||
{
|
||||
startTask3();
|
||||
buzzer(1);
|
||||
}
|
||||
}
|
||||
else if (data == 'B')
|
||||
{
|
||||
indicator_LED('G');
|
||||
startTask1();
|
||||
indicator_LED('B');
|
||||
buzzer(1);
|
||||
}
|
||||
else if ((data == 'S')||(data == 'T')||(data == 'U')||(data == 'V')||(data == 'W'))
|
||||
{
|
||||
indicator_LED('G');
|
||||
if(data == 'S')
|
||||
{
|
||||
startTask2(1);
|
||||
}
|
||||
else if(data == 'T')
|
||||
{
|
||||
startTask2(2);
|
||||
}
|
||||
else if(data == 'U')
|
||||
{
|
||||
startTask2(3);
|
||||
}
|
||||
else if(data == 'V')
|
||||
{
|
||||
startTask2(4);
|
||||
}
|
||||
else if(data == 'W')
|
||||
{
|
||||
startTask2(5);
|
||||
}
|
||||
indicator_LED('R');
|
||||
buzzer(1);
|
||||
}
|
||||
else if (data == 'O')
|
||||
{
|
||||
startTask4();
|
||||
buzzer(1);
|
||||
}
|
||||
else if ((data == 'I')||(data == 'F')||(data == 'X'))
|
||||
{
|
||||
if(data == 'I')
|
||||
{
|
||||
Serial.println(Device_ID);
|
||||
}
|
||||
else if (data == 'F')
|
||||
{
|
||||
int location=0;
|
||||
for (int i=0;i<Firmware_location_Auto.length();i++)
|
||||
{
|
||||
if(Firmware_location_Auto[i]=='\\')
|
||||
{
|
||||
location=i;
|
||||
}
|
||||
}
|
||||
Firmware_version_Auto.remove(0,location+1);
|
||||
if (appmode==0)
|
||||
{
|
||||
Serial.print("Firmware Location: ");Serial.println(Firmware_location_Auto);
|
||||
}
|
||||
Serial.print("Firmware Version: ");Serial.println(Firmware_version_Auto);
|
||||
Serial.print("Date and Time of Firmware Upload : ");Serial.println(compile_date);
|
||||
}
|
||||
else if (data =='X')
|
||||
{
|
||||
Serial.println(F("Command 'C' will do : Slow DAC sweep, stop the sweep once required ADC is reached, update DAC value"));
|
||||
Serial.println(F("Command 'D' will do : Fast DAC sweep, will sweep from 0 to 4096, prints ADC values"));
|
||||
Serial.println(F("Command 'B' will do : Blank readings"));
|
||||
Serial.println(F("Command 'S/T/U/V/W' will do : Sample readings with pre-defined secondary gain"));
|
||||
Serial.println(F("Command 'O' will do : Blank readings without turning on the LED"));
|
||||
Serial.println(F("Command 'I' will do : Print Device Serial No."));
|
||||
Serial.println(F("Command 'F' will do : Print the firmware version and upload date and time"));
|
||||
Serial.println(F("Command 'X' will do : Print all available commands"));
|
||||
Serial.println(F("Command 'Y' will do : LED warmup for 5 seconds"));
|
||||
Serial.println(F("Command 'G' will do : Write DAC values temporarily set into permanent EEPROM"));
|
||||
Serial.println(F("Command 'E' will do : Read EEPROM stored DAC values and store in temporary memory"));
|
||||
Serial.println(F("Command 'P' will do : Print all ADC values (blank and sample)"));
|
||||
Serial.println(F("Command 'R' will do : Print DAC values stored in temporary memory"));
|
||||
Serial.println(F("Command 'L' will do : Print the status of the limit switch"));
|
||||
Serial.println(F("Command '1/2/3/4' will do : Turen ON LED 1/2/3/4 if pressed ODD number of times, Turen OFF LED 1/2/3/4 if pressed EVEN number of times"));
|
||||
}
|
||||
}
|
||||
else if (data == 'Y')
|
||||
{
|
||||
Serial.println("#HS");
|
||||
LED_warmup(5000);
|
||||
Serial.println("#HC");
|
||||
}
|
||||
else if ((data == 'G')||(data == 'E'))
|
||||
{
|
||||
if(data == 'G')
|
||||
{
|
||||
eeprom_DAC_write();
|
||||
}
|
||||
else if(data == 'E')
|
||||
{
|
||||
eeprom_DAC_read();
|
||||
}
|
||||
}
|
||||
else if ((data == 'P')||(data == 'R'))
|
||||
{
|
||||
if(data == 'P')
|
||||
{
|
||||
Serial.print("RESULT"); Serial.println(" ");
|
||||
Serial.print("LB1 "); Serial.println(avg_blank[0]); Serial.print("LB2 "); Serial.println(avg_blank[1]);
|
||||
Serial.print("LB3 "); Serial.println(avg_blank[2]); Serial.print("LB4 "); Serial.println(avg_blank[3]);
|
||||
Serial.print("LS1 "); Serial.println(avg_sample[0]); Serial.print("LS2 "); Serial.println(avg_sample[1]);
|
||||
Serial.print("LS3 "); Serial.println(avg_sample[2]); Serial.print("LS4 "); Serial.println(avg_sample[3]);
|
||||
Serial.println("REND");
|
||||
delay(100);
|
||||
}
|
||||
else if (data == 'R')
|
||||
{
|
||||
Serial.println("#RS");
|
||||
int dac_print=0;
|
||||
for (int i=0;i<4;i++)
|
||||
{
|
||||
Serial.print("LED");Serial.print(i+1);Serial.print(" DAC : ");Serial.println(LED_dac[i]);
|
||||
}
|
||||
Serial.println("#RC");
|
||||
}
|
||||
}
|
||||
else if (data == 'L')
|
||||
{
|
||||
int switch_state = digitalRead(Limit_Switch);
|
||||
if (switch_state == LOW)
|
||||
{
|
||||
Serial.println("#CIN");
|
||||
}
|
||||
else
|
||||
{
|
||||
Serial.println("#AIN");
|
||||
}
|
||||
}
|
||||
else if ((data == '1')||(data == '2')||(data == '3')||(data == '4'))
|
||||
{
|
||||
int LED_ID = data-'0';
|
||||
if(LED_on_status[LED_ID-1]==0)
|
||||
{
|
||||
setOutput(GAIN_1, LED_dac[LED_ID-1], LED_ID);
|
||||
LED_on_status[LED_ID-1]=1;
|
||||
Serial.print("LED ");Serial.print(LED_ID);Serial.println(" ON");
|
||||
}
|
||||
else
|
||||
{
|
||||
setOutput(GAIN_1, 0, LED_ID);
|
||||
LED_on_status[LED_ID-1]=0;
|
||||
Serial.print("LED ");Serial.print(LED_ID);Serial.println(" OFF");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
void startTask1()
|
||||
{
|
||||
if((appmode==0)&&(timestamp_printer==1))
|
||||
{
|
||||
Serial.print("Process: Buffer start; Timestamp: ");Serial.println(millis());
|
||||
}
|
||||
all_LEDs_turnoff();
|
||||
delay(100);
|
||||
all_LEDs_turnoff();
|
||||
Serial.println("#BS");
|
||||
for (int i=0;i<4;i++)
|
||||
{
|
||||
setOutput(GAIN_1, LED_dac[i], LED_sequence[i]);
|
||||
delay(100);
|
||||
avg_blank[i] = detector(LED_sample_size[LED_sequence[i]-1], Detector_sequence[LED_sequence[i]-1], Blank_gain_combinations[LED_sequence[i]-1], LED_settling_time[LED_sequence[i]-1], ADC_reading_delay[LED_sequence[i]-1]);
|
||||
all_LEDs_turnoff();
|
||||
delay(1000);
|
||||
}
|
||||
if (appmode==0)
|
||||
{
|
||||
Serial.print(millis());Serial.print("\t");Serial.print("LED1B : "); Serial.print(avg_blank[0]); Serial.print("\t"); Serial.print("LED2B : "); Serial.print(avg_blank[1]); Serial.print("\t"); Serial.print("LED3B : "); Serial.print(avg_blank[2]); Serial.print("\t"); Serial.print("LED4B : "); Serial.println(avg_blank[3]);
|
||||
}
|
||||
Serial.println("#BC");
|
||||
if((appmode==0)&&(timestamp_printer==1))
|
||||
{
|
||||
Serial.print("Process: Buffer end; Timestamp: ");Serial.println(millis());
|
||||
}
|
||||
}
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
void startTask2(int selector)
|
||||
{
|
||||
if((appmode==0)&&(timestamp_printer==1))
|
||||
{
|
||||
Serial.print("Process: Sample start; Timestamp: ");Serial.println(millis());
|
||||
}
|
||||
all_LEDs_turnoff();
|
||||
delay(100);
|
||||
all_LEDs_turnoff();
|
||||
Serial.print("#SS");Serial.println(selector);
|
||||
for (int i=0;i<4;i++)
|
||||
{
|
||||
setOutput(GAIN_1, LED_dac[i], LED_sequence[i]);
|
||||
delay(100);
|
||||
avg_sample[i] = detector(LED_sample_size[LED_sequence[i]-1], Detector_sequence[LED_sequence[i]-1], Sample_gain_combinations[selector-1][LED_sequence[i]-1],LED_settling_time[LED_sequence[i]-1], ADC_reading_delay[LED_sequence[i]-1]);
|
||||
all_LEDs_turnoff();
|
||||
delay(1000);
|
||||
}
|
||||
if (appmode==0)
|
||||
{
|
||||
Serial.print(millis());Serial.print("\t");Serial.print("LED1S : "); Serial.print(avg_sample[0]); Serial.print("\t"); Serial.print("LED2S : "); Serial.print(avg_sample[1]); Serial.print("\t"); Serial.print("LED3S : "); Serial.print(avg_sample[2]); Serial.print("\t"); Serial.print("LED4S : "); Serial.println(avg_sample[3]);
|
||||
}
|
||||
Serial.print("#SC");Serial.println(selector);
|
||||
if((appmode==0)&&(timestamp_printer==1))
|
||||
{
|
||||
Serial.print("Process: Sample end; Timestamp: ");Serial.println(millis());
|
||||
}
|
||||
}
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
void startTask3()
|
||||
{
|
||||
if((appmode==0)&&(timestamp_printer==1))
|
||||
{
|
||||
Serial.print("Process: Diagnostics start; Timestamp: ");Serial.println(millis());
|
||||
}
|
||||
int16_t val_0 =0;
|
||||
int reading_increment=128;
|
||||
int lowerlimit_dac=0;
|
||||
int upperlimit_dac=0;
|
||||
all_LEDs_turnoff();
|
||||
Serial.println("#DS");
|
||||
|
||||
for (int j=0;j<4;j++)
|
||||
{
|
||||
all_LEDs_turnoff();
|
||||
int start_time=millis();
|
||||
int current_time=millis();
|
||||
while (((current_time-start_time)<(detector_settling_time*2)))
|
||||
{
|
||||
val_0 = ADS.readADC((Detector_sequence[LED_sequence[j]-1])-1);
|
||||
current_time=millis();
|
||||
}
|
||||
if((val_0 > 10)&&(appmode==0))
|
||||
{
|
||||
Serial.println("Error: stray light interference or LED partly ON ");
|
||||
}
|
||||
int flag=0;
|
||||
secondary_gain_select(DacSweep_gain_combinations[j]);
|
||||
for (int i = 0; i <=4096; i+= reading_increment)
|
||||
{
|
||||
setOutput(GAIN_1, i, j+1);
|
||||
int start_time=millis();
|
||||
int current_time=millis();
|
||||
while ((current_time-start_time)<detector_settling_time_DACsweep)
|
||||
{
|
||||
val_0 = ADS.readADC((Detector_sequence[LED_sequence[j]-1])-1);
|
||||
current_time=millis();
|
||||
}
|
||||
if((val_0>LED_DS_threshold[LED_sequence[j]-1])&&(flag==0))
|
||||
{
|
||||
lowerlimit_dac= i-(reading_increment*2);
|
||||
upperlimit_dac= i+(reading_increment*2);
|
||||
if (lowerlimit_dac<0)
|
||||
{
|
||||
lowerlimit_dac=0;
|
||||
}
|
||||
if(upperlimit_dac>4095)
|
||||
{
|
||||
upperlimit_dac=4095;
|
||||
}
|
||||
DAC_lower_limit[j]=lowerlimit_dac;
|
||||
DAC_upper_limit[j]=upperlimit_dac;
|
||||
flag=1;
|
||||
}
|
||||
Serial.print("LED:");Serial.print(j+1);Serial.print("__DAC:");Serial.print(i);Serial.print("__ADC:");Serial.println(val_0);
|
||||
}
|
||||
if (appmode==0)
|
||||
{
|
||||
Serial.print("LED:");Serial.print(j+1);Serial.print("__DAC LOWER LIMIT:");Serial.println(DAC_lower_limit[j]);
|
||||
Serial.print("LED:");Serial.print(j+1);Serial.print("__DAC UPPER LIMIT:");Serial.println(DAC_upper_limit[j]);
|
||||
}
|
||||
secondary_gain_select(0);
|
||||
all_LEDs_turnoff();
|
||||
}
|
||||
Serial.println("#DC");
|
||||
all_LEDs_turnoff();
|
||||
delay(1000);
|
||||
if((appmode==0)&&(timestamp_printer==1))
|
||||
{
|
||||
Serial.print("Process: Diagnostics end; Timestamp: ");Serial.println(millis());
|
||||
}
|
||||
}
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
void startTask4()
|
||||
{
|
||||
if((appmode==0)&&(timestamp_printer==1))
|
||||
{
|
||||
Serial.print("Process: Buffer start; Timestamp: ");Serial.println(millis());
|
||||
}
|
||||
all_LEDs_turnoff();
|
||||
delay(100);
|
||||
all_LEDs_turnoff();
|
||||
Serial.println("#BS");
|
||||
for (int i=0;i<4;i++)
|
||||
{
|
||||
setOutput(GAIN_1, 0, LED_sequence[i]);
|
||||
delay(100);
|
||||
avg_blank[i] = detector(LED_sample_size[LED_sequence[i]-1], Detector_sequence[LED_sequence[i]-1], Blank_gain_combinations[LED_sequence[i]-1], 2000, ADC_reading_delay[LED_sequence[i]-1]);
|
||||
all_LEDs_turnoff();
|
||||
delay(1000);
|
||||
}
|
||||
if (appmode==0)
|
||||
{
|
||||
Serial.print(millis());Serial.print("\t");Serial.print("LED1B : "); Serial.print(avg_blank[0]); Serial.print("\t"); Serial.print("LED2B : "); Serial.print(avg_blank[1]); Serial.print("\t"); Serial.print("LED3B : "); Serial.print(avg_blank[2]); Serial.print("\t"); Serial.print("LED4B : "); Serial.println(avg_blank[3]);
|
||||
}
|
||||
Serial.println("#BC");
|
||||
if((appmode==0)&&(timestamp_printer==1))
|
||||
{
|
||||
Serial.print("Process: Buffer end; Timestamp: ");Serial.println(millis());
|
||||
}
|
||||
}
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
Reference in New Issue
Block a user