HobbyTronics Ltd.

http://sites.prenninger.com/arduino-uno-r3/anleitung-tutorial/hobbytronics

http://www.linksammlung.info/

http://www.schaltungen.at/

                                                                                         Wels, am 2015-12-12

BITTE nützen Sie doch rechts OBEN das Suchfeld  [                                                              ] [ Diese Site durchsuchen]

DIN A3 oder DIN A4 quer ausdrucken
**********************************************************************************
DIN A4  ausdrucken
*********************************************************
~015_b_PrennIng-a_arduino.uno.r3-anleitung.tutorial-hobbytronics (xx Seiten)_1a.pdf


          HT  HobbyTronics Ltd  11 Tutorials
Hobby Electronics Components Supplier for ARDUINO
http://www.hobbytronics.co.uk/arduino
siehe auch
http://sites.prenninger.com/arduino-uno-r3/anleitung-tutorial/tutorial


01 - Blink LED rot 5mm
02 - Modellbau-Servos
03 - Timer 1Sek. bis 50 Tage
04 - LED Lauflicht mit 5 LEDs
05 - Arduino Fade-Befehl
06 - Dreh-Impulsgeber - Rotary Encoder
07 - Buzzer - Piezo Beep
08 - Dämmerungs-Schalter - NightLight LDR05
09 - N-Kanal Power-MOSFET                95N2LH5
10 - LCD Anzeige 16x2 Zeichen            HD44780
11 - Hall-Schalter                                    A1120EUA

http://www.hobbytronics.co.uk/tutorials-code/arduino-tutorials/arduino-tutorial11-hall-effect
http://www.hobbytronics.co.uk/tutorials-code/arduino-tutorials


Arduino UNO Tutorial 01 - Flashing LED

Dieses Arduino UNO Blitzlicht LED Tutorial ist eine grundlegende Einführung in das Arduino Tutorial und zeigt, wie einfach blinkt die LED, die auf der Arduino UNO-Platine ist. Das Arduino UNO hat bereits eine LED und einen Widerstand, der mit dem Pin 13 verbunden ist, so dass wir das nutzen werden. Es sind keine weiteren Komponenten erforderlich.
 

/* Flashing LED
 * ------------
 *
 * Turns on and off a light emitting diode(LED) connected to a digital  
 * pin, in intervals of 2 seconds.
 *
 */

int ledPin = 13;                 // LED connected to digital pin 13

void setup()
{
  pinMode(ledPin, OUTPUT);      // sets the digital pin as output
}

void loop()
{
  digitalWrite(ledPin, HIGH);   // sets the LED on
  delay(1000);                  // waits for a second
  digitalWrite(ledPin, LOW);    // sets the LED off
  delay(1000);                  // waits for a second
}


Quelle:

http://www.hobbytronics.co.uk/tutorials-code/arduino-tutorials/arduino-tutorial1-flash-led




Arduino UNO Tutorial 02 - Servos

Radiosteuerung Servos sind große Stücke des Installationssatzes. Sie sind wesentlich in so ziemlich jedem Roboter zu bauen, von der Kontrolle von Armen und Beinen zu treibenden Rädern und Spuren. Servos drehen normalerweise um 180 Grad, wobei der Mittelpunkt 90 Grad die mittlere Position ist und an jedem Punkt dazwischen positioniert werden kann. Durch das Ersetzen des Stellungsrückkopplungspotentiometers im Inneren eines Servos kann ein vollständiges Drehen in beide Richtungen gemacht werden, um die Räder für Ihren Roboter anzutreiben. (Diese Modifikation ist für ein späteres Tutorial)

Also, lasst uns an das Fahren eines Servos mit dem Arduino Uno gewöhnen

Laden Sie das folgende arduino Skizzenprogramm. Wir starten mit der <Servo.h> -Datei. Diese Datei enthält alle Codierung für die Steuerung Servos, um unser Leben wirklich einfach. Als nächstes müssen wir unser Servoobjekt erstellen. Unser Servo heißt servoMain (kann aber auch beliebig genannt werden). Als nächstes kommt die setup () - Funktion und im Inneren legen wir unser Servoobjekt an Pin 10 an.

Wir können nun Befehle an unser Servo senden. In der Hauptschleife () -Funktion geben wir eine Anzahl von Befehlen aus, um das Servo in verschiedene Positionen zu drehen, mit einer Verzögerung von 1 Sekunde zwischen jedem Befehl.

 

/*
Arduino Servo Test sketch
*/
#include <Servo.h>
Servo servoMain; // Define our Servo

void setup()
{
   servoMain.attach(10); // servo on digital pin 10
}

void loop()
{
   servoMain.write(45);  // Turn Servo Left to 45 degrees
   delay(1000);          // Wait 1 second
   servoMain.write(0);   // Turn Servo Left to 0 degrees
   delay(1000);          // Wait 1 second
   servoMain.write(90);  // Turn Servo back to center position (90 degrees)
   delay(1000);          // Wait 1 second
   servoMain.write(135); // Turn Servo Right to 135 degrees
   delay(1000);          // Wait 1 second
   servoMain.write(180); // Turn Servo Right to 180 degrees
   delay(1000);          // Wait 1 second
   servoMain.write(90);  // Turn Servo back to center position (90 degrees)
   delay(1000);          // Wait 1 second   
}

