INFO: Dieses Forum nutzt Cookies...
Cookies sind für den Betrieb des Forums unverzichtbar. Mit der Nutzung des Forums erklärst Du dich damit einverstanden, dass wir Cookies verwenden.

Es wird in jedem Fall ein Cookie gesetzt um diesen Hinweis nicht mehr zu erhalten. Desweiteren setzen wir Google Adsense und Google Analytics ein.

Antwort schreiben 
 
Themabewertung:
  • 0 Bewertungen - 0 im Durchschnitt
  • 1
  • 2
  • 3
  • 4
  • 5
Arduino am Motorrad (Blinker uvm...)
26.10.2015, 19:39
Beitrag #1
Arduino am Motorrad (Blinker uvm...)
Hallo liebe Gemeinde,

Ich hab mein Projekt schon fälschlicherweise in einen anderem Threat vorgestellt.

Zur Vorgeschichte:
Ich heiße Dirk, bin Mitte 30 und staatl. gepr. Maschinenbautechniker.
Ich bin sehr Technik-affin und habe grundlegenste Kenntnisse von Elektrik.
Bei Elektronik hört es nach LEDs auf. Von Programmieren brauchen wir leider garnicht erst sprechen...

Ich bin vor ca. 2,5 Jahren auf den Arduino gestoßen und hab mir vor 2 Jahren einen zum Geburtstag schenken lassen.
Leider bin ich kein guter Autodidakt. Ich bleibe (egal im welchen Bereich) immer an Fehlern hängen. Wenn ich etwas vorgemacht bekomme, dann bin ich wiederum sehr Lernfähig... wie auch immer...


Mein Projekt:

Ich lebe fürs Motorrad fahren und schraube daran auch gerne herum.
Mein Motorrad ist zur Zeit dem Thema "amerikanische Polizei" gewidmet.
Diesen Winter möchte/muss ich das Projekt fertig stellen.

Je nach Aufwand möchte ich über den Arduino ansteuern-
-die Blinker des Motorrads
-"Balulicht" realisieren (blinken/flashen in blau und rot [für Show & Events])
-eine Warnblinkanlage realisieren
-Garagentüröffner
-Zündschloss als RFiD
-vorhandenen elektronischen Kettenöler impelmentieren (RehOiler)
-... und mir fällt bestimmt noch mehr ein

Die Relevanz der einzelnen Funktionen ist absteigend aufgeführt.

Wie erwähnt, mein größtes Problem wird sein das ich das Wissen nicht hab und mich schwer tue über Bücher zu lernen. Einzelne Tutorials verstehe ich, aber das zusammenfügen von verschiedenen Funktionen stell für mich ein Problem dar.
Ich vermute das ein weiteres riesiges Problem ist, das ich nie genau weiss, wofür wann welche Klammern gesetzte werden.. Das bringt mich immer gehörig durcheinander.

Meistens tüftel ich bei https://123d.circuits.io/ herum, da ich das überall nutzen kann, wo ich Internet habe. Ich brauch nicht zwingend die Hardware zum testen.


https://123d.circuits.io/circuits/114007...e-function

Das ist mein momentaner Aufbau. Dort habe ic allerdings 2 Schalter für die Blinkfunktion genutzt, da es einen entsprechenden Schalter nicht gab.
Zur Erklärung: der klassische Schalter für einen Motorradblinker hat eine Rastfunktion in rechter und linker Stellung (blinken in die entprechnde Richtugn) und einer Druckfunktion mit der die Rastfunktion wieder gelöscht wird.
Bei meinen Aufbau muss ich das halt noch manuell löschen.

Der Code lautet:
Code:
/* Multiple independent delay - Two blinking LEDs

Working code example that blinks two LEDs, each with its own independent period.
This extends the BlinkWithoutDelay example of a single LED, showing how to
implement multiple independent timing paths in the main loop.

Written by several forum members. In public domain.  Oct 2011.

Note: works even when millis () wraps around to zero after approximately 50 days.
*/

// Which pins are connected to which LED
const byte redLEFT = 13 ;
const byte blueLEFT = 12 ;
const byte greenLEFT = 11 ;

const byte redRIGHT = 7 ;
const byte blueRIGHT = 6 ;
const byte greenRIGHT = 5 ;

const int buttonLEFT = 10 ;
const int buttonRIGHT = 4 ;

// Time periods of blinks in milliseconds (1000 milliseconds to a second).
// Time variable and constants are always unsigned long
const unsigned long redLEFTinterval = 600UL ;
const unsigned long blueLEFTinterval = 600UL ;
const unsigned long greenLEFTinterval = 600UL ;

