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
Grundprogramm Arduino
15.03.2015, 15:26
Beitrag #1
Brick Grundprogramm Arduino
Ich möchte euch in dieser Reihe mein kleines Projekt vorstellen. Eigentlich ist es ein Teilprojekt meines großen Projektes für Heimautomatisierung. Man kann es allerdings auch eigenständig nutzen bzw. für eigene Projekte anpassen.

Ein kleiner Hinweis noch :

Ich bin KEIN Elektroniker oder ähnliches. Mein bescheidenes Wissen auf dem Gebiet der Elektronik habe ich mir in zahleichen Versuchen und mühevoller Kleinarbeit selbst
angeeignet und bin für Hinweise dankbar, die mich wieder einen kleinen Schritt voranbringen. Meine Programmiersprache ist normalerweise VB.net und mit dem Arduino-C musste ich am Anfang ein bischen kämpfen. Den Code habe ich einfach gehalten (glaube ich jedenfalls).
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
15.03.2015, 16:59
Beitrag #2
RE: Grundprogramm Arduino
Öhm - hast Du evtl. den File-Anhang oder das Posten des des Codes vergessen?

Oder hab' ich was übersehen?

Gruss Ralf
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
15.03.2015, 17:21
Beitrag #3
RE: Grundprogramm Arduino
(15.03.2015 16:59)Foto-Ralf schrieb:  Öhm - hast Du evtl. den File-Anhang oder das Posten des des Codes vergessen?

Oder hab' ich was übersehen?

Gruss Ralf

Nein, alles i.O. , muss mich hier nur noch zurechtfinden und die Sachen reinstellen.

Wenn alles gut geht, ist ein Teil davon gleich verfügbar.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
15.03.2015, 18:32
Beitrag #4
RE: Grundprogramm Arduino
Teil 1

Die Komponenten

Im Anhang ein Video, um die Schaltung bzw. das Programm dazu in Aktion zu zeigen. Zuerst sollte es nur eine kleine Klingelanlage werden, die ich installieren wollte. Daraus entwickelte sich das Grundprogramm, daß ich auch für andere Sachen verwenden kann.

Die folgenden Komponenten habe ich dazu benutzt :

1. Saint-Smart Mega mit Netzwerkshield.

2. Relais-Karte 8-fach

3. Diverse Bauteile für LED und Taster (Liste folgt noch)

Hier ein paar Bilder als Video



Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
15.03.2015, 20:20
Beitrag #5
Teil2 - Funktionsweise
Teil 2

Funktionsweise

Diese Schaltung wird über die folgenden Taster (erkennbar an der Beschriftung) gesteuert.

I - Input

M - Modus

D - Debug-Modus

F - Funktion

S1 - Schalter 1

S2 - Schalter 2

Zuerst erfolgt ein I gefolgt von der Funktion , die man ausführen möchte.

In dem Video-Beispiel führe ich einen Funktionstest aller Relais durch,

die > Funktion01 <

Bitte diese Funktion merken, diese wird uns in ähnlicher Form noch einmal begegnen !

Dann drückt man 1 x F (Funktion01) , würde man 2 x F drücken
würde diese Funktion > Funktion02 < heißen !

Dann noch einmal I drücken, damit das Board weiß, daß die Eingabe beendet wurde.

Funktion01 I F I
Funktion02 I F F I
Funktion03 I F F F I
usw. (Theoretisch bis 99)

Jetzt werden alle Relais nacheinander durchgeschaltet.

Danach werden alle Relais gleichzeitig eingeschaltet und dann wieder ausgeschaltet.

In der kleinen Pause danachwerden noch zwei direkte Board-Ausgänge geschaltet (kann man hier nur erahnen)

Zum Schluß werden alle LED's noch einmal durchgetestet.

Hier das Video dazu.

https://www.youtube.com/watch?v=w5gClVPPJmg

Interessanter wird es dann im Teil 3 !
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
15.03.2015, 22:02 (Dieser Beitrag wurde zuletzt bearbeitet: 15.03.2015 23:00 von Home38.)
Beitrag #6
Teil 3 - Debug einschalten
Teil 3

Debug einschalten

Im 2.Teil konnte man also sehen, wie die Relais geschaltet wurden.

In diesem Teil werde ich zeigen, wie man den Debug-Modus einschalten kann.

Mit der Taster-Kombination I D I kann man den Debug-Modus einschalten.

I D I = Debug01
I D D I wäre dann Debug02

Diesen Namen wieder merken ! Im Teil 4 begegnet uns der Name wieder.

