Saturday, January 24, 2015

Arduino MP3-Player (13) - Punkt-Streifenrasterplatine und weitere Komponenten

Nachdem die Knöpfe auf der Punkt-Streifenrasterplatine angebracht worden sind und das Arduino-Board auf der Rückseite mit vier Distanzbolzen, Schrauben und Muttern aus dem Prototyping and Development Board befestigt worden sind, können die weiteren Komponenten auf die Punkt-Streifenrasterplatine angebracht beziehungsweise mit der Punkt-Streifenrasterplatine verbunden werden.


Neben das Arduino-Board kann der Batteriehalter platziert werden. Hierfür werden weitere zwei Löcher (3mm) in die Punkt-Streifenrasterplatine gebohrt. Mit zwei Schrauben M3/10 und zwei M3 Muttern kann der Batteriehalter befestigt werden.


Der Anschluss des Batteriehalters wird in die entsprechende Buchse des Arduino-Boards gesteckt.


Die Stromleitung des Batteriehalters wird durchtrennt damit der Kippschalter dazwischengeschaltet werden kann. Zwei Drahtbrücken mit Buchsen sind dazu an den Enden der durchtrennten Stromleitung und zwei Drahtbrücken mit Steckern an den Kippschalter angelötet und mit Schrumpfschlauch fixiert worden. Dadurch kann der Kippschalter an den Batteriehalter gesteckt werden.


An dem Lautsprecher werden zwei Drähte gelötet.


Die Drähte können mit dem MP3 Shield an einem der beiden Endstücke verbunden werden.


Das analoge Inputsignal der Knöpfe wird über die weiße Drahtbrücke gemessen. Das eine Ende ist an entsprechender Stelle an der Punkt-Streifenrasterplatine angelötet, das andere Ende wird in eines der analogen Pins des Arduino-Boards beziehungsweise des MP3 Shields gesteckt.

Die 5V-Stromversorgung der Knöpfe erfolgt über eine rote Drahtbrücke, die ebenfalls mit dem einen Ende an der Punkt entsprechenden Stelle an der Punkt-Streifenrasterplatine angelötet ist. Das andere Ende wird in die 5V-Buchse des Arduino-Boards/MP3 Shields gesteckt.

Auch für Gnd der Knöpfe wird eine schwarze Drahtbrücke an entsprechender Stelle an der Punkt-Streifenrasterplatine angelötet und das andere Ende in eines der Gnd-Pins gesteckt.


An dem Potentiometer sind drei Drahtbrücken mit Steckern gelötet und mit Schrumpfschläuchen fixiert. Die drei Drahtbrücken werden mit anderen drei Drahtbrücken mit Buchsen verbunden.

Die linke Drahtbrücke (rot) wird mit der 5V-Stromversorgung verbunden. Da das Arduino-Board nur eine 5V-Buchse hat, wird eine Drahtbrücke an der Stelle auf der Punkt-Streifenrasterplatine gelötet an der die 5V-Versorgung für die Knöpfe liegt und somit von dieser Stelle die 5V abgegriffen und mit dem Potentiometer verbunden.

Die mittlere Drahtbrücke (gelb) wird mit einem analogen Pin des Arduino-Boards/MP3 Shields verbunden.

Die rechte Drahtbrücke (schwarz) wird mit einem Gnd-Pin des Arduino-Boards/MP3 Shields verbunden.


Für die Befestigung der Punkt-Streifenrasterplatine ans Gehäuse werden in den Ecken vier Löcher in die Punkt-Streifenrasterplatine gebohrt (M3). Vorher kann die Punkt-Streifenrasterplatine noch zurecht geschnitten werden, sodass der Platzbedarf im Gehäuse reduziert wird. Durch die gebohrten Löcher können Kunststoff-Distanzbolzen gesteckt und mit Muttern befestigt werden. Die passenden Schrauben können verwendet werden, um die Punkt-Streifenrasterplatine ans Gehäuse zu befestigen.


Nachfolgend ist die Punkt-Streifenrasterplatine mit allen Komponenten dargestellt. Von vorne..


..und von hinten.




Weitere Blogeinträge

  1. Auswahl der Komponenten
  2. Das Entwicklungsbrett
  3. Das erste Einschalten
  4. Die Entwicklungsumgebung
  5. Knöpfe (digital)
  6. Mehrere Knöpfe (digital)
  7. Mehrere Knöpfe (analog)
  8. Potentiometer
  9. Das MP3 Shield
  10. Auswahl der Komponenten 2
  11. Auswahl der Komponenten (Zusammenfassung) 
  12. Punkt-Streifenrasterplatine und Knöpfe
  13. Punkt-Streifenrasterplatine und weitere Komponenten



Sunday, January 11, 2015

Arduino MP3-Player (12) - Punkt-Streifenrasterplatine und Knöpfe