const unsigned long redRIGHTinterval = 600UL ;
const unsigned long blueRIGHTinterval = 600UL ;
const unsigned long greenRIGHTinterval = 600UL ;

// Variable holding the timer value so far. One for each "Timer"
unsigned long redLEFTtimer = 0 ;
unsigned long blueLEFTtimer = 0 ;
unsigned long greenLEFTtimer = 0 ;

unsigned long redRIGHTtimer = 0 ;
unsigned long blueRIGHTtimer = 0 ;
unsigned long greenRIGHTtimer = 0 ;

// Variable to know what the current LED state is
int redLEFTState = LOW ;
int blueLEFTState = LOW ;
int greenLEFTState = LOW ;

int redRIGHTState = LOW ;
int blueRIGHTState = LOW ;
int greenRIGHTState = LOW ;

int stateLEFT = 0;
int stateRIGHT = 0;

void setup()
{
pinMode (redLEFT,OUTPUT) ;
pinMode (blueLEFT,OUTPUT) ;
pinMode (greenLEFT,OUTPUT) ;

pinMode (redRIGHT,OUTPUT) ;
pinMode (blueRIGHT,OUTPUT) ;
pinMode (greenRIGHT,OUTPUT) ;
  
redLEFTtimer = millis () ;
blueLEFTtimer = millis () ;
greenLEFTtimer = millis () ;

redRIGHTtimer = millis () ;
blueRIGHTtimer = millis () ;
greenRIGHTtimer = millis () ;  
  
pinMode (buttonLEFT, INPUT) ;
pinMode (buttonRIGHT, INPUT) ;
}
//################################################################################​####
void loop() {
  
    // read the state of the pushbutton value:
  stateLEFT = digitalRead(buttonLEFT);
  // check if the pushbutton is pressed.
  // if it is, the buttonState is HIGH:
  { if (stateLEFT == HIGH) {
    // turn LED on:
    // Handling the blink of one LED.
// First, check if it is time to change state
if ( (millis () - greenLEFTtimer) >= greenLEFTinterval ) {
   // It is time to change state. Calculate next state.
   if (greenLEFTState == LOW)
     greenLEFTState = HIGH ;
   else
     greenLEFTState = LOW ;
   // Write new state
   digitalWrite (greenLEFT, greenLEFTState ) ;
   // Reset timer
   greenLEFTtimer = millis () ;
}
if ( (millis () - redLEFTtimer) >= redLEFTinterval ) {
   // It is time to change state. Calculate next state.
   if (redLEFTState == LOW)
     redLEFTState = HIGH ;
   else
     redLEFTState = LOW ;
   // Write new state
   digitalWrite (redLEFT, redLEFTState ) ;
   // Reset timer
   redLEFTtimer = millis () ;

  } else {
    // turn LED off:
    digitalWrite(stateLEFT, LOW);
}}
  }
    
    // read the state of the pushbutton value:
  stateRIGHT = digitalRead(buttonRIGHT);
  // check if the pushbutton is pressed.
  // if it is, the buttonState is HIGH:
  { if (stateRIGHT == HIGH) {
    // turn LED on:

// The other LED is controlled the same way. Repeat for more LEDs
if ( (millis () - greenRIGHTtimer) >= greenRIGHTinterval ) {
   if (greenRIGHTState == LOW)
     greenRIGHTState = HIGH ;
   else
     greenRIGHTState = LOW ;
   digitalWrite (greenRIGHT, greenRIGHTState ) ;
   greenRIGHTtimer = millis ()  ;
}
if ( (millis () - redRIGHTtimer) >= redRIGHTinterval ) {
   if (redRIGHTState == LOW)
     redRIGHTState = HIGH ;
   else
     redRIGHTState = LOW ;
   digitalWrite (redRIGHT, redRIGHTState ) ;
   redRIGHTtimer = millis ()  ;

  } else {
    // turn LED off:
    digitalWrite(stateRIGHT, LOW);
}}
  }  

/* Other code that needs to execute goes here.
  It will be called many thousands of times per second because the above code
  does not wait for the LED blink interval to finish. */

}