On your servo you will have 3 wires. Normally black, red (center) and either orange or white.

Servo

Using some single strand hook up wire, connect the black wire to one of the Arduino 0V pins. Connect the red wire (center wire) to the Arduino 5V pin. And finally connect the orange/white wire to pin 10.

Try it out, and play around with the settings


Quelle:
http://www.hobbytronics.co.uk/tutorials-code/arduino-tutorials/arduino-tutorial2-servos



Arduino UNO Tutorial 03 - Timing

Weitergehen von Tutorial 1, wo wir eine LED blinkte eine für eine Sekunde dann aus für eine Sekunde in einer kontinuierlichen Schleife.

Das Programm ist unten gezeigt und hat einen großen Fehler. Wir verwenden die delay () -Funktion, um den Prozessor für 1 Sekunde zu verzögern, bevor die LED ein- oder ausgeschaltet wird. Während des Wartens kann der Mikrocontroller keine weiteren Funktionen in der Hauptschleife () ausführen.

 

/* Flashing LED
 * ------------
 * Turns on and off a light emitting diode(LED) connected to a digital    
 * pin, in intervals of 2 seconds.  *  
 */ 
int ledPin = 13; // LED connected to digital pin 13 
void setup() {
   pinMode(ledPin, OUTPUT); // sets the digital pin as output 
} 
void loop() {
   digitalWrite(ledPin, HIGH); // sets the LED on
   delay(1000);                // waits for a second
   digitalWrite(ledPin, LOW);  // sets the LED off
   delay(1000);                // waits for a second 
}

First, lets make a quick change to the loop() function. We will replace the two pairs of statements which turn the LED on and off with just one pair. Instead of setting the value to HIGH and then to LOW we will read it's current value and set it to the opposite using the NOT function !

void loop()
{
  digitalWrite(ledPin, !digitalRead(ledPin));   // toggles the LED on/off
  delay(1000);                  // waits for a second
}

OK, nun können die Verzögerungsfunktionen () verbessert werden. Stattdessen verwenden wir die Funktion Arduino millis ().
Die millis () -Funktion gibt die Anzahl der Millisekunden zurück, seit das Arduino-Board das laufende Programm gestartet hat. Diese Zahl wird nach ca. 50 Tagen überlaufen (zurück auf Null). So, solange Sie nicht verlassen Ihr Gerät für mehr als 50 Tage, dies ist ein guter Weg, um Timing-Funktionen durchzuführen. Sollte Ihr Gerät länger als 50 Tage bleiben, müssen Sie den Rollover in Ihrem Code berücksichtigen.

Alternativ kann für schnellere Timings die Funktion micros () verwendet werden. Dies gibt die Anzahl der Mikrosekunden zurück, seit das Arduino-Board das laufende Programm gestartet hat. Diese Zahl wird nach ca. 70 Minuten überlaufen (zurück auf Null).

Mit der millis () - Funktion steuern wir unsere LED wie bisher. Der Code dafür ist unten abgebildet


/* Flashing LED Version 2
 * ------------------------
 *
 * Turns on and off a light emitting diode(LED) connected to a digital  
 * pin, in intervals of 2 seconds using millis() function
 *
 */
int ledPin = 13;                 // LED connected to digital pin 13
unsigned long currentTime;
unsigned long loopTime;

void setup()
{
  pinMode(ledPin, OUTPUT);      // sets the digital pin as output
  currentTime = millis();
  loopTime = currentTime;  
}

void loop()
{
  currentTime = millis();
  if(currentTime >= (loopTime + 1000)){  
    digitalWrite(ledPin, !digitalRead(ledPin));   // toggles the LED on/off
    loopTime = currentTime;  // Updates loopTime
  }
  // Other processing can be done here
}

Diese Skizze verwendet zwei zusätzliche Variablen currentTime und loopTime.
In der setup () - Funktion werden beide Variablen zunächst auf denselben Wert gesetzt
In der Funktion main loop () wird currentTime immer durch die Schleife aktualisiert.
Nur wenn mindestens eine Sekunde verstrichen ist und die currentTime-Variable größer als loopTime + 1000 ist (1000 Millisekunden = 1 Sekunde), schaltet sie dann den ledPin-Wert um und setzt auch loopTime auf denselben Wert wie currentTime zurück.

Beachten Sie, dass es keine Verwendung der Verzögerung () -Funktion, so dass der Prozessor nicht gebunden Warten und kann jede zusätzliche Verarbeitung in der Hauptschleife, die erforderlich ist


Quelle:
http://www.hobbytronics.co.uk/tutorials-code/arduino-tutorials/arduino-tutorial3-timing



Arduino UNO Tutorial 04 - Simple Cylon

In diesem Arduino UNO Tutorial erweitern wir unser einfaches LED-Flash-Tutorial. Wir verwenden 5 LEDs, um einen einfachen Zylonenaugeneffekt zu verursachen. Dafür machen wir das Leben einfacher und nutzen die direkte Portmanipulation. Das heißt, wir schreiben direkt an einen der Arduino UNO-Ports, anstatt an einzelne Pins zu schreiben. Damit können die Werte für jede der LEDs in einem Arbeitsgang eingestellt werden.

