Circuit-Forge/easypiezi
3
0
Fork 0
Code Issues 4 Pull requests Projects Releases Packages Wiki Activity Actions

Fixed "Flappy DAC" bug in rev.2.x.x firmware

Browse source 
- Fixed https://github.com/pyr0ball/pyr0piezo/issues/26
  - Changed adjustment logic to be calculated based on Vcc rather than ADC reference, which was causing issues in the mathematical functions, resulting in negative number outputs
 - Migrated to internal vRef, fixed https://github.com/pyr0ball/pyr0piezo/issues/23
 - Eliminated floats, fixing https://github.com/pyr0ball/pyr0piezo/issues/31
  - This required addition of long, however
 - Fixed https://github.com/pyr0ball/pyr0piezo/issues/20
This commit is contained in:
pyr0ball 2019-06-27 01:07:44 -07:00
parent 1d098f184b
commit f745940904
6 changed files with 578 additions and 310 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

322
firmware/AVR-Source/Pyr0_Piezo_Sensor_v2.x.x/Pyr0_Piezo_Sensor_v2.x.x.ino
View file

@ -1,166 +1,156 @@
/* /*
Piezoelectric Z-Axis sensor using AtMega88/168/328 (AtMega 48 doesnt have enough memory for this version) Piezoelectric Z-Axis sensor using AtMega88/168/328 (AtMega 48 doesnt have enough memory for this version)
This sketch reads a piezo element to detect a touch of the printer's nozzle to the bed. This sketch reads a piezo element to detect a touch of the printer's nozzle to the bed.
The sense pin is tied to an interrupt, which is pulled high by internal pullup resistor. The sense pin is tied to an interrupt, which is pulled high by internal pullup resistor.
When the piezo touches the bed, the amplification circuit will draw the interrupt pin low When the piezo touches the bed, the amplification circuit will draw the interrupt pin low
and the atmega will output a pulse based on the programmed trigger duration and the atmega will output a pulse based on the programmed trigger duration
* PD2 INT0 (Piezo In 'D2') * PD2 INT0 (Piezo In 'D2')
* D7 PCINT23 (Trigger OUT 'D7') * D7 PCINT23 (Trigger OUT 'D7')
* PC0 ADC0 (Voltage Reference Check 'A0') * PC0 ADC0 (Voltage Reference Check 'A0')
* PC1 ADC1 (Sensitivity Adjustment Check 'A1') * PC1 ADC1 (Sensitivity Adjustment Check 'A1')
* PD4 PCINT20 (Error feedback LED 'D4') * PD4 PCINT20 (Error feedback LED 'D4')
* PB6 PCINT6 (Voltage Adjustment Resistor 0 'D20') * PB6 PCINT6 (Voltage Adjustment Resistor 0 'D20')
* PB7 PCINT7 (Voltage Adjustment Resistor 1 'D21') * PB7 PCINT7 (Voltage Adjustment Resistor 1 'D21')
* PD5 T1 (Voltage Adjustment Resistor 2 'D5') * PD5 T1 (Voltage Adjustment Resistor 2 'D5')
* PD6 PCINT22 (Voltage Adjustment Resistor 3 'D6') * PD6 PCINT22 (Voltage Adjustment Resistor 3 'D6')
* PB1 OC1A (Comparator VRef PWM Out 'D9') * PB1 OC1A (Comparator VRef PWM Out 'D9')
* PD3 OC2B (Voltage Follower VRef PWM Out 'D3') * PD3 OC2B (Voltage Follower VRef PWM Out 'D3')
Schematics for this project can be found here: https://github.com/pyr0ball/pyr0piezo/tree/master/docs/Schematics Schematics for this project can be found here: https://github.com/pyr0ball/pyr0piezo/tree/master/docs/Schematics
For Arduino IDE use MCUdude MiniCore: https://mcudude.github.io/MiniCore/package_MCUdude_MiniCore_index.json For Arduino IDE use MCUdude MiniCore: https://mcudude.github.io/MiniCore/package_MCUdude_MiniCore_index.json
created 2/18/2019 created 2/18/2019
by Alan "pyr0ball" Weinstock by Alan "pyr0ball" Weinstock
This code is in the public domain. This code is in the public domain.
*/ */
/* To set the below parameters using serial input, use the following: /* To set the below parameters using serial input, use the following:
To change trigger active duration: TRG_D [integer for milliseconds] To change trigger active duration: TRG_D [integer for milliseconds]
To change gain factor: GAIN_F [integer for gain state - see note*] To change gain factor: GAIN_F [integer for gain state - see note*]
To change ADC hysteresis value: HYST [integer] To change ADC hysteresis value: HYST [integer]
To change sensor input pullup vRef low threshold: VADJ [float value] To change sensor input pullup vRef low threshold: VADJ [float value]
To change comparator trigger high threshold: VCOMP [float value] To change comparator trigger high threshold: VCOMP [float value]
These commands should be wrapped in this format: These commands should be wrapped in this format:
<CMD, INT, FLOAT> <CMD, INT, FLOAT>
You must include the unused variable for each instance. You must include the unused variable for each instance.
Examples: Examples:
<GAIN_F, 3, 0.00> <GAIN_F, 3, 0.00>
<VADJ, 0, 2.35> <VADJ, 0, 2.35>
*Note for Gain Factor: *Note for Gain Factor:
The gain STATE is representative of these values: The gain STATE is representative of these values:
0 = 3x 0 = 3x
1 = 3.5x 1 = 3.5x
2 = 4.33x 2 = 4.33x
3 = 6x 3 = 6x
4 = 11x 4 = 11x
*/ */
// Configurable settings: // Configurable settings:
int GAIN_FACTOR = 2; // Gain adjustment factor. 0=3x, 1=3.5x, 2=4.33x, 3=6x, 4=11x int GAIN_FACTOR = 2; // Gain adjustment factor. 0=3x, 1=3.5x, 2=4.33x, 3=6x, 4=11x
#define InitCount 6 // Number of times to blink the LED on start #define InitCount 6 // Number of times to blink the LED on start
int LOOP_DUR = 50; // duration of time between ADC checks and other loop functions int LOOP_DUR = 50; // duration of time between ADC checks and other loop functions
int TRG_DUR = 20; // duration of the Z-axis pulse sent, in ms int TRG_DUR = 20; // duration of the Z-axis pulse sent, in ms
#define senseThrs 1.85 #define senseThrs 1450
#define compThrs 2.54 #define compThrs 2850
int dAdjFac = 1; // adjustment divider. Higher number will cause the DAC output to adjust more slowly.
int Hyst = 20; // Hysteresis value for ADC measurements int Hyst = 20; // Hysteresis value for ADC measurements
#define Vin 5 // input reference voltage
/*------------------------------------------------------------*/
/*------------------------------------------------------------*/
// Debug output toggle. Uncomment to enable
// Debug output toggle. Uncomment to enable #define DEBUG true
#define DEBUG true //#define VERBOSE true
// Headers, variables, and functions // Headers, variables, and functions
#include "pP_pins.h" #include "pP_pins.h"
#include "pP_volatile.h" #include "pP_volatile.h"
#include "pP_functions.h" #include "pP_function.h"
#include "pP_serial.h" #include "pP_serial.h"
// i2c input toggle. Uncomment to enable // i2c input toggle. Uncomment to enable
//#define I2C true //#define I2C true
#ifdef I2C #ifdef I2C
#include "pP_i2c.h" #include "pP_i2c.h"
#endif #endif
void setup() { void setup() {
pinMode(TRG_OUT, OUTPUT); // declare the Trigger as as OUTPUT pinMode(TRG_OUT, OUTPUT); // declare the Trigger as as OUTPUT
pinMode(ERR_LED, OUTPUT); pinMode(ERR_LED, OUTPUT);
pinMode(Z_TRG, INPUT_PULLUP); // declare z-sense input with pullup pinMode(Z_TRG, INPUT_PULLUP); // declare z-sense input with pullup
pinMode(V_FOLLOW_PIN, INPUT); pinMode(V_FOLLOW_PIN, INPUT);
pinMode(VCOMP_SENSE_PIN, INPUT); pinMode(VCOMP_SENSE_PIN, INPUT);
pinMode(GADJ_R0, INPUT); // declare input to break pull to ground pinMode(GADJ_R0, INPUT); // declare input to break pull to ground
pinMode(GADJ_R1, INPUT); // declare input to break pull to ground pinMode(GADJ_R1, INPUT); // declare input to break pull to ground
pinMode(GADJ_R2, INPUT); // declare input to break pull to ground pinMode(GADJ_R2, INPUT); // declare input to break pull to ground
pinMode(GADJ_R3, INPUT); // declare input to break pull to ground pinMode(GADJ_R3, INPUT); // declare input to break pull to ground
Serial.begin(9600); Serial.begin(9600);
// Uncomment the following lines to use PCInt pins instead of hardware interrupt attachInterrupt(digitalPinToInterrupt(Z_TRG), pulse, FALLING);
//#include <PinChangeInterrupt.h>
//attachPCINT(digitalPinToPCINT(Z_TRG), pulse, FALLING); Serial.println("Initializing Pyr0-Piezo Sensor...");
// Uncomment the followoing line to use hardware interrupt pin }
attachInterrupt(digitalPinToInterrupt(Z_TRG), pulse, FALLING);
Serial.println("Initializing Pyr0-Piezo Sensor..."); /*------------------------------------------------*/
} void loop() {
// Blink LED's on init
/*------------------------------------------------*/ if (BlinkCount > 0) {
BlinkState = !BlinkState;
void loop() { digitalWrite(ERR_LED, BlinkState);
digitalWrite(TRG_OUT, BlinkState);
// Blink LED's on init delay(LOOP_DUR);
if (BlinkCount > 0) { --BlinkCount;
BlinkState = !BlinkState; }
digitalWrite(ERR_LED, BlinkState);
digitalWrite(TRG_OUT, BlinkState); // Get Serial Input
delay(LOOP_DUR); serialInput();
--BlinkCount;
} // Set any new parameters from serial input
updateParams();
// Get Serial Input
serialInput(); // Set the amplification gain factor
adjustGain();
// Set any new parameters from serial input
updateParams(); // Check voltage of first and second stages and compare against thresholds
adjustVin();
// Check voltage of first and second stages and compare against thresholds VComp = analogRead(VCOMP_SENSE_PIN);
VComp = analogRead(VCOMP_SENSE_PIN); VAdj = analogRead(V_FOLLOW_PIN);
diffCompL = (VComp - compInt) - Hyst;
diffCompH = (compInt - VComp) - Hyst; // Voltage Follower adjustment
if (VLast > Hyst || VLast < -Hyst) {
VAdj = analogRead(V_FOLLOW_PIN); adjustFollow();
diffAdjL = (VAdj - senseInt) - Hyst; }
diffAdjH = (senseInt - VAdj) - Hyst;
// Voltage Comparator adjustment
if (VLast > Hyst || VLast > -Hyst) {
// Set the amplification gain factor adjustComp();
adjustGain(); }
// Voltage Follower adjustment // Alert the user that auto-calibration is ongoing
if (diffAdjL > 0 || diffAdjH > 0) { calibrateAlert();
adjustFollow();
} // Check for error state
checkError();
// Voltage Comparator adjustment
if (diffCompL > 0 || diffCompH > 0) { // Reply with status
adjustComp(); serialReply();
}
// Sets trigger output state to false after completing loop
// Alert the user that auto-calibration is ongoing delay(LOOP_DUR);
calibrateAlert(); digitalWrite(TRG_OUT, HIGH);
sensorHReading = 0;
// Check for error state }
checkError();
// Reply with status
serialReply();
// Sets trigger output state to false after completing loop
delay(LOOP_DUR);
digitalWrite(TRG_OUT, HIGH);
sensorHReading = 0;
}

142
firmware/AVR-Source/Pyr0_Piezo_Sensor_v2.x.x/pP_function.h Normal file
View file

@ -0,0 +1,142 @@
/*
pyr0-piezo functions library
Created by Alan "pyr0ball" Weinstock 6/26/2019
*/
/*------------------------------------------------*/
void pulse() {
digitalWrite(TRG_OUT, LOW);
sensorHReading = 1;
delay(TRG_DUR);
digitalWrite(TRG_OUT, HIGH);
}
/*------------------------------------------------*/
long readVcc() {
// Read 1.1V reference against AVcc
// set the reference to Vcc and the measurement to the internal 1.1V reference
#if defined(__AVR_ATmega32U4__) || defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
ADMUX = _BV(REFS0) | _BV(MUX4) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
#elif defined (__AVR_ATtiny24__) || defined(__AVR_ATtiny44__) || defined(__AVR_ATtiny84__)
ADMUX = _BV(MUX5) | _BV(MUX0);
#elif defined (__AVR_ATtiny25__) || defined(__AVR_ATtiny45__) || defined(__AVR_ATtiny85__)
ADMUX = _BV(MUX3) | _BV(MUX2);
#else
ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
#endif
delay(2); // Wait for Vref to settle
ADCSRA |= _BV(ADSC); // Start conversion
while (bit_is_set(ADCSRA,ADSC)); // measuring
uint8_t low = ADCL; // must read ADCL first - it then locks ADCH
uint8_t high = ADCH; // unlocks both
long result = (high<<8) | low;
result = 1125300L / result; // Calculate Vcc (in mV); 1125300 = 1.1*1023*1000
return result; // Vcc in millivolts
}
/*------------------------------------------------*/
void adjustVin() {
VOld = Vin;
Vin = readVcc(), DEC;
senseLong = senseThrs * 1024L;
compLong = compThrs * 1024L;
senseInt = (long long) senseLong / Vin;
compInt = (long long) compLong / Vin;
senseInt = (int) senseInt;
compInt = (int) compInt;
}
/*------------------------------------------------*/
void adjustFollow() {
/* Compares diffs of threshold vs read value
if positive, adjusts the follower to within
the range set above*/
ADJ_FOLLOW = (senseInt / 4);
// Analog output (PWM) of duty cycle
analogWrite(V_FOL_PWM, ADJ_FOLLOW);
}
/*------------------------------------------------*/
void adjustComp() {
ADJ_COMP = (compInt / 4);
analogWrite(VCOMP_PWM, ADJ_COMP);
}
/*------------------------------------------------*/
void calibrateAlert() {
VLast = VOld - Vin;
if (VLast > Hyst || VLast < -Hyst ) {
ERR_STATE = 1;
}
}
/*------------------------------------------------*/
void adjustGain() {
if (GAIN_FACTOR == 0) {
pinMode(GADJ_R3, INPUT);
pinMode(GADJ_R2, INPUT);
pinMode(GADJ_R1, INPUT);
pinMode(GADJ_R0, INPUT);
ERR_STATE = 0;
}
else if (GAIN_FACTOR > 0) {
pinMode(GADJ_R3, OUTPUT);
digitalWrite(GADJ_R3, LOW);
pinMode(GADJ_R2, INPUT);
pinMode(GADJ_R1, INPUT);
pinMode(GADJ_R0, INPUT);
ERR_STATE = 0;
}
else if (GAIN_FACTOR > 1) {
pinMode(GADJ_R2, OUTPUT);
digitalWrite(GADJ_R2, LOW);
pinMode(GADJ_R1, INPUT);
pinMode(GADJ_R0, INPUT);
ERR_STATE = 0;
}
else if (GAIN_FACTOR > 2) {
pinMode(GADJ_R1, OUTPUT);
digitalWrite(GADJ_R1, LOW);
pinMode(GADJ_R0, INPUT);
ERR_STATE = 0;
}
else if (GAIN_FACTOR > 3) {
pinMode(GADJ_R0, OUTPUT);
digitalWrite(GADJ_R0, LOW);
ERR_STATE = 0;
}
}
/*------------------------------------------------*/
void checkError () {
if (ERR_STATE == 1) {
digitalWrite(ERR_LED, BlinkState);
BlinkState = !BlinkState;
}
else if (ERR_STATE == 0) {
BlinkState = LOW;
digitalWrite(ERR_LED, BlinkState);
}
}
/*------------------------------------------------*/
// #endif

46
firmware/AVR-Source/Pyr0_Piezo_Sensor_v2.x.x/pP_i2c.h
View file

@ -1,23 +1,25 @@
/*------------------------------------------------*/ #include <Wire.h>
#ifdef I2C /*------------------------------------------------*/
void i2cInput() {
#ifdef I2C
// receive data from Serial and save it into inputBuffer void i2cInput() {
while(Wire.available()) { // receive data from Serial and save it into inputBuffer
identifyMarkers();
updateParams(); while(Wire.available()) {
i2cReply(); identifyMarkers();
} updateParams();
} i2cReply();
#endif }
}
/*------------------------------------------------*/ #endif
#ifdef I2C
void i2cReply() { /*------------------------------------------------*/
if (serialIncoming) { #ifdef I2C
Wire.write("OK"); void i2cReply() {
} if (serialIncoming) {
} Wire.write("OK");
}
}
#endif #endif

62
firmware/AVR-Source/Pyr0_Piezo_Sensor_v2.x.x/pP_pins.h
View file

@ -1,32 +1,32 @@
/* pyr0-piezo pins configuration file /* pyr0-piezo pins configuration file
Default pins (based on Rev.2.x.xPCB layout) Default pins (based on Rev.2.x.xPCB layout)
* PD2 INT0 (Piezo In 'D2') * PD2 INT0 (Piezo In 'D2')
* D7 PCINT23 (Trigger OUT 'D7') * D7 PCINT23 (Trigger OUT 'D7')
* PC0 ADC0 (Voltage Reference Check 'A0') * PC0 ADC0 (Voltage Reference Check 'A0')
* PC1 ADC1 (Sensitivity Adjustment Check 'A1') * PC1 ADC1 (Sensitivity Adjustment Check 'A1')
* PD4 PCINT20 (Error feedback LED 'D4') * PD4 PCINT20 (Error feedback LED 'D4')
* PB6 PCINT6 (Voltage Adjustment Resistor 0 'D20') * PB6 PCINT6 (Voltage Adjustment Resistor 0 'D20')
* PB7 PCINT7 (Voltage Adjustment Resistor 1 'D21') * PB7 PCINT7 (Voltage Adjustment Resistor 1 'D21')
* PD5 T1 (Voltage Adjustment Resistor 2 'D5') * PD5 T1 (Voltage Adjustment Resistor 2 'D5')
* PD6 PCINT22 (Voltage Adjustment Resistor 3 'D6') * PD6 PCINT22 (Voltage Adjustment Resistor 3 'D6')
* PB1 OC1A (Comparator VRef PWM Out 'D9') * PB1 OC1A (Comparator VRef PWM Out 'D9')
* PD3 OC2B (Voltage Follower VRef PWM Out 'D3') * PD3 OC2B (Voltage Follower VRef PWM Out 'D3')
*/ */
// Analog Pin Assignments // Analog Pin Assignments
#define V_FOLLOW_PIN A0 // Sense pin to check Voltage Follower stage #define V_FOLLOW_PIN A0 // Sense pin to check Voltage Follower stage
#define VCOMP_SENSE_PIN A1 // Sense pin to check comparator stage voltage #define VCOMP_SENSE_PIN A1 // Sense pin to check comparator stage voltage
// Digital Pin Assignments // Digital Pin Assignments
#define TRG_OUT 7 // LED and Z-Min trigger output connected to digital pin 7 #define TRG_OUT 7 // LED and Z-Min trigger output connected to digital pin 7
//#define TRG_OUT 13 // For testing on Atmega328/2560, Output is moved to onboard LED pin //#define TRG_OUT 13 // For testing on Atmega328/2560, Output is moved to onboard LED pin
#define Z_TRG 2 // the piezo is connected to INT0 / digital pin 2 #define Z_TRG 2 // the piezo is connected to INT0 / digital pin 2
#define ERR_LED 4 // LED will blink if optimal voltage range cannot be achieved #define ERR_LED 4 // LED will blink if optimal voltage range cannot be achieved
#define GADJ_R0 20 // Auto-adjust ladder pin assignments #define GADJ_R0 20 // Auto-adjust ladder pin assignments
#define GADJ_R1 21 // " #define GADJ_R1 21 // "
#define GADJ_R2 5 // " #define GADJ_R2 5 // "
#define GADJ_R3 6 // " #define GADJ_R3 6 // "
#define V_FOL_PWM 3 // PWM analog output pin for voltage follower adjustment #define V_FOL_PWM 3 // PWM analog output pin for voltage follower adjustment
#define VCOMP_PWM 9 // PWM analog output pin for comparator adjustment #define VCOMP_PWM 9 // PWM analog output pin for comparator adjustment

238
firmware/AVR-Source/Pyr0_Piezo_Sensor_v2.x.x/pP_serial.h
View file

@ -1,54 +1,184 @@
void serialInput() {
/*------------------------------------------------*/
// receive data from Serial and save it into inputBuffer
void parseData() {
if(Serial.available() > 0) {
// split the data into its parts
// the order of these IF clauses is significant
identifyMarkers(); char * strtokIndx; // this is used by strtok() as an index
} strtokIndx = strtok(inputBuffer,","); // get the first part - the string
} strcpy(serialMessageIn, strtokIndx); // copy it to serialMessageIn
/*------------------------------------------------*/ strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
serialInt = atoi(strtokIndx); // convert this part to an integer
void serialReply() {
if (serialIncoming) { strtokIndx = strtok(NULL, ",");
serialIncoming = false; serialFloat = atof(strtokIndx); // convert this part to a float
#ifdef DEBUG
Serial.print("Comp Reference:"); }
Serial.print(VComp); /*------------------------------------------------*/
Serial.print(" ");
Serial.print("Comparator State:"); void identifyMarkers() {
Serial.print(ADJ_COMP);
Serial.print(" "); char x = Serial.read();
Serial.println(compInt); // char y = Wire.read();
Serial.print("Diff"); if (x == endMarker) {
Serial.print(" "); readInProgress = false;
Serial.print(diffCompL); serialIncoming = true;
Serial.print(" "); inputBuffer[bytesRecvd] = 0;
Serial.println(diffCompH); parseData();
}
Serial.print("Amp Sense:");
Serial.print(VAdj); else if(readInProgress) {
Serial.print(" "); inputBuffer[bytesRecvd] = x;
Serial.print("Follower State:"); bytesRecvd ++;
Serial.print(ADJ_FOLLOW); if (bytesRecvd == buffSize) {
Serial.print(" "); bytesRecvd = buffSize - 1;
Serial.println(senseInt); }
}
Serial.print("Diff");
Serial.print(" "); else if (x == startMarker) {
Serial.print(diffAdjL); bytesRecvd = 0;
Serial.print(" "); readInProgress = true;
Serial.println(diffAdjH); }
#endif #ifdef I2C
if (y == endMarker) {
Serial.print("Delay:"); readInProgress = false;
Serial.println(TRG_DUR); serialIncoming = true;
Serial.print("Error State:"); inputBuffer[bytesRecvd] = 0;
Serial.println(ERR_STATE); parseData();
Serial.println("------------------"); }
}
} if(readInProgress) {
inputBuffer[bytesRecvd] = y;
bytesRecvd ++;
if (bytesRecvd == buffSize) {
bytesRecvd = buffSize - 1;
}
}
if (y == startMarker) {
bytesRecvd = 0;
readInProgress = true;
}
#endif
}
/*------------------------------------------------*/
void updateTrigDuration() {
if (serialInt >= 0) {
TRG_DUR = serialInt;
}
}
/*------------------------------------------------*/
void updateGainFactor() {
if (serialInt >= 0) {
GAIN_FACTOR = serialInt;
}
}
/*------------------------------------------------*/
void updateVComp() {
if (serialInt >= 0) {
compInt = (serialFloat * 1024) / Vin;
//senseInt = compInt; // syncing these params til #24 is fixed
}
}
/*------------------------------------------------*/
void updateVAdj() {
if (serialInt >= 0) {
senseInt = (serialFloat * 1024) / Vin;
//compInt = senseInt; // syncing these params til #24 is fixed
}
}
/*------------------------------------------------*/
void updateHysteresis() {
if (serialInt >= 0) {
Hyst = serialInt;
}
}
/*------------------------------------------------*/
/*------------------------------------------------*/
void updateParams() {
if (strcmp(serialMessageIn, "TRG_D") == 0) {
updateTrigDuration();
}
else if (strcmp(serialMessageIn, "GAIN_F") == 0) {
updateGainFactor();
}
else if (strcmp(serialMessageIn, "VCOMP") == 0) {
updateVComp();
}
else if (strcmp(serialMessageIn, "VADJ") == 0) {
updateVAdj();
}
}
void serialInput() {
// receive data from Serial and save it into inputBuffer
if(Serial.available() > 0) {
// the order of these IF clauses is significant
identifyMarkers();
}
}
/*------------------------------------------------*/
void serialReply() {
#ifndef VERBOSE
if (serialIncoming) {
serialIncoming = false;
#endif
#ifdef DEBUG
Serial.print("Vcc:");
Serial.println(Vin);
Serial.print("Comp Sense:");
Serial.print(VComp);
Serial.print(" ");
Serial.print("Comparator State:");
Serial.print(ADJ_COMP);
Serial.print(" ");
Serial.println(compInt);
Serial.print("Diff");
Serial.print(" ");
Serial.print(diffCompL);
Serial.print(" ");
Serial.println(diffCompH);
Serial.print("Amp Sense:");
Serial.print(VAdj);
Serial.print(" ");
Serial.print("Follower State:");
Serial.print(ADJ_FOLLOW);
Serial.print(" ");
Serial.println(senseInt);
Serial.print("Diff");
Serial.print(" ");
Serial.print(diffAdjL);
Serial.print(" ");
Serial.println(diffAdjH);
#endif
Serial.print("Delay:");
Serial.println(TRG_DUR);
Serial.print("Error State:");
Serial.println(ERR_STATE);
Serial.println("------------------");
#ifndef VERBOSE
}
#endif
}

78
firmware/AVR-Source/Pyr0_Piezo_Sensor_v2.x.x/pP_volatile.h
View file

@ -1,37 +1,41 @@
// these variables will change on their own. Do not edit ANYTHING below this line // these variables will change on their own. Do not edit ANYTHING below this line
volatile int sensorHReading = 0; // variable to store the value read from the sensor pin volatile int sensorHReading = 0; // variable to store the value read from the sensor pin
volatile int ADJ_FOLLOW = 0; // Variable for Follower adjustment volatile int ADJ_FOLLOW = 0; // Variable for Follower adjustment
volatile int ADJ_COMP = 0; // Variable for Comparator adjustment volatile int ADJ_COMP = 0; // Variable for Comparator adjustment
volatile int ERR_STATE = 0; volatile int ERR_STATE = 0;
// Convert float to integer for adjustment functions int Vin = 5000; // input reference voltage in millivolts (multiply V by 1000)
int senseInt = (senseThrs * 1024) / Vin; // Voltage Follower upper converted to adg interger int VOld = 5000; // Variable to store previous cycle's Vin
int compInt = (compThrs * 1024) / Vin; // Upper threshold of Comparator before adjustment int VLast = 0;
// Voltage Comparator Adjustment parameters // Convert threshold values based on the input voltage
//float VCompRef = 0.00; // variable to store the float value read from the comparator reference long senseLong = senseThrs * 1024L;
int VComp = 0; long compLong = compThrs * 1024L;
int diffCompL = VComp - compInt; long senseInt = senseLong / Vin;
int diffCompH = compInt - VComp; long compInt = compLong / Vin;
// Voltage Follower Adjustment parameters // Voltage Comparator Adjustment parameters
//float vAdjRead = 0.00; // variable to store the value read from the follower int VComp = 0;
int VAdj = 0; int diffCompL = VComp - compInt;
int diffAdjL = VAdj - senseInt; int diffCompH = compInt - VComp;
int diffAdjH = senseInt - VAdj;
// Voltage Follower Adjustment parameters
// Error blink parameters int VAdj = 0;
int BlinkState = LOW; int diffAdjL = VAdj - senseInt;
int BlinkCount = InitCount * 2; // Multiply Blink count by 2 to handle toggle state int diffAdjH = senseInt - VAdj;
// Serial Input Parsing Variables // Error blink parameters
#define buffSize 40 int BlinkState = LOW;
char inputBuffer[buffSize]; int BlinkCount = InitCount * 2; // Multiply Blink count by 2 to handle toggle state
#define startMarker '<'
#define endMarker '>' // Serial Input Parsing Variables
byte bytesRecvd = 0; #define buffSize 40
bool readInProgress = false; char inputBuffer[buffSize];
bool serialIncoming = false; #define startMarker '<'
char serialMessageIn[buffSize] = {0}; #define endMarker '>'
int serialInt = 0; byte bytesRecvd = 0;
float serialFloat = 0.00; bool readInProgress = false;
bool serialIncoming = false;
char serialMessageIn[buffSize] = {0};
int serialInt = 0;
float serialFloat = 0.00;