|
http://sites.schaltungen.at/arduino-uno-r3/anleitung-tutorial/hobbytronics
Wels, am 2015-12-12BITTE 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
Untergeordnete Seiten (12):
HT HobbyTronics Ltd 11 Tutorials
Hobby Electronics Components Supplier for ARDUINO siehe auchhttp://www.hobbytronics.co.uk/arduino http://sites.schaltungen.at/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 /* 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 13void 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} 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 Servovoid 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.
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
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 13unsigned 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
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. 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 4void 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
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 isint fadeAmount = 5; // how many points to fade the LED byunsigned 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 } 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.
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.
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
Hier ist die Schaltung auf einem Steckbrett
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 brightnessint fadeAmount = 10; // how many points to fade the LED byunsigned long currentTime;unsigned long loopTime;const int pin_A = 12; // pin 12const int pin_B = 11; // pin 11unsigned 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 }
Arduino UNO Tutorial 07 - Piezo Beep 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.
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 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
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
Hier ist die Schaltung auf einem Steckbrett. 5V und 0V sind dem Arduino entnommen. Der Eingang geht an pin-A0
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 ldrunsigned int sensorValue = 0; // variable to store the value coming from the ldrvoid 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 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.
Mit Hilfe der Pulsweitenmodulation (PWM) Ausgänge des Arduino können wir die Leistung (und damit die Geschwindigkeit) des Elektromotors steuern. http://www.hobbytronics.co.uk/tutorials-code/arduino-tutorials/arduino-tutorial9-power
Arduino UNO Tutorial 10 - LCD 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.
Unten ist ein Mockup der Verdrahtungsanschlüsse und der Ausgang auf dem Bildschirm angezeigt
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 pinsLiquidCrystal 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. Hier ist die Schaltung auf einem Steckbrett
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 pinconst int ledPin = 13; // the number of the LED pin// variables will change:int hallState = 0; // variable for reading the hall sensor statusvoid 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:
DIN A4 ausdrucken
|
Anleitung-Tutorial >