Zugegeben, ich hab das Grundgerüst geklaut/kopiert. Aber ich komm damit auch nicht weniger weit und auch nicht weiter als mit all meinen anderen versuchen und meinen eigenen Codes.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
26.10.2015, 22:28 (Dieser Beitrag wurde zuletzt bearbeitet: 26.10.2015 22:38 von hotsystems.)
Beitrag #2
RE: Arduino am Motorrad (Blinker uvm...)
Allgemeine Frage:
Ist das überhaupt zulässig und wird diese Änderung vom TÜV abgenommen bzw. zugelassen?

Aber nun zum Code, da du diesen nicht selbst erstellt hast, wie du schreibst, wirst du diesen auch nicht verstehen.

Aus diesem Grund möchte ich dir den Tipp geben: Befasse dich mit den Arduino Grundlagen und baue dein Arduino-Wissen langsam mit den Beispielen der IDE auf.
Da lernst du leicht, wie Taster und Leds beschaltet und per Sketch gesteuert werden.

Danach verstehst du evtl. auch den von dir reinkopierten Sketch und verstehst unsere Hinweise zur Verbesserung der Funktionen im Sketch.

Ohne dieses Grundwissen wirst du unsere Empfehlungen sicher nicht richtig umsetzen können.

I2C = weniger ist mehr: weniger Kabel, mehr Probleme. Cool
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
26.10.2015, 22:46
Beitrag #3
RE: Arduino am Motorrad (Blinker uvm...)
Joo.. ist größtenteils erlaubt.

Blinkfrequenz muss zwischen 500 und 1500ms liegen..
Warnblink braucht seperaten Schalter.
Blaulicht im StVO nicht zulässig. Für Events schon (privatgelände). Gängige Lösumg = ein Schalter, der während des allgemeinen Betriebs nicht betätigt werden kann (unter der Sitzbankabdeckung).

Zum Code... Ich werd mich damit noch beschäftigen, werde allerdings aktiv Schützenhilfe benötigen, wenn ich wieder hänge.
Da hoffe ich, auf euch bauen zu können...


der Dirk
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
26.10.2015, 22:49
Beitrag #4
RE: Arduino am Motorrad (Blinker uvm...)
(26.10.2015 22:46)WereWolf schrieb:  Zum Code... Ich werd mich damit noch beschäftigen, werde allerdings aktiv Schützenhilfe benötigen, wenn ich wieder hänge.
Da hoffe ich, auf euch bauen zu können...

Das ist kein Problem, Hilfestellung ist immer drin.

I2C = weniger ist mehr: weniger Kabel, mehr Probleme. Cool
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
27.10.2015, 05:51
Beitrag #5
RE: Arduino am Motorrad (Blinker uvm...)
Hallo,

ich glaube, für dein Projekt lohn ein Blick auf Neopixl-LED. Die gibt es als Stripes, Sticks, Matrix und Ringe z.B. bei Watterott oder EXP-Tech.
Der Vorteil ist ein geringerer Verkabelungsaufwand und die RGB-Fähigkeit.
Bei den im Motorrad zu erwartenden Kabellängen und Störquellen musst du dir aber Gedanken zur Störunterdrückung / Abschirmung machen.

Gruß Rainer
Webseite des Benutzers besuchen Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
30.10.2015, 13:04
Beitrag #6
RE: Arduino am Motorrad (Blinker uvm...)
Hab mir diese NeoPixel LEDs mal angeschaut. Sehen wirklich interessant aus.
Werd mich damit auch mal beschäftigen...


Habe aber soeben versucht mal ein wenig von Grund auf anzufangen..
Hänge jetzt an folgender Stelle:

Code:
void loop()
{
  unsigned long currentMillis = millis();
  if (currentMillis - previousMillis >= interval)
  {
    previousMillis = currentMillis;
    if (leftState == LOW)
    {leftState = HIGH;}
     else
     {leftState = LOW;}

    // set the LED with the ledState of the variable:
    digitalWrite(redPin, leftState);
    digitalWrite(greenPin, leftState);
  }
}

Das ist der Loop um eine RGB LED als Blinker in Gelb/Orange blinken zu lassen.

Wie kann ich das jetzt von einem "ButtonState" abhängig machen?
Ich will ja (natürlich) das es nur blinkt, wenn "leftBtn == HIGH" wenn der LOW ist, soll alles ruhen.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
30.10.2015, 13:59 (Dieser Beitrag wurde zuletzt bearbeitet: 30.10.2015 14:05 von Klaus(i).)
Beitrag #7
RE: Arduino am Motorrad (Blinker uvm...)
Hi,

