347 lines
14 KiB
Arduino
347 lines
14 KiB
Arduino
|
#include <Arduino.h>
|
||
|
|
#include <U8g2lib.h>
|
||
|
|
//#include "fonts.h"
|
||
|
|
#include <SPI.h>
|
||
|
|
#include "RF24.h"
|
||
|
|
#include "speedclock.h"
|
||
|
|
|
||
|
|
// internal defines for the OLED display ...
|
||
|
|
U8G2_SSD1306_128X64_NONAME_1_SW_I2C display(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE); // All Boards without Reset of the Display
|
||
|
|
|
||
|
|
|
||
|
|
/****************** User Config for NRF24***************************/
|
||
|
|
/*** Set this radio as radio number RADIO0 or RADIO1 ***/
|
||
|
|
radio_type_e radioNumber = BASESTATION; //---> TOPSTATION has the button connected
|
||
|
|
|
||
|
|
/* Hardware configuration: Set up nRF24L01 radio on SPI bus plus pins 7 & 8 */
|
||
|
|
RF24 radio(RF24_CNS,RF24_CE);
|
||
|
|
/**********************************************************/
|
||
|
|
byte addresses[][12] = {"top_station","basestation"}; // Radio pipe addresses for the 2 nodes to communicate.
|
||
|
|
|
||
|
|
unsigned long counter_time_offset = 0; // number of used values for the mean value calculation
|
||
|
|
unsigned long sum_time_offset = 0; // sum of offset values
|
||
|
|
unsigned long mean_time_offset = 0; // mean value for the offset
|
||
|
|
unsigned long current_time_offset = 0; // current offset ...
|
||
|
|
unsigned long running_time_offset = 0; // offset that will be used for this run ...
|
||
|
|
unsigned long start_time = 0; // if the timer is running this is that start time ...
|
||
|
|
unsigned long run_time = 0; // if the timer is running this is that start time ...
|
||
|
|
boolean warn_during_run = false; // will be set to true if there is a warning during the run - usually an offset sync error
|
||
|
|
|
||
|
|
timer_state_e timer_state = TIMER_INIT; // timer needs to be initialized ...
|
||
|
|
// timer is ready to be started ...
|
||
|
|
// will be true if the timer was started
|
||
|
|
// will be true if the timer is running and the stopbutton was pressed at the TOPSTATION
|
||
|
|
// will be true if the timeout of the timer is reached
|
||
|
|
// will be true if the chancel button was pressed - e.g. in case of a early start
|
||
|
|
|
||
|
|
|
||
|
|
transcv_s radio_data;
|
||
|
|
|
||
|
|
void setup(){
|
||
|
|
|
||
|
|
Serial.begin(115200);
|
||
|
|
|
||
|
|
// this is the top button - will be pressed by the speed climber as soon she/he reaches the top ...
|
||
|
|
pinMode(STOPBUTTON_IN, INPUT);
|
||
|
|
pinMode(STARTBUTTON_IN, INPUT);
|
||
|
|
pinMode(CHANCELBUTTON_IN, INPUT);
|
||
|
|
pinMode(FAILSTARTBUTTON_IN, INPUT);
|
||
|
|
|
||
|
|
pinMode(WARN_LED, OUTPUT);
|
||
|
|
pinMode(FAIL_LED, OUTPUT);
|
||
|
|
pinMode(READY_LED, OUTPUT);
|
||
|
|
|
||
|
|
// Get the station type (base or top) as set by the station select pin - BASESTATION is default
|
||
|
|
|
||
|
|
pinMode(STATION_SEL, INPUT);
|
||
|
|
Serial.print(F(" The station select pin (pin "));
|
||
|
|
Serial.print(STATION_SEL);
|
||
|
|
Serial.print(F(") is set to level: "));
|
||
|
|
Serial.println(RADIO_SEL);
|
||
|
|
if(digitalRead(RADIO_SEL) == HIGH){
|
||
|
|
stationNumber = TOPSTATION;
|
||
|
|
Serial.print(F("The level of the station select pin makes the current node set to the TOPSTATION."));
|
||
|
|
}
|
||
|
|
else{
|
||
|
|
Serial.print(F("The level of the station select pin makes the current node set to the BASESTATION"));
|
||
|
|
}
|
||
|
|
|
||
|
|
// Setup and configure the NRF radio
|
||
|
|
// radio setup ...
|
||
|
|
radio.begin();
|
||
|
|
radio.setRetries(15, 15); //the first is the time between reties in multiple of 250ms, the second is the numer of attempts
|
||
|
|
if(stationNumber == TOPSTATION){
|
||
|
|
radio.openWritingPipe(addresses[1]); // Both radios listen on the same pipes by default, but opposite addresses
|
||
|
|
radio.openReadingPipe(1,addresses[0]); // Open a reading pipe on address 0, pipe 1
|
||
|
|
radio.stopListening(); // top station will never receive data.
|
||
|
|
}else{
|
||
|
|
radio.openWritingPipe(addresses[0]);
|
||
|
|
radio.openReadingPipe(1,addresses[1]);
|
||
|
|
}
|
||
|
|
radio.startListening(); // Start listening
|
||
|
|
|
||
|
|
radio_data.topstationtime = millis(); // set the current milli second count
|
||
|
|
radio_data.topbuttonpressedtime = 0; // set the time the button was pressed last time to 0
|
||
|
|
|
||
|
|
//initialise OLED and display Welcome Message ...
|
||
|
|
display.begin();
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
void loop(void) {
|
||
|
|
|
||
|
|
|
||
|
|
/****************** Code for the TOPSTATION is here - the stop button is connected to the top station ***************************/
|
||
|
|
|
||
|
|
if (stationNumber == TOPSTATION){ // Radio is the top station and sends continously its time and the time the stop button was pressed.
|
||
|
|
bool topbuttonwaspressed = false;
|
||
|
|
// check for pressed button ...
|
||
|
|
if( (millis() - radio_data.topbuttonpressedtime) > MIN_DELAY_BETWEEN_PRESSED_MS){
|
||
|
|
// ignore if the button was "pressed" a few millis before - this is keybouncing and would give a false result and if the button is pressed for a longer time that would effect the time as well
|
||
|
|
if(digitalRead(STOPBUTTON_IN, STOPBUTTON_PRESSED)){
|
||
|
|
// button was pressed - store the time
|
||
|
|
radio_data.topbuttonpressedtime = millis();
|
||
|
|
topbuttonwaspressed = true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// if the button was not pressed only each few second data will be send to BASESTATION ...
|
||
|
|
if(topbuttonwaspressed || ((millis()-radio_data.topstationtime) >= MIN_DELAY_BETWEEN_SEND_MS)){
|
||
|
|
// store current millis to be send as reference ...
|
||
|
|
radio_data.topstationtime = millis(); // set the current milli second count
|
||
|
|
|
||
|
|
// send data ...
|
||
|
|
if (!radio.write(&radio_data,sizeof(radio_data) )){ // Send the counter variable to the other radio
|
||
|
|
Serial.println(F("Failed to send data to BASESSTATION ... will retry"));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/****************** Code for the BASESTATION is here - the display and the start button is connected here. All caclulation will be done here ***************************/
|
||
|
|
|
||
|
|
if ( stationNumber == BASESTATION ) {
|
||
|
|
|
||
|
|
// read data from TOP_STATION ...
|
||
|
|
if( radio.available()){
|
||
|
|
// check if radio data is available - if so read the data
|
||
|
|
radio.read( &radio_data, sizeof(radio_data) ); // Read the data the TOPSTATION sent
|
||
|
|
current_time_offset = radio_data.topstationtime - millis(); // the offset between TOP_STATION and BASESTATION
|
||
|
|
Serial.print(F(" Current time on client in millis: "));
|
||
|
|
Serial.println(radio_data.topstationtime);
|
||
|
|
Serial.print(F(" Button was pressed last time on client in millis: "));
|
||
|
|
Serial.println(radio_data.topbuttonpressedtime);
|
||
|
|
}
|
||
|
|
|
||
|
|
// offset calculation ... only needed if the variation is bigger than allowed or not enough values available already ...
|
||
|
|
// check current offset of the TOP_STATIOn and the BASESTATION if more than allowed ...
|
||
|
|
if(abs(current_time_offset - mean_time_offset) < MAX_DIFFERENCE_OFFSET_MS){
|
||
|
|
// the offset is in range - check if we have already enough values of if we need to add more ...
|
||
|
|
if(counter_time_offset < REQUIRED_NUMBER_MEANVALS){
|
||
|
|
//add the next value to meanvalue calculation ...
|
||
|
|
sum_time_offset = sum_time_offset + current_time_offset;
|
||
|
|
counter_time_offset++;
|
||
|
|
mean_time_offset = sum_time_offset/counter_time_offset;
|
||
|
|
Serial.print(F("Offset calulation. We already have "))
|
||
|
|
Serial.print(counter_time_offset)
|
||
|
|
Serial.print(F(" of "));
|
||
|
|
Serial.print(REQUIRED_NUMBER_MEANVALS);
|
||
|
|
Serial.print(F(" values used for offset calculation. Mean value of offset based on that is: "));
|
||
|
|
Serial.println(mean_time_offset);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
// the current offset is out of range so we need to restart the mean calculation and set the timer to unready state ...
|
||
|
|
Serial.print(F("Will restart offset calculation because the variation of the current offset: "));
|
||
|
|
Serial.print(current_time_offset);
|
||
|
|
Serial.print(F(" is more than the allowed: "));
|
||
|
|
Serial.print(MAX_DIFFERENCE_OFFSET_MS);
|
||
|
|
Serial.print(F(" compared to the mean offset: "));
|
||
|
|
Serial.println(mean_time_offset);
|
||
|
|
counter_time_offset = 0;
|
||
|
|
sum_time_offset = 0;
|
||
|
|
mean_time_offset = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// set LEDs
|
||
|
|
set_state_LEDs(timer_state, warn_during_run );
|
||
|
|
|
||
|
|
switch(timer_state){
|
||
|
|
case TIMER_INIT:
|
||
|
|
// check if we are ready ...
|
||
|
|
if(counter_time_offset > REQUIRED_NUMBER_MEANVALS){
|
||
|
|
// check if offset is OK - if not .. set state back to INIT
|
||
|
|
timer_state = TIMER_READY;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case TIMER_READY:
|
||
|
|
warn_during_run = false;
|
||
|
|
if(counter_time_offset < REQUIRED_NUMBER_MEANVALS){
|
||
|
|
// check if offset is OK - if not .. set state back to INIT
|
||
|
|
timer_state = TIMER_INIT;
|
||
|
|
}
|
||
|
|
else{
|
||
|
|
// check if the FALSESTATE button is pressed - somebody is ready to run ...
|
||
|
|
if(digitalRead(FAILSTARTBUTTON_IN, FAILSTARTBUTTON_PRESSED)){
|
||
|
|
//wait a few milliseconds to prevent keybouncing - this is a very simplistic method here
|
||
|
|
delay(300);
|
||
|
|
//read again and check if still active ...
|
||
|
|
if(digitalRead(FAILSTARTBUTTON_IN, FAILSTARTBUTTON_PRESSED)){
|
||
|
|
// check if the start button was pressed ... there is at least still someone waiting for the run .
|
||
|
|
if(digitalRead(STARTBUTTON_IN, STARTBUTTON_PRESSED)){
|
||
|
|
timer_state = TIMER_STARTED;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case TIMER_STARTED:
|
||
|
|
//enable the interrupt for the FALSESTART button and start the StartSequence - no interruption possible here anymore, except the FALSESTART button was released to early
|
||
|
|
|
||
|
|
//initialize the start countdown here ... if done set to RUNNING ... maybe check fail start already here ... ?? or in running state ... or extra state ...
|
||
|
|
startSequence();
|
||
|
|
|
||
|
|
case TIMER_FAILCHECK:
|
||
|
|
//check for fail start in this phase - interrupt is active, this state can only be reached from STARTED state ...
|
||
|
|
if(start_time - millis() >= STARTOK_TOLERANCETIME_MS)
|
||
|
|
{
|
||
|
|
timer_state = TIMER_RUNNING;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case TIMER_RUNNING:
|
||
|
|
if(counter_time_offset < REQUIRED_NUMBER_MEANVALS){
|
||
|
|
// check if offset is still OK - if not .. set state to TIMER_RUNNING
|
||
|
|
warn_during_run = true;
|
||
|
|
}
|
||
|
|
if(digitalRead(CHANCELBUTTON_IN, CHANCELBUTTON_PRESSED)){
|
||
|
|
timer_state = TIMER_CHANCELED;
|
||
|
|
}
|
||
|
|
if((radio_data.topbuttonpressedtime - running_time_offset) > millis()){
|
||
|
|
timer_state = TIMER_STOPPED;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case TIMER_STOPPED:
|
||
|
|
//calculate the run_time and switch to WAIT
|
||
|
|
|
||
|
|
timer_state = TIMER_WAIT;
|
||
|
|
break;
|
||
|
|
case TIMER_FAIL:
|
||
|
|
//fail start case ....
|
||
|
|
|
||
|
|
timer_state = TIMER_WAIT;
|
||
|
|
break;
|
||
|
|
case TIMER_CHANCELED:
|
||
|
|
// what to do in chancel mode ?
|
||
|
|
|
||
|
|
timer_state = TIMER_WAIT;
|
||
|
|
break;
|
||
|
|
case TIMER_TIMEDOUT:
|
||
|
|
//
|
||
|
|
|
||
|
|
timer_state = TIMER_WAIT;
|
||
|
|
break;
|
||
|
|
case TIMER_WAIT:
|
||
|
|
// wait until the start button was pressed to go ahead
|
||
|
|
if(digitalRead(STARTBUTTON_IN, STARTBUTTON_PRESSED)){
|
||
|
|
timer_state = TIMER_READY;
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
int ypos = 64-42/2;
|
||
|
|
snprintf ( temp_string, sizeof(temp_string),"%d.%1d", int(client_data.temperature), int(abs(client_data.temperature - int(client_data.temperature))*10 + 0.5));
|
||
|
|
Serial.println(temp_string);
|
||
|
|
|
||
|
|
display.setFontPosCenter();
|
||
|
|
display.setFont(u8g2_font_logisoso34_tn);
|
||
|
|
int xpos = (128-display.getStrWidth(temp_string))/2 - 10;
|
||
|
|
|
||
|
|
display.firstPage();
|
||
|
|
do {
|
||
|
|
display.setFont(u8g2_font_logisoso34_tn);
|
||
|
|
display.setCursor(xpos,ypos);
|
||
|
|
display.print(temp_string);
|
||
|
|
display.setCursor(xpos + display.getStrWidth(temp_string)+ 5,ypos-15);
|
||
|
|
display.setFont(u8g2_font_ncenB12_tr);
|
||
|
|
display.print(F("°C"));
|
||
|
|
} while ( display.nextPage() );
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/////////////////////
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
if( radio.available(&pipeNo)){
|
||
|
|
while( radio.available(&pipeNo)){ // Read all available payloads
|
||
|
|
radio.read( &control_data, sizeof(control_data) );
|
||
|
|
}
|
||
|
|
|
||
|
|
radio.stopListening(); // First, stop listening so we can talk
|
||
|
|
|
||
|
|
Serial.print(F("Got remote data counter: "));
|
||
|
|
Serial.print(control_data.counter);
|
||
|
|
Serial.print(F(" time: "));
|
||
|
|
Serial.println(control_data.time);
|
||
|
|
radio_data.counter = control_data.counter + 1; // Ack payloads are much more efficient than switching to transmit mode to respond to a call
|
||
|
|
radio_data.time = control_data.time;
|
||
|
|
Serial.print(F("Loaded next response "));
|
||
|
|
Serial.println(radio_data.counter);
|
||
|
|
|
||
|
|
if( radio.write(&radio_data, sizeof(radio_data) )){
|
||
|
|
Serial.println(F("Sending failed.")); // If no ack response, sending failed
|
||
|
|
//add error handling here if remote does not recieve the data anymore
|
||
|
|
}
|
||
|
|
|
||
|
|
radio.startListening();
|
||
|
|
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//####################### HELPER FUNCTIONS ###########################
|
||
|
|
|
||
|
|
void set_state_LEDs(timer_state_e state, boolean warn)
|
||
|
|
{
|
||
|
|
// set the LEDS corresponding to the state of the timer ... as long as the system is not waiting for input ...
|
||
|
|
if(TIMER_WAIT != state){
|
||
|
|
digitalWrite(READY_LED, LEDStates[state][0]};
|
||
|
|
digitalWrite(RUN_LED, LEDStates[state][1]};
|
||
|
|
digitalWrite(FAIL_LED, LEDStates[state][2]};
|
||
|
|
|
||
|
|
if(warn == true){
|
||
|
|
digitalWrite(WARN_LED, WARN_LED_ON};
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
digitalWrite(WARN_LED, WARN_LED_OFF};
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void startSequence(void)
|
||
|
|
{
|
||
|
|
// first - enable the interrupt
|
||
|
|
|
||
|
|
// set the startime - this is the current time plus the length of this sequence
|
||
|
|
start_time = millis() + STARTSEQ_LENGTH_MS;
|
||
|
|
running_time_offset = mean_time_offset;
|
||
|
|
|
||
|
|
// this is sequence of usually three tones after a wait time 1sec , in between the tones there is also a delay of 1 sec. Each tone is 200ms seconds long, except the last
|
||
|
|
delay(STARTSEQ_STARTPAUSE_MS);
|
||
|
|
// first tone
|
||
|
|
|
||
|
|
delay(STARTSEQ_TONEPAUSE_MS);
|
||
|
|
//second tone
|
||
|
|
|
||
|
|
delay(STARTSEQ_TONEPAUSE_MS);
|
||
|
|
//third tone
|
||
|
|
|
||
|
|
// disable the interrupt and than
|
||
|
|
|
||
|
|
|