Hallo, ich bin relativ neu bei Arduino und brauche einen Code für einen an aus Schalter mithilfe eines Tasters :) Es wäre super wenn der Code so einfach wie möglich wäre, danke im Voraus ;)
Im englischen Teil des Forum müssen die Beiträge und Diskussionen in englischer Sprache verfasst werden. Deswegen wurde diese Diskussion in den deutschen Teil des Forums verschoben.
mfg ein Moderator.
Hallo,
reichen dir die Tipps in der IDE nicht aus ?
Da findest du sicher etwas einfaches.
Es kann so einfach sein:
Noch einfacher
Es ginge noch einfacher (ohne den externen Pull-Up-Widerstand), wenn man nach GND schaltet und INPUT_PULLUP verwendet. Die Logik des Tasters kehrt sich dann um:
constexpr byte buttonPin {2};
constexpr byte ledPin {13};
bool buttonState = 0;
void setup() {
pinMode(ledPin, OUTPUT);
pinMode(buttonPin, INPUT_PULLUP);
}
void loop() {
buttonState = digitalRead(buttonPin);
if (!buttonState) {
digitalWrite(ledPin, HIGH);
} else {
digitalWrite(ledPin, LOW);
}
}
Wirklich?
versuche hier mit
/* switch
Each time the input pin goes from LOW to HIGH (e.g. because of a push-button
press), the output pin is toggled from LOW to HIGH or HIGH to LOW. There's
a minimum delay between toggles to debounce the circuit (i.e. to ignore
noise).
David A. Mellis
21 November 2006
*/
int inPin = 8; // the number of the input pin
int outPin = 13; // the number of the output pin
int state = HIGH; // the current state of the output pin
int reading; // the current reading from the input pin
int previous = LOW; // the previous reading from the input pin
// the follow variables are long's because the time, measured in miliseconds,
// will quickly become a bigger number than can be stored in an int.
unsigned long time = 0; // the last time the output pin was toggled
unsigned long debounce = 200UL; // the debounce time, increase if the output flickers
void setup()
{
pinMode(inPin, INPUT);
pinMode(outPin, OUTPUT);
}
void loop()
{
reading = digitalRead(inPin);
// if the input just went from LOW and HIGH and we've waited long enough
// to ignore any noise on the circuit, toggle the output pin and remember
// the time
if (reading == HIGH && previous == LOW && millis() - time > debounce)
{
if (state == HIGH)
state = LOW;
else
state = HIGH;
time = millis();
}
digitalWrite(outPin, state);
previous = reading;
}
Aber ist das nicht "Taster als Taster" statt "Taster als Schalter"?
Dann käme nämlich noch zusätzlich eine Abfrage rein:
constexpr byte buttonPin {2};
constexpr byte ledPin {13};
bool buttonState = 0;
bool lastbuttonState = 0;
bool ledState = 0;
void setup() {
pinMode(ledPin, OUTPUT);
pinMode(buttonPin, INPUT_PULLUP);
}
void loop() {
buttonState = digitalRead(buttonPin); // aktuellen buttonPin-Status auslesen
if ((buttonState == LOW) && (lastbuttonState == HIGH)) { // Tastendruck detektiert (vorher nicht gedrückt, jetzt gedrückt)
ledState = !ledState; // led-Status umschalten: AN <=> AUS
digitalWrite(ledPin, ledState);
}
lastbuttonState = buttonState; // buttonPin-Status für nächsten Durchlauf aktualisieren
}
..danach sollte man bestimmt noch den Taster entprellen, aber soll ja erstmal so einfach wie möglich sein 
EDIT: Ah.. hat @fony bereits schon alles umgesetzt 
Deshalb habe meins gelöscht.
Ich mache es gerne so. Da hat man entweder mit jedem Tastendruck ein oder aus, oder wenn man auf der Taste bleibt, hat man einen Wechel ein/aus alle 300ms. Ja, kann man kürzer fassen, aber den Code versteht man auch als Anfänger gut. Der ist für zwei Taster.
Im Serial Monitor sieht du was es macht.
// Baudrate fuer Serial Schnittstelle
const int baudSerial = 9600;
//-----------------------Taster01----------------------------------------
// const byte ist im Programm Constant und byte ist fuer Werte 0-255
const byte Taster01 = 15; // Pin 15 wird Constant als Taster01 bezeichnet
byte Tasterstatus01 = 0; // Zum Abfragen des Tatsenpins
byte Tastenmerker01 = 0; // Zum Merken des aktuellen Tatsenstatus
unsigned long Sekundenablauf01 = 0; // Tastenabfrage von Taster02 300ms aussetzen
const unsigned long Pausezeit01 = 300;
//-----------------------Taster02---------------------------------------
const byte Taster02 = 16; // Pin16 wird Constant als Taster02 bezeichnet
byte Tasterstatus02 = 0;
byte Tastenmerker02 = 0;
unsigned long Sekundenablauf02 = 0; // Tastenabfrage von Taster02 300ms aussetzen
const unsigned long Pausezeit02 = 300;
unsigned long milliablauf = 0;
//===============================================================================================
//===================================== SETUP ===============================================
//===============================================================================================
void setup() {
// Serial Schnittstelle starten
Serial.begin(baudSerial);
//-----------Taster einrichten----------------------------------------
// Pin 15 fuer Taster01 wird intern auf plus gelegt. Mit GND ueber Taste aktivieren
pinMode(Taster01, INPUT_PULLUP);
// Pin 16 fuer Taster02 wird intern auf plus gelegt. Mit GND ueber Taste aktivieren
pinMode(Taster02, INPUT_PULLUP);
//--------------------------------------------------------------------
}
//===============================================================================================
//================================ LOOP ==================================================
//===============================================================================================
void loop() {
milliablauf = millis();
//-----------Taster01 abfragen--------------------------------------------
if (milliablauf - Sekundenablauf01 >= Pausezeit01) { // 200msec abgelaufen?
Tasterstatus01 = digitalRead(Taster01); // Pin von Taster01 abfragen
if (Tasterstatus01 == LOW) { // Ist Taster01 gedrueckt?
Tastenmerker01 = !Tastenmerker01; // Merken dass Taster01 gedrueckt wurde
Serial.print("Taste 1 ");
Serial.println(Tastenmerker01);
Sekundenablauf01 = milliablauf; // Die 300ms neu starten
}
}
//-----------Taster02 abfragen--------------------------------------------
if (milliablauf - Sekundenablauf02 >= Pausezeit02) { // 200msec abgelaufen?
Tasterstatus02 = digitalRead(Taster02); // Pin von Taster02 abfragen
if (Tasterstatus02 == LOW) { // Ist Taster02 gedrueckt?
Tastenmerker02 = !Tastenmerker02; // Merken dass Taster02 gedrueckt wurde
Serial.print("Taste 2 ");
Serial.println(Tastenmerker02);
Sekundenablauf02 = milliablauf; // Die 300ms neu starten
}
}
}
//=======================Loop Ende=============================================================
// Forensketch
// https://forum.arduino.cc/
const uint8_t pin {2};
const uint32_t debounceTime = 50;
uint32_t pressTime;
bool pressState = HIGH;
bool switchState = LOW;
void setup()
{
Serial.begin(115200);
Serial.println(F("\r\nStart...\r\n"));
pinMode(pin, INPUT_PULLUP);
pinMode(LED_BUILTIN, OUTPUT);
}
void loop()
{
checkBtn();
digitalWrite(LED_BUILTIN, switchState);
}
void checkBtn()
{
if (digitalRead(pin) == LOW) // Taste gedrückt?
{
if (pressState == HIGH) // war vorher nicht gedrückt
{
pressTime = millis(); // Merken wann Taste ausgelöst wurde
pressState = LOW; // Merken dass Taste gedrückt
switchState = !switchState; // Neuen Status setzen
}
}
else if (pressState == LOW) // Taste nicht gedrückt und vorher gedrückt
{
if (millis() - pressTime > debounceTime) // debounce abgelaufen
{
pressState = HIGH; // Merker löschen
}
}
}
etwas nicht ganz so einfach, aber skalierbarer:
// Forensketch
// https://forum.arduino.cc/
#include <Streaming.h> // https://github.com/janelia-arduino/Streaming
constexpr uint8_t buttonPin {2};
constexpr bool AUS {LOW};
constexpr bool isPressed {LOW};
struct BTN
{
const uint8_t pin;
const uint32_t debounceTime;
uint32_t pressTime;
bool pressState;
bool state;
};
BTN btn {buttonPin, 50, 0, AUS, !isPressed};
void setup()
{
Serial.begin(115200);
Serial << (F("\r\nStart...\r\n")) << endl;
pinMode(btn.pin, INPUT_PULLUP);
pinMode(LED_BUILTIN, OUTPUT);
}
void loop()
{
checkBtn();
digitalWrite(LED_BUILTIN, btn.state);
}
void checkBtn()
{
if (digitalRead(btn.pin) == isPressed) // Taste gedrückt?
{
if (btn.pressState == !isPressed) // war vorher nicht gedrückt
{
btn.pressTime = millis(); // Merken wann Taste ausgelöst wurde
btn.pressState = isPressed; // Merken dass Taste gedrückt
btn.state = !btn.state; // Neuen Status setzen
}
}
else if (btn.pressState == isPressed) // Taste nicht gedrückt und vorher gedrückt
{
if (millis() - btn.pressTime > btn.debounceTime) // debounce abgelaufen
{
btn.pressState = !isPressed; // Merker löschen
}
}
}
Da Du nicht schreibst für welchen Controller, gibt es eine Kontrolle über die ONBoard-LED, soweit der Controller eine hat...
Ja, das stimmt. Habe "Schalter" überlesen.
Habe es jetzt mal noch um die Relaisausgänge zum Schalten erweitert.
// Baudrate fuer Serial Schnittstelle
const int baudSerial = 9600;
//-----------------------Taster01----------------------------------------
// const byte ist im Programm Constant und byte ist fuer Werte 0-255
const byte Taster01 = 15; // Pin 15 wird Constant als Taster01 bezeichnet
byte Tasterstatus01 = 0; // Zum Abfragen des Tatsenpins
byte Tastenmerker01 = 0; // Zum Merken des aktuellen Tatsenstatus
unsigned long Sekundenablauf01 = 0; // Tastenabfrage von Taster01 300ms aussetzen
const unsigned long Pausezeit01 = 300;
//-----------------------Taster02---------------------------------------
const byte Taster02 = 16; // Pin16 wird Constant als Taster02 bezeichnet
byte Tasterstatus02 = 0;
byte Tastenmerker02 = 0;
unsigned long Sekundenablauf02 = 0; // Tastenabfrage von Taster02 300ms aussetzen
const unsigned long Pausezeit02 = 300;
//-------------------------------------------------------------------------
unsigned long milliablauf = 0;
//-----------------------AusgangPIN 25-------------------------------------
const byte Ausgang01 = 25; // Pin 25 ist für das Relais01
byte Ausgangsstatus01 = 0;
//-----------------------AusgangPIN 26-------------------------------------
const byte Ausgang02 = 26; // Pin 26 ist für das Relais02
byte Ausgangsstatus02 = 0;
//=============================================================================
//===================================== SETUP =============================
//=============================================================================
void setup() {
// Serial Schnittstelle starten
Serial.begin(baudSerial);
//-----------Taster einrichten----------------------------------------
// Pin 15 fuer Taster01 wird intern auf plus gelegt. Mit GND ueber Taste aktivieren
pinMode(Taster01, INPUT_PULLUP);
// Pin 16 fuer Taster02 wird intern auf plus gelegt. Mit GND ueber Taste aktivieren
pinMode(Taster02, INPUT_PULLUP);
//-----------Relaisausgänge einrichten---------------------------------
Ausgangsstatus01 = 1; // Status auf HIGH
digitalWrite (Ausgang01, Ausgangsstatus01); // Dass Relaisausgang beim Start "aus" ist
pinMode(Ausgang01, OUTPUT); // Pin 25 (Ausgang01) ist als Ausgang aktiviert
Ausgangsstatus02 = 1; // Status auf HIGH
digitalWrite (Ausgang02, Ausgangsstatus02); // Dass Relaisausgang beim Start "aus" ist
pinMode(Ausgang02, OUTPUT); // Pin 26 (Ausgang02) ist als Ausgang aktiviert
}
//============================================================================
//================================ LOOP ===============================
//============================================================================
void loop() {
milliablauf = millis();
//-----------Taster01 abfragen--------------------------------------------
if (milliablauf - Sekundenablauf01 >= Pausezeit01) { // 200msec abgelaufen?
Tasterstatus01 = digitalRead(Taster01); // Pin von Taster01 abfragen
if (Tasterstatus01 == LOW) { // Ist Taster01 gedrueckt?
Tastenmerker01 = !Tastenmerker01; // Merken dass Taster01 gedrueckt wurde
Serial.print(F("Taste 1 "));
Serial.println(Tastenmerker01);
Sekundenablauf01 = milliablauf; // Die 300ms neu starten
}
}
//-----------Taster02 abfragen--------------------------------------------
if (milliablauf - Sekundenablauf02 >= Pausezeit02) { // 200msec abgelaufen?
Tasterstatus02 = digitalRead(Taster02); // Pin von Taster02 abfragen
if (Tasterstatus02 == LOW) { // Ist Taster02 gedrueckt?
Tastenmerker02 = !Tastenmerker02; // Merken dass Taster02 gedrueckt wurde
Serial.print(F("Taste 2 "));
Serial.println(Tastenmerker02);
Sekundenablauf02 = milliablauf; // Die 300ms neu starten
}
}
//----------- Ausgänge nach Schalterstellung schalten --------------------
Ausgangsstatus01 = !Tastenmerker01; Signal umkehren, da die Relais LowAktiv sind
digitalWrite (Ausgang01, Ausgangsstatus01); Signal ausgeben zum Relais
Ausgangsstatus02 = !Tastenmerker02;
digitalWrite (Ausgang02, Ausgangsstatus02);
}
//=======================Loop Ende============================================
es wäre für uns wesentlich leichter wenn du beschreiben würdest, was du aktuell an Code hast und was du gern anders haben möchtest.
Z.B. gibts in der Arduino IDE ein fix und fertiges Beispiel -
Debounce on a Pushbutton | Arduino Documentation
Hast du das ausprobiert? - wenn nicht nachholen!
Was hast du festgestellt?
Was soll anders sein?
Ein einfaches Programm - Taster als Schalter:
#include "Button_SL.hpp"
class Switch {
public:
Switch(uint8_t pin) : pin {pin} {}
void begin() { pinMode(pin, OUTPUT); }
uint8_t toggle() {
isOn = !digitalRead(pin);
digitalWrite(pin, isOn);
return isOn;
}
private:
const uint8_t pin;
uint8_t isOn;
};
Btn::ButtonSL btn {4};
Switch mySwitch {5};
void printSwitchState(uint8_t value) {
const char* strSwitchState[] {"Aus", "Ein"};
Serial.print(F("Schalter "));
Serial.println(strSwitchState[(value > 0)]); // Falls value >= 1 ist, den Wert auf = 1 setzen.
}
void setup() {
Serial.begin(115200);
btn.begin();
mySwitch.begin();
printSwitchState(false);
}
void loop() {
if (btn.tick() != Btn::ButtonState::notPressed) { printSwitchState(mySwitch.toggle()); }
}
Na ja, ob das so einfach für ein Anfänger ist, dazu muss man noch suchen die button_sl.hpp.
Und verstehen was das ganze soll.
Die gibt es als Arduino Bibliothek. Also warum das ganze Debounce wieder neu programmieren? Wenn jemand die Moba Tools für nen Servo nimmt, wird das ja auch nicht als zu „kompliziert“ deklariert. Deren Button Routinen könnten natürlich auch verwendet werden oder eine von den X anderen Button Bibliotheken.
Und für einen einfachen Schalter muss man nicht mehr wissen als in dem Programm zu sehen ist.
also ich bin davon überzeugt, dass wenn die Anforderung "kurz" sein soll, man besser mit einer Library das ganze probiert.
- Eine LED, ein Button,
- im Setup je ein .begin() aufrufen,
- im loop die LED umschalten wenn der Button gedrückt wurde.
/*
debounce a button
toggle a LED
by noiasca
2025-12-05
*/
#include <Noiasca_led.h> // download library from http://werner.rothschopf.net/microcontroller/202202_tools_led_en.htm
#include <utility/Noiasca_discrete.h> // use the discrete pins on the Arduino/Microcontroller
#include <Noiasca_button.h> // download library from http://werner.rothschopf.net/microcontroller/202202_tools_led_en.htm
OnOffPin led{13}; // create simple on/off pin object
Button button {A0}; // active LOW: button connects pin with GND
void setup() {
led.begin(); // start the pin
button.begin(); // start the button
}
void loop() {
if (button.wasPressed()) { // fire if button was pressed
led.toggle();
}
}
//in einer Zeile machts dann combie mit seinen Tools.
Natürlich!
Dafür wurden sie erfunden.
Wie auch ein Hammer seinen Job macht, wenn er richtig angewendet wird.
Ob @suessenwtmaus nochmal wiederkommt?
Hier habe ich mal noch einen Tastenpiep dazu gehängt. Dass die Umschaltung mit Ton bestätigt wird.
/*
##################################
Taster als Schalter benutzen
vom 06.12.2025
##################################
*/
// Baudrate fuer Serial Schnittstelle
const int baudSerial = 9600;
//-----------------------Taster01-----------------------------------------------
// const byte ist im Programm Constant und byte ist fuer Werte 0-255
const byte Taster01 = 15; // Pin 15 wird Constant als Taster01 bezeichnet
byte Tasterstatus01 = 0; // Zum Abfragen des Tatsenpins
byte Tastenmerker01 = 0; // Zum Merken des aktuellen Tatsenstatus
unsigned long Sekundenablauf01 = 0; // Tastenabfrage von Taster01 300ms aussetzen
const unsigned long Pausezeit01 = 300;
//-----------------------Taster02----------------------------------------------
const byte Taster02 = 16; // Pin16 wird Constant als Taster02 bezeichnet
byte Tasterstatus02 = 0;
byte Tastenmerker02 = 0;
unsigned long Sekundenablauf02 = 0; // Tastenabfrage von Taster02 300ms aussetzen
const unsigned long Pausezeit02 = 300;
//-----------------------------------------------------------------------------
unsigned long milliablauf = 0;
//-----------------------AusgangPIN 25-----------------------------------------
const byte Ausgang01 = 25; // Pin 25 ist für das Relais01
byte Ausgangsstatus01 = 1; //Auf 1 wenn eine LOW Aktive Relaisplatine gesteuert wird
//-----------------------AusgangPIN 26-----------------------------------------
const byte Ausgang02 = 26; // Pin 26 ist für das Relais02
byte Ausgangsstatus02 = 1; //Auf 1 wenn eine LOW Aktive Relaisplatine gesteuert wird
//----------------------Tasten Ton einrichten----------------------------------
const byte Tonpin = 7;
int Tonfrequenz = 800;
int Zeit = 100;
//=============================================================================
//===================================== SETUP =============================
//=============================================================================
void setup() {
// Serial Schnittstelle starten
Serial.begin(baudSerial);
//-----------Taster einrichten-----------------------------------------------
// Pin 15 fuer Taster01 wird intern auf plus gelegt. Mit GND ueber Taste aktivieren
pinMode(Taster01, INPUT_PULLUP);
// Pin 16 fuer Taster02 wird intern auf plus gelegt. Mit GND ueber Taste aktivieren
pinMode(Taster02, INPUT_PULLUP);
//-----------Relaisausgänge einrichten---------------------------------------
Ausgangsstatus01 = 1; // Status auf HIGH
digitalWrite (Ausgang01, Ausgangsstatus01); // Dass Relaisausgang beim Start "aus" ist
pinMode(Ausgang01, OUTPUT); // Pin 25 (Ausgang01) ist als Ausgang aktiviert
Ausgangsstatus02 = 1; // Status auf HIGH
digitalWrite (Ausgang02, Ausgangsstatus02); // Dass Relaisausgang beim Start "aus" ist
pinMode(Ausgang02, OUTPUT); // Pin 26 (Ausgang02) ist als Ausgang aktiviert
}
//============================================================================
//================================ LOOP ===============================
//============================================================================
void loop() {
milliablauf = millis();
//-----------Taster01 abfragen----------------------------------------------
if (milliablauf - Sekundenablauf01 >= Pausezeit01) { // 200msec abgelaufen?
Tasterstatus01 = digitalRead(Taster01); // Pin von Taster01 abfragen
if (Tasterstatus01 == LOW) { // Ist Taster01 gedrueckt?
Tastenmerker01 = !Tastenmerker01; // Merken dass Taster01 gedrueckt wurde
Serial.print(F("Taste 1 "));
Serial.println(Tastenmerker01);
tone(Tonpin, Tonfrequenz, Zeit); // Kurzer Bestätigungspiep bei tastendruck
Sekundenablauf01 = milliablauf; // Die 300ms neu starten
}
}
//-----------Taster02 abfragen----------------------------------------------
if (milliablauf - Sekundenablauf02 >= Pausezeit02) { // 200msec abgelaufen?
Tasterstatus02 = digitalRead(Taster02); // Pin von Taster02 abfragen
if (Tasterstatus02 == LOW) { // Ist Taster02 gedrueckt?
Tastenmerker02 = !Tastenmerker02; // Merken dass Taster02 gedrueckt wurde
Serial.print(F("Taste 2 "));
Serial.println(Tastenmerker02);
tone(Tonpin, Tonfrequenz, Zeit); // Kurzer Bestätigungspiep bei tastendruck
Sekundenablauf02 = milliablauf; // Die 300ms neu starten
}
}
//----------- Ausgänge nach Schalterstellung schalten ----------------------
Ausgangsstatus01 = !Tastenmerker01; //Signal umkehren, da die Relais LowAktiv sind
digitalWrite (Ausgang01, Ausgangsstatus01); //Signal ausgeben zum Relais
Ausgangsstatus02 = !Tastenmerker02;
digitalWrite (Ausgang02, Ausgangsstatus02);
}
//=======================Loop Ende============================================