habe da mal etwas geschrieben, was funktionieren könnte (ohne Gewähr).
Sind auch ein paar Kommentare drin. Selbst, wenn es nicht funktionieren sollte, kann man erkennen, wie ich es meine.
Die neuen Variablen muss Du selbstverständlich noch deklarieren.

Gruß, Klaus
PHP-Code:
void setup() {
  
//letzten Zustand des Buttons
  
prevBtnState=LOW;
  
//aktueller Zustand init
  
btnState=LOW;

  
//button PIN 
  
btnPIN=2;
}

void loop()
{
  
  
unsigned long currentMillis millis();

  
btnState=digitalRead(btnPIN);
  if (
btnState != prevBtnState
  {
    
//Schalterstellung hat sich geändert
    
if (btnState == LOW)
    {
      
//Schalter aus --> aufhören zu blinken
      
leftState LOW;
    } else {
      
//Anfangen zu blinken
      
leftState HIGH;
    }
    
// zum Setzen der LEDs sollte man eine Funktion machen
    
digitalWrite(redPinleftState);
    
digitalWrite(greenPinleftState);
    
// ---------------------------------------------------
    
    //merken Schalterstellung
    
prevBtnState btnState;
    
//merken Zeit
    
previousMillis currentMillis;
  } else {
    
// Schalterstellung ist geblieben
    
if (btnState == HIGHT)
    {
      
//Schalter immer noch an --> weiter Blinken
      
if (currentMillis previousMillis >= interval)
      {
        
previousMillis currentMillis;
        if (
leftState == LOW)
        {
leftState HIGH;}
         else
         {
leftState LOW;}
    
        
// zum Setzen der LEDs sollte man eine Funktion machen
        
digitalWrite(redPinleftState);
        
digitalWrite(greenPinleftState);
      }
    }
  }
  

Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
30.10.2015, 15:15
Beitrag #8
RE: Arduino am Motorrad (Blinker uvm...)
Hui...

Danke für die schnelle Antwort..
Werd mir das mal in Ruhe anschauen müssen..
Wenn ich das richtig lese, handelt es sich da um einen Taster, der durch betätigen immer 2 Zustände toggelt, richtig?

Ich hab das im Moment so versucht zu lösen:
Code:
// constants won't change. Used here to set a pin number :
const int redPin =  11;      // the number of the LED pin
const int bluePin =  10;
const int greenPin =  9;

const int leftPin =  8;

bool blinking = false; //defines when blinking should occur

// Variables will change :
int leftState = LOW;             // ledState used to set the LED
int rightState = LOW;

int redState = LOW;
int blueState = LOW;
int greenState = LOW;

// Generally, you should use "unsigned long" for variables that hold time
// The value will quickly become too large for an int to store
unsigned long previousMillis = 0;        // will store last time LED was updated
const long interval = 500;           // interval at which to blink (milliseconds)

//################################################################################​####
void setup()
{
  pinMode(redPin, OUTPUT);
  pinMode(bluePin, OUTPUT);
  pinMode(greenPin, OUTPUT);
  
  pinMode(leftPin, INPUT);
}

//################################################################################​####
void loop()
{
  
/*
  digitalRead(leftPin);
if (leftPin==HIGH)
  blinking=true; // start blinking
else
  blinking=false; // stop blinking
  
  
  if (blinking)
  {
*/    
  unsigned long currentMillis = millis();
  if (currentMillis - previousMillis >= interval)
  {
    previousMillis = currentMillis;
    if (leftState == LOW)
    {leftState = HIGH;}
     else
     {leftState = LOW;}

    // set the LED with the ledState of the variable:
    digitalWrite(redPin, leftState);
    digitalWrite(greenPin, leftState);
  }

}

Ich werde mit einem Raster arbeiten..
Hab dieses
Code:
bool blinking = false; //defines when blinking should occur
im Netz gefunden. Verstehe das wie einen Toggle-Schalter "im Code selbst".. Aber irgendwie bekomme ich das nicht am laufen.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
Antwort schreiben 


Möglicherweise verwandte Themen...
Thema: Verfasser Antworten: Ansichten: Letzter Beitrag
Question Motorrad Alarmanlage mit GPS-Tracker copperhead 1 1.124 28.03.2016 22:07
Letzter Beitrag: Scheams
  Arduino Neuling: Zugeklappten Laptop mit Arduino aufwecken + Kiste aufklappen? Ikearegal 2 2.527 02.02.2014 07:59
Letzter Beitrag: Ikearegal

Gehe zu:


Benutzer, die gerade dieses Thema anschauen: 1 Gast/Gäste