why does it after switch was low and then high, not wait for 2 sek before sleep , it goes immideatly to sleep , only couple of ms long the stuff in the while loop gets send . then it sleeps
where else should sleeptime be set ?
//********************************************************************* Fusspedal SENDER CODE NRF24L01 ******************************************************************************************************************
// Atmega88V
// BOD 1,8V on braucht 0.020mA mehr
// 8 MHZ Select Clock Source: Int. RC Osc. 8 MHz; Start-up time PWRDWN/RESET: 6 CK/14 CK + 4.1 ms
// no Bootloader = schneller start up + more flash space
// variant 88 = P = Picopower in sleep, PA Picopower A Variante ....... verwendet atmega88V da min 1,8V Vcc statt 2,7V V variante bis 10MHZ
// LTO disabled = Link time optimization, compiler irgendwas
// eprom retained = beim brennen alten eprom inhalt beibehalten
// Fuses E2 DD F9 = int 8MHZ no devider BOD 2,7V spi
// Fuses E2 DE F9 = int 8MHZ no devider BOD 1,8V spi
// Fuses E2 DF F9 = int 8MHZ no devider ohne BOD spi
// mit my avr programmieren !!!!
#include <avr/sleep.h>
#include <SPI.h>
#include <RF24.h>
#include <avr/wdt.h>
#include "LowPower.h"
#include "nRF24L01.h"
// 5 byte adresse = 5x char
uint8_t adresse[][6] = {"MGP#1" /* , "MGE#1" */}; // adresse pedal MGP#1, da nur gesendet wird, reicht die senderadresse / bei extra empfangen empfangeradresse hinzufugen ,"MGE#1"}; //
const byte CE = 8; // pin12
const byte CS = 10; // pin 14
RF24 radio(CE, CS); //Instanz erstellen
const byte mosfetbatt = 1; // pin 31
const byte mosfetpoti = 4; // pin 2
const byte mosfetTP4056 = 21; // pin8
const byte led33 = 18 ; // pin 27
const byte led35 = 6; // pin 10
const byte led37 = 5; // pin 9
const byte potipin = 19; // pin 28
const byte battpin = 15; // pin 24
const byte schalter_pin = 3; // pin 1
const byte taster_charger_pin = 2; // pin 32
const byte enableTP4056 = 14; // pin 23
const byte ledgrun = 17; // pin 26
const byte ledrot= 16; // pin 25
const byte charger_pin = 0; // pin 30 spannungsteiler von 5V auf 1,9V HIGH aktiv
const byte faktor_spannungsteiler=2; // vcc als ref und 10k + 10k faktor 2
unsigned long last_batt_update; // intervallzeit beim laden um spanung zu lesen
unsigned long sleeptime;
unsigned long last_send_out_time_poti; // intervallzeit zwischen potiwerte lesen und senden , stark begrenzt durch analogread sample size
int poti_read;
long poti_sum;
int poti_avg;
int poti_send;
int battvalue;
long battvalue_sum;
bool show_batt_status;
int time_batt_update;
bool charging_done;
bool firstride;
bool ledState ;
float Vcc;
float battvoltage ;
struct meine_struktur { //macht einen eigenem datentyp mit mit namen mein_datentyp bis zu 32 byte ( radio.setPayloadSize(32)) setzen!!
int raw_poti; //payloadsize beachten! int = 2 byte bool 1byte, float 4 byte ...
bool switch_on;
};
meine_struktur sendoutdata; // eine variable mit namen "senoutdata" mit der struktur von mein_datentyp
// anwahlen mit sendotdata.raw_poti
// anwahlen mit sendotdata.batt_voll
bool was_active;
//********************************************************* SETUP *************************************************************************************
void setup(){
Vcc = 2.515 ;
time_batt_update = 5000; // update battvoltage alle xxx sekunden 000; // time in millisec before pedal goes to sleep
wdt_enable(WDTO_120MS); // mogliche Werte 15MS 30MS 60MS 120MS 250MS 500MS 1S 2S 4S 8S
charging_done = true; // nach resset true ,wird von firstride beim einstecken korrigiert .
firstride = false; // !!! // // fuhrt sonst bei unterspannung zu endlos reset schleife bei messen !!!!
sendoutdata.raw_poti = 0; // reset oder start wert 0
sendoutdata.switch_on = false;
was_active = false ;
SPI.begin(); // spi beginn vor radio begin
radio.begin(); // radio begin
radio.setPALevel(RF24_PA_MAX); // RF24_PA_MIN=-18dBm, RF24_PA_LOW=-12dBm, RF24_PA_HIGH=-6dBM, and RF24_PA_MAX=0dBm.;
radio.setDataRate(RF24_250KBPS); // RF24_250KBPS for 250kbs, RF24_1MBPS for 1Mbps, or RF24_2MBPS for 2Mbps
radio.setChannel(20); // At 1MHZ channel bandwidth, (max freq - min freq) 2525 - 2400 MHz = 125 channels + 1 microwellen 2450 !!
radio.setAutoAck(1); // confirmation mode, 1 on 0 off
radio.setRetries(0, 0); // How long to wait between each retry, in multiples of 250us, max is 15. 0 means 250us, 15 means 4000us. count How many retries before giving up, max 15
radio.setPayloadSize(3); // 1-32 byte bei byte variable = 1
radio.stopListening (); // erst stop lisiting before open writing pipe
radio.openWritingPipe (adresse[0]); // adresse an die geschrieben wird , empfangeradresse
//radio.openReadingPipe (0, adresse[1]); // adresse von der gelesen werden soll also sendeadresse des empfangers die 1 ist erste pipe
pinMode(led33, OUTPUT);
pinMode(led35, OUTPUT);
pinMode(led37, OUTPUT); // LEDS
pinMode(ledrot, OUTPUT);
pinMode(ledgrun, OUTPUT);
pinMode(mosfetbatt, OUTPUT); // n-channel schaltet p-channel mosfet um stromverbrauch zu verringen
pinMode(mosfetpoti, OUTPUT); // p channel mosfet schaltet spannung an poti um stromverbrauch zu verringern
pinMode(enableTP4056, OUTPUT); // lader bei 4.00V ausschalten , sonst ein
pinMode(potipin, INPUT); // potipin spannung einlesen
pinMode(battpin, INPUT); // spannungsteiler mit p mosfet teilt halbe batt spannung 4,2V = 2,1V
pinMode(schalter_pin, INPUT_PULLUP); // schalter im pedal, interrupt 1, um sleep zu beenden, pedal start
pinMode(taster_charger_pin, INPUT_PULLUP); // lader oder tatser, interrupt 0, um sleep zu beenden, lader ein und oder battanzeige
pinMode(charger_pin, INPUT); // 5v auf 2V geteilt lader angesteckt = HIGH
digitalWrite(enableTP4056, LOW); // enable LOW = n-ch off, pullup von 5V vom ladegerat zieht pin high auf 2V
digitalWrite(mosfetbatt, LOW); // npn = off
digitalWrite(mosfetpoti, HIGH); // pnp = off
digitalWrite(led33, LOW); // off
digitalWrite(led35, LOW); // off
digitalWrite(led37, LOW); // off
digitalWrite(ledrot, LOW); // off
digitalWrite(ledgrun, LOW); // off
}
//************************************************************************************ LOOP **********************************************************************************************
void loop(){
if (digitalRead(schalter_pin)== LOW ) { // Pedal gedruckt
digitalWrite(mosfetpoti, LOW); // mosfetpoti ein und ein lasssen bis sleep
was_active = true; // bei watchdog reset nicth aktiv gesetzt
sendoutdata.switch_on = true; // an empfanger senden pedal ein
sleeptime = millis(); // updaten solange schalter gedruckt
poti_sum = 0;
poti_avg = 0;
for( int i = 1; i <= 3; i++){
poti_read = analogRead(potipin);
delay(1);
poti_sum += poti_read;}
sendoutdata.raw_poti = poti_sum/3;
if(millis() - last_send_out_time_poti >=4 ){ // 250/sek
last_send_out_time_poti = millis();
bool ok = radio.write(& sendoutdata, sizeof(meine_struktur));}
}
if(( digitalRead(schalter_pin) == HIGH) && (digitalRead(taster_charger_pin) == HIGH) ) { // schalter (pedal)ist aus und kein lader oder taster (sonst sendet es beim laden oder battanzeige auch!!!)
while(was_active ){
sendoutdata.switch_on = false; // nur wenn aktiv war senden , bei watchdog reset nicht
sendoutdata.raw_poti = 0;
bool ok = radio.write(& sendoutdata, sizeof(meine_struktur));
if((millis() - sleeptime) >= 2000 ){ // sendet zeitlang 0 und schalter aus an empfanger
was_active = false ;}}
sleepnow();}
if( digitalRead(charger_pin) == HIGH){ // falls 5V anliegen , also charger pin HIGH
digitalWrite(mosfetbatt, HIGH); // mosetbatt ein lassen bis sleep
charger();} // lader ein(sowieso immer enabled pullup) , leds anzeigen bei 4V ausschalten
if( digitalRead(charger_pin) == LOW ) { // kein ladermehr angesteckt
firstride = true;} // damit es gleich und nicht erst nach 5 sek was anzeigt
if((digitalRead(taster_charger_pin) == LOW) && (digitalRead(charger_pin) == LOW) && (show_batt_status == true) ) { // taster gedruckt, kein ladegerat eingesteckt, 1x anzeigen
Battanzeige();}
if(digitalRead(taster_charger_pin) == HIGH) { // taster losgelassen
show_batt_status = true; // erneut messen und anzeigen
digitalWrite(led37, LOW);
digitalWrite(led35, LOW);
digitalWrite(led33, LOW); // alle leds aus
digitalWrite(ledrot, LOW);
digitalWrite(ledgrun, LOW);}
wdt_reset(); // Wachhund zurucksetzen , sonst reset .
} //loop
//********************************************************************** Ladegerat + Battanzeige beim Laden *******************************************************************************************
void charger(){
if (millis() - last_batt_update >= time_batt_update || firstride == true){ // regelmassig spannung messen , wenn spannung uber 4V lader aus , wenn unter 3,8V lader enable
last_batt_update = millis(); // oder firstride == true damit der aktuelle status gelesen wird beim anstecken, vorsicht bei reset firstride =true, endloschleife verursachen
battvalue_sum = 0; // falls batt spannung zu wenig hangt sich der mc auf .. endlos reset .
battvalue = 0;
digitalWrite(enableTP4056, HIGH); //lader off sonst misst es die ladespannung
delay(5); // bissl warten
for( int i = 1; i <=25; i++){
battvalue = analogRead(battpin);
delay(1);
battvalue_sum += battvalue;}
battvalue = battvalue_sum /25;
battvoltage = (Vcc/1023.00)* (battvalue * faktor_spannungsteiler);
firstride = false;
} // ende funktion
if (battvoltage >= 4.00) {
charging_done = true;
digitalWrite(enableTP4056, HIGH); //off // akku voll , disable Ladegrat
digitalWrite(led37, HIGH);
digitalWrite(led35, HIGH);
digitalWrite(led33, HIGH);
digitalWrite(ledgrun, HIGH);
digitalWrite(ledrot, LOW);}
else if(battvoltage < 4.00 && battvoltage >= 3.80 && (charging_done == true)){ // Spannung uber 3,8V und nicht unter unter 3,8V gewesen
digitalWrite(enableTP4056, HIGH); // off // disable Ladegrat
charging_done = true;
digitalWrite(led37, HIGH);
digitalWrite(led35, HIGH);
digitalWrite(led33, HIGH);
digitalWrite(ledgrun,HIGH);
digitalWrite(ledrot, LOW);}
else if(battvoltage <= 4.00 && battvoltage >= 3.80 && (charging_done == false)) { // Spannung uber 3,8V und nicht unter unter 3,8V gewesen
digitalWrite(enableTP4056, LOW); // on // enable Ladegrat
charging_done = false;
digitalWrite(led37, HIGH);
digitalWrite(led35, HIGH);
digitalWrite(led33, HIGH);
digitalWrite(ledgrun,LOW);
digitalWrite(ledrot, HIGH);}
else if(battvoltage < 3.80 && battvoltage >= 3.50 ){
digitalWrite(enableTP4056, LOW); //on
charging_done = false;
digitalWrite(led37, LOW);
digitalWrite(led35, HIGH); // Spannung uber 3,5V halbvoll
digitalWrite(led33, HIGH);
digitalWrite(ledgrun, LOW);
digitalWrite(ledrot, HIGH);}
else if(battvoltage < 3.50 && battvoltage >= 3.20 ){
digitalWrite(enableTP4056, LOW); //on
charging_done = false;
digitalWrite(led37, LOW); // Spannung uber 3.20V
digitalWrite(led35, LOW);
digitalWrite(led33, HIGH);
digitalWrite(ledgrun, LOW);
digitalWrite(ledrot, HIGH);}
else if(battvoltage < 3.20){
digitalWrite(enableTP4056, LOW ); //on
charging_done = false;
digitalWrite(led37, LOW); // Spannung unter 3,2V
digitalWrite(led35, LOW);
digitalWrite(led33, LOW);
digitalWrite(ledgrun, LOW);
digitalWrite(ledrot, HIGH);}
}
//********************************************************************** Battanzeige bei Tasterdruck *******************************************************************************************
void Battanzeige(){
digitalWrite(mosfetbatt, HIGH); // npn high ist pnp low ist ein
delay(5);
show_batt_status= false; // einmal durchlaufen bei tasterdruck = false , springt sonst bei grenzspannungen hin und her
battvalue_sum = 0;
battvalue = 0;
for( int i = 1; i <= 25; i++){ // paar mal messen
battvalue = analogRead(battpin);
delay(1);
battvalue_sum += battvalue;}
battvalue = battvalue_sum /25; // durchschnitt rechnen
battvoltage = (Vcc/1023.00)* (battvalue * faktor_spannungsteiler); // umrechnen in spannung
if(battvoltage >= 3.80 ){
digitalWrite(led37, HIGH);
digitalWrite(led35, HIGH); // Spannung uber 3,8 voll
digitalWrite(led33, HIGH);
digitalWrite(ledgrun, HIGH);
digitalWrite(ledrot, LOW);}
if (battvoltage < 3.80 && battvoltage >= 3.50 ){
digitalWrite(led37, LOW);
digitalWrite(led35, HIGH); // Spannung uber 3,5V halbvoll
digitalWrite(led33, HIGH);
digitalWrite(ledgrun, HIGH);
digitalWrite(ledrot, LOW);}
if(battvoltage < 3.50 && battvoltage >= 3.20 ){
digitalWrite(led37, LOW); // Spannung unter 3,5V ein LED noch
digitalWrite(led35, LOW);
digitalWrite(led33, HIGH);
digitalWrite(ledgrun, HIGH);
digitalWrite(ledrot, LOW);}
if(battvoltage < 3.20){
digitalWrite(led37, LOW); // Spannung unter 3,2V
digitalWrite(led35, LOW);
digitalWrite(led33, LOW);
digitalWrite(ledgrun, HIGH);
digitalWrite(ledrot, LOW);} // bei 2,8V schaltet S8261ABP aus.
}
//************************************************************************************* SLEEP *******************************************************************************************************************
void sleepnow(){
radio.powerDown (); // nrf24 aus, bringt nicht viel aber dennoch
digitalWrite(led37, LOW);
digitalWrite(led35, LOW);
digitalWrite(led33, LOW); // LEDS LOW
digitalWrite(ledrot, LOW);
digitalWrite(ledgrun, LOW);
digitalWrite(mosfetpoti, HIGH); // pnp off poti versorgungsspannung , zieht sonst strom
digitalWrite(mosfetbatt, LOW); // npn off spannungsteiler akku
digitalWrite(enableTP4056, LOW); // lader enable ein , damit es bei lader anstecken ladt, low ist npn off enable hat pullup widerstand
static byte prevADCSRA = ADCSRA; // ADC register merken
ADCSRA = 0; // adc aus
set_sleep_mode (SLEEP_MODE_PWR_DOWN); // modus wahlen
sleep_enable(); // sleep ermoglichen
noInterrupts(); // keien interrupts jetzt
attachInterrupt(1, wakeup, LOW); //Interrupt 1 schalter LOW ! not falling
attachInterrupt(0, wakeup, LOW); //Interrupt 0 taster LOW ! not falling
interrupts(); // interrupts jetyt moglich
//MCUSR = 0; // Sonst funktioniert das Abschalten des Watchdogs nicht
//wdt_disable();
wdt_enable(WDTO_8S); // entweder watchdog ausschalten oder auf 8 sek stellen , resettet alles 8 sek in sleep .......... oder ganz aus ??
sleep_cpu();
// a sleep now //
wdt_enable(WDTO_120MS); // watchdog auf kleineren Wert setzen als vorher 8 sek
ADCSRA = prevADCSRA; // ADC register wieder einschalten
show_batt_status = true; // nach interrupt tasterdruck battanzeige moglich falls tster gedruckt
firstride = true; // damit es bei laden sofort die richtige spanung anzeigt / leds einschaltet , nicht erst nach 5 sek , nach resets ....
radio.powerUp(); // nrf24 in standby mode (0,022mA)
}
void wakeup(){ // Interrupt Service routine
sleep_disable(); // schlaf aus
detachInterrupt(0); // keine interrupts ab hier fur nr 0
detachInterrupt(1); // keine interrupts ab hier fur nr 1
}
//****************************************************************************************** ENDE **************************************************************************************************
