Und was ist damit? Lesbaren Code erstellen!
Hoffe es ist so Leserlicher.
/*
...
*/
// constants won't change. They're used here to set pin numbers:
const int Sensor = 2; // Sensor
const int Reset = 4; // Reset
const int Zaehler1Freigabe = 8; // Zähler 1 Freigabe
const int Zaehler2Freigabe = 9; // Zähler 2 Freigabe
// Variables will change:
int SensorState = 0; // Sensor
int ResetState = 0; // Reset
int Zaehler1FreigabeState = 0; // Zähler 1 Freigabe
int Zaehler2FreigabeState = 0; // Zähler 2 Freigabe
int lastSensorState = 0;
int Counter1 = 0; // Zähler 1
int Counter2 = 0; // Zähler 2
void setup() {
// initialize as a input:
pinMode(Sensor, INPUT); // Sensor
pinMode(Reset, INPUT); // Reset
pinMode(Zaehler1Freigabe, INPUT); // Zähler 1 Freigabe
pinMode(Zaehler2Freigabe, INPUT); // Zähler 2 Freigabe
// initialize serial communication:
Serial.begin(9600);
}
void loop() {
// digitalRead:
SensorState = digitalRead(Sensor); // Sensor
ResetState = digitalRead(Reset); // Reset
Zaehler1FreigabeState = digitalRead(Zaehler1Freigabe); // Zähler 1 Freigabe
Zaehler2FreigabeState = digitalRead(Zaehler2Freigabe); // Zähler 2 Freigabe
// Zähler 1
if (Zaehler1FreigabeState == HIGH && (SensorState != lastSensorState)) {
if (SensorState == HIGH) {
Counter1++;
Serial.print("Zähler 1: ");
Serial.println(Counter1);
}
}
lastSensorState = SensorState;
// Reset Zähler 1
if (ResetState == LOW && Zaehler1FreigabeState == HIGH) {
Counter1 = 0;
Serial.print("Zähler 1: ");
Serial.println(Counter1);
delay(750);
}
// Zähler 2
if (Zaehler2FreigabeState == HIGH && (SensorState != lastSensorState)) {
if (SensorState == HIGH) {
Counter2++;
Serial.print("Zähler 2: ");
Serial.println(Counter2);
}
}
lastSensorState = SensorState;
// Reset Zähler 2
if (ResetState == LOW && Zaehler2FreigabeState == HIGH) {
Counter2 = 0;
Serial.print("Zähler 2: ");
Serial.println(Counter2);
delay(750);
}
}
Das mit mehreren 0 ist erst mal nicht Prio. Möchte ich allerdings nicht so haben.
Das Hauptproblem ist das nur Zähle 1 zählt. Reset funktioniert für Zähler 1 und 2 getrennt. Hochzählen tut aber nur Zähler 1. bei Zähler 2 wir nicht mal etwas angezeigt im Monitor.
Bist du sicher dass die Pins gehen
Ja habe es auch schon mit anderen Pins probiert da ich auch erst den Gedanken hatte das etwas kaputt sein könnte.
Setz das ans Ende
Hallo,
die Zeile gibt es zweimal , das erste mal löschen
1 Like
Ich möchte schon einmal allen nochmals danken für die Hilfe. Ich hatte immer wenig Zeit zum weiter probieren. Nun ist mein Code allerdings fast fertig. Jetzt wollte ich einmal fragen ob man den so schreiben kann oder ob man den vereinfachen kann? (Funktion ist da, es geht nicht um Fehlersuche)
Der Zähler soll nach 10x Zählen die Daten in Excel übertragen.
/*
Zweigle D315 mit OLED Anzeige
*/
#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 32 // OLED display height, in pixels
// Declaration for an SSD1306 display connected to I2C (SDA, SCL pins)
#define OLED_RESET -1 // Reset pin # (or -1 if sharing Arduino reset pin)
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);
// constants won't change. They're used here to set pin numbers:
const int Sensor = 2; // Sensor
const int Reset = 4; // Reset
const int Rechtslauf = 6; // Rechtslauf
// Variables will change:
int SensorState = 0; // Sensor
int ResetState = 0; // Reset
int RechtslaufState = 0; // Rechtslauf
int lastSensorState = 0;
int Counter1 = 0; // Zähler 1
int Counter2 = 0; // Zähler 2
int Counter3 = 0; // Zähler 3
int Counter4 = 0; // Zähler 4
int Counter5 = 0; // Zähler 5
int Counter6 = 0; // Zähler 6
int Counter7 = 0; // Zähler 7
int Counter8 = 0; // Zähler 8
int Counter9 = 0; // Zähler 9
int Counter10 = 0; // Zähler 10
int CounterReset = 0; // Zähler Reset
void setup() {
// OLED Display 128x32
display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
display.clearDisplay();
display.display();
// initialize as a input:
pinMode(Sensor, INPUT_PULLUP); // Sensor
pinMode(Reset, INPUT_PULLUP); // Reset
pinMode(Rechtslauf, INPUT_PULLUP); // Rechtslauf
// initialize serial communication:
Serial.begin(9600);
}
void loop() {
// digitalRead:
SensorState = digitalRead(Sensor); // Sensor
ResetState = digitalRead(Reset); // Reset
RechtslaufState = digitalRead(Rechtslauf); // Rechtslauf
if (CounterReset == 0) {
display.clearDisplay();
display.setTextColor(WHITE); // Textfarbe ()
display.setCursor(5, 0); // erste Zahl von links rein, zweite Zahl von oben rein
display.setTextSize(2); // Textgröße
display.println("Test"); // Text wo auf Bildschirm steht
display.setCursor(5, 16); // erste Zahl von links rein, zweite Zahl von oben rein
display.setTextSize(2); // Textgröße
display.println("D315"); // Text wo auf Bildschirm steht
display.display();
}
// Reset Zähler 1
if (ResetState == LOW) {
CounterReset += 1;
delay(250);
}
if (CounterReset == 1) {
// Zähler 1 hochzählen
if (RechtslaufState != LOW && (SensorState != lastSensorState)) {
if (SensorState == LOW) {
Counter1 += 1;
}
}
// Zähler 1 runterzählen
if (RechtslaufState == LOW && (SensorState != lastSensorState)) {
if (SensorState == LOW) {
Counter1 -= 1;
}
}
display.clearDisplay();
display.setTextColor(WHITE); // Textfarbe ()
display.setCursor(5, 0); // erste Zahl von links rein, zweite Zahl von oben rein
display.setTextSize(2); // Textgröße
display.println("Test 1"); // Text wo auf Bildschirm steht
display.setCursor(5, 16); // erste Zahl von links rein, zweite Zahl von oben rein
display.setTextSize(2); // Textgröße
display.println(Counter1); // Text wo auf Bildschirm steht
display.display();
}
if (CounterReset == 2) {
// Zähler 2 hochzählen
if (RechtslaufState != LOW && (SensorState != lastSensorState)) {
if (SensorState == LOW) {
Counter2 += 1;
}
}
// Zähler 2 runterzählen
if (RechtslaufState == LOW && (SensorState != lastSensorState)) {
if (SensorState == LOW) {
Counter2 -= 1;
}
}
display.clearDisplay();
display.setTextColor(WHITE); // Textfarbe ()
display.setCursor(5, 0); // erste Zahl von links rein, zweite Zahl von oben rein
display.setTextSize(2); // Textgröße
display.println("Test 2"); // Text wo auf Bildschirm steht
display.setCursor(5, 16); // erste Zahl von links rein, zweite Zahl von oben rein
display.setTextSize(2); // Textgröße
display.println(Counter2); // Text wo auf Bildschirm steht
display.display();
}
if (CounterReset == 3) {
// Zähler 3 hochzählen
if (RechtslaufState != LOW && (SensorState != lastSensorState)) {
if (SensorState == LOW) {
Counter3 += 1;
}
}
// Zähler 3 runterzählen
if (RechtslaufState == LOW && (SensorState != lastSensorState)) {
if (SensorState == LOW) {
Counter3 -= 1;
}
}
display.clearDisplay();
display.setTextColor(WHITE); // Textfarbe ()
display.setCursor(5, 0); // erste Zahl von links rein, zweite Zahl von oben rein
display.setTextSize(2); // Textgröße
display.println("Test 3"); // Text wo auf Bildschirm steht
display.setCursor(5, 16); // erste Zahl von links rein, zweite Zahl von oben rein
display.setTextSize(2); // Textgröße
display.println(Counter3); // Text wo auf Bildschirm steht
display.display();
}
if (CounterReset == 4) {
// Zähler 4 hochzählen
if (RechtslaufState != LOW && (SensorState != lastSensorState)) {
if (SensorState == LOW) {
Counter4 += 1;
}
}
// Zähler 4 runterzählen
if (RechtslaufState == LOW && (SensorState != lastSensorState)) {
if (SensorState == LOW) {
Counter4 -= 1;
}
}
display.clearDisplay();
display.setTextColor(WHITE); // Textfarbe ()
display.setCursor(5, 0); // erste Zahl von links rein, zweite Zahl von oben rein
display.setTextSize(2); // Textgröße
display.println("Test 4"); // Text wo auf Bildschirm steht
display.setCursor(5, 16); // erste Zahl von links rein, zweite Zahl von oben rein
display.setTextSize(2); // Textgröße
display.println(Counter4); // Text wo auf Bildschirm steht
display.display();
}
if (CounterReset == 5) {
// Zähler 5 hochzählen
if (RechtslaufState != LOW && (SensorState != lastSensorState)) {
if (SensorState == LOW) {
Counter5 += 1;
}
}
// Zähler 5 runterzählen
if (RechtslaufState == LOW && (SensorState != lastSensorState)) {
if (SensorState == LOW) {
Counter5 -= 1;
}
}
display.clearDisplay();
display.setTextColor(WHITE); // Textfarbe ()
display.setCursor(5, 0); // erste Zahl von links rein, zweite Zahl von oben rein
display.setTextSize(2); // Textgröße
display.println("Test 5"); // Text wo auf Bildschirm steht
display.setCursor(5, 16); // erste Zahl von links rein, zweite Zahl von oben rein
display.setTextSize(2); // Textgröße
display.println(Counter5); // Text wo auf Bildschirm steht
display.display();
}
if (CounterReset == 6) {
// Zähler 6 hochzählen
if (RechtslaufState != LOW && (SensorState != lastSensorState)) {
if (SensorState == LOW) {
Counter6 += 1;
}
}
// Zähler 6 runterzählen
if (RechtslaufState == LOW && (SensorState != lastSensorState)) {
if (SensorState == LOW) {
Counter6 -= 1;
}
}
display.clearDisplay();
display.setTextColor(WHITE); // Textfarbe ()
display.setCursor(5, 0); // erste Zahl von links rein, zweite Zahl von oben rein
display.setTextSize(2); // Textgröße
display.println("Test 6"); // Text wo auf Bildschirm steht
display.setCursor(5, 16); // erste Zahl von links rein, zweite Zahl von oben rein
display.setTextSize(2); // Textgröße
display.println(Counter6); // Text wo auf Bildschirm steht
display.display();
}
if (CounterReset == 7) {
// Zähler 7 hochzählen
if (RechtslaufState != LOW && (SensorState != lastSensorState)) {
if (SensorState == LOW) {
Counter7 += 1;
}
}
// Zähler 7 runterzählen
if (RechtslaufState == LOW && (SensorState != lastSensorState)) {
if (SensorState == LOW) {
Counter7 -= 1;
}
}
display.clearDisplay();
display.setTextColor(WHITE); // Textfarbe ()
display.setCursor(5, 0); // erste Zahl von links rein, zweite Zahl von oben rein
display.setTextSize(2); // Textgröße
display.println("Test 7"); // Text wo auf Bildschirm steht
display.setCursor(5, 16); // erste Zahl von links rein, zweite Zahl von oben rein
display.setTextSize(2); // Textgröße
display.println(Counter7); // Text wo auf Bildschirm steht
display.display();
}
if (CounterReset == 8) {
// Zähler 8 hochzählen
if (RechtslaufState != LOW && (SensorState != lastSensorState)) {
if (SensorState == LOW) {
Counter8 += 1;
}
}
// Zähler 8 runterzählen
if (RechtslaufState == LOW && (SensorState != lastSensorState)) {
if (SensorState == LOW) {
Counter8 -= 1;
}
}
display.clearDisplay();
display.setTextColor(WHITE); // Textfarbe ()
display.setCursor(5, 0); // erste Zahl von links rein, zweite Zahl von oben rein
display.setTextSize(2); // Textgröße
display.println("Test 8"); // Text wo auf Bildschirm steht
display.setCursor(5, 16); // erste Zahl von links rein, zweite Zahl von oben rein
display.setTextSize(2); // Textgröße
display.println(Counter8); // Text wo auf Bildschirm steht
display.display();
}
if (CounterReset == 9) {
// Zähler 9 hochzählen
if (RechtslaufState != LOW && (SensorState != lastSensorState)) {
if (SensorState == LOW) {
Counter9 += 1;
}
}
// Zähler 9 runterzählen
if (RechtslaufState == LOW && (SensorState != lastSensorState)) {
if (SensorState == LOW) {
Counter9 -= 1;
}
}
display.clearDisplay();
display.setTextColor(WHITE); // Textfarbe ()
display.setCursor(5, 0); // erste Zahl von links rein, zweite Zahl von oben rein
display.setTextSize(2); // Textgröße
display.println("Test 9"); // Text wo auf Bildschirm steht
display.setCursor(5, 16); // erste Zahl von links rein, zweite Zahl von oben rein
display.setTextSize(2); // Textgröße
display.println(Counter9); // Text wo auf Bildschirm steht
display.display();
}
if (CounterReset == 10) {
// Zähler 10 hochzählen
if (RechtslaufState != LOW && (SensorState != lastSensorState)) {
if (SensorState == LOW) {
Counter10 += 1;
}
}
// Zähler 10 runterzählen
if (RechtslaufState == LOW && (SensorState != lastSensorState)) {
if (SensorState == LOW) {
Counter10 -= 1;
}
}
display.clearDisplay();
display.setTextColor(WHITE); // Textfarbe ()
display.setCursor(5, 0); // erste Zahl von links rein, zweite Zahl von oben rein
display.setTextSize(2); // Textgröße
display.println("Test 10"); // Text wo auf Bildschirm steht
display.setCursor(5, 16); // erste Zahl von links rein, zweite Zahl von oben rein
display.setTextSize(2); // Textgröße
display.println(Counter10); // Text wo auf Bildschirm steht
display.display();
}
lastSensorState = SensorState;
if (CounterReset == 11) {
display.clearDisplay();
display.setTextColor(WHITE); // Textfarbe ()
display.setCursor(5, 10); // erste Zahl von links rein, zweite Zahl von oben rein
display.setTextSize(2); // Textgröße
display.println(F("Data Data")); // Text wo auf Bildschirm steht
display.display();
display.startscrollleft(0x00, 0x0F);
delay(3000);
display.stopscroll();
Serial.print(Counter1);
Serial.print(",");
Serial.print(Counter2);
Serial.print(",");
Serial.print(Counter3);
Serial.print(",");
Serial.print(Counter4);
Serial.print(",");
Serial.print(Counter5);
Serial.print(",");
Serial.print(Counter6);
Serial.print(",");
Serial.print(Counter7);
Serial.print(",");
Serial.print(Counter8);
Serial.print(",");
Serial.print(Counter9);
Serial.print(",");
Serial.print(Counter10);
Serial.println();
CounterReset += 1;
}
if (CounterReset == 12) {
CounterReset = 0;
Counter1 = 0;
Counter2 = 0;
Counter3 = 0;
Counter4 = 0;
Counter5 = 0;
Counter6 = 0;
Counter7 = 0;
Counter8 = 0;
Counter9 = 0;
Counter10 = 0;
}
}
Sicher!
Durchnummerierte Variablen sind, bzw, gelten als, böse.
Da würde ich ein Array vorschlagen.
Dann sehe ich da Codeduplikate, die sich nur in den Nummern unterscheiden.
Das kann man zu Strukturen oder Klassen zusammenfassen.
Sehe ich das richtig, das countreset gar kein reset sondern ein indexmerker ist, welcher counter angesprochen wird?
Es fehlen einige Kommentare um da sofort was zu sehen, aber drr code ist mindestens um 1/3 kürzbar
wie @combie schon geschrieben hat.
Variablen durchnummerieren ist böse. Mach dir ein Array
int counter[10];Damit kannst du in der Folge deinen Sketch verkürzen, lesbar und wartbar halten.
Behalte dir im Auge, dass Computer mit 0 zu zählen beginnen, die Felder also von 0 bis 9 gehen.
Und überlege dir ob dein counter jemals negativ werden kann. Wenn nicht, dann nimm statt int ein uint16_t.
edit:
nur als Idee - musst vermutlich noch debuggen, aber es kompiliert.
/*
Zweigle D315 mit OLED Anzeige
2024-08-02 noiasca: von 369 auf 120 Zeilen
to be deleted 2024-11-02
*/
#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 32 // OLED display height, in pixels
// Declaration for an SSD1306 display connected to I2C (SDA, SCL pins)
#define OLED_RESET -1 // Reset pin # (or -1 if sharing Arduino reset pin)
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);
// constants won't change. They're used here to set pin numbers:
constexpr uint8_t Sensor = 2; // Sensor
constexpr uint8_t Reset = 4; // Reset
constexpr uint8_t Rechtslauf = 6; // Rechtslauf
// Variables will change:
int SensorState = 0; // Sensor
int ResetState = 0; // Reset
int RechtslaufState = 0; // Rechtslauf
int lastSensorState = 0;
uint16_t counter[10];
int counterReset = 0; // Zähler Reset
void setup() {
// OLED Display 128x32
display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
display.clearDisplay();
display.display();
// initialize as a input:
pinMode(Sensor, INPUT_PULLUP); // Sensor
pinMode(Reset, INPUT_PULLUP); // Reset
pinMode(Rechtslauf, INPUT_PULLUP); // Rechtslauf
// initialize serial communication:
Serial.begin(9600);
}
void loop() {
// digitalRead:
SensorState = digitalRead(Sensor); // Sensor
ResetState = digitalRead(Reset); // Reset
RechtslaufState = digitalRead(Rechtslauf); // Rechtslauf
// Reset Zähler 1
if (ResetState == LOW) {
counterReset++;
delay(250);
}
switch (counterReset) {
case 0 :
display.clearDisplay();
display.setTextColor(WHITE); // Textfarbe ()
display.setCursor(5, 0); // erste Zahl von links rein, zweite Zahl von oben rein
display.setTextSize(2); // Textgröße
display.println("Test"); // Text wo auf Bildschirm steht
display.setCursor(5, 16); // erste Zahl von links rein, zweite Zahl von oben rein
display.setTextSize(2); // Textgröße
display.println("D315"); // Text wo auf Bildschirm steht
display.display();
break;
case 1 ... 10 :
// Zähler raufzählen
if (RechtslaufState != LOW && (SensorState != lastSensorState)) {
if (SensorState == LOW) {
counter[counterReset - 1]++;
}
}
// Zähler runterzählen
if (RechtslaufState == LOW && (SensorState != lastSensorState)) {
if (SensorState == LOW) {
counter[counterReset - 1]--;
}
}
display.clearDisplay();
display.setTextColor(WHITE); // Textfarbe ()
display.setCursor(5, 0); // erste Zahl von links rein, zweite Zahl von oben rein
display.setTextSize(2); // Textgröße
display.print("Test "); // Text wo auf Bildschirm steht
display.println(counterReset);
display.setCursor(5, 16); // erste Zahl von links rein, zweite Zahl von oben rein
display.setTextSize(2); // Textgröße
display.println(counter[counterReset - 1]); // Text wo auf Bildschirm steht
display.display();
break;
case 11 :
display.clearDisplay();
display.setTextColor(WHITE); // Textfarbe ()
display.setCursor(5, 10); // erste Zahl von links rein, zweite Zahl von oben rein
display.setTextSize(2); // Textgröße
display.println(F("Data Data")); // Text wo auf Bildschirm steht
display.display();
display.startscrollleft(0x00, 0x0F);
delay(3000);
display.stopscroll();
for (auto & c : counter) {
Serial.print(c);
Serial.print(",");
}
Serial.println();
counterReset++;
break;
case 12 :
counterReset = 0;
for (auto & c : counter) c = 0;
break;
}
}
//Ich muss mich revidieren.
Das geht um einige hundert Zeilen weniger.
Als Idee - ich bin noch nicht ganz fertig geworden, aber die Sbahn fährt nicht so lange.
/*
Zweigle D315 mit OLED Anzeige
*/
#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 32 // OLED display height, in pixels
// Declaration for an SSD1306 display connected to I2C (SDA, SCL pins)
#define OLED_RESET -1 // Reset pin # (or -1 if sharing Arduino reset pin)
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);
// constants won't change. They're used here to set pin numbers:
constexpr uint8_t sensorPin {2}; // Sensor
constexpr uint8_t counterPin {4}; // Reset
constexpr uint8_t rechtslaufPin {6}; // Rechtslauf
// Variables will change:
bool RechtslaufState = false; // Rechtslauf
bool sensorState;
bool lastSensorState = false;
int myCounter[10] = {0};
uint8_t countIdx = 0;
void setup()
{
// initialize serial communication:
Serial.begin(9600);
Serial.println(F("Start..."));
// OLED Display 128x32
display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
display.clearDisplay();
display.display();
// initialize as a input:
pinMode(sensorPin, INPUT_PULLUP); // Sensor
pinMode(counterPin, INPUT_PULLUP); // Reset
pinMode(rechtslaufPin, INPUT_PULLUP); // Rechtslauf
}
void checkCounterPin()
{
constexpr uint32_t bounceTime {250};
static bool lastState = false;
static uint32_t pressedTime = 0;
if (!digitalRead(counterPin))
{
if (!lastState)
{
countIdx++;
lastState = !lastState;
pressedTime = millis();
}
}
else if (lastState)
{
if (millis() - pressedTime > bounceTime)
{
lastState = !lastState;
}
}
display.clearDisplay();
display.setTextColor(WHITE); // Textfarbe ()
display.setCursor(5, 0); // erste Zahl von links rein, zweite Zahl von oben rein
display.setTextSize(2); // Textgröße
display.println("Test"); // Text wo auf Bildschirm steht
display.setCursor(5, 16); // erste Zahl von links rein, zweite Zahl von oben rein
display.setTextSize(2); // Textgröße
display.println("D315"); // Text wo auf Bildschirm steht
display.display();
}
void loop()
{
checkCounterPin();
if (countIdx < 11)
{ checkSensors(); }
else
{
printAll();
counterReset();
}
}
void checkSensors()
{
sensorState = digitalRead(sensorPin);
if (sensorState != lastSensorState)
{
if (sensorState == LOW)
{ digitalRead(rechtslaufPin) ? myCounter[countIdx]++ : myCounter[countIdx]--; }
lastSensorState = sensorState;
display.clearDisplay();
display.setTextColor(WHITE); // Textfarbe ()
display.setCursor(5, 0); // erste Zahl von links rein, zweite Zahl von oben rein
display.setTextSize(2); // Textgröße
display.print("Test "); // Text wo auf Bildschirm steht
display.print(countIdx + 1);
display.setCursor(5, 16); // erste Zahl von links rein, zweite Zahl von oben rein
display.setTextSize(2); // Textgröße
display.println(myCounter[countIdx]); // Text wo auf Bildschirm steht
display.display();
}
}
void printAll()
{
display.clearDisplay();
display.setTextColor(WHITE); // Textfarbe ()
display.setCursor(5, 10); // erste Zahl von links rein, zweite Zahl von oben rein
display.setTextSize(2); // Textgröße
display.println(F("Data Data")); // Text wo auf Bildschirm steht
display.display();
display.startscrollleft(0x00, 0x0F);
delay(3000);
display.stopscroll();
for (byte b = 0; b < 10; b++)
{
Serial.print(myCounter[b]);
Serial.print(", ");
}
Serial.println();
}
void counterReset()
{
for (byte b = 0; b < 10; b++)
{ myCounter[b] = 0; }
countIdx = 0;
}Der compiliert, aber ist noch auszubauen bei den letzten beiden countIdx, da bin ich noch nicht fertig.
Aber zumindest siehst, wie weit das zu ändern geht....
1 Like
Vielen Dank schon einmal für die ganzen Hilfreichen Antworten.
Selber habe ich keine Ahnung von der ganzen Materie. Ich habe einfach an Hand den Beispielen wo es im Programm gibt versucht etwas funktionierendes zusammen zu bauen. Und nun versuche ich es dank eurer Hilfe zu verschönern und neues daraus zu lernen.
Wurde noch BLACK dazu nehmen, sonst ist schnell ein weißer Rechteck zu sehen.
display.setTextColor(WHITE, BLACK);
Dazu wurde die U8X8 nehmen als Lib für Display, ist nicht so aufgeblasen wie die Ada.
Ich hab kein display und mach das immer trocken 
also nur Logik. Design macht wer anders :-))
OK Gekauft 
1 Like
Vielen Dank schon einmal für die Vorlage.
Verstehe ich das richtig das ich allerdings einen zweiten Zähler brauche für den Reset Taster?
Und was ich nicht verstehe wie erkennt mein checkSensors welchen Zähler ich aktuell habe? Finde das als Laie irgend wie etwas unübersichtlicher. Würde es allerdings gerne verstehen.
Aem...
Nein.
Also nehmen wir das mal auseinander.
Du hast 10 Zähler.
Die sind versteckt in einem Array:
int myCounter[10] = {0};Da es sich um ein array handelt, muss dieses initialisiert werden - hier mit 0
Du hast eine Taste:
constexpr uint8_t counterPin {4}; // ResetDa ist die Beschreibung für das, was der Pin machen soll falsch.
Mit jedem auslösen des PIN
if (!digitalRead(counterPin))wird der eine Variable
uint8_t countIdx = 0;hochgezählt
Das ist jetzt nur etwas aufwändiger geworden.
- Ich frage den PIN ab.
- ist die Taste gedrückt, wird das gemerkt und der countIdx erhöht.,
- gleichzeitig wird der PIN gesperrt und die Auslösezeit gemerkt
- Ist die Taste nicht gedrückt und war sie vorher gedrückt (ist ja gemerkt) wird überprüft, ob die Tastenprellzeit abgelaufen ist -> und dann wir die Tastenfunktion wieder frei gegeben. Der "Timer" darin bildet Dein delay() ab, aber ohne den restlichen Code zu blockieren.
Du könntest jetzt an anderer Stelle noch LED's blinken lassen oder was auch immer.
Auch bist Du in Deinem Ausgangscode für die delay-Zeit blind für Ereignisse, die am
sensorState = digitalRead(sensorPin);passieren.
Soweit als das durchzählen der Counter.
Wenn Du alle 10 Counter bespielt hast:
if (countIdx < 11)
{ checkSensors(); }
else
{
printAll();
counterReset();
}wird mit dem 11ten auslösen des PIN die Ausgabe und der Reset der Counter angestossen.
void counterReset()
{
for (byte b = 0; b < 10; b++)
{ myCounter[b] = 0; }
countIdx = 0;
}erst zähle ich alle Counter durch und setze diese auf 0 und dann wird counterIdx auf 0 gesetzt, da ja sonst mit dem nächsten auslösen dieser auf 12 erhöht würde und damit in einer Endlosschleife das löschen der Counter erfolgen würde
Soweit klar?
Das Reseten könnte man auch mit memset machen.
void counterReset() {
memset(myCounter,0,sizeof(myCounter));
countIdx = 0;
}
Gruß Tommy
Ja, hab ich früher auch, aber um die Zählerei und das Verständnis für Arrays rüber zu bringen, ist das mit dem durchzählen "warum denn bei 0 anfangen ", oder "der zählt nur bis 9" eine Übungsaufgabe.
Ich sprech da aus Erfahrung.
Im Übrigen geht die Variante nur, wenn myCounter vom Typ her passt. Sonst gehört da noch ein sizeof(mycounter[0]) dazu
Nö, memset setzt die Bytes, d.h. sizeof( mycounter), also den Speicherplatz des Arrays.
Das Konstrukt sizeof( mycounter) / sizeof( mycounter[0]) ermittelt die Anzahl der Elemente im Array
Bei der Übung des Durchzählens des Arrays gebe ich Dir Recht, das ist hier didaktisch wohl angebracht.
Gruß Tommy