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

Merge pull request #68 from loredan/master

Browse source 
New file structure, bringing the project into spec with C++ standards
This commit is contained in:
Alan Weinstock 2020-02-27 11:41:25 -08:00 committed by GitHub
commit c521adccd3
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
9 changed files with 669 additions and 511 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
firmware/AVR-Source/Pyr0_Piezo_Sensor_v2.x.x/src/Pyr0_Piezo_Sensor_V2.x.x.cpp
View file

@ -84,16 +84,12 @@ update the voltMeterConstant variable in pP_config.h with the correct value
------------------------------------------------------------*/ ------------------------------------------------------------*/
/* Debug output verbose mode will continuously output sensor readings
rather than waiting for user input */
#define VERBOSE true
// Headers, variables, and functions // Headers, variables, and functions
#include <Arduino.h> #include <Arduino.h>
#include <EEPROM.h> #include <EEPROM.h>
#include "LightChrono.h" #include "LightChrono.h"
#include "pP_pins.h" #include "pP_pins.h"
#include "pP_config.h" // #include "pP_config.h"
#include "pP_volatile.h" #include "pP_volatile.h"
#include "pP_function.h" #include "pP_function.h"
#include "pP_serial.h" #include "pP_serial.h"

119
firmware/AVR-Source/Pyr0_Piezo_Sensor_v2.x.x/src/pP_cmd.h Normal file
View file

@ -0,0 +1,119 @@
#ifndef PP_CMD_H
#define PP_CMD_H
#include "pP_config.h"
#include "pP_function.h"
#include "EEPROM.h"
/*------------------------------------------------*/
void updateGainFactor(int value)
{
if (value >= 0)
{
GAIN_FACTOR = value;
adjustGain();
EEPROM.put(GAIN_FACTOR_ADDRESS, GAIN_FACTOR);
}
}
/*------------------------------------------------*/
void updateVFol(int value)
{
if (value >= 0)
{
followerThrs = value;
adjustFollow();
EEPROM.put(FOLLOWER_THRESHOLD_ADDRESS, followerThrs);
}
}
/*------------------------------------------------*/
void updateVComp(int value)
{
if (value >= 0)
{
compThrs = value;
adjustComp();
EEPROM.put(COMP_THRESHOLD_ADDRESS, compThrs);
}
}
/*------------------------------------------------*/
void updateLoopDuration(int value)
{
if (value >= 0)
{
LOOP_DUR = value;
EEPROM.put(LOOP_DUR_ADDRESS, LOOP_DUR);
}
}
/*------------------------------------------------*/
void updateTrigDuration(int value)
{
if (value >= 0)
{
TRG_DUR = value;
EEPROM.put(TRG_DUR_ADDRESS, TRG_DUR);
}
}
/*------------------------------------------------*/
void updateHysteresis(int value)
{
if (value >= 0)
{
Hyst = value;
EEPROM.put(HYST_ADDRESS, Hyst);
}
}
/*------------------------------------------------*/
void updateLogic(int value)
{
if (value >= 0)
{
LOGIC = value;
EEPROM.put(LOGIC_ADDRESS, LOGIC);
pulse();
}
}
/*------------------------------------------------*/
void updatePzDet(int value)
{
if (value >= 0)
{
PZDET = value;
EEPROM.put(PZDET_ADDRESS, PZDET);
}
}
/*------------------------------------------------*/
void updateConstant(long value)
{
if (value >= 0)
{
voltMeterConstant = value;
EEPROM.put(VM_CONST_ADDRESS, voltMeterConstant);
}
}
/*------------------------------------------------*/
void updateDebug(int value)
{
if (value > 0)
{
Debug = 1;
}
else if (value == 0)
{
Debug = 0;
}
}
#endif //PP_CMD_H

122
firmware/AVR-Source/Pyr0_Piezo_Sensor_v2.x.x/src/pP_config.cpp
View file