Die Arduino UNO hat 3 Häfen

    
B (digitaler Stift 8 bis 13)
    
C (Analogeingangspins)
    
D (digitale Stifte 0 bis 7)

Jeder Port wird durch drei Register gesteuert, die auch definierte Variablen in der arduino-Sprache sind. Das DDR-Register bestimmt, ob der Pin ein INPUT oder OUTPUT ist. Das PORT-Register steuert, ob der Stift HIGH oder LOW ist, und das PIN-Register liest den Zustand der INPUT-Pins, die auf den Eingang mit pinMode () gesetzt sind,

Wir benutzen Port B für unsere Zylonen-Skizze. Zuerst müssen wir alle Port B Pins als digitale Ausgänge einstellen. Port B hat nur sechs Pins zugeordnet. Die Bits in dem Port-B-Register (DDRB) steuern, ob jeder der Pins in PORTB als Eingänge oder Ausgänge konfiguriert sind. Wenn ein Pin auf 1 gesetzt wird, macht er einen OUTPUT, während er auf 0 gesetzt wird, ein INPUT. Port-Pins sind von 0 bis 7 nummeriert, aber nicht alle Ports haben 8 Pins. So zum Beispiel:

DDRB = B00111110; // sets Arduino port B pins 1 to 5 as outputs, pin 0 as input

NOTE:If you have used any of Microchips microcontrollers they use the opposite strategy, where 0 is OUTPUT and 1 is INPUT

For our Cylon eye we will use port B pins 0 to 4, so we set them as outputs with

DDRB = B00011111; // sets Arduino port B pins 0 to 4 as outputs

To write to our port we use the PORTB register. We can turn on just the first LED with

PORTB = B00000001;

or we can turn on alternate LEDs with

PORTB = B00010101;


Sehen Sie, wie viel einfacher ist, als jedes LED einzuschalten / auszuschalten. Jetzt für einige einfache binäre Bit-Shift-Operatoren

Es gibt zwei Bit-Shift-Operatoren: den linken Shift-Operator << und den rechten Shift-Operator >>. Diese Operatoren bewirken, daß die Bits in dem linken Operanden nach links oder nach rechts verschoben werden, und zwar durch die Anzahl von Positionen, die durch den rechten Operanden spezifiziert sind.

E.g.
variableA = 1;      // 00000001
variableA = 1 << 0; // 00000001
variableA = 1 << 1; // 00000010
variableA = 1 << 2; // 00000100


Beachten Sie, wie die einzelne Ziffer 1 die Nummer nach oben bewegt. Dies ist die genaue Wirkung, die wir für unsere Arduino Cylon Auge Skizze brauchen

Nun zu dem Code, der unten gezeigt wird. Wir benötigen ein paar Variablen, eine (upDown), um anzuzeigen, ob wir die Port-LEDs nach oben oder unten bewegen und ein anderer (Cylon), um anzuzeigen, welche LED leuchten soll.

In setup () definieren wir die Port-Pins, die als OUTPUTs benötigt werden.

In der Hauptschleife (), wenn wir die LEDs ansteigen, erhöhen wir die Zylonvariable um 1 und testen, ob wir die letzte LED erreicht haben, wenn wir dann die Variable upDown nach unten gehen lassen. In ähnlicher Weise verringern wir die Zylonvariable um 1 und testen, ob wir die erste LED erreicht haben, wenn wir die Variable upDown nach oben setzen.

Wir leuchten dann die richtige LED auf und warten eine Sortierung, bevor wir wieder anfangen.


/*
  Simple Cylon
  Cylon Eye sweep using 5 LEDs
  
 */

unsigned char upDown=1;	// start off going UP	
unsigned char cylon=0;  // determines which LED is on 0 to 4

void setup() {                
  // initialize the digital pins as outputs.
  DDRB = B00011111;  // sets Arduino port B pins 0 to 4 as outputs	   
}

void loop() {
  if(upDown==1){
    cylon++;
    if(cylon>=4) upDown=0;      // Reached max LED, next time we need to go down
  }
  else {
    cylon--;
    if(cylon==0) upDown=1;      // Reached min LED, next time we need to go up
  }
  PORTB = 1 << cylon;
  delay(150);              // wait for a second
}

Hier ist die Schaltung auf einem Steckbrett

Arduino Simple Cylon Breadboard


Quelle:
http://www.hobbytronics.co.uk/tutorials-code/arduino-tutorials/arduino-tutorial4-cylon



Arduino UNO Tutorial 05 - Fade

Im Anschluss an unsere Arduino UNO Tutorial 3, wo wir untersucht Timing, hier ist ein Update auf die Standard-Arduino Fade Beispiel. Anstatt die verschwenderische delay () -Funktion zu verwenden, verwenden wir die Timing-Funktionalität aus Tutorial 3, die es ermöglicht, dass der andere Code gleichzeitig ausgeführt wird. Der Code sollte selbsterklärend sein.

Verbinden Sie einfach eine LED und einen Widerstand von 220 Ohm zwischen Pin 9 und Masse.
/*
 Fade
 
 This example shows how to fade an LED on pin 9
 using the analogWrite() function.
 
 This example based on the Arduino Example Fade sketch
 but modified to use timing instead of the delay() function
 
 */
