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

Formatting

Browse source
This commit is contained in:
Vsevolod Merenkov 2020-03-27 11:32:34 +03:00
parent 60a26ad3f7
commit f2c3843668
16 changed files with 343 additions and 433 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
firmware/AVR-Source/Pyr0_Piezo_Sensor_v2.x.x/.clang-format Normal file
View file

@ -0,0 +1,3 @@
BasedOnStyle: LLVM
ColumnLimit: 200
AllowShortFunctionsOnASingleLine: false

18
firmware/AVR-Source/Pyr0_Piezo_Sensor_v2.x.x/src/LightChrono.cpp
View file

@ -32,15 +32,15 @@
#endif #endif
#include "LightChrono.h" #include "LightChrono.h"
LightChrono::LightChrono() LightChrono::LightChrono() {
{
restart(); restart();
} }
void LightChrono::start() { restart(); } void LightChrono::start() {
restart();
}
void LightChrono::restart() void LightChrono::restart() {
{
_startTime = millis(); _startTime = millis();
} }
@ -48,8 +48,7 @@ LightChrono::chrono_t LightChrono::elapsed() const {
return (millis() - _startTime); return (millis() - _startTime);
} }
bool LightChrono::hasPassed(LightChrono::chrono_t timeout) const bool LightChrono::hasPassed(LightChrono::chrono_t timeout) const {
{
return (elapsed() >= timeout); return (elapsed() >= timeout);
} }
@ -58,10 +57,7 @@ bool LightChrono::hasPassed(LightChrono::chrono_t timeout, bool restartIfPassed)
if (restartIfPassed) if (restartIfPassed)
restart(); restart();
return true; return true;
} } else {
else {
return false; return false;
} }
} }

5
firmware/AVR-Source/Pyr0_Piezo_Sensor_v2.x.x/src/LightChrono.h
View file

@ -39,8 +39,7 @@
* // do something * // do something
* // ... * // ...
*/ */
class LightChrono class LightChrono {
{
public: public:
#if defined(ARDUINO_ARC32_TOOLS) #if defined(ARDUINO_ARC32_TOOLS)
typedef uint64_t chrono_t; typedef uint64_t chrono_t;
@ -68,5 +67,3 @@ public:
}; };
#endif #endif

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

@ -85,14 +85,14 @@ update the voltMeterConstant variable in pP_config.h with the correct value
------------------------------------------------------------*/ ------------------------------------------------------------*/
// Headers, variables, and functions // Headers, variables, and functions
#include <Arduino.h>
#include <EEPROM.h>
#include "LightChrono.h" #include "LightChrono.h"
#include "pP_pins.h" #include "pP_pins.h"
#include <Arduino.h>
#include <EEPROM.h>
// #include "pP_config.h" // #include "pP_config.h"
#include "pP_volatile.h"
#include "pP_function.h" #include "pP_function.h"
#include "pP_serial.h" #include "pP_serial.h"
#include "pP_volatile.h"
// i2c input toggle. Uncomment to enable // i2c input toggle. Uncomment to enable
#define I2C_INPUT #define I2C_INPUT

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

