arduino i2c probleem


Oh, daar heb ik het pas nog met de Gcc-gasten over gehad.

Het gebeurt tegenwoordig regelmatig dat de compiler na wat optimalisaties ziet dat een if altijd "false" wordt of misschien heb je een

code:


if (iets_semi_raars) 
   DEBUG_PRINTF ("Semi-raar gebeurt nu!\n");

waarbij je voor niet-debuggen dus

code:


#define DEBUG_PRINTF() /*nothing*/

doet. En zie daar precies de code waarvan je een waarschuwing had verwacht. Tja. Dit is dus te "normaal" om daar een waarschuwing van te maken: Het kan makkelijk in normale code voorkomen die eigenlijk zonder waarschuwingen door de compiler moet kunnen komen....

four NANDS do make a NOR . Kijk ook eens in onze shop: http://www.bitwizard.nl/shop/

STM32CubeIDE

code:


   if(tickStart == 1000);
   {  CDC_Flush();
   }

Geeft toch een warning:

../Core/Src/Main.cpp:120:10: warning: this 'if' clause does not guard... [-Wmisleading-indentation]
if(tickStart == 1000);
^~
../Core/Src/Main.cpp:121:10: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the 'if'
{ CDC_Flush();

Maar dat kan wel afhangen van de warning levels in de compiler settings.

Oke, de startknop werkt. wanneer ik nu de volgende code uploadt, krijg ik 01:00:00 te zien. Maar wanneer ik nu buttonA, button B, of button C indruk, verandert de waarde op het display niet. Weet iemand de oorzaak hiervan? En hoe kan ik de drukknoppen optimaal laten werken zodat er per druk op de knop de tijdwaarde met 1 omhoog gaat en niet met 4 bijvoorbeeld (antibounce).

code:


#include "Countimer.h"
int buttonA = 2; //button voor instellen uren
int buttonB = 3; //button voor instellen minuten
int buttonC = 4; //button voor instellen secondes
int buttonD = 5;  //Start button
int A = 1; //uren
int B = 0; //minuten
int C = 0;  //seconden
int readingA = 0;
int readingB = 0;
int readingC = 0;
int readingD = 0;
int relaispin = 6; //Pin naar relais
#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define OLED_RESET 4
Adafruit_SSD1306 display(OLED_RESET);
Countimer timer;

void setup() {
display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
display.clearDisplay();
pinMode(buttonA, INPUT); //ingang voor uren button
pinMode(buttonB, INPUT); //ingang voor minuten button
pinMode(buttonC, INPUT); //ingang voor seconden button
pinMode(buttonD, INPUT); //ingang voor startbutton
pinMode(relaispin, OUTPUT); //uitgang naar relais
Serial.begin(9600); //begin serial monitor
timer.setCounter(A, B, C, timer.COUNT_DOWN, onComplete); //instellen timer
// Print current time every 1s on serial port by calling method refreshClock().
timer.setInterval(refreshClock, 1000);
}

void refreshClock() {
Serial.print("Current count time is: ");
Serial.println(timer.getCurrentTime());
display.setTextSize(1);
display.setTextColor(WHITE);
display.setCursor( 40, 20 );
display.print(timer.getCurrentTime());
display.display();
display.clearDisplay(); 
}

void onComplete() {
Serial.println("Complete!!!");
display.setTextSize(1);
display.setTextColor(WHITE);
display.setCursor( 40, 20 );
display.print("DONE");
display.display();
display.clearDisplay(); 
digitalWrite(relaispin, LOW); //hier zetten we de motor uit
}

void loop() {
// Run timer
readingA = digitalRead(buttonA);
readingB = digitalRead(buttonB);
readingC = digitalRead(buttonC);
readingD = digitalRead(buttonD); 
timer.run();

if (readingA ==HIGH)
{
(A+1);
}

if (readingB == HIGH)
{
(B+1);
}

if (readingC == HIGH)
{
(C+1);
}

if (A >= 99)
{
 A = 99; //max uren begrenzen
}

if (B >= 59)
{
 B = 59; //max minuten begrenzen
}

if (C >= 59)
{
 C = 59; //max secondes begrenzen
}


if(readingD == HIGH){
timer.start();
digitalWrite(relaispin, HIGH); //hier zetten we de motor aan
} 
}

Nog steeds niet de waardes omhoog kunnen krijgen. Weet iemand wat ik hier fout doe?

met vriendelijke groeten,

Sven

In je "loop" worden alleen de variabelen timerA enz. opgehoogd. De waardes worden nooit naar het display geschreven. Daarnaast gaat bij het drukken van een toets de waarde niet met 1 verhogen, maar telkens als de "loop" doorlopen wordt (dit kan makkelijk 1000 maal/s) zijn.
Tip : begin eerst met één toets en één variabele om op te hogen. Zoek eens naar het begrip "flank" detectie. En denk eraan, de "loop" wordt 1000 den maal/sec doorlopen, dus als je toets 100 ms ingedrukt houdt, zal het programma op die plaats mogelijk de opdracht 100 maal uitvoeren !

Maar wanneer ik bijvoorbeeld Waarde A ophoog verander ik toch ook de tijdwaarde? En die tijdwaarde wordt dan weer weergegeven op het scherm.

Ik zal even kijken naar de flank detectie
dank

buckfast_beekeeper

Golden Member

Persoonlijk zou ik buttonA... buttonD vervangen door een duidelijke naam. btnUren, btnMinuten, btnSec, btnStart. Weet je verderop in het programma ook met welke knop je nu aan de slag gaat. Net zo voor A, B, C... veel cryptischer kan het niet. In een kort programma kom je er nog wel uit maar als het wat meer wordt, geraak je snel de weg kwijt.

Laat je code ook inspringen zodat deze leesbaarder wordt.

c code:


void setup(){
   if(vergelijking){
       doe wat
   }
   else{
      if(wat anders){
          doe wat anders
      }
      else if (weer wat anders{
          doe weer wat anders
      }
   }
}

Zo is direct duidelijk wat de scope is van dat bepaald stukje code.

c code:


if (readingA ==HIGH){
    (A+1);
}

Je gaat een int vergelijken met een boolean. Gaat dat goed? A+1 werkt volgens mij ook niet. Moet dat niet zijn A=A+1 of A+=1 of A++
Persoonlijk zou ik schrijven

c code:


if (readingA == 1){
    (A++);
}

edit: wat RP6conrad zegt klopt uiteraard ook. Je moet je programma laten wachten tot de knop is losgelaten. En dan je waarde wegschrijven naar timer.setcounter

c code:


void refreshClock() {
    Serial.print("Current count time is: ");
    Serial.println(timer.getCurrentTime());
    display.setTextSize(1);
    display.setTextColor(WHITE);
    display.setCursor( 40, 20 );
    display.print(timer.getCurrentTime());
    display.display();
    display.clearDisplay(); 
}

Dit gaat ook niet doen wat je wil. Je gaat zaken op het display zetten en direct erna ga je het display terug wissen. Wat is het nut daarvan? De clear verwacht je bij het begin van de refresh(). Het nadeel is dat je een flikkerend display krijgt. Je kan beter alleen de gegevens wijzigen die nodig zijn. Of gewoon alle gegevens terug schrijven. Duurt niet gigantisch lang. Hoewel een gewoon LCD nu ook weer niet vliegensvlug is.

edit 2:
debounce kan je voor een groot deel ondervangen door een delay_ms(200) te voorzien

c code:


if(BTN_LOW){
   delay_ms(200);
   While(BTN_LOW){
      waarde++;
      delay_ms(200);
      if(waarde > MaxWaarde){
          waarde = 0;
      }
   }
}

Zodra je op de knop duwt en je programma passeert voor het eerst deze passage, gaat er 200ms gewacht worden om contactdender weg te werken. Zodra is de knop dan nog laag, dan wordt de waarde verhoogd en wordt er weer 200ms gewacht. Is de knop nog steeds ingedrukt wordt de waarde weer verhoogd. Zodra de max waarde overschreden is begint het tellen vanaf 0. Uiteraard kan je de wachttijden aanpassen aan je eigen gevoel.

[Bericht gewijzigd door buckfast_beekeeper op 30 augustus 2020 09:41:51 (15%)]

Van Lambiek wordt goede geuze gemaakt.

code:


(A+1);

Dat werkt natuurlijk niet. Je berekent wel A+1, maar vervolgens doe je niks met het resultaat. A verandert hier dus niet.

Dat kan wel zo:

code:


A = (A+1);
A++;
A += 1;

Hoe komt het trouwens dat de indenting niet werkt? De Je code wordt zo wel erg moeilijk leesbaar.

hopelijk is dit duidelijker:

code:


#include "Countimer.h"
int btnhours = 2; //button voor instellen uren
int btnminutes = 3; //button voor instellen minuten
int btnseconds = 4; //button voor instellen secondes
int btnstart = 5;  //Start button
int hourvalue = 1; //uren
int minutevalue = 0; //minuten
int secondsvalue = 0;  //seconden
int readinghours = 0;
int readingminutes = 0;
int readingseconds = 0;
int readingstart = 0;
int relaypin = 6; //Pin naar relais
#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define OLED_RESET 4
Adafruit_SSD1306 display(OLED_RESET);
Countimer timer;

void setup() {
display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
display.clearDisplay();
pinMode(btnhours, INPUT); //ingang voor uren button
pinMode(btnminutes, INPUT); //ingang voor minuten button
pinMode(btnseconds, INPUT); //ingang voor seconden button
pinMode(btnstart, INPUT); //ingang voor startbutton
pinMode(relaypin, OUTPUT); //uitgang naar relais
Serial.begin(9600); //begin serial monitor
timer.setCounter(hourvalue, minutevalue, secondsvalue, timer.COUNT_DOWN, onComplete); //instellen timer
// Print current time every 1s on serial port by calling method refreshClock().
timer.setInterval(refreshClock, 1000);
}

void refreshClock() {
Serial.print("Current count time is: ");
Serial.println(timer.getCurrentTime());
display.setTextSize(1);
display.setTextColor(WHITE);
display.setCursor( 40, 20 );
display.print(timer.getCurrentTime());
display.display();
display.clearDisplay(); 
}

void onComplete() {
Serial.println("Complete!!!");
display.setTextSize(1);
display.setTextColor(WHITE);
display.setCursor( 40, 20 );
display.print("DONE");
display.display();
display.clearDisplay(); 
digitalWrite(relaypin, LOW); //hier zetten we de motor uit
}

void loop() {
// Run timer
readinghours = digitalRead(btnhours);
readingminutes= digitalRead(btnminutes);
readingseconds = digitalRead(btnseconds);
readingstart = digitalRead(btnstart); 
timer.run();

if (readinghours = HIGH)
{
(hourvalue++);
}

if (readingminutes = HIGH)
{
(minutevalue++);
}

if (readingseconds = HIGH)
{
(secondsvalue++);
}

if (hourvalue >= 99)
{
 hourvalue = 99; //max uren begrenzen
}

if (minutevalue >= 59)
{
 minutevalue = 59; //max minuten begrenzen
}

if (secondsvalue >= 59)
{
 secondsvalue = 59; //max secondes begrenzen
}


if(readingstart = HIGH){
timer.start();
digitalWrite(relaypin, HIGH); //hier zetten we de motor aan
} 
}

Waar moet de displayclear komen?
Jammer dat op internet niet codes zijn die ik gelijk kan gebruiken voor wat ik wil/

mvg

sven

buckfast_beekeeper

Golden Member

Soms kan je iets vinden wat doet wat je exact wil. Wat leer je daar uit? Meestal is het toch zelf wat schrijven.

clearDisplay aan het begin van de void. Ik vraag me ook af of je telkens de kleur en de grootte moet instellen. Is die niet blijvend tot je ze ergens wijzigt?

Tip 1: kijk eens naar de naamgeving van je display functies. clear en display zijn normaal 2 woorden. Het is good practice elk nieuw woord met een hoofdletter te beginnen. dus btnHours ipv btnhours.
Tip 2: probeer de variabele zo klein als mogelijk te houden. Een byte is ruim voldoende voor je knoppen. Je kan ook schrijven uint8_t ipv byte.
Tip 3: de knoppen wijzigen nooit. Maak er een constante van. Neemt minder geheugen in.

if (waarde1 = waarde2) gaat niet werken. if (waarde1 == waarde2) gebruik je bij een vergelijking. Ik denk dat je in het eerste geval zelfs waarde1 gelijk gaat maken aan waarde2.

Je werkt jezelf ook in de problemen met

c code:


if (minutevalue >= 59){
   minutevalue = 59; //max minuten begrenzen
}

Je hebt geen knop om af te tellen, wil je 46 instellen en je duwt een keer te veel, kan je niet meer terug. Zorg dat er dan terug vanaf 0 geteld wordt.

c code:


if (minutevalue >= 59){
    minutevalue = 0; //max minuten begrenzen
}
Van Lambiek wordt goede geuze gemaakt.

heb nu dit geschreven met de debounce functie:

code:


#include "Countimer.h"
int btnhours = 2; //button voor instellen uren
int btnminutes = 3; //button voor instellen minuten
int btnseconds = 4; //button voor instellen secondes
int btnstart = 5;  //Start button
int hourvalue = 1; //uren
int minutevalue = 0; //minuten
int secondsvalue = 0;  //seconden
int readinghours = 0;
int readingminutes = 0;
int readingseconds = 0;
int readingstart = 0;
int relaypin = 6; //Pin naar relais
int btnstatehours;
int btnstateminutes;
int btnstateseconds;
int btnstatestart;
int lastbtnstatehours = LOW;
int lastbtnstateminutes = LOW;
int lastbtnstateseconds = LOW;
int lastbtnstatestart = LOW;
unsigned long lastDebouncehours = 0;
unsigned long lastDebounceminutes = 0;
unsigned long lastDebounceseconds = 0;
unsigned long lastDebouncestart = 0;
unsigned long debouncedelay = 50;
#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define OLED_RESET 4
Adafruit_SSD1306 display(OLED_RESET);
Countimer timer;

void setup() {
display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
display.clearDisplay();
pinMode(btnhours, INPUT); //ingang voor uren button
pinMode(btnminutes, INPUT); //ingang voor minuten button
pinMode(btnseconds, INPUT); //ingang voor seconden button
pinMode(btnstart, INPUT); //ingang voor startbutton
pinMode(relaypin, OUTPUT); //uitgang naar relais
Serial.begin(9600); //begin serial monitor
timer.setCounter(hourvalue, minutevalue, secondsvalue, timer.COUNT_DOWN, onComplete); //instellen timer
// Print current time every 1s on serial port by calling method refreshClock().
timer.setInterval(refreshClock, 1000);
}

void refreshClock() {
Serial.print("Current count time is: ");
Serial.println(timer.getCurrentTime());
display.setTextSize(1);
display.setTextColor(WHITE);
display.setCursor( 40, 20 );
display.print(timer.getCurrentTime());
display.display();
display.clearDisplay(); 
}

void onComplete() {
Serial.println("Complete!!!");
display.setTextSize(1);
display.setTextColor(WHITE);
display.setCursor( 40, 20 );
display.print("DONE");
display.display();
display.clearDisplay(); 
digitalWrite(relaypin, LOW); //hier zetten we de motor uit
}

void loop() {
// Run timer
readinghours = digitalRead(btnhours);
readingminutes= digitalRead(btnminutes);
readingseconds = digitalRead(btnseconds);
readingstart = digitalRead(btnstart); 
timer.run();

if (readinghours != lastbtnstatehours) {
// reset the debouncing timer               //debounce voor de uren button
lastDebouncehours = millis();
}

if ((millis() - lastbtnstatehours) > debouncedelay) {
if (readinghours != btnstatehours) {
btnstatehours = readinghours;
}
}

if (btnstatehours = HIGH)
{
(hourvalue++);
}

if (readingminutes != lastbtnstateminutes) {
// reset the debouncing timer               //debounce voor de minutes button
lastDebounceminutes = millis();
}

if ((millis() - lastbtnstateminutes) > debouncedelay) {
if (readingminutes!= btnstateminutes) {
btnstateminutes = readingminutes;
}
}
if (btnstateminutes = HIGH)
{
(minutevalue++);
}

if (readingseconds != lastbtnstateseconds) {
// reset the debouncing timer               //debounce voor de seconds button
lastDebounceseconds = millis();
}

if ((millis() - lastbtnstateseconds) > debouncedelay) {
if (readingseconds!= btnstateseconds) {
btnstateseconds = readingseconds;
}
}
if (btnstateseconds = HIGH)
{
(secondsvalue++);
}

if (hourvalue >= 99)
{
 hourvalue = 99; //max uren begrenzen
}

if (minutevalue >= 59)
{
 minutevalue = 59; //max minuten begrenzen
}

if (secondsvalue >= 59)
{
 secondsvalue = 59; //max secondes begrenzen
}

if (readingstart != lastbtnstatestart) {
// reset the debouncing timer               //debounce voor de start button
lastDebouncestart = millis();
}

if ((millis() - lastbtnstatestart) > debouncedelay) {
if (readingstart != btnstatestart) {
btnstatestart = readingstart;
}
}


if (readingstart = HIGH){
timer.start();
digitalWrite(relaypin, HIGH); //hier zetten we de motor aan
} 
}

Op 30 augustus 2020 14:51:04 schreef SvenTech:
heb nu dit geschreven met de debounce functie:

code:


#include "Countimer.h"
int btnhours = 2; //button voor instellen uren
int btnminutes = 3; //button voor instellen minuten
int btnseconds = 4; //button voor instellen secondes
int btnstart = 5;  //Start button
int hourvalue = 1; //uren
int minutevalue = 0; //minuten
int secondsvalue = 0;  //seconden
int readinghours = 0;
int readingminutes = 0;
int readingseconds = 0;
int readingstart = 0;
int relaypin = 6; //Pin naar relais
int btnstatehours;
int btnstateminutes;
int btnstateseconds;
int btnstatestart;
int lastbtnstatehours = LOW;
int lastbtnstateminutes = LOW;
int lastbtnstateseconds = LOW;
int lastbtnstatestart = LOW;
unsigned long lastDebouncehours = 0;
unsigned long lastDebounceminutes = 0;
unsigned long lastDebounceseconds = 0;
unsigned long lastDebouncestart = 0;
unsigned long debouncedelay = 50;
#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define OLED_RESET 4
Adafruit_SSD1306 display(OLED_RESET);
Countimer timer;

void setup() {
display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
display.clearDisplay();
pinMode(btnhours, INPUT); //ingang voor uren button
pinMode(btnminutes, INPUT); //ingang voor minuten button
pinMode(btnseconds, INPUT); //ingang voor seconden button
pinMode(btnstart, INPUT); //ingang voor startbutton
pinMode(relaypin, OUTPUT); //uitgang naar relais
Serial.begin(9600); //begin serial monitor
timer.setCounter(hourvalue, minutevalue, secondsvalue, timer.COUNT_DOWN, onComplete); //instellen timer
// Print current time every 1s on serial port by calling method refreshClock().
timer.setInterval(refreshClock, 1000);
}

void refreshClock() {
Serial.print("Current count time is: ");
Serial.println(timer.getCurrentTime());
display.setTextSize(1);
display.setTextColor(WHITE);
display.setCursor( 40, 20 );
display.print(timer.getCurrentTime());
display.display();
display.clearDisplay(); 
}

void onComplete() {
Serial.println("Complete!!!");
display.setTextSize(1);
display.setTextColor(WHITE);
display.setCursor( 40, 20 );
display.print("DONE");
display.display();
display.clearDisplay(); 
digitalWrite(relaypin, LOW); //hier zetten we de motor uit
}

void loop() {
// Run timer
readinghours = digitalRead(btnhours);
readingminutes= digitalRead(btnminutes);
readingseconds = digitalRead(btnseconds);
readingstart = digitalRead(btnstart); 
timer.run();

if (readinghours != lastbtnstatehours) {
// reset the debouncing timer               //debounce voor de uren button
lastDebouncehours = millis();
}

if ((millis() - lastbtnstatehours) > debouncedelay) {
if (readinghours != btnstatehours) {
btnstatehours = readinghours;
}
}

if (btnstatehours = HIGH)
{
(hourvalue++);
}

if (readingminutes != lastbtnstateminutes) {
// reset the debouncing timer               //debounce voor de minutes button
lastDebounceminutes = millis();
}

if ((millis() - lastbtnstateminutes) > debouncedelay) {
if (readingminutes!= btnstateminutes) {
btnstateminutes = readingminutes;
}
}
if (btnstateminutes = HIGH)
{
(minutevalue++);
}

if (readingseconds != lastbtnstateseconds) {
// reset the debouncing timer               //debounce voor de seconds button
lastDebounceseconds = millis();
}

if ((millis() - lastbtnstateseconds) > debouncedelay) {
if (readingseconds!= btnstateseconds) {
btnstateseconds = readingseconds;
}
}
if (btnstateseconds = HIGH)
{
(secondsvalue++);
}

if (hourvalue >= 99)
{
 hourvalue = 0; //max uren begrenzen
}

if (minutevalue >= 59)
{
 minutevalue = 0; //max minuten begrenzen
}

if (secondsvalue >= 59)
{
 secondsvalue = 0; //max secondes begrenzen
}

if (readingstart != lastbtnstatestart) {
// reset the debouncing timer               //debounce voor de start button
lastDebouncestart = millis();
}

if ((millis() - lastbtnstatestart) > debouncedelay) {
if (readingstart != btnstatestart) {
btnstatestart = readingstart;
}
}


if (readingstart = HIGH){
timer.start();
digitalWrite(relaypin, HIGH); //hier zetten we de motor aan
} 
}

nu blijft de timer tellen terwijl poort 5 (btnstart) gewoon aan de nul hangt. Wat zou hiervoor de oorzaak kunnen zijn

Is al gezegd:

code:


if (btnstateseconds = HIGH)

Is een assignement in een if statement. Je maakt btnstateseconds HIGH, en daarmee wordt de if dus altijd true.

Voor een compare moet je een dubbele == gebruiken.

buckfast_beekeeper

Golden Member

c code:


if (minutevalue >= 59)
{
   minutevalue = 0; //max minuten begrenzen
}

Brengt je weer in de problemen. Maak hier ofwel

c code:


if (minutevalue > 59)
{
   minutevalue = 0; //max minuten begrenzen
}

of

c code:


if (minutevalue >= 60)
{
  minutevalue = 0; //max minuten begrenzen
}

van.
In de huidige situatie kan je nooit 59 minuten krijgen. Waar ik voor de eerste optie zou gaan.

Je kijkt ook of de knoppen hoog zijn. Bij een µC is het heel vaak gemakkelijker om het omgekeerde te doen. Pull Up in de µC aan zetten en kijken of de knop LOW wordt.

Van Lambiek wordt goede geuze gemaakt.

buckfast beekeeper zegt dat ik bij het volgende stukje code een int met een bolean gaat vergelijken. Waarom zou dit niet kunnen?

code:


if (readingA ==HIGH){
    (A+1);
}

ik heb nu de volgende code geschreven, de timer werkt helaas nog niet, denk dat er toch iets misgaat met vergelijkingen en clr display.

code:

code:


#include "Countimer.h"
int btnhours = 2; //button voor instellen uren
int btnminutes = 3; //button voor instellen minuten
int btnseconds = 4; //button voor instellen secondes
int btnstart = 5;  //Start button
int hourvalue = 1; //uren
int minutevalue = 0; //minuten
int secondsvalue = 0;  //seconden
int readinghours = 0;
int readingminutes = 0;
int readingseconds = 0;
int readingstart = 0;
int relaypin = 6; //Pin naar relais
int btnstatehours;
int btnstateminutes;
int btnstateseconds;
int btnstatestart;
int lastbtnstatehours = LOW;
int lastbtnstateminutes = LOW;
int lastbtnstateseconds = LOW;
int lastbtnstatestart = LOW;
unsigned long lastDebouncehours = 0;
unsigned long lastDebounceminutes = 0;
unsigned long lastDebounceseconds = 0;
unsigned long lastDebouncestart = 0;
unsigned long debouncedelay = 50;
#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define OLED_RESET 4
Adafruit_SSD1306 display(OLED_RESET);
Countimer timer;

void setup() {
display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
display.clearDisplay();
pinMode(btnhours, INPUT); //ingang voor uren button
pinMode(btnminutes, INPUT); //ingang voor minuten button
pinMode(btnseconds, INPUT); //ingang voor seconden button
pinMode(btnstart, INPUT); //ingang voor startbutton
pinMode(relaypin, OUTPUT); //uitgang naar relais
Serial.begin(9600); //begin serial monitor
timer.setCounter(hourvalue, minutevalue, secondsvalue, timer.COUNT_DOWN, onComplete); //instellen timer
// Print current time every 1s on serial port by calling method refreshClock().
timer.setInterval(refreshClock, 1000);
}

void refreshClock() {
Serial.print("Current count time is: ");
Serial.println(timer.getCurrentTime());
display.setTextSize(1);
display.setTextColor(WHITE);
display.setCursor( 40, 20 );
display.print(timer.getCurrentTime());
display.display();
display.clearDisplay(); 
}

void onComplete() {
Serial.println("Complete!!!");
display.setTextSize(1);
display.setTextColor(WHITE);
display.setCursor( 40, 20 );
display.print("DONE");
display.display();
display.clearDisplay(); 
digitalWrite(relaypin, LOW); //hier zetten we de motor uit
}

void loop() {
// Run timer
readinghours = digitalRead(btnhours);
readingminutes= digitalRead(btnminutes);
readingseconds = digitalRead(btnseconds);
readingstart = digitalRead(btnstart); 
timer.run();

if (readinghours != lastbtnstatehours) {
// reset the debouncing timer               //debounce voor de uren button
lastDebouncehours = millis();
}

if ((millis() - lastbtnstatehours) > debouncedelay) {
if (readinghours != btnstatehours) {
btnstatehours = readinghours;
}
}

if (btnstatehours == LOW)
{
(hourvalue++);
}

if (readingminutes != lastbtnstateminutes) {
// reset the debouncing timer               //debounce voor de minutes button
lastDebounceminutes = millis();
}

if ((millis() - lastbtnstateminutes) > debouncedelay) {
if (readingminutes!= btnstateminutes) {
btnstateminutes = readingminutes;
}
}
if (btnstateminutes == LOW)
{
(minutevalue++);
}

if (readingseconds != lastbtnstateseconds) {
// reset the debouncing timer               //debounce voor de seconds button
lastDebounceseconds = millis();
}

if ((millis() - lastbtnstateseconds) > debouncedelay) {
if (readingseconds!= btnstateseconds) {
btnstateseconds = readingseconds;
}
}
if (btnstateseconds == LOW)
{
(secondsvalue++);
}

if (hourvalue > 99)
{
 hourvalue = 0; //max uren begrenzen
}

if (minutevalue > 59)
{
 minutevalue = 0; //max minuten begrenzen
}

if (secondsvalue > 59)
{
 secondsvalue = 0; //max secondes begrenzen
}

if (readingstart != lastbtnstatestart) {
// reset the debouncing timer               //debounce voor de start button
lastDebouncestart = millis();
}

if ((millis() - lastbtnstatestart) > debouncedelay) {
if (readingstart != btnstatestart) {
btnstatestart = readingstart;
}
}


if (readingstart == LOW){
timer.start();
digitalWrite(relaypin, HIGH); //hier zetten we de motor aan
} 
}
buckfast_beekeeper

Golden Member

Op 30 augustus 2020 14:47:59 schreef buckfast_beekeeper:
[...]

clearDisplay aan het begin van de void. Ik vraag me ook af of je telkens de kleur en de grootte moet instellen. Is die niet blijvend tot je ze ergens wijzigt?
[...]

Waarom een int met een boolean vergelijken en niet 2 boolean gebruiken?

Of een vergelijking wordt uitgevoerd is gemakkelijk te detecteren. Een Serial.print met een bepaalde boodschap er in.

c code:

timer.setCounter(hourvalue, minutevalue, secondsvalue, timer.COUNT_DOWN, onComplete); //instellen timer

Staat wel in je setup maar gebruik je nergens meer in je loop. Je gaat met een boolean moeten bijhouden of de tijd is gewijzigd en dan ga je die moeten wegschrijven. Werd al eens op gewezen.

c code:


boolean flgGewijzigd = false;

if (btnstateseconds == LOW){
    secondsvalue++; // de () zijn hier niet nodig
    flgGewijzigd = true;
}

if (flgGewijzigd){
   timer.setCounter(hourvalue, minutevalue, secondsvalue, timer.COUNT_DOWN, onComplete); //instellen timer
}
Van Lambiek wordt goede geuze gemaakt.

Voor de late avond heb ik nog een vraagje: Heb een mooie link gevonden met daarin precies wat ik nodig heb: https://electronics-project-hub.com/arduino-countdown-timer-with-lcd-a….

Maaarrr, nu heb ik een i2c oled display (128x32). Deze heb ik nu aangesloten op de arduino met de code iets veranderd.(andere libary, SPI, WIRE). Maar nu geeft helaas mijn oled display nog geen beeld.

Weet iemand onder de programmeurs waar de fout ligt?

Dit is mijn aangepaste code:

code:



#include <SPI.h>
#include <Wire.h>
#include<EEPROM.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#define OLED_RESET 4
Adafruit_SSD1306 display(OLED_RESET);
const int stsp = A0;
const int inc = A1;
const int dec = A2;
const int set = A3;
const int Led = 9;
const int relay = 8; //relaypin
int hrs = 0;
int Min = 0;
int sec = 0;
unsigned int check_val = 50;
int add_chk = 0;
int add_hrs = 1;
int add_min = 2;
bool RUN = true;
bool min_flag = true;
bool hrs_flag = true;

void setup()
{
display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
display.clearDisplay();
display.setTextSize(1);
display.setTextColor(WHITE);
display.setCursor(0, 0);
display.print("ELECTRONIC");
display.setCursor(0, 10);
display.print("COUNTDOWN TIMER");
pinMode(stsp, INPUT_PULLUP);
pinMode(inc, INPUT_PULLUP);
pinMode(dec, INPUT_PULLUP);
pinMode(set, INPUT_PULLUP);
pinMode(Led, OUTPUT);
pinMode(relay, OUTPUT);
digitalWrite(relay, LOW); 
digitalWrite(Led, LOW);
  if (EEPROM.read(add_chk) != check_val)
  {
    EEPROM.write(add_chk, check_val);
    EEPROM.write(add_hrs, 0);
    EEPROM.write(add_min, 1);
  }
  else
  {
    hrs = EEPROM.read(add_hrs);
    Min = EEPROM.read(add_min);
  }
  delay(1500);
  INIT();
}

void loop()
{
  if (digitalRead(stsp) == LOW)
  {
    display.clearDisplay(); 
    delay(250);
    RUN = true;
    while (RUN)
    {
      if (digitalRead(stsp) == LOW)
      {
        delay(1000);
        if (digitalRead(stsp) == LOW)
        {
          digitalWrite(relay, LOW); 
          display.clearDisplay(); 
          display.setCursor(0, 0);
          display.println("  TIMER STOPPED");
          display.setCursor(0, 10);
          display.println("----------------");
          delay(2000);
          RUN = false;
          INIT();
          break;
        }
      }
      digitalWrite(relay, HIGH); 
      sec = sec - 1;
      delay(1000);
      if (sec == -1)
      {
        sec = 59;
        Min = Min - 1;
      }
      if (Min == -1)
      {
        Min = 59;
        hrs = hrs - 1;
      }
      if (hrs == -1) hrs = 0;
      display.setCursor(0, 10);
      display.println("****************");
      display.setCursor(4, 0);
      if (hrs <= 9)
      {
        display.println('0');
      }
      display.print(hrs);
      display.println(':');
      if (Min <= 9)
      {
        display.println('0');
      }
      display.print(Min);
      display.println(':');
      if (sec <= 9)
      {
        display.println('0');
      }
      display.print(sec);
      if (hrs == 0 && Min == 0 && sec == 0)
      {
        digitalWrite(relay, LOW); 
        display.setCursor(4, 0);
        RUN = false;
        for (int i = 0; i < 20; i++)
        {
          digitalWrite(Led, HIGH);
          delay(100);
          digitalWrite(Led, LOW);
          delay(100);
        }
        INIT();
      }
    }
  }
  if (digitalRead(set) == LOW)
  {
    delay(500);
    while (min_flag)
    {
      display.clearDisplay(); 
      display.setCursor(0, 0);
      display.println("SET MINUTE: ");
      display.print(Min);
      delay(100);
      if (digitalRead(inc) == LOW)
      {
        Min = Min + 1;
        if (Min >= 60) Min = 0;
        delay(100);
      }
      if (digitalRead(dec) == LOW)
      {
        Min = Min - 1;
        if (Min <= -1) Min = 0;
        delay(100);
      }
      if (digitalRead(set) == LOW)
      {
        min_flag = false;
        delay(250);
      }
    }
    while (hrs_flag)
    {
        display.clearDisplay(); 
      display.setCursor(0, 0);
      display.println("SET HOUR: ");
      display.print(hrs);
      delay(100);
      if (digitalRead(inc) == LOW)
      {
        hrs = hrs + 1;
        if (hrs > 23) hrs = 0;
        delay(100);
      }
      if (digitalRead(dec) == LOW)
      {
        hrs = hrs - 1;
        if (hrs <= -1) hrs = 0;
        delay(100);
      }
      if (digitalRead(set) == LOW)
      {
        hrs_flag = false;
        delay(250);
      }
    }
    if (hrs == 0 && Min == 0)
    {
      display.clearDisplay(); 
      display.setCursor(0, 0);
      display.println("  INVALID TIME");
      delay(2000);
    }
    else
    {
      EEPROM.write(add_hrs, hrs);
      EEPROM.write(add_min, Min);
    }
    INIT();
  }
}

void INIT()
{
  hrs = EEPROM.read(add_hrs);
  Min = EEPROM.read(add_min);
  sec = 0;
  display.clearDisplay(); 
  display.setCursor(0, 0);
  display.println("Start / Set Time");
  display.setCursor(4, 10);
  if (hrs <= 9)
  {
    display.println('0');
  }
  display.print(hrs);
  display.println(':');
  if (Min <= 9)
  {
    display.println('0');
  }
  display.print(Min);
  display.println(':');
  if (sec <= 9)
  {
    display.println('0');
  }
  display.print(sec);
  min_flag = true;
  hrs_flag = true;
  delay(500);
}

en dit is de code die ik van internet af heb geplukt(om verschil te zien)

code:


//--------------(c) Electronics project hub -----------//
#include <LiquidCrystal.h>
#include<EEPROM.h>
const int rs = 7, en = 6, d4 = 5, d5 = 4, d6 = 3, d7 = 2;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
const int stsp = A0;
const int inc = A1;
const int dec = A2;
const int set = A3;
const int buzz = 9;
const int relay = 8;
int hrs = 0;
int Min = 0;
int sec = 0;
unsigned int check_val = 50;
int add_chk = 0;
int add_hrs = 1;
int add_min = 2;
bool RUN = true;
bool min_flag = true;
bool hrs_flag = true;
void setup()
{
  lcd.begin(16, 2);
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("   ELECTRONIC");
  lcd.setCursor(0, 1);
  lcd.print("COUNTDOWN TIMER");
  pinMode(stsp, INPUT_PULLUP);
  pinMode(inc, INPUT_PULLUP);
  pinMode(dec, INPUT_PULLUP);
  pinMode(set, INPUT_PULLUP);
  pinMode(buzz, OUTPUT);
  pinMode(relay, OUTPUT);
  digitalWrite(relay, LOW); 
  digitalWrite(buzz, LOW);
  if (EEPROM.read(add_chk) != check_val)
  {
    EEPROM.write(add_chk, check_val);
    EEPROM.write(add_hrs, 0);
    EEPROM.write(add_min, 1);
  }
  else
  {
    hrs = EEPROM.read(add_hrs);
    Min = EEPROM.read(add_min);
  }
  delay(1500);
  INIT();
}

void loop()
{
  if (digitalRead(stsp) == LOW)
  {
    lcd.clear();
    delay(250);
    RUN = true;
    while (RUN)
    {
      if (digitalRead(stsp) == LOW)
      {
        delay(1000);
        if (digitalRead(stsp) == LOW)
        {
          digitalWrite(relay, LOW); 
          lcd.clear();
          lcd.setCursor(0, 0);
          lcd.print("  TIMER STOPPED");
          lcd.setCursor(0, 1);
          lcd.print("----------------");
          delay(2000);
          RUN = false;
          INIT();
          break;
        }
      }
      digitalWrite(relay, HIGH); 
      sec = sec - 1;
      delay(1000);
      if (sec == -1)
      {
        sec = 59;
        Min = Min - 1;
      }
      if (Min == -1)
      {
        Min = 59;
        hrs = hrs - 1;
      }
      if (hrs == -1) hrs = 0;
      lcd.setCursor(0, 1);
      lcd.print("****************");
      lcd.setCursor(4, 0);
      if (hrs <= 9)
      {
        lcd.print('0');
      }
      lcd.print(hrs);
      lcd.print(':');
      if (Min <= 9)
      {
        lcd.print('0');
      }
      lcd.print(Min);
      lcd.print(':');
      if (sec <= 9)
      {
        lcd.print('0');
      }
      lcd.print(sec);
      if (hrs == 0 && Min == 0 && sec == 0)
      {
        digitalWrite(relay, LOW); 
        lcd.setCursor(4, 0);
        RUN = false;
        for (int i = 0; i < 20; i++)
        {
          digitalWrite(buzz, HIGH);
          delay(100);
          digitalWrite(buzz, LOW);
          delay(100);
        }
        INIT();
      }
    }
  }
  if (digitalRead(set) == LOW)
  {
    delay(500);
    while (min_flag)
    {
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("SET MINUTE: ");
      lcd.print(Min);
      delay(100);
      if (digitalRead(inc) == LOW)
      {
        Min = Min + 1;
        if (Min >= 60) Min = 0;
        delay(100);
      }
      if (digitalRead(dec) == LOW)
      {
        Min = Min - 1;
        if (Min <= -1) Min = 0;
        delay(100);
      }
      if (digitalRead(set) == LOW)
      {
        min_flag = false;
        delay(250);
      }
    }
    while (hrs_flag)
    {
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("SET HOUR: ");
      lcd.print(hrs);
      delay(100);
      if (digitalRead(inc) == LOW)
      {
        hrs = hrs + 1;
        if (hrs > 23) hrs = 0;
        delay(100);
      }
      if (digitalRead(dec) == LOW)
      {
        hrs = hrs - 1;
        if (hrs <= -1) hrs = 0;
        delay(100);
      }
      if (digitalRead(set) == LOW)
      {
        hrs_flag = false;
        delay(250);
      }
    }
    if (hrs == 0 && Min == 0)
    {
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("  INVAID TIME");
      delay(2000);
    }
    else
    {
      EEPROM.write(add_hrs, hrs);
      EEPROM.write(add_min, Min);
    }
    INIT();
  }
}

void INIT()
{
  hrs = EEPROM.read(add_hrs);
  Min = EEPROM.read(add_min);
  sec = 0;
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Start / Set Time");
  lcd.setCursor(4, 1);
  if (hrs <= 9)
  {
    lcd.print('0');
  }
  lcd.print(hrs);
  lcd.print(':');
  if (Min <= 9)
  {
    lcd.print('0');
  }
  lcd.print(Min);
  lcd.print(':');
  if (sec <= 9)
  {
    lcd.print('0');
  }
  lcd.print(sec);
  min_flag = true;
  hrs_flag = true;
  delay(500);
}
//--------------(c) Electronics project hub -----------//

Als er een peripheral (zoals je display) niet werkt, is het handig om je probleem te isoleren. In jouw geval zou je onder de regel

code:

lcd.print("COUNTDOWN TIMER");

dit kunnen zetten

code:

while(1);

Je programma zal daar dus oneindig blijven hangen. Voordeel is dat het hele EEPROM gebeuren en de loop() niet gebruikt worden, maar de tekst "ELECTRONIC COUNTDOWN TIMER" zou wel op het scherm moeten komen. Er zijn dan dus nog minder dan 10 regels code over waar je probleem kan zitten.
Naast de regels die met "lcd." of "display." beginnen bovenaan in setup(), is er nog één andere regel die van belang is om te bestuderen op correctheid

code:

Adafruit_SSD1306 display(OLED_RESET);

Feitelijk zou je dus je code kunnen reduceren tot dit, en dan daarin je probleem zoeken en oplossen. Daarna kan je weer verder met wat je daaruit geleerd hebt

c code:


#include <SPI.h>
#include <Wire.h>
#include<EEPROM.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#define OLED_RESET 4
Adafruit_SSD1306 display(OLED_RESET);

void setup()
{
  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(WHITE);
  display.setCursor(0, 0);
  display.print("ELECTRONIC");
}

void loop()
{
}

Probeer ook de includes te reduceren zover mogelijk. Bijvoorbeeld de EEPROM heb je niet nodig, maar hoe zit het met Wire, GFX, en SPI?

Meep! Meep!

Op 11 september 2020 09:41:33 schreef roadrunner84:
Als er een peripheral (zoals je display) niet werkt, is het handig om je probleem te isoleren. In jouw geval zou je onder de regel

code:

lcd.print("COUNTDOWN TIMER");

dit kunnen zetten

code:

while(1);

Je programma zal daar dus oneindig blijven hangen. Voordeel is dat het hele EEPROM gebeuren en de loop() niet gebruikt worden, maar de tekst "ELECTRONIC COUNTDOWN TIMER" zou wel op het scherm moeten komen. Er zijn dan dus nog minder dan 10 regels code over waar je probleem kan zitten.
Naast de regels die met "lcd." of "display." beginnen bovenaan in setup(), is er nog één andere regel die van belang is om te bestuderen op correctheid

code:

Adafruit_SSD1306 display(OLED_RESET);

Feitelijk zou je dus je code kunnen reduceren tot dit, en dan daarin je probleem zoeken en oplossen. Daarna kan je weer verder met wat je daaruit geleerd hebt

c code:


#include <SPI.h>
#include <Wire.h>
#include<EEPROM.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#define OLED_RESET 4
Adafruit_SSD1306 display(OLED_RESET);

void setup()
{
  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(WHITE);
  display.setCursor(0, 0);
  display.print("ELECTRONIC");
}

void loop()
{
}

Probeer ook de includes te reduceren zover mogelijk. Bijvoorbeeld de EEPROM heb je niet nodig, maar hoe zit het met Wire, GFX, en SPI?

bedankt voor uw reactie, ik heb de volgende code van u getest, deze werkt helaas niet:

code:


#include <SPI.h>
#include <Wire.h>
#include<EEPROM.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#define OLED_RESET 4
Adafruit_SSD1306 display(OLED_RESET);

void setup()
{
  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  display.clearDisplay();
}
  display.setCursor(0, 0);
  display.print("ELECTRONIC");
}

void loop()
{
}

maar nu heb ik een code die wel werkt, nu staat display text en display white wel in de loop. Ook zonder display.display() werkt het display niet. Wat is de functie van displaydisPLAY()?
En hoe kan ik de code van de counter laten werken met deze informatie?

code die wel werkt:

code:



#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#define OLED_RESET 4
Adafruit_SSD1306 display(OLED_RESET);

void setup() 
{
  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  display.clearDisplay();

}

void loop() 
{

  display.setTextSize(1);
  display.setTextColor(WHITE);

  display.setCursor(0,0);
  display.println("Test");
  
  display.display();

} 

heb nu het volgende stukje code:

code:


  display.display();

toegevoegd onder het stukje:

code:


display.print("COUNTDOWN TIMER");

nu zie ik wel electronic countdown timer op mijn display verschijnen. Het is dus de functie display display die niet was toegevoegd. Zou ik gewoon de while nu kunnen weghalen en display display aan het einde van de setup en de loop kunnen zetten?

Update: Heb een display.display gezet aan het einde van de setup. Dit heb ik ook gedaan in de loop en de functie INIT. Nu heb ik wel een goede weergave van het display. (ook alle println naar print veranderd).

Nu heb ik als enigste probleem dat ik geen update zie van het scherm wanneer ik bijvoorbeeld een decimaal increase met een button (of bijvoorbeeld een startbutton indruk). Weet iemand hoe ik dit kan oplossen?

groeten Sven

[Bericht gewijzigd door SvenTech op 11 september 2020 17:10:02 (34%)]

Met deze code laat hij dus wel alle tekst zien maar kan ik de tekst niet wijzigen:

code:



#include <SPI.h>
#include <Wire.h>
#include<EEPROM.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#define OLED_RESET 4
Adafruit_SSD1306 display(OLED_RESET);
const int stsp = A0;
const int inc = A1;
const int dec = A2;
const int set = A3;
const int Led = 9;
const int relay = 8; //relaypin
int hrs = 0;
int Min = 0;
int sec = 0;
unsigned int check_val = 50;
int add_chk = 0;
int add_hrs = 1;
int add_min = 2;
bool RUN = true;
bool min_flag = true;
bool hrs_flag = true;

void setup()
{
display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
display.clearDisplay();
display.setTextSize(1);
display.setTextColor(WHITE);
display.setCursor(0, 0);
display.print("ELECTRONIC");
display.setCursor(0, 10);
display.print("COUNTDOWN TIMER");
display.display();
pinMode(stsp, INPUT_PULLUP);
pinMode(inc, INPUT_PULLUP);
pinMode(dec, INPUT_PULLUP);
pinMode(set, INPUT_PULLUP);
pinMode(Led, OUTPUT);
pinMode(relay, OUTPUT);
digitalWrite(relay, LOW); 
digitalWrite(Led, LOW);
  if (EEPROM.read(add_chk) != check_val)
  {
    EEPROM.write(add_chk, check_val);
    EEPROM.write(add_hrs, 0);
    EEPROM.write(add_min, 1);
  }
  else
  {
    hrs = EEPROM.read(add_hrs);
    Min = EEPROM.read(add_min);
  }
  delay(1500);
  INIT();
}

void loop()
{
  if (digitalRead(stsp) == LOW)
  {
    display.clearDisplay(); 
    delay(250);
    RUN = true;
    while (RUN)
    {
      if (digitalRead(stsp) == LOW)
      {
        delay(1000);
        if (digitalRead(stsp) == LOW)
        {
          digitalWrite(relay, LOW); 
          display.clearDisplay(); 
          display.setCursor(0, 0);
          display.print("TIMER STOPPED");
          display.setCursor(0, 10);
          display.print("----------------");
          delay(2000);
          RUN = false;
          INIT();
          break;
        }
      }
      digitalWrite(relay, HIGH); 
      sec = sec - 1;
      delay(1000);
      if (sec == -1)
      {
        sec = 59;
        Min = Min - 1;
      }
      if (Min == -1)
      {
        Min = 59;
        hrs = hrs - 1;
      }
      if (hrs == -1) hrs = 0;
      display.setCursor(0, 10);
      display.print("****************");
      display.setCursor(0, 10);
      if (hrs <= 9)
      {
        display.print('0');
      }
      display.print(hrs);
      display.print(':');
      if (Min <= 9)
      {
        display.print('0');
      }
      display.print(Min);
      display.print(':');
      if (sec <= 9)
      {
        display.print('0');
      }
      display.print(sec);
      if (hrs == 0 && Min == 0 && sec == 0)
      {
        digitalWrite(relay, LOW); 
        display.setCursor(0, 10);
        RUN = false;
        for (int i = 0; i < 20; i++)
        {
          digitalWrite(Led, HIGH);
          delay(100);
          digitalWrite(Led, LOW);
          delay(100);
        }
        INIT();
      }
    }
  }
  if (digitalRead(set) == LOW)
  {
    delay(500);
    while (min_flag)
    {
      display.clearDisplay(); 
      display.setCursor(0, 0);
      display.print("SET MINUTE: ");
      display.print(Min);
      delay(100);
      if (digitalRead(inc) == LOW)
      {
        Min = Min + 1;
        if (Min >= 60) Min = 0;
        delay(100);
      }
      if (digitalRead(dec) == LOW)
      {
        Min = Min - 1;
        if (Min <= -1) Min = 0;
        delay(100);
      }
      if (digitalRead(set) == LOW)
      {
        min_flag = false;
        delay(250);
      }
    }
    while (hrs_flag)
    {
        display.clearDisplay(); 
      display.setCursor(0, 0);
      display.print("SET HOUR: ");
      display.print(hrs);
      delay(100);
      if (digitalRead(inc) == LOW)
      {
        hrs = hrs + 1;
        if (hrs > 23) hrs = 0;
        delay(100);
      }
      if (digitalRead(dec) == LOW)
      {
        hrs = hrs - 1;
        if (hrs <= -1) hrs = 0;
        delay(100);
      }
      if (digitalRead(set) == LOW)
      {
        hrs_flag = false;
        delay(250);
      }
    }
    if (hrs == 0 && Min == 0)
    {
      display.clearDisplay(); 
      display.setCursor(0, 0);
      display.print("INVALID TIME");
      delay(2000);
    }
    else
    {
      EEPROM.write(add_hrs, hrs);
      EEPROM.write(add_min, Min);
    }
    INIT();
  }
    display.display();
}

void INIT()
{
  display.clearDisplay(); 
  hrs = EEPROM.read(add_hrs);
  Min = EEPROM.read(add_min);
  sec = 0;
  display.clearDisplay(); 
  display.setCursor(0, 0);
  display.print("Start / Set Time");
  display.setCursor(0, 10);
  if (hrs <= 9)
  {
    display.print('0');
  }
  display.print(hrs);
  display.print(':');
  if (Min <= 9)
  {
    display.print('0');
  }
  display.print(Min);
  display.print(':');
  if (sec <= 9)
  {
    display.print('0');
  }
  display.print(sec);
  min_flag = true;
  hrs_flag = true;
  delay(500);
    display.display();
}

Probleem

[Bericht gewijzigd door SvenTech op 13 september 2020 19:12:51 (94%)]

Probleem helaas nog steeds niet kunnen vinden. Ik denk wel dat de functie display.display ergens moet worden ingevoegd wil het gaan werken. Weet iemand waar ik dit het beste kan neerzetten?

Ik zie jullie reacties met belangstelling tegemoet.

Met vriendelijke groeten,

Sven

Het lijkt er dus op dat de display.display() functie het "geprepareerde" beeld overzet van het geheugen op het scherm.

Als je zelgt dat je het beeld niet kan wijzigen, wat bedoel je daar dan mee? Is er geheel geen verschil tussen beelden, of blijft de oude tekst staan terwijl je nieuwe tekst wilt weergeven?

Kijk even mee naar deze loop() functie, het is dezelfde als jij hebt, maar met wat code eruit gehaald voor de leesbaarheid:

c code:


void loop()
{
  if (digitalRead(stsp) == LOW)
  {
    display.clearDisplay(); 
    delay(250);
    RUN = true;
    while (RUN)
    {
      // veel code hier
    }
  }
  // hier nog een hoop code
    display.display();
}

Zie je het probleem? je display() functie wordt buiten je while(RUN) aangeroepen. Probeer het stuk code te isoleren dat een beeld prepareert en slechts direct daarna moet de display() functie aangeroepen worden, zo minimaliseer je de (in tijd gezien dure) schrijfacties naar het scherm die toch het beoogde resultaat creeëren.

Meep! Meep!