int brightness = 0;    // how bright the LED is
int fadeAmount = 5;    // how many points to fade the LED by
unsigned long currentTime;
unsigned long loopTime;

void setup()  { 
  // declare pin 9 to be an output:
  pinMode(9, OUTPUT);
  currentTime = millis();
  loopTime = currentTime; 
} 

void loop()  { 
  currentTime = millis();
  if(currentTime >= (loopTime + 20)){  
    // set the brightness of pin 9:
    analogWrite(9, brightness);    

    // change the brightness for next time through the loop:
    brightness = brightness + fadeAmount;

    // reverse the direction of the fading at the ends of the fade: 
    if (brightness == 0 || brightness == 255) {
      fadeAmount = -fadeAmount ; 
    }     
    loopTime = currentTime;  // Updates loopTime
  }
  // Other processing can be done here
                           
}



Quelle:
http://www.hobbytronics.co.uk/tutorials-code/arduino-tutorials/arduino-tutorial5-fade






Arduino UNO Tutorial 06 - Rotary Encoder

Wir haben ein Tutorium für Rotary Encoder mit einem Microchip Mikrocontroller geschrieben, aber jetzt wäre eine gute Zeit, um eine Arduino UNO-Version zu machen.

Sparkfun Rotary Encoder

Mit einem Drehgeber haben wir zwei Rechteckwellenausgänge (A und B), die 90 Grad phasenverschoben zueinander sind. Die Anzahl der Impulse oder Schritte, die pro vollständiger Umdrehung erzeugt werden, variiert. Der Sparkfun Rotary Encoder hat 12 Schritte, aber andere können mehr oder weniger haben. Das nachstehende Diagramm zeigt, wie sich die Phasen A und B aufeinander beziehen, wenn der Codierer im Uhrzeigersinn oder gegen den Uhrzeigersinn gedreht wird.

Rotary Encoder Phase Pulses

Jedes Mal, wenn der A-Signalimpuls von positiv nach null geht, lesen wir den Wert des B-Impulses. Wir sehen, dass, wenn der Encoder im Uhrzeigersinn gedreht wird, der B-Impuls immer positiv ist. Wenn der Codierer gegen den Uhrzeigersinn gedreht wird, ist der B-Impuls negativ. Wenn wir beide Ausgänge mit einem Mikrocontroller testen, können wir die Drehrichtung bestimmen und die Anzahl der A-Pulse zählen, wie weit sie sich gedreht hat. Tatsächlich könnten wir eine Stufe weiter gehen und die Frequenz der Impulse zählen, um festzustellen, wie schnell sie gedreht wird. Wir sehen, dass der Drehgeber über ein Potentiometer viele Vorteile hat.

Wir werden jetzt den Drehgeber in der einfachsten Anwendung verwenden, werden wir es verwenden, um die Helligkeit einer LED durch die Änderung eines pwm-Signals zu steuern. Wir verwenden die einfachste Methode, den Encoder zu lesen, dh die Verwendung eines Timer-Interrupts, um die Werte zu überprüfen.