@ -1,14 +1,122 @@
#include "pP_config.h" #include "pP_config.h"
#include "pP_function.h"
#include <EEPROM.h> #include <EEPROM.h>
int GAIN_FACTOR = GAIN_FACTOR_DEFAULT; // Gain adjustment factor. 0=3x, 1=3.5x, 2=4.33x, 3=6x, 4=11x int GAIN_FACTOR = GAIN_FACTOR_DEFAULT;
int followerThrs = FOLLOWER_THRESHOLD_DEFAULT; int followerThrs = FOLLOWER_THRESHOLD_DEFAULT;
int compThrs = COMP_THRESHOLD_DEFAULT; int compThrs = COMP_THRESHOLD_DEFAULT;
int LOOP_DUR = LOOP_DUR_DEFAULT; // duration of time between ADC checks and other loop functions int LOOP_DUR = LOOP_DUR_DEFAULT;
int TRG_DUR = TRG_DUR_DEFAULT; // duration of the Z-axis pulse sent, in ms int TRG_DUR = TRG_DUR_DEFAULT;
int Hyst = HYST_DEFAULT; // Hysteresis value for ADC measurements int Hyst = HYST_DEFAULT;
int LOGIC = LOGIC_DEFAULT; // Trigger output logic (active low or active high) int LOGIC = LOGIC_DEFAULT;
int PZDET = PZDET_DEFAULT; // Enable/disable piezo connection detection int PZDET = PZDET_DEFAULT;
int Debug = 0; int Debug = 0;
long voltMeterConstant = VM_CONST_DEFAULT; long voltMeterConstant = VM_CONST_DEFAULT;
uint8_t pP_i2c_address = 0xa0;
/*------------------------------------------------*/
void eraseEEPROM() {
setDefaultConfig();
EEPROM.put(GAIN_FACTOR_ADDRESS, GAIN_FACTOR);
EEPROM.put(FOLLOWER_THRESHOLD_ADDRESS, followerThrs);
EEPROM.put(COMP_THRESHOLD_ADDRESS, compThrs);
EEPROM.put(LOOP_DUR_ADDRESS, LOOP_DUR);
EEPROM.put(TRG_DUR_ADDRESS, TRG_DUR);
EEPROM.put(HYST_ADDRESS, Hyst);
EEPROM.put(PZDET_ADDRESS, PZDET);
EEPROM.put(LOGIC_ADDRESS, LOGIC);
EEPROM.put(VM_CONST_ADDRESS, voltMeterConstant);
}
// Restore config from EEPROM, otherwise erase config and write to EEPROM
void restoreConfig() {
int temp;
bool erase = false;
EEPROM.get(GAIN_FACTOR_ADDRESS, temp);
if (temp < 0 || temp > 4) {
erase = true;
} else {
GAIN_FACTOR = temp;
}
EEPROM.get(FOLLOWER_THRESHOLD_ADDRESS, temp);
if (temp < 0 || temp > 5000) {
erase = true;
} else {
followerThrs = temp;
}
EEPROM.get(COMP_THRESHOLD_ADDRESS, temp);
if (temp < 0 || temp > 5000) {
erase = true;
} else {
compThrs = temp;
}
EEPROM.get(LOOP_DUR_ADDRESS, temp);
if (temp < 0 && temp > 1000) {
erase = true;
} else {
LOOP_DUR = temp;
}
EEPROM.get(TRG_DUR_ADDRESS, temp);
if (temp < 0 || temp > 1000) {
erase = true;
} else {
TRG_DUR = temp;
}
EEPROM.get(HYST_ADDRESS, temp);
if (temp < 0 || temp > 1000) {
erase = true;
} else {
Hyst = temp;
}
EEPROM.get(PZDET_ADDRESS, temp);
if (temp < 0 || temp > 1) {
erase = true;
} else {
PZDET = temp;
}
EEPROM.get(LOGIC_ADDRESS, temp);
if (temp < 0 || temp > 1) {
erase = true;
} else {
LOGIC = temp;
}
long longTemp;
EEPROM.get(VM_CONST_ADDRESS, longTemp);
if (longTemp < 1000000L || longTemp > 1200000L) {
erase = true;
} else {
voltMeterConstant = longTemp;
}
if (erase) {
eraseEEPROM();
}
adjustFollow();
adjustComp();
}
void setDefaultConfig() {
GAIN_FACTOR = GAIN_FACTOR_DEFAULT;
followerThrs = FOLLOWER_THRESHOLD_DEFAULT;
compThrs = COMP_THRESHOLD_DEFAULT;
LOOP_DUR = LOOP_DUR_DEFAULT;
TRG_DUR = TRG_DUR_DEFAULT;
Hyst = HYST_DEFAULT;
PZDET = PZDET_DEFAULT;
LOGIC = LOGIC_DEFAULT;
voltMeterConstant = VM_CONST_DEFAULT;
adjustFollow();
adjustComp();
}

24
firmware/AVR-Source/Pyr0_Piezo_Sensor_v2.x.x/src/pP_config.h
View file