Im nachfolgenden Video wird über diese Kombination zuerst der Debug-Modus
eingeschaltet und dann der Funktionstest wieder durchgeführt.

Das Programm im Hintergrund habe ich selbst geschrieben.

Es empfängt UDP-Pakete, die das Board versendet und zeigt diese auch an.

Hier das Video dazu

https://www.youtube.com/watch?v=kL-ZzQpdZRU

Teil 4

Externe Steuerung

Das Board lässt sich über das Grundprogramm über die Taster manuell steuern.

Auch kann man sich über den Debug-Modus anzeigen lassen, was das Board gerade so macht ! Die Anzeige funktioniert also über Netzwerk und übrigens auch über die Serielle Verbindung,

In diesem Teil zeige ich, wie man mit dem Grundprogramm über UDP und seriell mit dem Board kommunizieren kann.

In den Teilen 2 und 3 hatte ich die Namen Funktion01 und Debug01 erwähnt.

Etwas abgewandelt kann man diese Befehle per UDP und seriell an das Board senden und somit kann das Board ferngesteuert werden.

I F I = Funktion01 = !FUNCTION01

I D I = Debug01 = !DEBUG01

Empfängt das Board diese !-Befehle werden exakt die gleichen Befehle
ausgeführt, die den Tastenb-Befehlen entsprechen.

Hier eine kleine Liste der Befehle :

S1 = !SWITCH01 = Drückt den Taster S1
S2 = !SWITCH02 = Drückt den Taster S2

I M I = !MODUS01
I M M I = !MODUS02
I M M M I = !MODUS03

Mit Modus ist gemeint, wie das Board reagieren soll, wenn S1 oder S2 gedrückt werden. Im Bezug auf die Klingelanlage könnte das bedeuten, ob nur der Gong ertönt oder ob der Summer am Gartentor gleich mitbetätigt werden soll.

Das müsste dann im Grundprogramm geändert werden. Dazu aber in den nachfolgenden Teilen mehr.

Hier erst einmal das Video dazu.

Ein Hinweis noch :

Als erstes wird der Funktionstest (Funktion01) über die serielle Verbindung ausgelöst.

Danach wird das gleiche Kommando per UDP an das Board gesendet !

https://www.youtube.com/watch?v=A_Ul_3sdrqA

In den nachfolgenden Teilen werde ich dann den Quellcode erläutern.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
16.03.2015, 20:13 (Dieser Beitrag wurde zuletzt bearbeitet: 16.03.2015 21:03 von Home38.)
Beitrag #7
RE: Grundprogramm Arduino
Anbei der Quellcode für das Grundprogramm.

Die Erläuterungen bzw. die einzelnen Abschnitte werde ich dann in dann nach und nach kommentieren.

Code:
/*

  V26 - Grundprogramm zur Ansteuerung von 6 Tastern und einer Relais-Karte

  !!! Zusätzliche Hinweise sowie die Ansteuerung des Boards befinden sich am Ende des Programmes

    
*/

/* ------------------( 1 )------------------------  */

#include <SPI.h>        
#include <Ethernet.h>
#include <EthernetUdp.h>

/* ------------------( 2 )------------------------  */

// *** Ethernet, einstellen von Parametern für UDP / TCP ???

byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };       // mac-Adresse
IPAddress UDP_localIP(192, 168, 1, 177);                  // eigene IP-Adresse
unsigned int UDP_localPort = 8888;                        // eigener lokaler Port !

int UDP_Active = 0 ;

int UDP_packetSize ;

char UDP_packetBuffer[UDP_TX_PACKET_MAX_SIZE];            // buffer to hold incoming packet,
IPAddress UDP_recvIP ;

/* ------------------( 3 )------------------------  */

IPAddress UDP_remoteIP(192, 168, 1, 255) ;                // Senden ans komplette Subnetz (ansonsten direkte IP)
unsigned int UDP_remotePort = 10000;

EthernetUDP Udp;                                          // EthernetUDP-Instanz, mit der man UDP-Päckchen über UDP senden und empfangen kann !

// **********************************************************

/* ------------------( 4 )------------------------  */

#define INLENGTH 20                                // Max.Eingabelänge Zeichenkette für Serial
#define INTERMINATOR 13                            // Ende-Kennzeichen der Zeile
#define CHARDELETE '#'                             // Beim Erkennen dieses Zeichens wird der "Eingabepuffer" gelöscht !

#define BOARD_TYP 'MEGA2560'                      // Später für Compiler wichtig, welche Teile mitcompiliert werden !
#define BOARD_NAME 'BOARD01'                       // Name des Board, mit dem es sich meldet