Wir verwenden den Funkenfunktionscodierer, wie oben diskutiert. Die erste Sache ist, festzustellen, wie schnell wir unseren Timer benötigen, um zu funktionieren. Wenn Sie sich vorstellen, dass wir im besten Fall den Drehregler um 180 Grad in 1/10 Sekunde drehen könnten, würde das uns 6 Impulse in 1/10 Sekunde oder 60 Impulse pro Sekunde geben. In Wirklichkeit ist es nie so schnell. Da wir sowohl hohe als auch niedrige Werte erkennen müssen, ergibt sich eine minimale Frequenz von 120 Hz. Lets für 200Hz nur um sicher zu gehen. (Hinweis: Da es sich bei diesen Geräten um mechanische Schalter handelt, besteht die Möglichkeit, dass der Schalter springt.

Jedes Mal, wenn unser Timer-Code auslöst, vergleichen wir den Wert unseres A-Pulses mit seinem vorherigen Wert. Wenn es von positiv auf null gegangen ist, dann prüfen wir den Wert des B-Impulses, um zu sehen, ob er positiv oder null ist. Abhängig von dem Ergebnis können wir inkrementieren dekrementieren einen Zähler. Wir verwenden dieses, um den PWM-Wert zu steuern, um die Helligkeit der LED zu erhöhen oder zu verringern
Das Schema ist unten gezeigt

Arduino Rotary Encoder Schematic

Hier ist die Schaltung auf einem Steckbrett

Arduino Rotary Encoder Breadboard

Und der Quellcode für die Skizze ist unten gezeigt. Es baut auf dem vorherigen Tutorial, wo wir die Millis () -Funktion verwendet, um uns ein Timing-Intervall. Wir verwenden die gleiche Idee, aber verwenden Sie 5ms als verstrichene Zeit überprüfen (5ms = 200Hz). Hoffentlich sollte der Code einfach genug zu verstehen und leicht modifizierbar sein, um den Rotary Encoder auf andere Verwendungen zu stellen.

/*
** Rotary Encoder Example
** Use the Sparkfun Rotary Encoder to vary brightness of LED
**
** Sample the encoder at 200Hz using the millis() function
*/

int brightness = 120;    // how bright the LED is, start at half brightness
int fadeAmount = 10;    // how many points to fade the LED by
unsigned long currentTime;
unsigned long loopTime;
const int pin_A = 12;  // pin 12
const int pin_B = 11;  // pin 11
unsigned char encoder_A;
unsigned char encoder_B;
unsigned char encoder_A_prev=0;

void setup()  {
  // declare pin 9 to be an output:
  pinMode(9, OUTPUT);
  pinMode(pin_A, INPUT);
  pinMode(pin_B, INPUT);
  currentTime = millis();
  loopTime = currentTime; 
} 

void loop()  {
  // get the current elapsed time
  currentTime = millis();
  if(currentTime >= (loopTime + 5)){
    // 5ms since last check of encoder = 200Hz  
    encoder_A = digitalRead(pin_A);    // Read encoder pins
    encoder_B = digitalRead(pin_B);   
    if((!encoder_A) && (encoder_A_prev)){
      // A has gone from high to low 
      if(encoder_B) {
        // B is high so clockwise
        // increase the brightness, dont go over 255
        if(brightness + fadeAmount <= 255) brightness += fadeAmount;               
      }   
      else {
        // B is low so counter-clockwise      
        // decrease the brightness, dont go below 0
        if(brightness - fadeAmount >= 0) brightness -= fadeAmount;               
      }   

    }   
    encoder_A_prev = encoder_A;     // Store value of A for next time    
    
    // set the brightness of pin 9:
    analogWrite(9, brightness);   
   
    loopTime = currentTime;  // Updates loopTime
  }
  // Other processing can be done here
                           
}


Quelle:
http://www.hobbytronics.co.uk/tutorials-code/arduino-tutorials/arduino-tutorial6-rotary-encoder



Arduino UNO Tutorial 07 - Piezo Beep

n diesem einfachen Arduino UNO Tutorial werden wir einen einfachen Piezo Transducer verwenden, um einige Pieptöne zu erzeugen. Piezo-Wandler sind ähnlich wie Lautsprecher, da eine angelegte Spannung bewirkt, dass sich das Piezo-Kristall bewegt und einen Klang erzeugt. Um einen Ton zu erhalten, muss eine Rechteckwelle üblicherweise im Bereich von 20 Hz bis 20 kHz angewendet werden.

Piezo-Wandler nicht mit Piezo- oder Piezo-Summern verwechseln. Diese verhalten sich genauso wie Buzzer und haben einen eingebauten Oszillator und werden durch einen Gleichstromschalter eingeschaltet. Signalspannung. Sie sind daher auf eine Frequenz beschränkt

Wir verwenden die PWM-Funktionalität des Arduino, um einen Ton auf dem Piezo-Wandler zu erzeugen.

Hinweis: Für dieses Tutorial verwenden wir nicht die Arduino-Funktion tone (), da dies eine Reihe von Einschränkungen hat

    
Kann nur auf einem Stift auf einmal verwendet werden
    
Die Verwendung der Funktion tone () stört den PWM-Ausgang auf den Pins 3 und 11

Die Funktion tone () sollte verwendet werden, wenn Sie eine andere Frequenz benötigen und / oder PWM auf den Pins 3 und 11 nicht verwenden

Die Arduino PWM läuft bei 500 Hz und erzeugt so einen guten Ton.

We use the Piezo Transducer available here.

Piezo Transducer

Schließen Sie den Wandler an Pin 9 und 0V am Arduino an

In der unten dargestellten Arduino-Skizze haben wir einen separaten Funktionsbeep () erzeugt, der das PWM-Signal an den Wandler sendet, auf eine kleine Verzögerung wartet, dann den Wandler ausschaltet und dann eine weitere kleine Verzögerung hat. So piept es einmal. Die Verzögerung (in Millisekunden) wird als Parameter übergeben. Die PWM-Pulsdauer (20 in Skizze unten) sollte nicht wichtig sein, da es die Frequenz ist, die zählt; Setzen Sie es irgendwo in der Mitte der PWM-Bereich.

Die Skizze unterhalb des Signaltons ertönt dreimal beim Start und piept dann kontinuierlich langsamer.
/*
 Piezo
 
 This example shows how to run a Piezo Buzzer on pin 9
 using the analogWrite() function.
 
 It beeps 3 times fast at startup, waits a second then beeps continuously
 at a slower pace
 
 */

void setup()  { 
  // declare pin 9 to be an output:
  pinMode(9, OUTPUT);
  beep(50);
  beep(50);
  beep(50);
  delay(1000);
} 

void loop()  { 
  beep(200); 
}

void beep(unsigned char delayms){
  analogWrite(9, 20);      // Almost any value can be used except 0 and 255
                           // experiment to get the best tone
  delay(delayms);          // wait for a delayms ms
  analogWrite(9, 0);       // 0 turns it off
  delay(delayms);          // wait for a delayms ms   
}  

Quelle:
http://www.hobbytronics.co.uk/tutorials-code/arduino-tutorials/arduino-tutorial7-piezo-beep




Arduino UNO Tutorial 08 - NightLight

In diesem Arduino UNO Tutorial werden wir einen Lichtabhängigen Widerstand (LDR) verwenden, um ein einfaches Kinderzimmernachtlicht zu schaffen, das automatisch einschaltet, wenn es dunkel wird und schaltet sich aus, wenn es Licht erhält.

Ein LDR-Widerstand ändert sich in Abhängigkeit von der Lichtmenge, die auf den Sensor trifft. Für den LDR, den wir verwenden, wird der Widerstand reduziert, wenn das auf das Gerät fallende Licht ansteigt. In Verbindung mit einem 4.7K Widerstand bildet dies einen einfachen Spannungsteiler, bei dem die Spannung über dem LDR abhängig vom Licht variiert.

Wir können diese dann in einen der Analog-Digital-Eingänge im Arduino eingeben, um die Spannung zu messen. Dann ist es eine einfache Sache der Überprüfung, ob der Wert oberhalb oder unterhalb eines Schwellwertes ist und um einen der Ausgänge ein- oder auszuschalten.

Der LDR, den wir benutzen, ist hier verfügbar


Der Schaltplan ist unten dargestellt. Wenn das Licht ansteigt, sinkt der LDR-Widerstand und daher sinkt die Spannung darüber. Somit erhöht sich die Spannung über dem Widerstand, so daß die Spannung in den Arduino-ADC zunimmt. Das Gegenteil ist wahr, da es dunkler wird.

Arduino Nightlight circuit diagram

In diesem Arduino UNO Tutorial werden wir einen Lichtabhängigen Widerstand (LDR) verwenden, um ein einfaches Kinderzimmernachtlicht zu schaffen, das automatisch einschaltet, wenn es dunkel wird und schaltet sich aus, wenn es Licht erhält.

Ein LDR-Widerstand ändert sich in Abhängigkeit von der Lichtmenge, die auf den Sensor trifft. Für den LDR, den wir verwenden, wird der Widerstand reduziert, wenn das auf das Gerät fallende Licht ansteigt. In Verbindung mit einem 4.7K Widerstand bildet dies einen einfachen Spannungsteiler, bei dem die Spannung über dem LDR abhängig vom Licht variiert.

Wir können diese dann in einen der Analog-Digital-Eingänge im Arduino eingeben, um die Spannung zu messen. Dann ist es eine einfache Sache der Überprüfung, ob der Wert oberhalb oder unterhalb eines Schwellwertes ist und um einen der Ausgänge ein- oder auszuschalten.

Der LDR, den wir benutzen, ist hier verfügbar


Der Schaltplan ist unten dargestellt. Wenn das Licht ansteigt, sinkt der LDR-Widerstand und daher sinkt die Spannung darüber. Somit erhöht sich die Spannung über dem Widerstand, so daß die Spannung in den Arduino-ADC zunimmt. Das Gegenteil ist wahr, da es dunkler wird.

Arduino Nightlight circuit diagram

Hier ist die Schaltung auf einem Steckbrett. 5V und 0V sind dem Arduino entnommen. Der Eingang geht an pin-A0



arduino Nightlight Breadboard

Unten ist die Arduino-Skizze. In dieser Skizze schalten wir die eingebaute LED einfach ein, wenn der ADC-Wert unter einen bestimmten Wert fällt. Um ein Nachtlicht zu machen, kann eine hellere LED (mit Begrenzungswiderstand ~ 220 Ohm) an den Pin 13 Ausgang angeschlossen werden.

In dem Code werden Sie feststellen, dass es einige serielle Ausgabe-Anweisungen, die kommentiert werden. Wenn Sie dies kommentieren, sehen Sie auf dem seriellen Monitor den aktuellen Wert der Spannung, die vom Arduino ADC Eingang gelesen wird. Dieser Wert liegt zwischen 0 und 1024. Bedecke den LDR mit deiner Hand und leuchte ein Licht darauf, um den Effekt zu sehen.

Ändern Sie den Wert in dem Code, in dem die LED eingeschaltet ist, auf einen geeigneten Wert.
/*
** Nightlight LDR test program
** Created 06 Feb 2010
**
** This example code is in the public domain.
** www.hobbytronics.co.uk
*/

int sensorPin = A0;            // select the input pin for the ldr
unsigned int sensorValue = 0;  // variable to store the value coming from the ldr

void setup()
{
  pinMode(13, OUTPUT);
  //Start Serial port
  Serial.begin(9600);        // start serial for output - for testing
}

void loop()
{
  // read the value from the ldr:
  sensorValue = analogRead(sensorPin);     
  if(sensorValue<400) digitalWrite(13, HIGH);   // set the LED on
  else digitalWrite(13, LOW);   // set the LED on
  
  // For DEBUGGING - Print out our data, uncomment the lines below
  //Serial.print(sensorValue, DEC);     // print the value (0 to 1024)
  //Serial.println("");                   // print carriage return  
  //delay(500);  
}

Quelle:
http://www.hobbytronics.co.uk/tutorials-code/arduino-tutorials/arduino-tutorial8-nightlight



Arduino UNO Tutorial 09 - Power

Ok, wir haben mit Dimming-LEDs in einem früheren Arduino UNO Tutorial gespielt, aber der gleiche Code kann verwendet werden, um mächtigere Komponenten wie Hochleistungs-LEDs und Elektromotoren zu steuern. Das arduino kann nicht genug Energie für diese Einzelteile zwar liefern und ziemlich häufig laufen sie auch bei viel höheren Spannungen. Leistungsstarke Motoren, die oft in der Robotik eingesetzt werden, können mit 12, 24 oder sogar 36 Volt betrieben werden.

Es gibt eine einfache Möglichkeit, die Leistungsumschaltung bereitzustellen, die diese Elemente benötigen und die über den MOSFET-Transistor erfolgt. Diese kommen in verschiedenen Typen und Leistungsfähigkeiten, aber wir werden einen bestimmten MOSFET für dieses Tutorial betrachten. Der N-Kanal-Leistungs-MOSFET der ST-Mikroelektronik 95N2LH5

Dieser MOSFET ist in der Lage, einen Dauerstrom von 80 Amps (mit Kühlkörper natürlich) zu handhaben und kann einfach mit nur 1V an seinem Gate angelegt werden. So können wir diesen MOSFET durch Einschalten der Arduino Digital-Ausgangspins direkt an den MOSFET-Gate-Pin anschließen. Wenn der MOSFET vollständig eingeschaltet ist, hat er einen Source-to-Drain-Widerstand von nur 0,0049 Ohm. Daher würde der MOSFET, wenn der MOSFET einen Elektromotor bei 12 V mit 10 Ampere versorgt, nur 0,049 Volt abfallen und 0,49 Watt Leistung verwenden.

Das folgende Diagramm zeigt, wie wir den MOSFET mit dem Motor und dem Arduino verbinden würden

Wichtiger Hinweis: Versuchen Sie nicht, Hochleistungsmotoren durch die Anschlüsse auf einem Steckbrett laufen zu lassen. Sie können nicht mit der Macht umgehen und Sie brennen die Spuren darunter aus.

Power Mosfet connection to Arduino


Mit Hilfe der Pulsweitenmodulation (PWM) Ausgänge des Arduino können wir die Leistung (und damit die Geschwindigkeit) des Elektromotors steuern.

Probieren Sie es aus mit der Skizze von Arduino Tutorial 5 und eine 12V-Autobatterie und 12V-Batterie. Die 0V Leitung muss auch an eine der 0V Anschlüsse auf dem Arduino angeschlossen werden, aber die + 12V geht nur zur Birne.

Quelle:
http://www.hobbytronics.co.uk/tutorials-code/arduino-tutorials/arduino-tutorial9-power




Arduino UNO Tutorial 10 - LCD

Wir werden nun ein LCD-Display zu unserem Arduino hinzufügen. Die Arduino IDE kommt mit einem Beispiel LCD Skizze, die eine Hitachi HD44780 kompatiblen LCD verwendet. Wir verwenden eine ähnliche LCD (Pololu 16x2 Character LCD 773 oder 772)

Nur um anders zu sein, werden wir eine kleine Erweiterung zu machen und weg mit dem Potentiometer, die normalerweise erforderlich ist, um den Bildschirm Kontrast einstellen. Stattdessen verwenden wir einen der Arduino PWM-Ausgänge, geglättet durch einen Kondensator, um einen einfachen Digital-Analog-Ausgang zu erzeugen, der es uns ermöglicht, den Bildschirmkontrast digital aus unserem Programm heraus zu steuern. Pin 9 wird als PWM-Ausgang verwendet und verbindet sich mit dem Vo-Kontrast-Pin auf dem LCD (Pin 3). Zwischen dem PWM-Ausgang und Masse liegt ein 100uF-Kondensator an.

Der Kontraststift auf dem LCD erfordert eine ziemlich kleine Spannung für ideale Anzeigebedingungen. Je niedriger die Spannung, desto höher der Kontrast und umgekehrt. Eine Spannung von ca. 0,5V bis 1V ist etwa rechts, ist aber abhängig von der Umgebungstemperatur. Wir haben den PWM-Ausgang zunächst auf 50 eingestellt (Ausgang ist auf ca. 20% der Zeit eingeschaltet), um einen Wert zu ergeben, der annähernd 1V beträgt. Sie können diese Zahl erhöhen oder verringern, um den korrekten Kontrast auf Ihrem LCD-Bildschirm zu erhalten.

Hier sind die Pinbelegung vom LCD und die entsprechende Pinbelegung am Arduino.

LCD Pin Symbol Function Arduino Pin
1 Vss ground (0 V) ground (0 V)
2 Vdd power (4.5 – 5.5 V) +5V
3 Vo contrast adjustment 9
4 RS H/L register select signal 12
5 R/W H/L read/write signal ground (0 V)
6 E H/L enable signal 11
11 DB4 H/L data bus for 4-bit mode 5
12 DB5 H/L data bus for 4--bit mode 4
13 DB6 H/L data bus for 4-bit mode 3
14 DB7 H/L data bus for 4-bit mode 2

 


Unten ist ein Mockup der Verdrahtungsanschlüsse und der Ausgang auf dem Bildschirm angezeigt


Und hier haben wir eine detailliertere Ansicht


Und hier haben wir eine detailliertere Ansicht

Und hier ist die Arduino-Skizze. Der PWM-Ausgang zur Steuerung des Kontrasts wird in der Setup-Routine durchgeführt. Wenn Sie jedoch den Kontrast manuell steuern möchten, können Sie mit dem Hinzufügen von zwei Drucktasten und ein bisschen mehr Codierung den Kontrast erhöhen oder verringern Einfache Schritte innerhalb des Programms.

/*
 LiquidCrystal Library - Hobbytronics
 
 Demonstrates the use a 16x2 LCD display.  The LiquidCrystal
 library works with all LCD displays that are compatible with the 
 Hitachi HD44780 driver. There are many of them out there, and you
 can usually tell them by the 16-pin interface.
 
 This sketch prints "Hobbytronics" to the LCD
 and shows the time.
 This sketch is based on the Arduino sample sketch at 
 http://www.arduino.cc/en/Tutorial/LiquidCrystal
 but with modifications  to the LCD contrast to make it 
 adjustable via software
 
  The circuit:
 * LCD RS pin to digital pin 12
 * LCD Enable pin to digital pin 11
 * LCD R/W pin to Ground 
 * LCD VO pin (pin 3) to PWM pin 9
 * LCD D4 pin to digital pin 5
 * LCD D5 pin to digital pin 4
 * LCD D6 pin to digital pin 3
 * LCD D7 pin to digital pin 2

 */

// include the library code:
#include <LiquidCrystal.h>

// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup() {
  // declare pin 9 to be an output:
  pinMode(9, OUTPUT);  
  analogWrite(9, 50);   
  // set up the LCD's number of columns and rows: 
  lcd.begin(16, 2);
  // Print a message to the LCD.
  lcd.print("  HobbyTronics");
}

