First thing to try ... and yes, this is one of those "DUH, where did that come from" moments.
In the main processing loop there is are these lines ...
and I think we need to change it to ...
I'm not exactly sure where the '= 0' came from but it is certainly wrong;
I also changed how the value of the data line is captured in the interrupt. Here is the code for the new, improved version [don't forget to remove the 'include' at the top of the file. Note the new define ... DATA_STATE_INDICATING_A_ONE ... which will allow us to easily set if a HIGH or a LOW on the data line means ONE.
Let me know if this is progress or ...,
Arvid
In the main processing loop there is are these lines ...
Code:
ATOMIC_BLOCK(ATOMIC_RESTORESTATE) { // Needs to be marked as atomic so the interrupt does not mess with it while we get a local copy of it
burstData = capturedBurstData = 0;
}and I think we need to change it to ...
Code:
ATOMIC_BLOCK(ATOMIC_RESTORESTATE) { // Needs to be marked as atomic so the interrupt does not mess with it while we get a local copy of it
burstData = capturedBurstData;
}I'm not exactly sure where the '= 0' came from but it is certainly wrong;
I also changed how the value of the data line is captured in the interrupt. Here is the code for the new, improved version [don't forget to remove the 'include' at the top of the file. Note the new define ... DATA_STATE_INDICATING_A_ONE ... which will allow us to easily set if a HIGH or a LOW on the data line means ONE.
Code:
// Do not remove the include below
#include "scaleReader.h"
#define CLOCK_PIN 2 // The pin associated with the clock pulse
#define CLOCK_TRANSITION FALLING // What will happen on the clock pulse that will want us to read the data pin
#define CLOCK_TERMINATION INPUT_PULLUP // What kind of termination do we want on the clock pin
#define DATA_PIN 3 // The pin associated with the data
#define DATA_TERMINATION INPUT_PULLUP // What kind of termination do we want on the data pin
#define DATA_STATE_INDICATING_A_ONE LOW // Does a HIGH or LOW on the data line indicate a value of 1
#define CLOCK_NOISE_FILTER 1000 // How many microseconds long must the clock be stable for it to be consider 'good'
#define MINIMUM_BURST_START_PULSE_WIDTH 100000 // At a minimum, how many microseconds long is the pulse at the beginning of a burst
#define MAXIMUM_TIME_FOR_A_SINGLE_BURST 100000 // The maximum amount of time that a burst should take before considered invalid
#define DATA_BIT_ZERO_VALUE 0UL // For readability ...
#define DATA_BIT_ONE_VALUE 1UL // For readability ...
#define DATA_BITS_IN_A_VALID_BURST 24 // The number of data bits that are expected in a complete burst of data
volatile boolean initialized = false; // Lets the interrupt get set up right after application start up
volatile boolean processingBurst = false; // Does the interrupt think it is processing a burst
volatile byte dataBitsReceived = 0; // Data bit counter used by the interrupt routine
volatile unsigned long lastGoodClockTime = 0; // The last time the interrupt saw what it thought was a valid clock pulse
volatile unsigned long burstStartTime = 0; // The time when the interrupt thought the burst started
volatile unsigned long inProcessBurstData = 0; // The burst of data as it is being captured by the interrupt routine
volatile unsigned long capturedBurstData = 0; // A complete and validated burst of data
volatile byte capturedBurstCounter = 0; // A rolling counter of the number of complete bursts we have seen. It must be a byte so increments will be atomic.
// This looks like a lot of code for an interrupt but the if statements should ensure that
// only a small portion of it actually runs during any given interrupt
void clockTransitioned() {
unsigned long timeAtInterupt = micros();
unsigned long intervalSinceLastInterrupt = timeAtInterupt - lastGoodClockTime;
// If we do not have our ducks in a row so we will get organized
if (!initialized) {
lastGoodClockTime = timeAtInterupt;
processingBurst = false;
initialized = true;
}
// Is the interrupt because of noise?
else if (intervalSinceLastInterrupt < CLOCK_NOISE_FILTER) {
/*
Note that we are going to do absolutely nothing in this case, not even update the last valid clock time.
We are really waiting for a transition that is at least CLOCK_NOISE_FILTER later than the
last transition that we thought was good.
*/
}
// Is the interrupt because of a 'beginning of burst' pulse?
else if (intervalSinceLastInterrupt > MINIMUM_BURST_START_PULSE_WIDTH) {
if (!processingBurst) {
lastGoodClockTime = timeAtInterupt;
burstStartTime = timeAtInterupt;
(digitalRead(DATA_PIN) == DATA_STATE_INDICATING_A_ONE) ? (inProcessBurstData = DATA_BIT_ONE_VALUE) : (inProcessBurstData = DATA_BIT_ZERO_VALUE);
dataBitsReceived = 1;
processingBurst = true;
}
// OK, we were in the process of receiving a burst but just got another 'beginning of burst' pulse.
// We'll need to do something here but I will have to figure out exactly what after another cup of coffee.
else {
}
}
// OK, we are here because we are initialized and we do not think it is noise or a 'beginning of burst' pulse.
// Let see if we believe it is a valid data bit.
else {
// If we are not in the process of reading a burst then we have a problem and need more coffee
if (!processingBurst) {
}
// If it has taken longer than we thought is should to show up then we have a problem ... see the coffe issue mentined earlier
else if ((timeAtInterupt - burstStartTime) > MAXIMUM_TIME_FOR_A_SINGLE_BURST) {
}
// We seem to be at the right place at the right time so grab what ever is on the data line.
else {
lastGoodClockTime = timeAtInterupt;
inProcessBurstData << 1; // Make room for the next data bit and then set it
if (digitalRead(DATA_PIN) == DATA_STATE_INDICATING_A_ONE) {
// We only need to do something if the data line indicates a ONE as the shift has already put in the ZERO value
inProcessBurstData | DATA_BIT_ONE_VALUE;
}
dataBitsReceived += 1;
if (dataBitsReceived == DATA_BITS_IN_A_VALID_BURST) { // Are we done with this burst?
capturedBurstData = inProcessBurstData;
capturedBurstCounter ++;
processingBurst = false;
}
}
}
}
// Variables used by the application loop
byte lastCapturedBurstCounter = 0;
unsigned long burstData = 0;
//The setup function is called once at startup of the sketch
void setup() {
// Pin Set Up
pinMode(DATA_PIN, INPUT_PULLUP);
pinMode(CLOCK_PIN, INPUT_PULLUP);
attachInterrupt(CLOCK_PIN, clockTransitioned, CLOCK_TRANSITION);
Serial.begin(115200);
Serial.println("Ready: ");}
// The loop function is called in an endless loop
void loop() {
if ((lastCapturedBurstCounter - capturedBurstCounter) > 0) { // If there is something new available then get it and print it
lastCapturedBurstCounter = capturedBurstCounter; // This is a byte so it should be an atomic assignment
ATOMIC_BLOCK(ATOMIC_RESTORESTATE) { // Needs to be marked as atomic so the interrupt does not mess with it while we get a local copy of it
burstData = capturedBurstData;
}
Serial.print(lastCapturedBurstCounter);
Serial.print(", ");
Serial.print(burstData, HEX);
Serial.print(", ");
Serial.println(burstData, BIN);
}
}Let me know if this is progress or ...,
Arvid