Zuvor ein Hinweis zum Code. Einige Zeilen und kleine Abschnitte stammen nicht aus meiner Feder. Dafür meinen ehrlichen Dank an alle, die Ihren Code hier wiederfinden oder gar nicht wissen, daß er in diesem Programm verwendet wird.

Ich kann nicht jede Zeile kommentieren und habe einige Tage gebraucht, damit das Programm stabil läuft und die Logik passt. In VB ist es um einiges leichter.

Die kleinen Anschnitte werde ich mit /* -----------------------( x )---------------------- */ kennzeichnen, damit man die Stellen leicher findet !

Und noch eine Bitte bevor es losgeht :

Bei Fragen oder gefundenen Fehlern sendet mir bitte eine Nachricht, damit ich das erklären oder korrigieren kann.

Los gehts :

/* ------------------( 1 )------------------------ */

In diesem Abschnitt werden die benötigten Bibliotheken eingebunden.

/* ------------------( 2 )------------------------ */

Diese Stelle ist viel interessanter.
Hier wird die IP-Adresse des Shields und der Sende Port festgelegt, über den
das UDP-Päckchen gesendet wird.

Die MAC-Adresse (Board) sollte man ändern, wenn mehrere Board mit Shield im Einsatz sind. Auf doppelte MAC-Adressen im Netzwerk sollte man auf jeden Fall verzichten.

/* ------------------( 3 )------------------------ */

Hier trägt man die Zieladresse ein, an die man das UDP-Päckchen versenden will.

Die 255 am Ende sendet das Päckchen an ALLE Rechner im Subnetz (Broadcast) !

Der Remoteport ist der Empfangsport, auf dem der oder die Zielrechner lauschen !

/* ------------------( 4 )------------------------ */

An dieser Stelle werden noch Werte definiert, die erst später benötigt werden.



Weiter in Teil 6 !


Angehängte Datei(en)
.ino  GrundProgrammMEGA2560_V21.ino (Größe: 44,94 KB / Downloads: 73)
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
16.03.2015, 21:21 (Dieser Beitrag wurde zuletzt bearbeitet: 16.03.2015 21:34 von Home38.)
Beitrag #8
RE: Grundprogramm Arduino
Ich werde die Kommentierung gleich hier eintragen, ist wohl einfacher :




Code:
// Eingänge definieren
int value = 0 ;

int prellDelay = 50 ;

int stdLedDelay1 = 200 ;                            // StandardDelay für Blinkdauer
int stdLedDelay2 = 150 ;                            // StandardDelay für das Warten nach dem Blinken

char inString[INLENGTH+1];                          /* Maximale Länge des Strings */
int inCount;                                        /* StringZähler                */
byte inTerminated;                                  /* Endekennzeichen ist eingegeben worden ! */
// alt char inTerminated;                           /* Endekennzeichen ist eingegeben worden ! */
int inTermCount ;                                   /* Zählt Anzahl der Zeichen ! */
char inReadChar ;                                   /* Einzelnes Zeichen lesen */
int hCounter ;                                      /* Hilfszähler              */

int PressCounter = 0 ;                              /* Wurde irgendeine Taste gedrückt ?? */
int PressCounter_Old = 0 ;

/* ------------------------------------------- ( 1 )-------------------------------------------*/

An dieser Stelle werden die Pins für die Relais, Taster und
OnBoard-Kontakte festgelegt. Wenn man das Programm für
kleinere Boards verwendet kann man das ausdünnen !

/* ------------------------------------------- ( 1 )-------------------------------------------*/


/* **** Für Relais ********************************************************************************​*/

const int circle1 = 41 ;
const int circle2 = 42 ;
const int circle3 = 43 ;
const int circle4 = 44 ;

const int circle5 = 45 ;
const int circle6 = 46 ;
const int circle7 = 47 ;
const int circle8 = 48 ;

/* **** Für "andere" Kontakte (Bsp. Eigener Schließer OHNE Strom ***********************************/

const int circle9 = 22 ;
const int circle10 = 18 ;

/* *** Reset ********************************************************************************​*******/

const int resetPin = 11 ;                           // Software-Reset

/* ------------------------------------------- ( 2 )-------------------------------------------*/

Für jeden Taster gibt es (fast) immer die gleichen Variablennamen.
Ganz wichtig sind

pin_<Taste>                  - Pin auf dem Board

und

<Taste>LED                 - Angeschlossene LED auf dem Ausgang !

/* ------------------------------------------- ( 2 )-------------------------------------------*/