void loop() {
  // set the cursor to column 0, line 1
  // (note: line 1 is the second row, since counting begins with 0):
  lcd.setCursor(0, 1);
  // print the number of seconds since reset:
  lcd.print(millis()/1000);
}

Hinweis auf 16x4 Displays.
Es gibt einen gut dokumentierten Fehler in der Arduino LCD-Bibliothek im Hinblick auf alle 16x4-Displays.
Das Problem ist, dass die 16x4 hat unterschiedliche Startadressen für Zeilen 3 und 4 als die 20x4, für die die Bibliothek geschrieben wird.Dies bedeutet, dass der lcd.setCursor Befehl funktioniert nicht richtig für die Zeilen 3 und 4.

Es gibt zum Glück eine einfache Lösung. Anstelle von lcd.setCursor (0,3), um die Position am Anfang von Zeile 3 zu setzen, sollten Sie lcd.setCursor (-4,3) verwenden. Gleiches gilt für Zeile 4.


Quelle:

http://www.hobbytronics.co.uk/tutorials-code/arduino-tutorials/arduino-tutorial10-lcd



Arduino UNO Tutorial 11 - Hall Effect Switch

Ok, das ist leicht zu machen. Wir werden einen Halleffekt-Schalter verwenden, um die eingebaute LED des Arduino UNO mit einem Magnet ein- und auszuschalten.