@ -5,21 +5,15 @@
#define GAIN_FACTOR_DEFAULT 2 // Gain adjustment factor. 0=3x, 1=3.5x, 2=4.33x, 3=6x, 4=11x #define GAIN_FACTOR_DEFAULT 2 // Gain adjustment factor. 0=3x, 1=3.5x, 2=4.33x, 3=6x, 4=11x
#define GAIN_FACTOR_ADDRESS 0 #define GAIN_FACTOR_ADDRESS 0
#if !(defined(GAIN_FACTOR))
extern int GAIN_FACTOR; extern int GAIN_FACTOR;
#endif
#define FOLLOWER_THRESHOLD_DEFAULT 1450 // Voltage follower default voltage in mV #define FOLLOWER_THRESHOLD_DEFAULT 1450 // Voltage follower default voltage in mV
#define FOLLOWER_THRESHOLD_ADDRESS 4 #define FOLLOWER_THRESHOLD_ADDRESS 4
#if !(defined(followerThrs))
extern int followerThrs; extern int followerThrs;
#endif
#define COMP_THRESHOLD_DEFAULT 2850 // Comparatore Vref default voltage in mV #define COMP_THRESHOLD_DEFAULT 2850 // Comparatore Vref default voltage in mV
#define COMP_THRESHOLD_ADDRESS 8 #define COMP_THRESHOLD_ADDRESS 8
#if !(defined(compThrs))
extern int compThrs; extern int compThrs;
#endif
#ifndef InitCount #ifndef InitCount
#define InitCount 6 // Number of times to blink the LED on start #define InitCount 6 // Number of times to blink the LED on start
@ -27,49 +21,33 @@
#define LOOP_DUR_DEFAULT 50 // duration of time between ADC checks and other loop functions #define LOOP_DUR_DEFAULT 50 // duration of time between ADC checks and other loop functions
#define LOOP_DUR_ADDRESS 12 #define LOOP_DUR_ADDRESS 12
#if !(defined(LOOP_DUR))
extern int LOOP_DUR; extern int LOOP_DUR;
#endif
#define TRG_DUR_DEFAULT 20 // duration of the Z-axis pulse sent, in ms #define TRG_DUR_DEFAULT 20 // duration of the Z-axis pulse sent, in ms
#define TRG_DUR_ADDRESS 16 #define TRG_DUR_ADDRESS 16
#if !(defined(TRG_DUR))
extern int TRG_DUR; extern int TRG_DUR;
#endif
#define HYST_DEFAULT 20 #define HYST_DEFAULT 20
#define HYST_ADDRESS 20 #define HYST_ADDRESS 20
#if !(defined(Hyst))
extern int Hyst; // Hysteresis value for ADC measurements extern int Hyst; // Hysteresis value for ADC measurements
#endif
#define LOGIC_DEFAULT 1 #define LOGIC_DEFAULT 1
#define LOGIC_ADDRESS 32 #define LOGIC_ADDRESS 32
#if !(defined(LOGIC))
extern int LOGIC; // Trigger logic scheme, Active LOW is default extern int LOGIC; // Trigger logic scheme, Active LOW is default
#endif
#define PZDET_DEFAULT 0 #define PZDET_DEFAULT 0
#define PZDET_ADDRESS 26 #define PZDET_ADDRESS 26
#if !(defined(PZDET))
extern int PZDET; // Enable or disable piezo connection detection, default is off extern int PZDET; // Enable or disable piezo connection detection, default is off
#endif
#if !(defined(Debug))
extern int Debug; extern int Debug;
#endif
#define VM_CONST_ADDRESS 28 #define VM_CONST_ADDRESS 28
#define VM_CONST_DEFAULT 1125300L #define VM_CONST_DEFAULT 1125300L
#if !(defined(voltMeterConstant))
extern long voltMeterConstant; // For fine tuning input voltage sense extern long voltMeterConstant; // For fine tuning input voltage sense
#endif
#ifdef I2C_INPUT #ifdef I2C_INPUT
#define I2C_SLAVE_ADDRESS 24 #define I2C_SLAVE_ADDRESS 24
#if !(defined(pP_i2c_address)) uint8_t pP_i2c_address = 0xa0; // I2C Bus Address
extern uint8_t pP_i2c_address; // I2C Bus Address
#endif
#endif // I2C_INPUT #endif // I2C_INPUT
void eraseEEPROM(); void eraseEEPROM();

216
firmware/AVR-Source/Pyr0_Piezo_Sensor_v2.x.x/src/pP_function.cpp Normal file
View file