/* **** DEBUG ********************************************************************************​******/

int pin_Debug=12 ;                                      // Pin 12 (neben GND / 13 / )
int Debug ;                                        /* Schaltet Debug ein = 1 bzw. aus */
String DebugText ;                                  // wird für zusammengestellte Texte benötigt
int DebugCounter = 0 ;                              // Zählt die Ausgaben für Debug
int DebugCounter_Modus_0 = 0;
int DebugCounter_Modus_1 = 0;
int DebugValue = 0 ;
int DebugValue2 = 0 ;
int DebugPress = 0 ;
int DebugLed = 30 ;        
String DebugBoardName = "BOARD01" ;
String DebugBoardTyp = "MEGA2560" ;

/* **** MODUS ********************************************************************************​******/

int pin_Modus=8 ;
int Modus ;                                          // Enthält den Modus
String ModusText ;
int ModusValue = 0 ;
int ModusValue2 = 0 ;
int ModusPress = 0 ;
int ModusLed = 31 ;

/* **** INPUT ********************************************************************************​******/

int pin_Input=2 ;
int Input ;                                          // Eingabe
String InputText ;
int InputValue = 0 ;
int InputValue2 = 0 ;
int InputPress = 0 ;                                  // Wie oft gedrückt !!!
int InputLed = 32 ;

/* **** SWITCH1 ********************************************************************************​******/

int pin_Switch1=3 ;
int Switch1 ;                                          // Klingeltaster
String Switch1Text ;
int Switch1Value = 0 ;
int Switch1Value2 = 0 ;
int Switch1Press = 0 ;                                  // Wie oft gedrückt !!!
int Switch1Led = 35 ;

/* **** SWITCH2 ********************************************************************************​******/

int pin_Switch2=5 ;
int Switch2 ;                                          // Klingeltaster
String Switch2Text ;
int Switch2Value = 0 ;
int Switch2Value2 = 0 ;
int Switch2Press = 0 ;                                  // Wie oft gedrückt !!!
int Switch2Led = 33 ;

/* **** FUNCTION ********************************************************************************​******/

int pin_Function=6 ;
int Function ;                                          // Klingeltaster
String FunctionText ;
int FunctionValue = 0 ;
int FunctionValue2 = 0 ;
int FunctionPress = 0 ;                                  // Wie oft gedrückt !!!
int FunctionLed = 34 ;

/********************************************************************************​*******************/


String hString1 ;
String hString2 ;

Bitte nicht wundern, daß einige Variablen (noch) nicht verwendet werden.
Bei Bedarf entwickle ich das Programm weiter und baue oftmals schon
Sachen ein, die ich später gut gebrauchen kann.

Im Setup wird die UDP-Netzwerkkommunikation aktiviert und die serielle Schnittstelle 1 aktiviert, das Mega hat 4 davon (Das bringt mich wieder auf Ideen ....) !!

Danach werden die Ein und Ausgänge geschaltet bzw. aktiviert !

!!!! Beim Durchgehen des Codes ist mir wieder eingefallen, daß das Debugging aktiviert wird, wenn die Debug-Taste beim Start gedrückt und gehalten wird !!!!