Wir verwenden den Allegro Microsystems A1120EUA Halleffektschalter

     Verbinden Sie den Pin 1 des Schalters mit der Arduino + 5V Versorgung (roter Draht)
     Verbinden Sie Pin 2 mit 0V (schwarzes Kabel)
     Verbinden Sie den Pin 3 mit dem Arduino-Eingangspin 12 (orangefarbener Draht)

Ein Pull-up-Widerstand wird zwischen Pin 1 und Pin 3 benötigt, um den Ausgang des Schalters auf +5 V zu ziehen.

Wenn der Schalter einen Magneten erkennt, zieht er seinen Ausgangspin niedrig, was wir leicht auf der Arduino-Platine erkennen können.

  Hier ist die Schaltung auf einem Steckbrett

Arduino UNO and Hall Effect Switch

Der Arduino Sketch

/*
 Hall Effect Switch
 
 Turns on and off a light emitting diode(LED) connected to digital  
 pin 13, when Hall Effect Sensor attached to pin 2 is triggered by a magnet
 
 Hall effect sensor used is the A1120EUA from Allegro Microsystems
 
 This example code is in the public domain.
 
 http://www.hobbytronics.co.uk/arduino-tutorial8-hall-effect
*/

// constants won't change. They're used here to set pin numbers:
const int hallPin = 12;     // the number of the hall effect sensor pin
const int ledPin =  13;     // the number of the LED pin
// variables will change:
int hallState = 0;          // variable for reading the hall sensor status

void setup() {
  // initialize the LED pin as an output:
  pinMode(ledPin, OUTPUT);      
  // initialize the hall effect sensor pin as an input:
  pinMode(hallPin, INPUT);     
}

void loop(){
  // read the state of the hall effect sensor:
  hallState = digitalRead(hallPin);

  if (hallState == LOW) {     
    // turn LED on:    
    digitalWrite(ledPin, HIGH);  
  } 
  else {
    // turn LED off:
    digitalWrite(ledPin, LOW); 
  }
}

Quelle:
http://www.hobbytronics.co.uk/tutorials-code/arduino-tutorials/arduino-tutorial11-hall-effect



DIN A4 ausdrucken
*********************************************************

Impressum: Fritz Prenninger, Haidestr. 11A, A-4600 Wels, Ober-Österreich, mailto:schaltungen@schaltungen.at
ENDE



Comments