Rennsimulator Button Box HILFE!!!

Hallo liebes Arduino Forum,

ich benötige zur Verwirklichung eines Projektes euer Hilfe. Das Projekt einer ButtonBox mit blinkenden Led Tastern lässt mich mit dem Thema Arduino kollidieren.

Ich habe in meiner Box 6x Taster jeweils mit Led bestückt verbaut die, wenn ich die Box einschalte permanent leuchten sollen und wenn ich den jeweiligen Taster drücke soll die Led dieses Tasters blinken damit ich sehe das diese taste aktiviert ist.Blinkabstand und Geschwindigkeit ist an der Stelle ersteinmal egal.Ich will mir auf 6 unabhängige Led/Taster jeweils nur den Statuszustand (An/Aus) über die Led anzeigen lassen.Die taster sind jeweils mit einem Gamepad-Board (+/-) verbunden um der PC Software (Project cars) zusagen das ich z.B den Scheibenwischer anmachen will.Das heißt ich muss über den Taster dem Arduino ein Impuls geben um die Led anders anzusteuern und dass für 6 unabhängige Led´s.Ist das machbar?Würdet Ihr mir so einen Programmiercode zum programmieren bereitstellen.mfg

euer Niko030

Hallo,

willst du was lernen oder einfach nur haben wollen ....

Ehrlich gesagt... für dieses Projekt ersteinmal nur haben wollen da ich grad voll im Simulatorbau stecke.Aber grundsätzlich finde ich das Thema echt interessant.Nicht zuletzt da ich auch Modellbauer bin und mit dem Arduino ganz neue,für mich noch ungeahnte, Möglichkeiten habe. Gruss Niko030

niko030:
Ehrlich gesagt… für dieses Projekt ersteinmal nur haben wollen…

Dann träum weiter… :wink:

Also wenn du dir die Beispiele "Blink Without Delay" und "Button" kurz anschaust, brauchst du diese nur zusammen zu bringen und dann mal 6.

Hallo,

na wenigstens biste ehrlich. Alles schreiben werde ich dir oder andere sicherlich nicht. Aber das du vorwärts kommst gebe ich dir ein Bsp. wie man es machen könnte. Ob du da durchblickst weis ich allerdings nicht. 2 weitere Taster/Blink LEDs sind schon vorbereitet, damit du siehst wo die Reise hingeht. Die Blinker Funktion müßte man auch 6x schreiben oder man lagert die als Klasse aus oder wie das heißt. Dann würde die 6x mal erstellt im Speicher steht aber nur einmal im Code.

LED 13 ist nur Kontroll LED zum Lernzweck, wechselt mit jeden Tastendruck. Die andere LED blinkt dann entsprechend.
Das ganze beruht auf dem “change” Bsp. der Bounce2 Library, die müßtest du dir installieren.
Erweitert um den LED Blinker.
Jetzt mußte dich einarbeiten und verstehen lernen. Vielleicht ist der ein oder andere Variablenname verwirrend, weil so vom Bsp. übernommen und nicht mehr ganz so passend, aber da mußte jetzt durch. Anders gehts nicht …

Den Taster einfach mit einer Seite auf Masse legen, die andere Seite zum Pin 2.
Der Code nutzt den internen Pullup und detektiert auf LOW Pegel.

// Detect the falling edge

// Include the Bounce2 library found here :
// https://github.com/thomasfredericks/Bounce-Arduino-Wiring
#include <Bounce2.h>


const byte BUTTON_PIN = 2;
const byte LED_PIN = 13;      // Taster Kontrolle
const byte Blink_LED_Pin = 7;
byte ledState = LOW;
//byte ledState2 = LOW;
//byte ledState3 = LOW;

unsigned long lastTime;
unsigned long on_time  = 200;  // ms
unsigned long off_time = 800;  // ms
bool state_Blink_LED;

// Instantiate a Bounce object :
Bounce debouncer = Bounce(); 
//Bounce debouncer2 = Bounce(); 
//Bounce debouncer3 = Bounce(); 

void setup() {
  
  // Setup the button with an internal pull-up :
  pinMode(BUTTON_PIN,INPUT_PULLUP);
  
  // After setting up the button, setup the Bounce instance :
  debouncer.attach(BUTTON_PIN);
  debouncer.interval(30);
  //debouncer2.attach(BUTTON_PIN2);
  //debouncer2.interval(30);
  //debouncer3.attach(BUTTON_PIN3);
  //debouncer3.interval(30);
  
  // Setup the LED :
  pinMode(LED_PIN,OUTPUT);
  digitalWrite(LED_PIN,ledState);
  
  pinMode(Blink_LED_Pin,OUTPUT);
  digitalWrite(Blink_LED_Pin, state_Blink_LED);
 
  
}

void loop() {

  
   debouncer.update();  // Update the Bounce instance
   //debouncer2.update();  // Update the Bounce instance
   //debouncer3.update();  // Update the Bounce instance
   
   // Call code if Bounce fell (transition from HIGH to LOW) :
   if ( debouncer.fell() ) {
     ledState = !ledState;       // Toggle LED state 
     digitalWrite(LED_PIN,ledState); 
   }

   /*
   if ( debouncer2.fell() ) {
     ledState2 = !ledState2;       // Toggle LED-2 state 
     digitalWrite(LED_PIN2,ledState2); 
   }
   if ( debouncer3.fell() ) {
     ledState3 = !ledState3;       // Toggle LED-3 state 
     digitalWrite(LED_PIN3,ledState3); 
   }
   */
   
   if (ledState == true)  {
     Blinker(); 
   }
   else  {
     digitalWrite(Blink_LED_Pin, LOW);     // LED sofort ausschalten
   }
   
}  // Ende loop