@ -1,16 +1,14 @@
#ifndef PP_CMD_H #ifndef PP_CMD_H
#define PP_CMD_H #define PP_CMD_H
#include "EEPROM.h"
#include "pP_config.h" #include "pP_config.h"
#include "pP_function.h" #include "pP_function.h"
#include "EEPROM.h"
/*------------------------------------------------*/ /*------------------------------------------------*/
void updateGainFactor(int value) void updateGainFactor(int value) {
{ if (value >= 0) {
if (value >= 0)
{
GAIN_FACTOR = value; GAIN_FACTOR = value;
adjustGain(); adjustGain();
EEPROM.put(GAIN_FACTOR_ADDRESS, GAIN_FACTOR); EEPROM.put(GAIN_FACTOR_ADDRESS, GAIN_FACTOR);
@ -19,10 +17,8 @@ void updateGainFactor(int value)
/*------------------------------------------------*/ /*------------------------------------------------*/
void updateVFol(int value) void updateVFol(int value) {
{ if (value >= 0) {
if (value >= 0)
{
followerThrs = value; followerThrs = value;
adjustFollow(); adjustFollow();
EEPROM.put(FOLLOWER_THRESHOLD_ADDRESS, followerThrs); EEPROM.put(FOLLOWER_THRESHOLD_ADDRESS, followerThrs);
@ -30,10 +26,8 @@ void updateVFol(int value)
} }
/*------------------------------------------------*/ /*------------------------------------------------*/
void updateVComp(int value) void updateVComp(int value) {
{ if (value >= 0) {
if (value >= 0)
{
compThrs = value; compThrs = value;
adjustComp(); adjustComp();
EEPROM.put(COMP_THRESHOLD_ADDRESS, compThrs); EEPROM.put(COMP_THRESHOLD_ADDRESS, compThrs);
@ -42,40 +36,32 @@ void updateVComp(int value)
/*------------------------------------------------*/ /*------------------------------------------------*/
void updateLoopDuration(int value) void updateLoopDuration(int value) {
{ if (value >= 0) {
if (value >= 0)
{
LOOP_DUR = value; LOOP_DUR = value;
EEPROM.put(LOOP_DUR_ADDRESS, LOOP_DUR); EEPROM.put(LOOP_DUR_ADDRESS, LOOP_DUR);
} }
} }
/*------------------------------------------------*/ /*------------------------------------------------*/
void updateTrigDuration(int value) void updateTrigDuration(int value) {
{ if (value >= 0) {
if (value >= 0)
{
TRG_DUR = value; TRG_DUR = value;
EEPROM.put(TRG_DUR_ADDRESS, TRG_DUR); EEPROM.put(TRG_DUR_ADDRESS, TRG_DUR);
} }
} }
/*------------------------------------------------*/ /*------------------------------------------------*/
void updateHysteresis(int value) void updateHysteresis(int value) {
{ if (value >= 0) {
if (value >= 0)
{
Hyst = value; Hyst = value;
EEPROM.put(HYST_ADDRESS, Hyst); EEPROM.put(HYST_ADDRESS, Hyst);
} }
} }
/*------------------------------------------------*/ /*------------------------------------------------*/
void updateLogic(int value) void updateLogic(int value) {
{ if (value >= 0) {
if (value >= 0)
{
LOGIC = value; LOGIC = value;
EEPROM.put(LOGIC_ADDRESS, LOGIC); EEPROM.put(LOGIC_ADDRESS, LOGIC);
pulse(); pulse();
@ -83,20 +69,16 @@ void updateLogic(int value)
} }
/*------------------------------------------------*/ /*------------------------------------------------*/
void updatePzDet(int value) void updatePzDet(int value) {
{ if (value >= 0) {
if (value >= 0)
{
PZDET = value; PZDET = value;
EEPROM.put(PZDET_ADDRESS, PZDET); EEPROM.put(PZDET_ADDRESS, PZDET);
} }
} }
/*------------------------------------------------*/ /*------------------------------------------------*/
void updateConstant(long value) void updateConstant(long value) {
{ if (value >= 0) {
if (value >= 0)
{
voltMeterConstant = value; voltMeterConstant = value;
EEPROM.put(VM_CONST_ADDRESS, voltMeterConstant); EEPROM.put(VM_CONST_ADDRESS, voltMeterConstant);
} }
@ -104,14 +86,10 @@ void updateConstant(long value)
/*------------------------------------------------*/ /*------------------------------------------------*/
void updateDebug(int value) void updateDebug(int value) {
{ if (value > 0) {
if (value > 0)
{
Debug = 1; Debug = 1;
} } else if (value == 0) {
else if (value == 0)
{
Debug = 0; Debug = 0;
} }
} }

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

@ -9,24 +9,19 @@
#include "pP_function.h" #include "pP_function.h"
#include "Arduino.h" #include "Arduino.h"
#include "pP_config.h" #include "pP_config.h"
#include "pP_volatile.h"
#include "pP_pins.h" #include "pP_pins.h"
#include "pP_volatile.h"
#include "stdint.h" #include "stdint.h"
void digitalWriteFast(uint8_t pin, uint8_t x) void digitalWriteFast(uint8_t pin, uint8_t x) {
{ if (pin / 8) { // pin >= 8
if (pin / 8)
{ // pin >= 8
PORTB ^= (-x ^ PORTB) & (1 << (pin % 8)); PORTB ^= (-x ^ PORTB) & (1 << (pin % 8));
} } else {
else
{
PORTD ^= (-x ^ PORTD) & (1 << (pin % 8)); PORTD ^= (-x ^ PORTD) & (1 << (pin % 8));
} }
} }
int analogReadFast(uint8_t ADCpin) int analogReadFast(uint8_t ADCpin) {
{
byte ADCSRAoriginal = ADCSRA; byte ADCSRAoriginal = ADCSRA;
ADCSRA = (ADCSRA & B11111000) | 4; ADCSRA = (ADCSRA & B11111000) | 4;
int adc = analogRead(ADCpin); int adc = analogRead(ADCpin);
@ -36,15 +31,13 @@ int analogReadFast(uint8_t ADCpin)
/*------------------------------------------------*/ /*------------------------------------------------*/
void doubleFlash() void doubleFlash() {
{
BlinkCount = 4; BlinkCount = 4;
} }
/*------------------------------------------------*/ /*------------------------------------------------*/
void pulse() void pulse() {
{
digitalWriteFast(TRG_OUT, LOGIC); digitalWriteFast(TRG_OUT, LOGIC);
sensorHReading = 1; sensorHReading = 1;
delay(TRG_DUR); delay(TRG_DUR);
@ -55,8 +48,7 @@ void pulse()
/*------------------------------------------------*/ /*------------------------------------------------*/
long readVcc() long readVcc() {
{
// Read 1.1V reference against AVcc // Read 1.1V reference against AVcc
// Atmega's Secret Voltmeter setup: // Atmega's Secret Voltmeter setup:
@ -103,8 +95,7 @@ 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() {
{
VOld = Vin; VOld = Vin;
Vin = readVcc(); Vin = readVcc();
followerLong = followerThrs * 1023L; followerLong = followerThrs * 1023L;
@ -117,8 +108,7 @@ void readVin()
/*------------------------------------------------*/ /*------------------------------------------------*/
void adjustFollow() void adjustFollow() {
{
/* Compares diffs of threshold vs read value /* Compares diffs of threshold vs read value
if positive, adjusts the follower to within if positive, adjusts the follower to within
the range set above*/ the range set above*/
@ -133,8 +123,7 @@ void adjustFollow()
/*------------------------------------------------*/ /*------------------------------------------------*/
void adjustComp() void adjustComp() {
{
compLong = compThrs * 1023L; compLong = compThrs * 1023L;
compInt = (long long)compLong / Vin; compInt = (long long)compLong / Vin;
compInt = (int)compInt; compInt = (int)compInt;
@ -143,21 +132,17 @@ void adjustComp()
/*------------------------------------------------*/ /*------------------------------------------------*/
void calibrateAlert() void calibrateAlert() {
{
VLast = VOld - Vin; VLast = VOld - Vin;
if (VLast > Hyst || VLast < -Hyst) if (VLast > Hyst || VLast < -Hyst) {
{
ERR_STATE = 1; ERR_STATE = 1;
} }
} }
/*------------------------------------------------*/ /*------------------------------------------------*/
void adjustGain() void adjustGain() {
{ switch (GAIN_FACTOR) {
switch (GAIN_FACTOR)
{
case 4: case 4:
pinMode(GADJ_R0, OUTPUT); pinMode(GADJ_R0, OUTPUT);
digitalWriteFast(GADJ_R0, LOW); digitalWriteFast(GADJ_R0, LOW);
@ -205,11 +190,9 @@ void adjustGain()
/*------------------------------------------------*/ /*------------------------------------------------*/
void pzConCheck() void pzConCheck() {
{
PZ_STATE = digitalRead(PZDET_PIN); PZ_STATE = digitalRead(PZDET_PIN);
if (PZ_STATE == PZDET) if (PZ_STATE == PZDET) {
{
// digitalWriteFast(TRG_OUT, LOGIC); // digitalWriteFast(TRG_OUT, LOGIC);
ERR_STATE = 1; ERR_STATE = 1;
} }

9
firmware/AVR-Source/Pyr0_Piezo_Sensor_v2.x.x/src/pP_i2c.cpp
View file

@ -1,8 +1,8 @@
#ifdef I2C_INPUT #ifdef I2C_INPUT
#include <Arduino.h>
#include "pP_config.h"
#include "pP_i2c.h" #include "pP_i2c.h"
#include "pP_config.h"
#include <Arduino.h>
#include <Wire.h> #include <Wire.h>
byte registerMap[regMapSize]; byte registerMap[regMapSize];
@ -10,7 +10,6 @@ byte registerMapTemp[regMapSize - 1];
byte receivedCommands[maxBytes]; byte receivedCommands[maxBytes];
pP_i2c::pP_i2c() { pP_i2c::pP_i2c() {
} }
void pP_i2c::init() { void pP_i2c::init() {
@ -24,19 +23,15 @@ void pP_i2c::i2cReportStatus() {
} }
void pP_i2c::i2cReportVersion() { void pP_i2c::i2cReportVersion() {
} }
void pP_i2c::i2cReportConfig() { void pP_i2c::i2cReportConfig() {
} }
void pP_i2c::i2cReportIdentity() { void pP_i2c::i2cReportIdentity() {
} }
void pP_i2c::i2cRequestInput() { void pP_i2c::i2cRequestInput() {
} }
void pP_i2c::i2cReply() { void pP_i2c::i2cReply() {

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

@ -26,7 +26,6 @@ byte regMapTemp[regMapSize];
byte cmdRcvd[maxBytes]; byte cmdRcvd[maxBytes];
byte longRcvd[longBytes]; byte longRcvd[longBytes];
/*------------------------------------------------*/ /*------------------------------------------------*/
class pP_i2c { class pP_i2c {
@ -34,6 +33,7 @@ class pP_i2c {
pP_i2c(uint8_t address = pP_i2c_address); pP_i2c(uint8_t address = pP_i2c_address);
void init(); void init();
void i2cInput(int bytesReceived); void i2cInput(int bytesReceived);
private: private:
char _i2cResponse; char _i2cResponse;
}; };

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

@ -1,7 +1,7 @@
#include "pP_cmd.h" #include "pP_cmd.h"
#include "pP_volatile.h"
void parseData() void parseData() {
{
// split the data into its parts // split the data into its parts
@ -15,45 +15,36 @@ void parseData()
} }
/*------------------------------------------------*/ /*------------------------------------------------*/
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;
} }
} }
@ -62,12 +53,10 @@ void identifyMarkers()
/*------------------------------------------------*/ /*------------------------------------------------*/
void serialPrintConfig() 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;
@ -116,8 +105,7 @@ void serialPrintConfig()
Serial.println(PP_VERSION); Serial.println(PP_VERSION);
} }
void serialPrintState() void serialPrintState() {
{
Serial.print("{"); Serial.print("{");
Serial.print("\"Vcc\":"); Serial.print("\"Vcc\":");
@ -147,64 +135,36 @@ 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(serialLong); updateGainFactor(serialLong);
} } else if (strcmp(serialMessageIn, "VFOL") == 0) {
else if (strcmp(serialMessageIn, "VFOL") == 0)
{
updateVFol(serialLong); updateVFol(serialLong);
} } else if (strcmp(serialMessageIn, "VCOMP") == 0) {
else if (strcmp(serialMessageIn, "VCOMP") == 0)
{
updateVComp(serialLong); updateVComp(serialLong);
} } else if (strcmp(serialMessageIn, "LOOP_D") == 0) {
else if (strcmp(serialMessageIn, "LOOP_D") == 0)
{
updateLoopDuration(serialLong); updateLoopDuration(serialLong);
} } else if (strcmp(serialMessageIn, "TRG_D") == 0) {
else if (strcmp(serialMessageIn, "TRG_D") == 0)
{
updateTrigDuration(serialLong); updateTrigDuration(serialLong);
} } else if (strcmp(serialMessageIn, "HYST") == 0) {
else if (strcmp(serialMessageIn, "HYST") == 0)
{
updateHysteresis(serialLong); updateHysteresis(serialLong);
} } else if (strcmp(serialMessageIn, "LOGIC") == 0) {
else if (strcmp(serialMessageIn, "LOGIC") == 0)
{
updateLogic(serialLong); updateLogic(serialLong);
} } else if (strcmp(serialMessageIn, "PZDET") == 0) {
else if (strcmp(serialMessageIn, "PZDET") == 0)
{
updatePzDet(serialLong); updatePzDet(serialLong);
} } else if (strcmp(serialMessageIn, "CONST") == 0) {
else if (strcmp(serialMessageIn, "CONST") == 0)
{
updateConstant(serialLong); updateConstant(serialLong);
} } else if (strcmp(serialMessageIn, "DEBUG") == 0) {
else if (strcmp(serialMessageIn, "DEBUG") == 0)
{
updateDebug(serialLong); 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]");
@ -235,11 +195,9 @@ 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();