Code:
// the setup routine runs once when you press reset:
void setup() {                
  
  // start the Ethernet and UDP:
  Ethernet.begin(mac,UDP_localIP);                                   // Ethernetschnittstelle einschalten ??
  
  Udp.begin(UDP_localPort);                                          // Port zum Senden öffnen
  
  // initialize the digital pin as an output.
  pinMode(DebugLed, OUTPUT);        // Leuchtdiode 13 (neben R7/R10)

  // LED's konfigurieren
  pinMode(DebugLed,OUTPUT) ;
  pinMode(ModusLed,OUTPUT) ;
  pinMode(InputLed,OUTPUT) ;
  pinMode(Switch1Led,OUTPUT) ;
  pinMode(Switch2Led,OUTPUT) ;
  pinMode(FunctionLed,OUTPUT) ;
  
  // Pull-Widerstand ResetPin einschalten !

  pinMode(resetPin, INPUT) ;
  digitalWrite(resetPin, LOW) ;

  // Pull-Widerstand der Relais-Kreise einschalten !
  pinMode(circle1, OUTPUT) ;       // Relais 1
  digitalWrite(circle1, HIGH) ;    // Pull-Widerstand einschalten, damit zieht wahrscheinlich das Relais nicht an
  
  pinMode(circle2, OUTPUT) ;       // Relais 1
  digitalWrite(circle2, HIGH) ;    // Pull-Widerstand einschalten, damit zieht wahrscheinlich das Relais nicht an
  
  pinMode(circle3, OUTPUT) ;       // Relais 1
  digitalWrite(circle3, HIGH) ;    // Pull-Widerstand einschalten, damit zieht wahrscheinlich das Relais nicht an
  
  pinMode(circle4, OUTPUT) ;       // Relais 1
  digitalWrite(circle4, HIGH) ;    // Pull-Widerstand einschalten, damit zieht wahrscheinlich das Relais nicht an

  pinMode(circle5, OUTPUT) ;       // Relais 1
  digitalWrite(circle5, HIGH) ;    // Pull-Widerstand einschalten, damit zieht wahrscheinlich das Relais nicht an
  
  pinMode(circle6, OUTPUT) ;       // Relais 1
  digitalWrite(circle6, HIGH) ;    // Pull-Widerstand einschalten, damit zieht wahrscheinlich das Relais nicht an

  pinMode(circle7, OUTPUT) ;       // Relais 1
  digitalWrite(circle7, HIGH) ;    // Pull-Widerstand einschalten, damit zieht wahrscheinlich das Relais nicht an

  pinMode(circle8, OUTPUT) ;       // Relais 1
  digitalWrite(circle8, HIGH) ;    // Pull-Widerstand einschalten, damit zieht wahrscheinlich das Relais nicht an

  // Andere Taster / Schließer

  pinMode(circle9, OUTPUT) ;       // Relais 1
  digitalWrite(circle9, HIGH) ;    // Pull-Widerstand einschalten, damit zieht wahrscheinlich das Relais nicht an

  pinMode(circle10, OUTPUT) ;       // Relais 1
  digitalWrite(circle10, HIGH) ;    // Pull-Widerstand einschalten, damit zieht wahrscheinlich das Relais nicht an
  
  // Pull-Widerstände der Taster einschalten !
    
  pinMode(pin_Debug, INPUT) ;      // Pin als Eingang definieren
  digitalWrite(pin_Debug,HIGH) ;   // Pull-Up-Widerstand einschalten
  
  pinMode(pin_Modus, INPUT) ;      // Pin als Eingang definieren
  digitalWrite(pin_Modus,HIGH) ;   // Pull-Up-Widerstand einschalten
  
  pinMode(pin_Input, INPUT) ;      // Pin als Eingang definieren
  digitalWrite(pin_Input,HIGH) ;   // Pull-Up-Widerstand einschalten
  
  pinMode(pin_Switch1, INPUT) ;      // Pin als Eingang definieren
  digitalWrite(pin_Switch1,HIGH) ;   // Pull-Up-Widerstand einschalten
  
  pinMode(pin_Switch2, INPUT) ;      // Pin als Eingang definieren
  digitalWrite(pin_Switch2,HIGH) ;   // Pull-Up-Widerstand einschalten
  
  pinMode(pin_Function, INPUT) ;      // Pin als Eingang definieren
  digitalWrite(pin_Function,HIGH) ;   // Pull-Up-Widerstand einschalten
    
  Serial.begin(9600);
  
  BlinkLed(DebugLed,stdLedDelay1,stdLedDelay2,5) ;
  BlinkLed(ModusLed,stdLedDelay1,stdLedDelay2,5) ;
  BlinkLed(InputLed,stdLedDelay1,stdLedDelay2,5) ;
  BlinkLed(Switch1Led,stdLedDelay1,stdLedDelay2,5) ;
  BlinkLed(Switch2Led,stdLedDelay1,stdLedDelay2,5) ;
  BlinkLed(FunctionLed,stdLedDelay1,stdLedDelay2,5) ;
  
  // Für Debug-Ausgaben
  if (digitalRead(pin_Debug) == 0) {
     Debug = 1 ; }
     else {
       Debug = 0 ; }
      
  
  DebugText = "" ;
  DebugCounter = 0 ;
  
  // Ausgabe der Debug-Informationen
  PrintDebugInfo() ;
    
  Modus = 1 ;                          // Modus standardmäßig auf 1 setzen !
  
  DebugText = "Modus=" + String(Modus) ;
  DebugPrint(DebugText,"1");

    
}
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
Antwort schreiben 


Möglicherweise verwandte Themen...
Thema: Verfasser Antworten: Ansichten: Letzter Beitrag
  Arduino Neuling: Zugeklappten Laptop mit Arduino aufwecken + Kiste aufklappen? Ikearegal 2 2.515 02.02.2014 07:59
Letzter Beitrag: Ikearegal

Gehe zu:


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