// ************ Funktionen ************ //
void Blinker ()
{
  if (state_Blink_LED == LOW && millis() - lastTime > off_time ) {
    digitalWrite(Blink_LED_Pin, HIGH);       // LED einschalten für x ms
    lastTime = millis();             
    state_Blink_LED = HIGH;
  }

  if (state_Blink_LED == HIGH && millis() - lastTime > on_time ) {
    digitalWrite(Blink_LED_Pin, LOW);         // LED ausschalten für x ms
    lastTime = millis();  
    state_Blink_LED = LOW;
  }
}

Ich finde das Beispiel ganz interessant zum üben.
Ich hatte jetzt aber nur 4 Taster zur Hand zum testen. Mein Programm kann aber auch auf mehr Taster ausgebaut werden (wobei irgendwann die Ports ausgehen).
Ich wollte mal die Entprellung von Hand machen (ganz ohne Library) und natürlich durfte kein Delay vorkommen. Und damit das kein ewig langes Programm mit immer dem gleichen Code wird, mussten Arrays her. :slight_smile:

Lange Rede, kurzer Code:

byte Btn_Pin[] = {2, 3, 4, 5};                    // Array mit der Pinbelegung fuer die Taster
byte Led_Pin[] = {6, 7, 8, 9};                    // Array mit der Pinbelegung fuer die LEDs
uint32_t Btn_Debounce[4] = {0, 0, 0, 0};          // Array zum speichern der einzelnen Entprellzeiten
byte DebounceTime = 50;                           // Zeit zum entprellen der Taster (in Millisekunden)
bool Btn_State[] = {HIGH, HIGH, HIGH, HIGH};      // Array fuer den Buttonstatus: HIGH = nicht gedrueckt (wegen INPUT_PULLUP)
bool Blk_OnOff[] = {false, false, false, false};  // Array fuer den Blinkstatus: ja/nein
bool LED_State[] = {HIGH, HIGH, HIGH, HIGH};      // Array fuer den LED-Zustand: an/aus
uint32_t LED_BlkTime = 0;                         // Variable zum speichern der Blinkzeit
bool BlkState = HIGH;                             // Variable zum speichern des Blinkstatus
byte BlkInterval = 250;                           // Blink-Intervall (in Millisekunden)

void setup() {
  for (int i = 0; i < 4; i++) {
    pinMode(Led_Pin[i], OUTPUT);                  // LED-Pin auf Ausgang schalten
    digitalWrite(Led_Pin[i], LED_State[i]);       // die LEDs einschalten
    pinMode(Btn_Pin[i], INPUT_PULLUP);            // Taster-Pin auf Eingang schalten (mit internen PULLUP)
  }
}

void loop() {
  if (millis() - LED_BlkTime > BlkInterval) {
    BlkState = !BlkState;
    LED_BlkTime = millis();
  }
  
  for (int i = 0; i < 4; i++) {
    if (digitalRead(Btn_Pin[i]) == LOW) {
      Btn_Debounce[i] = millis();
      Btn_State[i] = LOW;
    }
    if (!Btn_State[i] && millis() - Btn_Debounce[i] > DebounceTime) {
      Blk_OnOff[i] = !Blk_OnOff[i];
      Btn_State[i] = HIGH;
    }
    LED_State[i] = (Blk_OnOff[i] ? BlkState : HIGH);
    digitalWrite(Led_Pin[i], LED_State[i]);
  }
}

Ersteinmal Danke für eure Hilfestellung.

Hätte nicht gedacht dass es so kompliziert (als unwissender) ist. Werde mir aber den UNO R3 328 ATMEGA328P bestellen und es mit dem Lernbeispiel versuchen. Entweder ich verstehe es oder es klappt halt nicht.

Danke Niko030

Das ist genau die richtige Vorgehensweise! Probier einfach mal und melde wenn Fragen oder Probleme aufkommen, dann ist die Hilfestellung auch konkreter wenn die Fragen nicht mehr so allgemein sind.

Gruß

Für deine Anwendung könnte ein Leonardo geschickter sein. Er kann im Gegensatz zu den Arduinos mit 328 als USB-HID vom PC erkannt werden. Das heißt er kann eine Tastatur, Maus, Joystick emulieren und dadurch ohne spezielle Treiber PC-Eingaben machen. Auf der anderen Seite hat der Leonardo einigen Tücken und Inkompatibilitäten zum Uno, so dass er nicht so einsteigerfreundlich ist. Willst du wirklich einsteigen, dann ein Uno zum lernen und ein Leonardo für die Box. Aus China kosten Leonardos kaum 5Euro.

Die Pro Micros (Leonardos im wie die Nanos) aus China sind auch günstig, 3,41€ aufwärts.

Die Suche nach atmega32u4 auf ebay oder aliexpress ist durchaus interessant.

Also ein Platzproblem bekommt er in der Box sicher nicht.. :)

Ich finde das Uno Standard Format schwer ohne Shield anzuschließen, mit sind die ziemlich dick.

Die Nanos kann man einfach auf eine Platine löten, oder auf so einen günstigen Schraubadapter stecken.

Nano Terminal Adapter 0,72 €

Da geb ich dir recht, aber ansonsten gibt es das meiste Zubehör immernoch für den Uno. Der Adapter lächelt mich aber auch gerade an :)

Die unmontierten Einzelteile lassen sich auch prima in anderen Projekten verbauen, die Schraubterminals sind wie üblich anreihbar und als Einzelteile für den Preis (hier) nicht zu bekommen.

Ja oder ich montiere sie nur dort wo ich sie auch brauche, für das Geld unschlagbar