@ -0,0 +1,216 @@
/*
pyr0-piezo functions library
Created by Alan "pyr0ball" Weinstock 6/26/2019
*/
//#pragma once
//#include "pP_function.h"
#include "pP_function.h"
#include "Arduino.h"
#include "pP_config.h"
#include "pP_volatile.h"
#include "pP_pins.h"
#include "stdint.h"
void digitalWriteFast(uint8_t pin, uint8_t x)
{
if (pin / 8)
{ // pin >= 8
PORTB ^= (-x ^ PORTB) & (1 << (pin % 8));
}
else
{
PORTD ^= (-x ^ PORTD) & (1 << (pin % 8));
}
}
int analogReadFast(uint8_t ADCpin)
{
byte ADCSRAoriginal = ADCSRA;
ADCSRA = (ADCSRA & B11111000) | 4;
int adc = analogRead(ADCpin);
ADCSRA = ADCSRAoriginal;
return adc;
}
/*------------------------------------------------*/
void doubleFlash()
{
BlinkCount = 4;
}
/*------------------------------------------------*/
void pulse()
{
digitalWriteFast(TRG_OUT, LOGIC);
sensorHReading = 1;
delay(TRG_DUR);
digitalWriteFast(TRG_OUT, !LOGIC);
Serial.println("Trig'd!");
doubleFlash();
}
/*------------------------------------------------*/
long readVcc()
{
// Read 1.1V reference against AVcc
// Atmega's Secret Voltmeter setup:
// 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 = voltMeterConstant / result; // Calculate Vcc (in mV); 1125300 = 1.1*1023*1000
return result; // Vcc in millivolts
}
/*-------------------------------------------------
The above function assumes an "ideal" multiplier constant.
Each Atmega chip is slightly different, so it won't be completely accurate
without tuning. Most of the time this won't be necessary, so don't mess
with this if you don't know what you're doing!
The reading can be fine-tuned by using a multimeter, and this equation:
scale_constant = internal1.1Ref * 1023 * 1000
where
internal1.1Ref = 1.1 * Vcc1 (per voltmeter) / Vcc2 (per readVcc() function)
If the scale_constant calculated is different from the default 1125300,
update the voltMeterConstant variable in pP_config.h with the correct value
--------------------------------------------------*/
void readVin()
{
VOld = Vin;
Vin = readVcc();
followerLong = followerThrs * 1023L;
compLong = compThrs * 1023L;
followerInt = (long long)followerLong / Vin;
compInt = (long long)compLong / Vin;
followerInt = (int)followerInt;
compInt = (int)compInt;
}
/*------------------------------------------------*/
void adjustFollow()
{
/* Compares diffs of threshold vs read value
if positive, adjusts the follower to within
the range set above*/
followerLong = followerThrs * 1023L;
followerInt = (long long)followerLong / Vin;
followerInt = (int)followerInt;
ADJ_FOLLOW = (followerInt / 4);
// Analog output (PWM) of duty cycle
OCR2B = ADJ_FOLLOW;
}
/*------------------------------------------------*/
void adjustComp()
{
compLong = compThrs * 1023L;
compInt = (long long)compLong / Vin;
compInt = (int)compInt;
OCR1A = compInt;
}
/*------------------------------------------------*/
void calibrateAlert()
{
VLast = VOld - Vin;
if (VLast > Hyst || VLast < -Hyst)
{
ERR_STATE = 1;
}
}
/*------------------------------------------------*/
void adjustGain()
{
switch (GAIN_FACTOR)
{
case 4:
pinMode(GADJ_R0, OUTPUT);
digitalWriteFast(GADJ_R0, LOW);
break;
case 3:
pinMode(GADJ_R1, OUTPUT);
digitalWriteFast(GADJ_R1, LOW);
pinMode(GADJ_R0, INPUT);
break;
case 2:
pinMode(GADJ_R2, OUTPUT);
digitalWriteFast(GADJ_R2, LOW);
pinMode(GADJ_R1, INPUT);
pinMode(GADJ_R0, INPUT);
break;
case 1:
pinMode(GADJ_R3, OUTPUT);
digitalWriteFast(GADJ_R3, LOW);
pinMode(GADJ_R2, INPUT);
pinMode(GADJ_R1, INPUT);
pinMode(GADJ_R0, INPUT);
break;
case 0:
default:
pinMode(GADJ_R3, INPUT);
pinMode(GADJ_R2, INPUT);
pinMode(GADJ_R1, INPUT);
pinMode(GADJ_R0, INPUT);
break;
}
}
/*------------------------------------------------*/
//void checkError () {
// if (ERR_STATE == 1) {
// digitalWriteFast(ERR_LED, BlinkState);
// BlinkState = !BlinkState;
// }
// else if (ERR_STATE == 0) {
// BlinkState = LOW;
// digitalWriteFast(ERR_LED, BlinkState);
// }
//}
/*------------------------------------------------*/
void pzConCheck()
{
PZ_STATE = digitalRead(PZDET_PIN);
if (PZ_STATE == PZDET)
{
//digitalWriteFast(TRG_OUT, LOGIC);
ERR_STATE = 1;
}
}

278
firmware/AVR-Source/Pyr0_Piezo_Sensor_v2.x.x/src/pP_function.h
View file

