Basteln_mit_dem_Arduino-2

Ausgabe von analogen Werten
PWM-Ausgänge: 3, 5, 6, 9, 10, and 11..
int ledPin = 9;
pinMode(ledPin, OUTPUT);
Output von 0 - 255
PWM
int brightness = 0;
int fadeAmount = 5;
void setup() {
pinMode(9, OUTPUT);
}
void loop() {
analogWrite(9, brightness);
brightness = brightness + fadeAmount;
if (brightness == 0 || brightness == 255) {
fadeAmount = -fadeAmount ;
}
delay(30);
}
EEPROM
Das EEPROM des Arduino ist ein 512 Byte großer Speicher, den man
beschreiben und auslesen kann. Der Speicherinhalt bleibt beim ausschalten
erhalten. Das EEPROM kann ca. 100.000 mal beschrieben werden!
#include <EEPROM.h>
value = EEPROM.read(address);
//lesen
EEPROM.write(addr, 0);
//löschen
EEPROM.write(addr, val);
//schreiben
Einfacher Timer
Installiert einen einfachen Timer, der alle 7 Sekunden eine Nachricht erzeugt
unsigned long previousTime = 0;
void setup()
{
Serial.begin(9600);
previousTime = millis(); // millis gibt den Wert seit Einschalten des Arduino an
}
void loop()
{
if ((millis() - previousTime) >= 7000 )
{
Serial.println(„7 Sekunden sin vorbei");
previousTime = millis();
}
}
Timer 1
Der Arduino hat 3 Timer. Jeder Timer hat verschiedene Funktionen
So kann periodisch ein Programm aufgerufen werden. Z.B. kann man
so eine LED blinken lassen, ohne dass das eigentliche Programm beeinflußt wird.
Am besten lädt man sich eine Library, wo die wichtigsten Teile schon definiert sind.
http://code.google.com/p/arduino-timerone/downloads/list
Timer1
#include "TimerOne.h"
void setup()
{
pinMode(10, OUTPUT);
Timer1.initialize(500000);
// Timer 1 initialisieren und auf 0,5 sek setzen
Timer1.attachInterrupt(LED); // ruft „LED“ auf, wenn Zeit abgelaufen ist
}
void LED()
{
digitalWrite(10, digitalRead(10) ^ 1); //Toggle LED
}
void loop()
{
// irgendein Programm
}
Der Initialisierungswert ist in Mikrosekunden
Funktioniert nur mit Pin 9 oder 10
Infrarot-Dekoder (RC5-Code)
Wir benötigen eine zusätzliche Library:
Library: http://www.arcfn.com/2009/08/multi-protocol-infrared-remote-library.html
Die Library muss in den Ordner „Arduino/Library“ kopiert werden.
Ausgeben des Codes auf dem Monitor
IR1
#include <IRremote.h>
int RECV_PIN = 11;
IRrecv irrecv(RECV_PIN);
decode_results results;
void setup()
{
Serial.begin(9600);
irrecv.enableIRIn();
}
void loop()
{
if (irrecv.decode(&results))
{
Serial.println(results.value, HEX);
irrecv.resume(); // Receive the next value
}
}
Plus
Minus
out
Infrarot-Dekoder (RC5-Code)
IR2
#include <IRremote.h>
int RECV_PIN = 11;
IRrecv irrecv(RECV_PIN);
decode_results results;
void setup()
{
Serial.begin(9600);
irrecv.enableIRIn(); // Start the receiver
}
Bei Betätigen der Ziffern 1,2,3- … werden
auf dem Monitor die Schriftfolgen „Eins,
Zwei, Drei…“ ausgegeben
Hier wie Anschlüsse der 2 bekanntesten Typen:
void loop() {
if (irrecv.decode(&results)) {
int i = (results.value);
switch (i) {
case 1: Serial.println ("Eins");
break;
case 2: Serial.println ("Zwei");
break;
case 3: Serial.println ("Drei");
break;
}
irrecv.resume(); // Receive the next value
}
}
Wichtige Daten der IR-Empfänger-Module:
36 KHz
950nm
TSOP 31236
Infrarot-Sender
LD274
SFH415
Infrarot senden
IR3
#include <IRremote.h>
IRsend irsend;
void setup() {
Serial.begin(9600);
}
void loop()
{
irsend.sendSony(01, 12);
delay(100);
}
Library findet sich unter:
http://www.arcfn.com/2009/08/multi-protocol-infrared-remote-library.html
Infrarot-Datenübertragung
Im Monitor eingegeben Zeichen werden zum Empfänger
übertragen und auf dem LCD dargestellt. Das Löschen
des LCD geschieht mit dem #.
Empfamgsprogramm
ir_rcv.ino
Sendeprogramm
#include <IRremote.h>
#include <LiquidCrystal.h>
int RECV_PIN = 11;
IRrecv irrecv(RECV_PIN);
decode_results results;
LiquidCrystal lcd(7,6,2,3,4,5);
ir_send_ser.ino
void setup()
{
irrecv.enableIRIn();
lcd.begin(16, 2);
}
void loop()
{
if (irrecv.decode(&results))
{
char zeichen = results.value;
if (zeichen == 35) //wenn # dann löschen
{
lcd.clear();}
else
{ lcd.print(zeichen);
}
irrecv.resume(); // Receive the next value
}
}
#include <IRremote.h>
IRsend irsend;
void setup() {
Serial.begin(9600);
}
void loop()
{
if (Serial.available() > 0) {
char zeichen = Serial.read();
irsend.sendRC5(zeichen, 12);
delay(4);
}
}
Reflektor-Koppler
A0
Reflektor-Koppler
Einfacher Test des Reflekor-Kopplers
CNY1
int sensorValue;
void setup() {
Serial.begin(9600);
}
void loop()
{
sensorValue = analogRead(0);
Serial.println(sensorValue, DEC);
delay(100);
}
Gelesene digitale Werte
ausgeben.
CNY2 (mit Servo)
#include <SoftwareServo.h>
SoftwareServo myservo;
int cny = 0;
int val; int cny = 0;
void setup()
{
myservo.attach(2);
}
void loop()
{
val = analogRead(cny);
if (val < 400) {myservo.write(0); }
else {myservo.write(180); }
delay(15);
SoftwareServo::refresh();
}
Hell, dann drehe nach links,
sonst drehe nach rechts
Infrarot „TV-Go“
Sketch:
http://www.arcfn.com/2010/11/improved-arduino-tv-b-gone.html
Gleichstrommotor
Spannung je nach Motor!!!
Bei den kleinen Solarmotoren mit +5V
vom Arduino verbinden.
Motor2
Funktion des Programms:
Eingabe von 0-5 im Monitor
Damit wird die Geschwindigkeit in
5 Stufen eingestellt.
Regelung eines Gleichstrommotors durch PWM
Motor2
//0 = aus, 1-5 = Geschwindigkeit
void setup() {
pinMode(9, OUTPUT);
Serial.begin(9600);
}
void loop() {
if (Serial.available() > 0) {
int a = Serial.read();
Serial.print (a);
switch (a) {
case 48: analogWrite (9,0); //48 = Ascii für 0
break;
case 49: analogWrite (9,50); // sehr langsam
break;
case 50: analogWrite (9,100);
break;
case 51: analogWrite (9,150);
break;
case 52: analogWrite (9,200);
break;
case 53: analogWrite (9,255); //volle Geschwindigkeit
break;
}
}
}
weite
Gleichstrommotor
Drehrichtungsumkehr
mit H-Brücke
Gleichstrommotor
Gleichstrommotor regeln
H293_1
int EN1 = 8; //enable
int IN1 = 9; //1A
int IN2 = 10; //2A
void setup()
{
pinMode(8, OUTPUT);
pinMode(9, OUTPUT);
pinMode(10, OUTPUT);
Serial.begin(9600);
}
void loop()
{
char val;
while(1)
{
val = Serial.read();
if(val!=-1)
{
switch(val)
{
case 'r':
Serial.println("rechts");
digitalWrite (EN1,true);
digitalWrite (IN1,false);
digitalWrite (IN2,true);
break;
case 'l':
Serial.println("links");
digitalWrite (EN1,true);
digitalWrite (IN1,true);
digitalWrite (IN2,false);
break;
case 's':
Serial.println("stop");
digitalWrite (EN1,true);
digitalWrite (IN1,false);
digitalWrite (IN2,false);
break;
}
}
}
}
Gleichstrommotor über Infrarot steuern
H293_2
#include <IRremote.h>
int RECV_PIN = 11;
IRrecv irrecv(RECV_PIN);
decode_results results;
int EN1 = 8; //enable
int IN1 = 9; //1A
int IN2 = 10; //2A
void setup()
{
pinMode(8, OUTPUT);
pinMode(9, OUTPUT);
pinMode(10, OUTPUT);
Serial.begin(9600);
irrecv.enableIRIn();
}
void loop()
{
if (irrecv.decode(&results)) {
int val = (results.value);
switch(val)
{
case '1':
Serial.println("rechts");
digitalWrite (EN1,true);
digitalWrite (IN1,false);
digitalWrite (IN2,true);
break;
case '2':
Serial.println("links");
digitalWrite (EN1,true);
digitalWrite (IN1,true);
digitalWrite (IN2,false);
break;
case '3':
Serial.println("stop");
digitalWrite (EN1,true);
digitalWrite (IN1,false);
digitalWrite (IN2,false);
break;
}
}
}
1 = rechtsrun
2 = linksrum
3 = stop
Servo ansteuern
Anschlüsse:
schwarz: GND (Minus)
Rot: + 5V
Gelb: Signal (Pin 2)
Mit einem Potentiometer die Position des Servos steuern
Servo1
#include <Servo.h>
Servo myservo;
int potipin = 0;
int val;
void setup()
{
myservo.attach(2);
}
void loop()
{
val = analogRead(potipin);
val = map(val, 0, 1023, 0, 179);
myservo.write(val);
delay(15);
}
// Objekt erzeugen
// Poti an A0
// Zugriff zum Servo an Pin 2
// liest Potentiometer (Werte zwischen 0 and 1023)
// Skalieren
// Servo stellen
Servo ansteuern
Mit der IR-Fernsteuerung den Servo steuern
Servo2
#include <Servo.h>
#include <IRremote.h>
int RECV_PIN = 11;
IRrecv irrecv(RECV_PIN);
decode_results results;
Servo myservo;
int potipin = 0;
int val = 90;
void setup()
{
myservo.attach(2);
irrecv.enableIRIn();
}
void loop()
{
if (irrecv.decode(&results)) {
int val = (results.value);
switch (val)
{
case '1':
myservo.write(val += 10);
break;
case ‚2':
myservo.write(val -= 10);
break;
}
}
}
// Objekt erzeugen
// Poti an A0
//Mittelstellung anfahren
// Zugriff zum Servo an Pin 2
Fährt zufällige Positionen an
#include <Servo.h>
Servo myservo;
void setup()
{
myservo.attach(2);
}
void loop()
{
int randNumber = random(180);
myservo.write(randNumber);
delay (300);
}
Fährt immer hin und her
#include <Servo.h>
Servo myservo; int pos = 0;
void setup()
{
myservo.attach(2);
}
void loop()
{
for(pos = 0; pos < 180; pos += 1)
{
myservo.write(pos); delay(15);
}
for(pos = 179; pos>=0; pos-=1)
{
myservo.write(pos); delay(15);}
}
Eingabe von „1“ dreht den Servo weiter
#include <Servo.h>
Servo Theodor;
int wert; int wertneu;
void setup()
{
Theodor.attach(2);
Serial.begin(9600);
}
void loop()
{
if (Serial.available() > 0)
{
wert = Serial.read();
if (wert==49)
{
position = position + 1;
Theodor.write(position);
}
}
servo.attach(pin, min, max)
servo.write(angle);
servo.read()
servo.attached()
servo.detach()
}
// 49 = ASCII „1““
Schrittmotor
Schrittmotor
Stepper1
#include <Stepper.h>
const int stepsPerRevolution = 200
Stepper myStepper(stepsPerRevolution, 2,3,4,5);
int stepCount = 0;
void setup() {
Serial.begin(9600);
}
void loop() {
int sensorReading = analogRead(A0);
int motorSpeed = map(sensorReading, 0, 1023, 0, 100);
if (motorSpeed > 0) {
myStepper.setSpeed(motorSpeed);
myStepper.step(stepsPerRevolution/100);
}
}
Porterweiterung mit Shift-Register HC595
595-Port
int taktPin = 8;
int speicherPin = 9;
int datenPin = 10;
byte wert = B10101010; //zu übertragender Wert Binär
void setup(){
pinMode(taktPin, OUTPUT);
pinMode(speicherPin, OUTPUT);
pinMode(datenPin, OUTPUT);
}
void loop(){
digitalWrite(speicherPin, LOW);
shiftOut(datenPin, taktPin, MSBFIRST, wert);
digitalWrite(speicherPin, HIGH);
delay(20);
}
Porterweiterung mit Shift-Register HC595
Taktung
Shift-Register
Mit nur 3 Verbindungen das LCD bedienen
Benötigt wird eine spezielle Library
Library hierzu:
http://cjparish.blogspot.com/2010/01/controlling-lcd-display-with-shift.html
595-LCD
#include <ShiftLCD.h>
ShiftLCD lcd(2, 4, 3);
void setup() {
lcd.begin(16, 2);
lcd.print("Hello, World!");
}
void loop() {
lcd.setCursor(0, 1);
lcd.print(millis()/1000);
}
LCD über I2C-Bus anschließen
Library holen von der Seite:
www.arduino.cc/playground/Code/LCDi2c
unter PCF8574-HD44780
I2C-LCD
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x38,16,2); //Adresse 0x38 für I2C
void setup()
{
lcd.init();
lcd.print(„Halloele!“)
}
void loop()
{
}
Uhr mit PCF8583 an I2C-Bus
Library: https://github.com/edebill/PCF8583
Den Widerstand an Pin 7 (int) nicht vergessen!
Uhr mit PCF8583 I2C
Beispiel
I2C-Uhr
#include <Wire.h> // necessary, or the application won't build properly
#include <stdio.h>
#include <PCF8583.h>
/*****************************************************************************
* read/write serial interface to PCF8583 RTC via I2C interface
* Arduino analog input 5 - I2C SCL (PCF8583 pin 6)
* Arduino analog input 4 - I2C SDA (PCF8583 pin 5)
* You can set the type by sending it YYMMddhhmmss;
* the semicolon on the end tells it you're done...
******************************************************************************/
int correct_address = 0;
PCF8583 p (0xA0);
void setup(void){
Serial.begin(9600);
Serial.print("booting...");
Serial.println(" done");
}
void loop(void){
if(Serial.available() > 0){
p.year= (byte) ((Serial.read() - 48) *10 + (Serial.read() - 48)) + 2000;
p.month = (byte) ((Serial.read() - 48) *10 + (Serial.read() - 48));
p.day = (byte) ((Serial.read() - 48) *10 + (Serial.read() - 48));
p.hour = (byte) ((Serial.read() - 48) *10 + (Serial.read() - 48));
p.minute = (byte) ((Serial.read() - 48) *10 + (Serial.read() - 48));
p.second = (byte) ((Serial.read() - 48) * 10 + (Serial.read() - 48)); // Use of (byte) type
casting and ascii math to achieve result.
if(Serial.read() == ';'){
Serial.println("setting date");
p.set_time();
}
}
p.get_time();
char time[50];
sprintf(time, "%02d/%02d/%02d %02d:%02d:%02d",
p.year, p.month, p.day, p.hour, p.minute, p.second);
Serial.println(time);
delay(3000);
}
Uhr mit PCF8583 mit Batterie I2C
Schaltung für die Uhr mit Gangreserve
Eeprom an I2C-Bus anschließen
#include <Wire.h> //I2C library
Visualisierung mit Procesing
Arduino-Teil – erzeugen von analogen Messwerten mittels Poti
int Messwert;
int Spannung;
void setup() {
Serial.begin(9600);
}
void loop() {
Messwert=analogRead(5);
Serial.println(Messwert);
delay(10);
}
Processing-Teil: Werte als veränderlicher Kreis darstellen
import processing.serial.*;
int valPoti;
float valFloat;
int linefeed = 10;
Serial serport;
void setup () {
size(600, 600);
serport = new Serial(this, Serial.list()[Serial.list().length-1], 9600);
}
void draw() {
while (serport.available() > 0) {
String valString = serport.readStringUntil(linefeed);
if (valString != null)
{
print(valString);
valFloat=float(valString);
valPoti=int(valFloat);
}
}
background(153);
fill(255,200,0);
ellipse(200,200,valPoti,valPoti);
serport.clear();
}

Download Report