Die Knöpfe werden auf der Punkt-Streifenrasterplatine platziert. Hierbei kann mit den Abständen etwas variiert werden. Am Rand habe ich etwas Platz gelassen, da hier noch Leitungen kommen und auch die Befestigung der Punkt-Streifenrasterplatine ans Gehäuse benötigt etwas Platz.


Auf der Rückseite gegenüber den Knöpfen kann das Arduino-Board mit dem MP3 Shield platziert werden. Entsprechend werden Borlöcher (3mm) gebohrt, sodass das Leitungslayout nicht beeinträchtigt wird.


Die Knöpfe werden von der einen Seite durchgesteckt und auf der anderen Seite gelötet. Das gleiche gilt für die Widerstände und einige Draht-Leitungen.


Auf der gelöteten Seite werden benötigte Verbindungen gelötet.


Das Leitungslayout sollte, entsprechend zu Arduino MP3-Player (7) - Mehrere Knöpfe (analog), den nachfolgenden Abbildungen entsprechen. Diese weichen von den oberen Fotos ab. Im ursprünglichen Layout hatte sich ein Fehler eingeschlichen, der durch verschieben eines Widerstands behoben worden ist. Dieser Fehler ist nun hoffentlich behoben.

Die Leitungen, die mit dem Arduino-Board bzw. MP3 Shield verbunden werden sind hier die 5V Stromversorgung (rot), die Masse (schwarz) und das analoge Inputsignal (weiß). Da neben den Knöpfen noch der Potentiometer mit Strom versorgt werden muss, wird über eine weitere Leitung auf der Punkt-Streifenrasterplatine die 5V Stromversorgung abgegriffen.

Im nachfolgenden Bild sind die Frontansicht und die Rückansicht zusammen dargestellt.


In der Frontansicht sind die Knöpfe und Widerstände zu sehen. Ebenso wie einige Draht-Leitungen.


In der Rückansicht werden die Knöpfe, Widerstände und Draht-Leitungen angelötet. Zudem werden noch weitere Abschnitte der Rasterplatine miteinander verbunden.


Als nächstes werden die weiteren Komponenten, die noch auf die Punkt-Streifenrasterplatine platziert oder mit dieser verbunden werden sollen, betrachtet.

Weitere Blogeinträge

  1. Auswahl der Komponenten
  2. Das Entwicklungsbrett
  3. Das erste Einschalten
  4. Die Entwicklungsumgebung
  5. Knöpfe (digital)
  6. Mehrere Knöpfe (digital)
  7. Mehrere Knöpfe (analog)
  8. Potentiometer
  9. Das MP3 Shield
  10. Auswahl der Komponenten 2
  11. Auswahl der Komponenten (Zusammenfassung)
  12. Punkt-Streifenrasterplatine und Knöpfe
  13. Punkt-Streifenrasterplatine und weitere Komponenten

Saturday, January 10, 2015

Arduino MP3-Player (11) - Auswahl der Komponenten (Zusammenfassung)

Hier möchte ich nochmal zusammenfassen welche Komponenten aus den vorherigen Beiträgen Arduino MP3-Player (1) - Auswahl der Komponenten und Arduino MP3-Player (10) - Auswahl der Komponenten 2 zum Einsatz kommen.

Zudem gibt es noch eine weitere Ergänzung: Anstelle des Widerstand-Kits reichen 13 3,3K-Ohm Widerstände.

Somit kommen nun folgenden Komponenten nach derzeitiger Plannung zum Einsatz:

KomponentePreis
Arduino UNO R323,80€
4 x Kunststoff-Distanzbolzen M3x10 + Schrauben M3/8 + Muttern M3
(anstelle Prototyping and Development Board)
1,84€
Jumper Wires Premium 150mm M/F Pack of 101,79€
Jumper Wires Premium 150mm M/M Pack of 10 1,79€
13 3,3K-Ohm Widerstände0,43€
11 Knöpfe Taster 3FTL610,56€
11 Kappen2,75€
6xAA Battery Holder with DC2.1 Power Jack2,80€
Kippschalter2,50€
Potentiometer 10k1,99€
Drehknopf1,89€
Lautsprecher - 7,8cm (3") Durchmesser - 8Ohm 1Watt1,95€
Schutzgitter VIS SG 11383,95€
Adafruit "Music Maker" MP3 Shield for Arduino w/3W Stereo Amp33,27€
Punkt-Streifenrasterplatine, Hartpapier, 160x100mm1,95€
Kupferlitze isoliert, 10M, 1x0,14mm0,74€
10er Pack 2:1 Schrumpfschlauch, 1,6mm schwarz0,25€
2 x Schrauben M3/10 und Muttern M30,16€
4 x Kunststoff-Distanzbolzen M3x10 + Schrauben M3/8 + Muttern M31,84€
4 x Schrauben M4/20 + Muttern M40,36€
Summe96,61€

Als nächstes schaue ich mir die Punkt-Streifenrasterplatine an und die Knöpfe, die darauf gelötet werden sollen.

Weitere Blogeinträge

  1. Auswahl der Komponenten
  2. Das Entwicklungsbrett
  3. Das erste Einschalten
  4. Die Entwicklungsumgebung
  5. Knöpfe (digital)
  6. Mehrere Knöpfe (digital)
  7. Mehrere Knöpfe (analog)
  8. Potentiometer
  9. Das MP3 Shield
  10. Auswahl der Komponenten 2
  11. Auswahl der Komponenten (Zusammenfassung) 
  12. Punkt-Streifenrasterplatine und Knöpfe
  13. Punkt-Streifenrasterplatine und weitere Komponenten

Tuesday, December 23, 2014

Arduino MP3-Player (10) - Auswahl der Komponenten 2

Nun haben wir alles zusammen - die Knöpfe, der Lautstärkeregler, das MP3 Shield - um die komplette Anwendung fertigzustellen. Mit den definierten Schaltungen und den Beispiel-Codes kann das Programm soweit ergänzt werden, dass es voll funktionsfähig ist.

Da die Schaltung allerdings nicht auf dem Entwicklungsbrett enden soll, ist es nun Zeit sich über die noch fehlenden Komponenten Gedanken zu machen.

Als erstes brauche ich größere Knöpfe, wie beispielsweise diese hier 3FTL6.
Und die passenden Kappen werden natürlich auch benötigt (1D09, 1D06, 1D03, 1D08, 1D00, 1D02, 1D04).
Die Kappen können dann einfach auf die Knöpfe gesteckt werden.
Die ganze Elektronik soll dann auf eine Punkt-Streifenrasterplatine kommen. 160x100mm sollte ausreichend sein.
Für einzelne Verbindungen kommt isolierte Kupferlitze (blau, schwarz, rot) zum Einsatz.
Für einzelne elektrische Isolierungen und zum Schutz können Schrumpfschläuche verwendet werden.
Auch das Isolierband kann für Isolierungen eingesetzt werden.
Damit der Lautsprecher geschützt ist, wird noch ein passendes Schutzgitter benötigt.
Das bisherige Potentiometer habe ich durch einen neuen Potentiometer ersetzt, der eine längere Achslänge und Gewinde hat.
Auch den bisherigen Kippschalter habe ich durch einen längeren Kippschalter ersetzt.
Auf dem Potentiometer kommt noch ein passender Drehknopf.
Für die Befestigung der Platine werde ich 4 Kunststoff-Distanzbolzen (M3x10mm) mit einem Innen- (7mm) und einem Außengewinde (8mm) verwenden. Dazu kommen passende Senkschrauben M3/8 und passende Muttern M3.
Für die Befestigung des Lautsprechers kommen 4 Senkschrauben M4/20 und passende Muttern M4 zum Einsatz.
Der Batteriehalter wird durch 2 Senkschrauben M3/10 und passenden Muttern M3 an der Platine befestigt.


Die elektronischen Teile habe ich diesmal bei Reichelt oder Conrad gekauft. Schrauben und Muttern bekommt man gut bei Zweygart.

Als nächstes werde ich mir einen Überblick über alle Komponenten verschaffen, die nun zum Einsatz kommen sollen.

Weitere Blogeinträge

  1. Auswahl der Komponenten
  2. Das Entwicklungsbrett
  3. Das erste Einschalten
  4. Die Entwicklungsumgebung
  5. Knöpfe (digital)
  6. Mehrere Knöpfe (digital)
  7. Mehrere Knöpfe (analog)
  8. Potentiometer
  9. Das MP3 Shield
  10. Auswahl der Komponenten 2
  11. Auswahl der Komponenten (Zusammenfassung)
  12. Punkt-Streifenrasterplatine und Knöpfe
  13. Punkt-Streifenrasterplatine und weitere Komponenten

Monday, December 22, 2014

Arduino MP3-Player (9) - Das MP3 Shield

Damit das MP3 Shield auf das Arduino-Board gesteckt und verwendet werden kann, müssen entweder die mitgelieferten Steckleisten zurechtgeschnitten und dran gelötet werden (https://learn.adafruit.com/adafruit-music-maker-shield-vs1053-mp3-wav-wave-ogg-vorbis-player/assembly) oder man besorgt sich passende Buchsenleisten (Header), die dann dran gelötet werden (https://learn.sparkfun.com/tutorials/arduino-shields/installing-headers-assembly).


Tipps über das Löten gibt es auf vielen Seiten, wie beispielsweise unter https://learn.sparkfun.com/tutorials/how-to-solder---through-hole-soldering oder unter https://learn.adafruit.com/adafruit-guide-excellent-soldering/tools.


Auch der 6-Pin Socket und die Endstücke für die Lautsprecher müssen drangelötet werden.


Falls noch die GPIOs des MP3 Shields benötigt werden, muss hier noch die passende Buchsenleiste (2x7) drangelötet werden.



Nachdem alles gelötet ist, kann die VS1053-Bibliothek installiert werden, die hier runtergeladen werden kann: https://learn.adafruit.com/adafruit-music-maker-shield-vs1053-mp3-wav-wave-ogg-vorbis-player/installing-software.

Das Vorgehen für die Installation innerhalb der Arduino-Entwicklungsumgebung kann hier nachgelesen werden:http://arduino.cc/en/Guide/Libraries. Für die Installation unter Visual Studio/Visual Micro muss als erstes der richtige Pfad unter "Tools-->Visual Micro-->Configure Ide location--> Sketchbook location" angegeben werden. Dann kann unter "Project-->Add/Import Sketch Library-->User" die Bibliothek "Adafruit_VS1053" geladen werden.

Mit dem Beispiel-Sketch "player_simple" kann das MP3 Shield getestet werden. Dabei muss darauf geachtet werden, dass das "shield-example object" anstelle des "breakout-example object" erzeugt wird.


Die Ausgabe des Serial Monitor gibt den Erfolg zurück.



Im nächsten Beitrag geht es um die noch fehlenden Komponenten.

Weitere Blogeinträge

  1. Auswahl der Komponenten
  2. Das Entwicklungsbrett
  3. Das erste Einschalten
  4. Die Entwicklungsumgebung
  5. Knöpfe (digital)
  6. Mehrere Knöpfe (digital)
  7. Mehrere Knöpfe (analog)
  8. Potentiometer 
  9. Das MP3 Shield
  10. Auswahl der Komponenten 2
  11. Auswahl der Komponenten (Zusammenfassung)
  12. Punkt-Streifenrasterplatine und Knöpfe
  13. Punkt-Streifenrasterplatine und weitere Komponenten

Monday, December 15, 2014

Arduino MP3-Player (8) - Potentiometer

Um die Lautstärke zu regulieren ist ein 10k Ohm Potentiometer vorgeshen. Der mittlere Pin des Potentiometers habe ich mit dem A5-Pin des Arduinos verbunden. Die äußeren Pins des Potentiometers werden mit der 5V-Stromversorgung und der Masse verbunden.




Im Programmcode sind der verwendete Pin als Konstante und der Lautstärkenpegel als Variable definiert.

// the pin of the potentiometer that is used to control the volume
const int volumePin = A5;
// variable for reading the potentiometer status
int volumeState = 0;

In der loop() Methode wird der aktuelle Status des Potentiometers ausgelesen. Der ausgelesene Wert wird in den Bereich von 0 bis 100 transformiert, um eine prozentualle Lautstärke zu erhalten. Der ausgelesene Wert wird mit dem gespeicherten Wert verglichen, wenn es eine Änderung um 2% festgestellt wird, wird der gespeicherte Wert durch den neuen ersetzt.

int state;
 
// read the state of the volume potentiometer
state = analogRead(volumePin);
 
// set the range of the volume from 0 to 100
state = map(state, 0, 1023, 0, 100);
 
// recognize state (volume) changes in steps of two
if (state < volumeState - 1 || state > volumeState + 1)
{
    // remember the new volume state
    volumeState = state;
 
    // print out the state of the volume
    Serial.print(volumePin);
    Serial.print(" volume ");
    Serial.println(volumeState);
}
delay(1); // delay in between reads for stability

Hier noch mal der gesamte Programmcode.

// constants won't change
 
// the pin of the potentiometer that is used to control the volume
const int volumePin = A5;
 
// variables will change
 
// variable for reading the potentiometer status
int volumeState = 0;
 
// the setup routine runs once when you turn the device on or you press reset
void setup()
{
    // disable LED L
    pinMode(13, OUTPUT);
    digitalWrite(13, LOW);
 
    // initialize serial communication at 9600 bits per second
    Serial.begin(9600);
}
 
 
// the loop routine runs over and over again forever
void loop()
{
    int state;
 
    // read the state of the volume potentiometer
    state = analogRead(volumePin);
 
    // set the range of the volume from 0 to 100
    state = map(state, 0, 1023, 0, 100);
 
    // recognize state (volume) changes in steps of two
    if (state < volumeState - 1 || state > volumeState + 1)
    {
        // remember the new volume state
        volumeState = state;
 
        // print out the state of the volume
        Serial.print(volumePin);
        Serial.print(" volume ");
        Serial.println(volumeState);
    }
 
    delay(1); // delay in between reads for stability
}

Als nächstes nehme ich mir das MP3 Shield näher unter die Lupe.

Weitere Blogeinträge

  1. Auswahl der Komponenten
  2. Das Entwicklungsbrett
  3. Das erste Einschalten
  4. Die Entwicklungsumgebung
  5. Knöpfe (digital)
  6. Mehrere Knöpfe (digital)
  7. Mehrere Knöpfe (analog)
  8. Potentiometer 
  9. Das MP3 Shield
  10. Auswahl der Komponenten 2
  11. Auswahl der Komponenten (Zusammenfassung)
  12. Punkt-Streifenrasterplatine und Knöpfe
  13. Punkt-Streifenrasterplatine und weitere Komponenten

Sunday, December 14, 2014

Arduino MP3-Player (7) - Mehrere Knöpfe (analog)


Um Pins zu sparen (falls diese knapp sein sollten), können die Knopfdrücke mehrerer Knöpfe auch über einen analogen Pin registriert werden (spanischer Blogeintrag dazu). Hier sind 11 Knöpfe verwendet worden. Über einen analogen Pin wird festgestellt welcher Knopf gedrückt worden ist.




Dabei werden mehrere Widerstände in Reihe geschaltet. Die Knöpfe werden so angebracht, dass bei einem Knopfdruck eine Parallelschaltung entsteht, durch die eine bestimmte Anzahl von Widerständen übersprungen wird. Der Messpunkt liegt hinter dem siebten Widerstand. Dadurch kann die Reihenschaltung auf zwei Elemente zusammengefasst werden. Das erste Element umfasst die ersten sieben Widerstände und das zweite Element umfasst die letzten sechs Widerstände. Durch einen Knopfdruck entsteht nun eine Spannungsänderung, die über den analogen Eingang ausgelesen werden kann. Über den gemessenen Spannungswert kann auf den gedrückten Knopf geschlossen werden.


Dazu der passende Programmcode, der den gelesen Wert am analogen Pin A5 ausgebiet. Zudem wird, falls eine Taste gedrückt worden ist, die Nummer dieser Taste ausgegeben.

// constants won't change

// the number of the pin that is used for the pushbuttons
const int buttonsPin = A5;

// variables will change

// variable for the pressed button
int pressedButton = 0;

// the setup routine runs once when you turn the device on or you press reset
void setup()
{
    // initialize serial communication at 9600 bits per second
    Serial.begin(9600);
}

// the loop routine runs over and over again forever
void loop()
{
    // check if a button is pressed
    pressedButton = CheckButtons();
 
    if (pressedButton != 0)
    {
        Serial.print("Taste: ");
        Serial.println(pressedButton);
        delay(100);
    }
}

// returns 0 if no button is pressed,
// else the number of the pressed button is returned (1 - 11)
int CheckButtons()
{
    int buttonsPinValue = analogRead(buttonsPin);
    int pressedButton = 0;
 
    Serial.println(buttonsPinValue);
 
    if (buttonsPinValue > 823)
    {
        // button 6 has a value of about 878
        pressedButton = 6;
    }
    else if (buttonsPinValue > 725)
    {
        // button 5 has a value of about 768
        pressedButton = 5;
    }
    else if (buttonsPinValue > 649)
    {
        // button 4 has a value of about 683
        pressedButton = 4;
    }
    else if (buttonsPinValue > 586)
    {
        // button 3 has a value of about 614
        pressedButton = 3;
    }
    else if (buttonsPinValue > 535)
    {
        // button 2 has a value of about 559
        pressedButton = 2;
    }
    else if (buttonsPinValue > 492)
    {
        // button 1 has a value of about 512
        pressedButton = 1;
    }
    else if (buttonsPinValue > 450)
    {
        // if no button is pressed the value is of about 473
        pressedButton = 0;
    }
    else if (buttonsPinValue > 400)
    {
        // button 8 has a value of about 427
        pressedButton = 11;
    }
    else if (buttonsPinValue > 340)
    {
        // button 10 has a value of about 372
        pressedButton = 10;
    }
    else if (buttonsPinValue > 267)
    {
        // button 9 has a value of about 307
        pressedButton = 9;
    }
    else if (buttonsPinValue > 178)
    {
        // button 8 has a value of about 228
        pressedButton = 8;
    }
    else if (buttonsPinValue > 0)
    {
        // button 7 has a value of about 128
        pressedButton = 7;
    }
    return pressedButton;
}

Nächstes Mal werde ich mir die Verwendung eines Potentiometers anschauen.

Weitere Blogeinträge

  1. Auswahl der Komponenten
  2. Das Entwicklungsbrett
  3. Das erste Einschalten
  4. Die Entwicklungsumgebung
  5. Knöpfe (digital)
  6. Mehrere Knöpfe (digital)
  7. Mehrere Knöpfe (analog)
  8. Potentiometer
  9. Das MP3 Shield
  10. Auswahl der Komponenten 2
  11. Auswahl der Komponenten (Zusammenfassung)
  12. Punkt-Streifenrasterplatine und Knöpfe
  13. Punkt-Streifenrasterplatine und weitere Komponenten

Sunday, November 16, 2014

Arduino MP3-Player (6) - Mehrere Knöpfe (digital)

Der Aufbau der Schaltung für mehrere Knöpfe ist nicht sonderlich anders als für einen Knopf. Es können sowohl digitale als auch analoge Pins verwendet werden. Hier sind 5 digitale und 5 analoge Pins verwendet worden. Alle werden als digitale Eingänge verwendet. Bei der Wahl der Pins ist berücksichtigt, welche Pins das MP3 Shield verwendet und welche nicht (https://learn.adafruit.com/adafruit-music-maker-shield-vs1053-mp3-wav-wave-ogg-vorbis-player/pinouts).

Digital PinVerwendet
#0TX
#1RX
#2frei
#3MP3 Shield
#4MP3 Shield
#5frei
#6MP3 Shield
#7MP3 Shield
#8frei
#9frei
#10frei
#11MP3 Shield
#12MP3 Shield
#13MP3 Shield

Als analoge Pins stehen A0 bis A5 zur Verfügung, die auch als digitale Eingänge verwendet werden können. Ein analoger Pin wird für den Potentiometer (Lautstärkeregelung) benötigt. Somit stehen insgesamt 10 Pins als digitale Eingänge vom Arduino-Board zur Verfügung. Weitere 7 Pins werden, falls benötigt,vom MP3 Shield zur Verfügung gestellt (https://learn.adafruit.com/adafruit-music-maker-shield-vs1053-mp3-wav-wave-ogg-vorbis-player/gpio-pins).


Der Programmcode ist leicht verändert worden. Zum einen wird die LED nicht mehr verwendet. Dadurch ist die Logik des Programmcodes vereinfacht worden. Zum anderen werden Arrays verwendet, deren Inhalt über eine Schleife abgearbeitet wird. Dadurch konnten Codezeilen gespart werden, im Vergleich zum Ausprogrammieren der Logik für jeden einzelnen Pin.

// constants won't change
 
// the number of the pushbutton pins
const int buttonPins[] = { 2, 5, 8, 9, 10, A0, A1, A2, A3, A4 };
 
// variables will change
 
// variable for reading the pushbutton status
int buttonStates[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 
// variable for remember the number of button pressed
int counters[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 
 
// the setup routine runs once when you turn the device on or you press reset
void setup()
{
    // initialize the pushbutton pins as input and enable internal pull-up resistor
    for (int i = 0; i < (sizeof(buttonPins) / sizeof(int)); i++)
    {
        pinMode(buttonPins[i], INPUT_PULLUP);
    }
 
    // disable LED L
    pinMode(13, OUTPUT);
    digitalWrite(13, LOW);
 
    // initialize serial communication at 9600 bits per second
    Serial.begin(9600);
}
 
 
// the loop routine runs over and over again forever
void loop()
{
    int state;
 
    // go through all button pins
    for (int i = 0; i < 10; i++)
    {
        // read the state of the pushbutton value
        state = digitalRead(buttonPins[i]);
        
        // recognize state changes: button pressed and button released
        if (state != buttonStates[i])
        {
            // remember new button state
            buttonStates[i] = state;
 
            // print out the state of the button
            Serial.print(buttonPins[i]);
            Serial.print(" State changed ");
            Serial.println(buttonStates[i]);
 
            // button is pressed
            if (buttonStates[i] == LOW)
            {
                // increment number of button pressed
                counters[i]++;
 
                // print out the number of button pressed
                Serial.print(buttonPins[i]);
                Serial.print(" counter: ");
                Serial.println(counters[i]);
            }
            // button is released
            else
            {
                // print out new line
                Serial.println();
 
                // wait before next click is recognized
                delay(100);
            }
        }
    }
}

Nächstes Mal werde ich mir eine Alternative für "Mehrere Knöpfe" mit analogen Pins anschauen.

Weitere Blogeinträge

  1. Auswahl der Komponenten
  2. Das Entwicklungsbrett
  3. Das erste Einschalten
  4. Die Entwicklungsumgebung
  5. Knöpfe (digital)
  6. Mehrere Knöpfe (digital)
  7. Mehrere Knöpfe (analog)
  8. Potentiometer
  9. Das MP3 Shield
  10. Auswahl der Komponenten 2
  11. Auswahl der Komponenten (Zusammenfassung)
  12. Punkt-Streifenrasterplatine und Knöpfe
  13. Punkt-Streifenrasterplatine und weitere Komponenten

Saturday, November 15, 2014

Arduino MP3-Player (5) - Knöpfe (digital)

Knopfdrücke können im Arduino registriert werden. Nach einem Knopfdruck können dann entsprechende Aktionen ausgeführt werden. Ein einfacher Schaltkreis kann realisiert werden indem der Knopf mit dem digitalen Port 2 und der Masse verbunden wird. Dabei wird der interne Pull-up Widerstand verwendet. Alternativ kann eine Schaltung mit einem externen Pull-down Widerstand verwendet werden. Ein Beispiel dafür ist hier zu sehen Arduino - Button.


Der Programmcode schaltet solange der Knopf gedrückt wird die LED an. Wird der Knopf wieder losgelassen, wird die LED wieder ausgeschaltet. Jeder Knopfdruck wird gezählt. Der aktuelle Status des Knopfs und die Anzahl der Knopfdrücke wird über eine serielle Kommunikation ausgegeben.

// constants won't change
const int buttonPin = 2; // the number of the pushbutton pin
const int ledPin = 13;   // the number of the LED pin
 
// variables will change
int buttonState = 0;     // variable for reading the pushbutton status
 
int counter = 0;         // variable for remember the number of button pressed
 
 
// the setup routine runs once when you turn the device on or you press reset
void setup()
{
    // initialize the LED pin as an output
    pinMode(ledPin, OUTPUT);
 
    // initialize the pushbutton pins as input and enable internal pull-up resistor
    pinMode(buttonPin, INPUT_PULLUP);
 
    // initialize serial communication at 9600 bits per second
    Serial.begin(9600);
}
 
 
// the loop routine runs over and over again forever
void loop()
{
    // read the state of the pushbutton value
    int state = digitalRead(buttonPin);
 
    // recognize state changes: button pressed and button released
    if (state != buttonState)
    {
        // remember new button state
        buttonState = state;
 
        // print out the state of the button
        Serial.print("2 State changed ");
        Serial.println(buttonState);
 
        // button is pressed
        if (buttonState == LOW)
        {
            // turn LED on
            digitalWrite(ledPin, HIGH);
 
            // increment number of button pressed
            counter++;
 
            // print out the number of button pressed
            Serial.print("2 counter: ");
            Serial.println(counter);
        }
        // button is released
        else if (buttonState == HIGH)
        {
            // turn LED off
            digitalWrite(ledPin, LOW);
        }
    }
}

Dieser Programmcode kann für Aktionen verwendet werden, die ausgeführt werden sollen, solange ein Knopf gedrückt ist. Eine Alternative zu dieser Logik ist es, dass eine Aktion bei einem Knopfdruck nur einmal ausgeführt werden soll. Dazu das folgende Beispiel. Der Programmcode schaltet bei einem Knopfdruck die LED an, bei einem weiteren Knopfdruck wieder aus. Jeder Knopfdruck wird gezählt. Der aktuelle Status des Knopfs, der LED und die Anzahl der Knopfdrücke wird über eine serielle Kommunikation ausgegeben.

// constants won't change
const int buttonPin = 2; // the number of the pushbutton pin
const int ledPin = 13;   // the number of the LED pin
 
// variables will change
int buttonState = 0;     // variable for reading the pushbutton status
int ledState = 0;        // variable for reading the LED status
 
int counter = 0;         // variable for remember the number of button pressed
 
 
// the setup routine runs once when you turn the device on or you press reset
void setup()
{
    // initialize the LED pin as an output
    pinMode(ledPin, OUTPUT);
 
    // initialize the pushbutton pins as input and enable internal pull-up resistor
    pinMode(buttonPin, INPUT_PULLUP);
 
    // initialize serial communication at 9600 bits per second
    Serial.begin(9600);
}
 
 
// the loop routine runs over and over again forever
void loop()
{ 
    // read the state of the pushbutton value
    int state = digitalRead(buttonPin);
 
    // recognize state changes: button pressed and button released
    if (state != buttonState)
    {
        // remember new button state
        buttonState = state;
 
        // print out the state of the button
        Serial.print("2 State changed ");
        Serial.println(buttonState);
 
        // button is pressed and LED is off
        if (buttonState == LOW && ledState == LOW)
        {
            // remember new LED state
            ledState = HIGH;
 
            // turn LED on
            digitalWrite(ledPin, HIGH);
 
            // print out the state of the LED
            Serial.print("2 Set high ");
            Serial.println(ledState);
 
            // increment number of button pressed
            counter++;
 
            // print out the number of button pressed
            Serial.print("2 counter: ");
            Serial.println(counter);
        }
        // button is pressed and LED is on
        else if (buttonState == LOW && ledState == HIGH)
        {
            // remember new LED state
            ledState = LOW;
 
            // turn LED off
            digitalWrite(ledPin, LOW);
 
            // print out the state of the LED
            Serial.print("2 Set low ");
            Serial.println(ledState);
 
            // increment number of button pressed
            counter++;
 
            // print out the number of button pressed
            Serial.print("2 counter: ");
            Serial.println(counter);
        }
        // button is released
        else if (buttonState == HIGH)
        {
            // print out new line
            Serial.println();
 
            // wait before next click is recognized
            delay(100);
        }
    }
}


Als nächstes werde ich die Schaltung und den Programmcode um weitere Knöpfe erweitern.

Weitere Blogeinträge

  1. Auswahl der Komponenten
  2. Das Entwicklungsbrett
  3. Das erste Einschalten
  4. Die Entwicklungsumgebung
  5. Knöpfe (digital)
  6. Mehrere Knöpfe (digital)
  7. Mehrere Knöpfe (analog)
  8. Potentiometer
  9. Das MP3 Shield
  10. Auswahl der Komponenten 2
  11. Auswahl der Komponenten (Zusammenfassung)
  12. Punkt-Streifenrasterplatine und Knöpfe
  13. Punkt-Streifenrasterplatine und weitere Komponenten

Thursday, November 13, 2014

Arduino MP3-Player (4) - Die Entwicklungsumgebung

Die Arduino Entwicklungsumgebung (Version 1.0.6) ist für die ersten Schritte ausreichend. Vor allem die enthaltenen Beispiele erleichtern den Einstieg.
Allerdings ist die Entwicklungsumgebung wenig komfortabel sobald man eigenen Code schreiben möchte. Daher habe ich mich nach Alternativen umgesehen, die das Entwickeln erleichtern, weil beispielsweise Codevervollständigung oder die Anzeige von Typen und Methodenparametern vorhanden ist.

Durch das Setzen von definierten Eigenschaften, das Einbinden von gewissen Werkzeugen oder das Installieren von bestimmten Plugins können die weitverbreiteten Entwicklungsumgebungen Microsoft Visual Studio, Atmel Studio oder Eclipse zur Entwicklung von Arduino-Software verwendet werden. Weitere Informationen dazu können unter dem Link http://playground.arduino.cc/Main/DevelopmentTools gefunden werden.

Gerade im Zusammenhang mit Visual Studio oder Atmel Studio, welches auf Visual Studio basiert, ist Arduino IDE für Visual Studio von Visual Micro interessant.

Die Arduino-Entwicklung integriert sich in Visual Studio.
Es können einige Optionen angepasst werden.
Zudem kann über Tools auf einige Funktionen zugegriffen werden.
Über "New" oder "Open" kann ein "Sketch Project" angelegt bzw. geöffnet werden.
 
Anschließend kann das Projekt in der IDE bearbeitet, hochgeladen und überwacht werden.
Mit F5 oder mit einem Klick auf "Local Windows Debugger" wird das Projekt kompiliert und auf das Arduino geladen.
Um den Serial Monitor zu nutzen, muss nach dem hochladen des Projekts immer auf "Show the serial monitor tool window" gedrückt werden.
Es öffnet sich das Fenster, in welchem die serielle Kommunikation angezeigt wird.
Um eine serielle Kommunikation in Arduino herzustellen wird in der setup() Methode diese initialisiert.
Serial.begin(9600);
In der loop() Methode kann dann die serielle Kommunikation verwendet werden. Beispielsweise können Nachrichten gesendet werden.
Serial.print("2 State changed ");
Serial.println(buttonState1);
Dies kann genutzt werden, um Fehler zu finden, was gerade dann sinnvoll ist, wenn kein Debugger zur Verfügung steht.

Eine weitere interessante Anwendung ist Fritzing. Mit dieser Anwendung können Schaltpläne erstellt werden. Es können auch die Aufbauten, die mit einer Steckplatine realisiert worden sind, visuell dokumentiert werden. Seit neustem ist in dieser Anwendung auch ein Code-Editor integriert.

Einen Schritt weiter geht es hier http://123d.circuits.io/. Hier kann das Arduino-Board sogar simuliert werden. Ich habe das Online-Tool allerdings nicht ausprobiert.


Als nächstes werde ich mich mit den Knöpfen beschäftigen und versuchen ein Knopfdruck in Arduino zu registrieren.

Weitere Blogeinträge

  1. Auswahl der Komponenten
  2. Das Entwicklungsbrett
  3. Das erste Einschalten
  4. Die Entwicklungsumgebung
  5. Knöpfe (digital)
  6. Mehrere Knöpfe (digital)
  7. Mehrere Knöpfe (analog)
  8. Potentiometer
  9. Das MP3 Shield
  10. Auswahl der Komponenten 2
  11. Auswahl der Komponenten (Zusammenfassung)
  12. Punkt-Streifenrasterplatine und Knöpfe
  13. Punkt-Streifenrasterplatine und weitere Komponenten