@ -6,70 +6,16 @@
//#pragma once //#pragma once
//#include "pP_function.h" //#include "pP_function.h"
void digitalWriteFast(uint8_t pin, uint8_t x) { #ifndef PP_FUNCTION_H
if (pin / 8) { // pin >= 8 #define PP_FUNCTION_H
PORTB ^= (-x ^ PORTB) & (1 << (pin % 8));
}
else {
PORTD ^= (-x ^ PORTD) & (1 << (pin % 8));
}
}
int inline analogReadFast(byte ADCpin) #include "stdint.h"
{ byte ADCSRAoriginal = ADCSRA;
ADCSRA = (ADCSRA & B11111000) | 4;
int adc = analogRead(ADCpin);
ADCSRA = ADCSRAoriginal;
return adc;
}
/*------------------------------------------------*/ void digitalWriteFast(uint8_t pin, uint8_t x);
int analogReadFast(uint8_t ADCpin);
void doubleFlash() { void doubleFlash();
BlinkCount = 4 ; void pulse();
} long readVcc();
/*------------------------------------------------*/
void pulse() {
digitalWriteFast(TRG_OUT, LOGIC);
sensorHReading = 1;
delay(TRG_DUR);
digitalWriteFast(TRG_OUT, !LOGIC);
Serial.println("Trig'd!");
doubleFlash();
}
/*------------------------------------------------*/
long readVcc() {
// Read 1.1V reference against AVcc
// Atmega's Secret Voltmeter setup:
// 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 = voltMeterConstant / result; // Calculate Vcc (in mV); 1125300 = 1.1*1023*1000
return result; // Vcc in millivolts
}
/*------------------------------------------------- /*-------------------------------------------------
The above function assumes an "ideal" multiplier constant. The above function assumes an "ideal" multiplier constant.
@ -87,90 +33,11 @@ internal1.1Ref = 1.1 * Vcc1 (per voltmeter) / Vcc2 (per readVcc() function)
If the scale_constant calculated is different from the default 1125300, If the scale_constant calculated is different from the default 1125300,
update the voltMeterConstant variable in pP_config.h with the correct value update the voltMeterConstant variable in pP_config.h with the correct value
--------------------------------------------------*/ --------------------------------------------------*/
void readVin();
void readVin() { void adjustFollow();
VOld = Vin; void adjustComp();
Vin = readVcc(); void calibrateAlert();
followerLong = followerThrs * 1023L; void adjustGain();
compLong = compThrs * 1023L;
followerInt = (long long) followerLong / Vin;
compInt = (long long) compLong / Vin;
followerInt = (int) followerInt;
compInt = (int) compInt;
}
/*------------------------------------------------*/
void adjustFollow() {
/* Compares diffs of threshold vs read value
if positive, adjusts the follower to within
the range set above*/
followerLong = followerThrs * 1023L;
followerInt = (long long) followerLong / Vin;
followerInt = (int) followerInt;
ADJ_FOLLOW = (followerInt / 4);
// Analog output (PWM) of duty cycle
OCR2B = ADJ_FOLLOW;
}
/*------------------------------------------------*/
void adjustComp() {
compLong = compThrs * 1023L;
compInt = (long long) compLong / Vin;
compInt = (int) compInt;
OCR1A = compInt;
}
/*------------------------------------------------*/
void calibrateAlert() {
VLast = VOld - Vin;
if (VLast > Hyst || VLast < -Hyst ) {
ERR_STATE = 1;
}
}
/*------------------------------------------------*/
void adjustGain() {
switch (GAIN_FACTOR)
{
case 4:
pinMode(GADJ_R0, OUTPUT);
digitalWriteFast(GADJ_R0, LOW);
break;
case 3:
pinMode(GADJ_R1, OUTPUT);
digitalWriteFast(GADJ_R1, LOW);
pinMode(GADJ_R0, INPUT);
break;
case 2:
pinMode(GADJ_R2, OUTPUT);
digitalWriteFast(GADJ_R2, LOW);
pinMode(GADJ_R1, INPUT);
pinMode(GADJ_R0, INPUT);
break;
case 1:
pinMode(GADJ_R3, OUTPUT);
digitalWriteFast(GADJ_R3, LOW);
pinMode(GADJ_R2, INPUT);
pinMode(GADJ_R1, INPUT);
pinMode(GADJ_R0, INPUT);
break;
case 0:
default:
pinMode(GADJ_R3, INPUT);
pinMode(GADJ_R2, INPUT);
pinMode(GADJ_R1, INPUT);
pinMode(GADJ_R0, INPUT);
break;
}
}
/*------------------------------------------------*/
//void checkError () { //void checkError () {
// if (ERR_STATE == 1) { // if (ERR_STATE == 1) {
// digitalWriteFast(ERR_LED, BlinkState); // digitalWriteFast(ERR_LED, BlinkState);
@ -181,121 +48,6 @@ void adjustGain() {
// digitalWriteFast(ERR_LED, BlinkState); // digitalWriteFast(ERR_LED, BlinkState);
// } // }
//} //}
void pzConCheck();
/*------------------------------------------------*/ #endif //PP_FUNCTION_H
void pzConCheck () {
PZ_STATE = digitalRead(PZDET_PIN);
if (PZ_STATE == PZDET) {
//digitalWriteFast(TRG_OUT, LOGIC);
ERR_STATE = 1;
}
}
/*------------------------------------------------*/
void eraseEEPROM() {
setDefaultConfig();
EEPROM.put(GAIN_FACTOR_ADDRESS, GAIN_FACTOR);
EEPROM.put(FOLLOWER_THRESHOLD_ADDRESS, followerThrs);
EEPROM.put(COMP_THRESHOLD_ADDRESS, compThrs);
EEPROM.put(LOOP_DUR_ADDRESS, LOOP_DUR);
EEPROM.put(TRG_DUR_ADDRESS, TRG_DUR);
EEPROM.put(HYST_ADDRESS, Hyst);
EEPROM.put(PZDET_ADDRESS, PZDET);
EEPROM.put(LOGIC_ADDRESS, LOGIC);
EEPROM.put(VM_CONST_ADDRESS, voltMeterConstant);
}
// Restore config from EEPROM, otherwise erase config and write to EEPROM
void restoreConfig() {
int temp;
bool erase = false;
EEPROM.get(GAIN_FACTOR_ADDRESS, temp);
if (temp < 0 || temp > 4) {
erase = true;
} else {
GAIN_FACTOR = temp;
}
EEPROM.get(FOLLOWER_THRESHOLD_ADDRESS, temp);
if (temp < 0 || temp > 5000) {
erase = true;
} else {
followerThrs = temp;
}
EEPROM.get(COMP_THRESHOLD_ADDRESS, temp);
if (temp < 0 || temp > 5000) {
erase = true;
} else {
compThrs = temp;
}
EEPROM.get(LOOP_DUR_ADDRESS, temp);
if (temp < 0 && temp > 1000) {
erase = true;
} else {
LOOP_DUR = temp;
}
EEPROM.get(TRG_DUR_ADDRESS, temp);
if (temp < 0 || temp > 1000) {
erase = true;
} else {
TRG_DUR = temp;
}
EEPROM.get(HYST_ADDRESS, temp);
if (temp < 0 || temp > 1000) {
erase = true;
} else {
Hyst = temp;
}
EEPROM.get(PZDET_ADDRESS, temp);
if (temp < 0 || temp > 1) {
erase = true;
} else {
PZDET = temp;
}
EEPROM.get(LOGIC_ADDRESS, temp);
if (temp < 0 || temp > 1) {
erase = true;
} else {
LOGIC = temp;
}
long longTemp;
EEPROM.get(VM_CONST_ADDRESS, longTemp);
if (longTemp < 1000000L || longTemp > 1200000L) {
erase = true;
} else {
voltMeterConstant = longTemp;
}
if (erase) {
eraseEEPROM();
}
adjustFollow();
adjustComp();
}
void setDefaultConfig() {
GAIN_FACTOR = GAIN_FACTOR_DEFAULT;
followerThrs = FOLLOWER_THRESHOLD_DEFAULT;
compThrs = COMP_THRESHOLD_DEFAULT;
LOOP_DUR = LOOP_DUR_DEFAULT;
TRG_DUR = TRG_DUR_DEFAULT;
Hyst = HYST_DEFAULT;
PZDET = PZDET_DEFAULT;
LOGIC = LOGIC_DEFAULT;
voltMeterConstant = VM_CONST_DEFAULT;
adjustFollow();
adjustComp();
}

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

@ -1,4 +1,7 @@
void parseData() { #include "pP_cmd.h"
void parseData()
{
// split the data into its parts // split the data into its parts
@ -9,40 +12,48 @@ void parseData() {
strtokIndx = strtok(NULL, " "); // this continues where the previous call left off strtokIndx = strtok(NULL, " "); // this continues where the previous call left off
serialLong = atol(strtokIndx); // convert this part to an integer serialLong = atol(strtokIndx); // convert this part to an integer
} }
/*------------------------------------------------*/ /*------------------------------------------------*/
void identifyMarkers() { void identifyMarkers()
{
char x = Serial.read(); char x = Serial.read();
#ifdef I2C_INPUT #ifdef I2C_INPUT
char y = Wire.read(); char y = Wire.read();
#endif // I2C_INPUT #endif // I2C_INPUT
if (x == '\n' || x == '\r') { if (x == '\n' || x == '\r')
{
serialIncoming = true; serialIncoming = true;
inputBuffer[bytesRecvd] = 0; inputBuffer[bytesRecvd] = 0;
parseData(); parseData();
bytesRecvd = 0; bytesRecvd = 0;
} else { }
else
{
inputBuffer[bytesRecvd] = x; inputBuffer[bytesRecvd] = x;
bytesRecvd++; bytesRecvd++;
if (bytesRecvd == buffSize) { if (bytesRecvd == buffSize)
{
bytesRecvd = buffSize - 1; bytesRecvd = buffSize - 1;
} }
} }
#ifdef I2C_INPUT #ifdef I2C_INPUT
if (y == '\n' || y == '\r') { if (y == '\n' || y == '\r')
{
serialIncoming = true; serialIncoming = true;
inputBuffer[bytesRecvd] = 0; inputBuffer[bytesRecvd] = 0;
parseData(); parseData();
bytesRecvd = 0; bytesRecvd = 0;
} else { }
else
{
inputBuffer[bytesRecvd] = y; inputBuffer[bytesRecvd] = y;
bytesRecvd++; bytesRecvd++;
if (bytesRecvd == buffSize) { if (bytesRecvd == buffSize)
{
bytesRecvd = buffSize - 1; bytesRecvd = buffSize - 1;
} }
} }
@ -51,100 +62,12 @@ void identifyMarkers() {
/*------------------------------------------------*/ /*------------------------------------------------*/
void updateGainFactor() void serialPrintConfig()
{ {
if (serialLong >= 0) {
GAIN_FACTOR = serialLong;
adjustGain();
EEPROM.put(GAIN_FACTOR_ADDRESS, GAIN_FACTOR);
}
}
/*------------------------------------------------*/
void updateVFol() {
if (serialLong >= 0) {
followerThrs = serialLong;
adjustFollow();
EEPROM.put(FOLLOWER_THRESHOLD_ADDRESS, followerThrs);
}
}
/*------------------------------------------------*/
void updateVComp() {
if (serialLong >= 0) {
compThrs = serialLong;
adjustComp();
EEPROM.put(COMP_THRESHOLD_ADDRESS, compThrs);
}
}
/*------------------------------------------------*/
void updateLoopDuration() {
if (serialLong >= 0) {
LOOP_DUR = serialLong;
EEPROM.put(LOOP_DUR_ADDRESS, LOOP_DUR);
}
}
/*------------------------------------------------*/
void updateTrigDuration() {
if (serialLong >= 0) {
TRG_DUR = serialLong;
EEPROM.put(TRG_DUR_ADDRESS, TRG_DUR);
}
}
/*------------------------------------------------*/
void updateHysteresis() {
if (serialLong >= 0) {
Hyst = serialLong;
EEPROM.put(HYST_ADDRESS, Hyst);
}
}
/*------------------------------------------------*/
void updateLogic() {
if (serialLong >= 0) {
LOGIC = serialLong;
EEPROM.put(LOGIC_ADDRESS, LOGIC);
pulse();
}
}
/*------------------------------------------------*/
void updatePzDet() {
if (serialLong >= 0) {
PZDET = serialLong;
EEPROM.put(PZDET_ADDRESS, PZDET);
}
}
/*------------------------------------------------*/
void updateConstant() {
if (serialLong >= 0) {
voltMeterConstant = (long) serialLong;
EEPROM.put(VM_CONST_ADDRESS, voltMeterConstant);
}
}
/*------------------------------------------------*/
void updateDebug() {
if (serialLong > 0) {
Debug = 1;
} else if (serialLong == 0) {
Debug = 0;
}
}
/*------------------------------------------------*/
void serialPrintConfig() {
Serial.print("GAIN_F "); Serial.print("GAIN_F ");
Serial.print(GAIN_FACTOR); Serial.print(GAIN_FACTOR);
switch (GAIN_FACTOR) { switch (GAIN_FACTOR)
{
case 0: case 0:
Serial.println(" 3x"); Serial.println(" 3x");
break; break;
@ -193,7 +116,8 @@ void serialPrintConfig() {
Serial.println(PP_VERSION); Serial.println(PP_VERSION);
} }
void serialPrintState() { void serialPrintState()
{
Serial.print("{"); Serial.print("{");
Serial.print("\"Vcc\":"); Serial.print("\"Vcc\":");
@ -223,49 +147,64 @@ void serialPrintState() {
Serial.println("}"); Serial.println("}");
} }
void updateParams() { void updateParams()
{
serialIncoming = false; serialIncoming = false;
if (strcmp(serialMessageIn, "GAIN_F") == 0) { if (strcmp(serialMessageIn, "GAIN_F") == 0)
updateGainFactor(); {
updateGainFactor(serialLong);
} }
else if (strcmp(serialMessageIn, "VFOL") == 0) { else if (strcmp(serialMessageIn, "VFOL") == 0)
updateVFol(); {
updateVFol(serialLong);
} }
else if (strcmp(serialMessageIn, "VCOMP") == 0) { else if (strcmp(serialMessageIn, "VCOMP") == 0)
updateVComp(); {
updateVComp(serialLong);
} }
else if (strcmp(serialMessageIn, "LOOP_D") == 0) { else if (strcmp(serialMessageIn, "LOOP_D") == 0)
updateLoopDuration(); {
updateLoopDuration(serialLong);
} }
else if (strcmp(serialMessageIn, "TRG_D") == 0) { else if (strcmp(serialMessageIn, "TRG_D") == 0)
updateTrigDuration(); {
updateTrigDuration(serialLong);
} }
else if (strcmp(serialMessageIn, "HYST") == 0) { else if (strcmp(serialMessageIn, "HYST") == 0)
updateHysteresis(); {
updateHysteresis(serialLong);
} }
else if (strcmp(serialMessageIn, "LOGIC") == 0) { else if (strcmp(serialMessageIn, "LOGIC") == 0)
updateLogic(); {
updateLogic(serialLong);
} }
else if (strcmp(serialMessageIn, "PZDET") == 0) { else if (strcmp(serialMessageIn, "PZDET") == 0)
updatePzDet(); {
updatePzDet(serialLong);
} }
else if (strcmp(serialMessageIn, "CONST") == 0) { else if (strcmp(serialMessageIn, "CONST") == 0)
updateConstant(); {
updateConstant(serialLong);
} }
else if (strcmp(serialMessageIn, "DEBUG") == 0) { else if (strcmp(serialMessageIn, "DEBUG") == 0)
updateDebug(); {
updateDebug(serialLong);
} }
else if (strcmp(serialMessageIn, "CONFIG") == 0) { else if (strcmp(serialMessageIn, "CONFIG") == 0)
{
serialPrintConfig(); serialPrintConfig();
} }
else if (strcmp(serialMessageIn, "ERASE") == 0) { else if (strcmp(serialMessageIn, "ERASE") == 0)
{
eraseEEPROM(); eraseEEPROM();
serialPrintConfig(); serialPrintConfig();
} }
else if (strcmp(serialMessageIn, "STATE") == 0) { else if (strcmp(serialMessageIn, "STATE") == 0)
{
serialPrintState(); serialPrintState();
} }
else if (strcmp(serialMessageIn, "HELP") == 0) { else if (strcmp(serialMessageIn, "HELP") == 0)
{
#if defined(ARDUINO_AVR_ATmega328PB) #if defined(ARDUINO_AVR_ATmega328PB)
Serial.println("To change gain factor: GAIN_F [integer for gain state - see note*]"); Serial.println("To change gain factor: GAIN_F [integer for gain state - see note*]");
Serial.println("To change voltage follower voltage (low threshold): VFOL [float value]"); Serial.println("To change voltage follower voltage (low threshold): VFOL [float value]");
@ -296,10 +235,11 @@ void updateParams() {
parseData(); parseData();
} }
void serialInput()
void serialInput() { {
// receive data from Serial and save it into inputBuffer // receive data from Serial and save it into inputBuffer
if (Serial.available() > 0) { if (Serial.available() > 0)
{
// the order of these IF clauses is significant // the order of these IF clauses is significant
identifyMarkers(); identifyMarkers();

41
firmware/AVR-Source/Pyr0_Piezo_Sensor_v2.x.x/src/pP_volatile.cpp Normal file
View file

@ -0,0 +1,41 @@
#include "pP_volatile.h"
#include "pP_config.h"
#include "stdint.h"
// 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 ADJ_FOLLOW = 0; // Variable for Follower adjustment
volatile int ADJ_COMP = 0; // Variable for Comparator adjustment
volatile int ERR_STATE = 0;
volatile int PZ_STATE = 0;
int Vin = 5000; // input reference voltage in millivolts (multiply V by 1000)
int VOld = 5000; // Variable to store previous cycle's Vin
int VLast = 0;
// Convert threshold values based on the input voltage
long followerLong = followerThrs * 1023L;
long compLong = compThrs * 1023L;
long followerInt = 0;
long compInt = 0;
// Voltage Comparator Adjustment parameters
int VComp = 0;
// Voltage Follower Adjustment parameters
int VFol = 0;
// Error blink parameters
int BlinkState = 0;
int BlinkCount = (InitCount * 2) + 1; // Multiply Blink count by 2 to handle toggle state, add one extra to make sure light is on after
// Serial Input Parsing Variables
char inputBuffer[buffSize];
uint8_t bytesRecvd = 0;
bool serialIncoming = false;
char serialMessageIn[buffSize] = {0};
long serialLong = 0;
LightChrono mainLoop;

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

@ -1,43 +1,51 @@
// these variables will change on their own. Do not edit ANYTHING below this line #ifndef PP_VOLATILE_H
volatile int sensorHReading = 0; // variable to store the value read from the sensor pin #define PP_VOLATILE_H
volatile int ADJ_FOLLOW = 0; // Variable for Follower adjustment
volatile int ADJ_COMP = 0; // Variable for Comparator adjustment
volatile int ERR_STATE = 0;
volatile int PZ_STATE = 0;
int Vin = 5000; // input reference voltage in millivolts (multiply V by 1000) #include "LightChrono.h"
int VOld = 5000; // Variable to store previous cycle's Vin #include "stdint.h"
int VLast = 0;
// these variables will change on their own. Do not edit ANYTHING below this line
extern volatile int sensorHReading; // variable to store the value read from the sensor pin
extern volatile int ADJ_FOLLOW; // Variable for Follower adjustment
extern volatile int ADJ_COMP; // Variable for Comparator adjustment
extern volatile int ERR_STATE;
extern volatile int PZ_STATE;
extern int Vin; // input reference voltage in millivolts (multiply V by 1000)
extern int VOld; // Variable to store previous cycle's Vin
extern int VLast;
// Convert threshold values based on the input voltage // Convert threshold values based on the input voltage
long followerLong = followerThrs * 1023L; extern long followerLong;
long compLong = compThrs * 1023L; extern long compLong;
long followerInt; extern long followerInt;
long compInt; extern long compInt;
// Voltage Comparator Adjustment parameters // Voltage Comparator Adjustment parameters
int VComp = 0; extern int VComp;
// Voltage Follower Adjustment parameters // Voltage Follower Adjustment parameters
int VFol = 0; extern int VFol;
// Error blink parameters // Error blink parameters
int BlinkState = 0; extern int BlinkState;
int BlinkCount = (InitCount * 2) + 1; // Multiply Blink count by 2 to handle toggle state, add one extra to make sure light is on after extern int BlinkCount; // Multiply Blink count by 2 to handle toggle state, add one extra to make sure light is on after
// Serial Input Parsing Variables // Serial Input Parsing Variables
#define buffSize 40 #define buffSize 40
char inputBuffer[buffSize]; extern char inputBuffer[buffSize];
#define endMarker '\n' #define endMarker '\n'
byte bytesRecvd = 0; extern uint8_t bytesRecvd;
bool serialIncoming = false; extern bool serialIncoming;
char serialMessageIn[buffSize] = {0}; extern char serialMessageIn[buffSize];
long serialLong = 0; extern long serialLong;
//#define LOW 0 //#define LOW 0
//#define HIGH 1 //#define HIGH 1
// Task scheduler instances // Task scheduler instances
LightChrono mainLoop; extern LightChrono mainLoop;
#endif //PP_VOLATILE_H