Schrittmotoren kann man aus alten Druckern, Scannern ausbauen oder z.B. billig im Webshop http://www.muero-fraeser.de/ kann man Schrittmotoren für 2,98 Euro kaufen. Leider fehlt oft ein Datenblatt oder ähnliches. Im Fall der Schrittmotoren von Müro — Fräsen und Mehr ist das einzige was man erfährt: Schrittmotor unipolar 12V; 3,6°; 240 mA
Zuerst muss man herausfinden wie die 6 Drähte anzuschließen sind. Dazu kann man die Widerstände zwischen jeweils zwei Drähten messen und auf der Seite Javascript Page to determine stepper wires in eine Tabelle eintragen, die Seite liefert einem dann die richtige Reihenfolge:
Bipolar Stepper Wiring Report
————————————-
Date (user): 29. Mai 2012 22:59:21 MESZ
(script version wires4.htm – plp 2005)
— Description:
Schrittmotor unipolar 12V; 3,6°; 240 mA manufacturer: unknown, dimensions:
— End Description
— Wire Identification:
1 white, 2 yellow, 3 red, 4 black, 5 orange, 6 brown
— End Wire Identification
Your motor wiring, as detected by the script, is:
6 wire motor:
————-
Group A Common: 1 phases: 2 3
Group B Common: 4 phases: 5 6
Not connected: 7
Not connected: 8
Zusätzlich findet man auf der Seite http://www.piclist.com/techref/io/steppers.htm Anleitungen (in Englisch) um zusätzliche Informationen zum Schrittmotor, wie Drehmoment, Leistungsaufnahme etc. herauszufinden.
Adafruit Motor/Stepper/Servo Shield for Arduino kit – v1.0
Anschluss Nr.
Drahtfarbe
Bezeichnung
1
gelb
M1 A
2
rot
M1 B
3
schwarz und weiß
GND
4
orange
M2 A
5
braun
M2 B
Wenn man das MotorShield von adafruit verwendet muss man eine externe Spannungsquelle anschließend (die Spannungsversorgung über den Arduino Uno reicht nicht aus).
In diesem Beitrag möchte ich meine Versuch mit Arduino und Android dokumentieren.
Ausgangspunkt war für mich das Video von der Android Open 2011: Massimo Banzi, “Arduino & Android, Infinite Possibilities”
In diesem Video beschreibt Herr Banzi, verschiedene Möglichkeiten des Zusammenspiels von Arduino und Android.
Auf der Blog-Seite des Arduino-Projekt ist diesem Thema eine Kategorie gewidmet.
Der Post Tutorial: Arduino UNO + Google’s ADK von Alex TC hat mein Interesse geweckt. Leider ist er auf spanisch, aber dank Google-Übersetzer ist er eigentlich ganz gut lesbar. Es gibt nur ein paar Fußangeln, über die ich im Folgenden berichten möchte.
Für den Arduino Uno benötigen man noch
ein USB-Host-Shield und
die Hardware die über Android gesteuert werden soll.
Ein Telefon oder Gerät Android-Version 2.3.4 oder 3.1 (ich habe ein HTC Magic mit Androide 2.2.3 das ich noch updaten muss.)
An Software für den PC oder Mac benötigt man:
Java JDK Version 1.6 oder 1.7
Android SDK
Eclipse
Arduino IDE Version 0023 (Wichtig!)
Installation der Software
Wenn der Java Development Kit (JDK) noch nicht installiert ist, installiert man die Version 1.7 von JDK. In GNU/Linux kann es leicht aus dem Paket-Manager auswählen, für Mac OS X und Windows kann es von hier herunterladen werden.
Nun muss der Androide SDK heruntergeladen werden (die Version von Android ist nicht so wichtig, da man später mit Eclipse die benötigte Version und die zusätzlich Tools bequem installieren kann).
Eclipse herunterladen und die zwei Plugins Subclipse und ADT Plugin installieren.
Eclipse muss nicht installiert werden. Es genügt den gezippten Ordner zu entpacken und die ausführbare Datei Eclipse zu starten.
Nach dem öffnen von Eclipse, müssen die zwei Plugins installiert werden. Dazu geht man unter in Eclipse zu dem Menü-Punkt Help -> „Install new Software …“ und fügt über den Button „ADD“ die Quelle http://subclipse.tigris.org/update_1.8.x des Plugins Subclipse hinzu. Danach kann man das Plugin auswählen und mit „Next“ und „Finish“ installieren. Um das ADT Plugin Plugin zu installieren wiederholt man die Vorherigen Schritte mit der Quelle: https://dlssl.google.com/android/eclipse/.
Nun müssen noch die benötigten Pakete des Android SDKs zum Kompilieren und Ausführen des Projekts heruntergeladen werden. Um dies zu tun, gehen man im Eclipse-Menu über „Window“ zu „Android SDK“, man wählt folgende Pakete „Tools“ „Android 2.3.2 (API10)“ und „Extras“ aus und drückt den Button „install“. Wenn man mit Windows arbeite sollten auch die USB-Treiber installiert werden.
(optional) Um ein virtuelles Gerät zu erstellen, geht man im Eclipse-Menu über „Window“ zu „ADV Manager“ und wählt im „Android Virtual Devices“ den Button „New“. Nachdem man dem virtuellem Gerät einen Namen gegeben hat, kann die Version von Android (2.3.2) ausgewählt werden zusätzlich kann noch eine SD-Karte mit mindestens 256 Megabyte Speicher hinzugefügt werden. Die anderen Optionen können auf Standardeinstellungen bleiben.
Die Adruino IDE Version 0023 herunterladen und entpacken. Achtung: Die Version 1.0 unterstützt nicht das USB-Host-Shield. (Stand Dezember 2011)
Herunterladen der verschiedenen Projekt Dateien
Das ADK Packet herunterladen. Das ADK Packet enthält die Firmware für das ADK-Board und die Hardware Design Files für das ADK-Board and Shield.
Arduino Sketch-Datei von http://blog.bricogeek.com herunterladen.
Nun müssen die richtigen Dateien an den richtigen Ort kopiert werden.
Aus dem AKD-Paket wird der Ordner „AndroidAccessory“ aus dem Verzeichnis „Firmeware/adruion_libs/“ in das Verzeichnis mit den lokalen Arduino Bibliotheken kopiert. Unter Mac OS X ist es das Verzeichnis „Documents/Adruino/libraries/“.
Notes: 1
Der Ordner mit der modifizierten UBS-Host-Shield Bibliothek „USB_Host_Shiled“ wird ebenfalls in das Verzeichnis mit den lokalen Arduino Bibliotheken kopiert.
Wenn man jetzt die Sketch-Datei mit der Adruino IDE (Version 0023) öffnet sollte es ohne Probleme kompiliert und auf den Arduino Uno mit USB-Host-Shield geladen werden können.
Konfiguration und Kompilierung des AKD-Packets unter Eclipse
In Eclipse erstellen man ein neues Projekt. Im Eclipse-Menu „File“ „New“ wählen man „Android Project“.
Im Dialogfeld nennt man das neue Projekt „DemoKit“. Man wählt „Create a project from existing source“, und wählt als Quelle den „app“-Ordner des AKD-Packtes. Nun geht man zum nächsten Dialog über den Button „Next“.
Man wählen die Android-Version „Googles APIs“ Version „2.3.3“ API Level „10“ aus und drückt den Button „Finish“.
Nun muss doch das USB-Debbuging auf „true“ gesetzt werden. Dazu öffnet man am einfachsten in den Projekt-Source die Datei „AndroidManifest.xml“ und wählt unter „Application“ im Unterpunkt „Debuggable“ „true“ aus.
Wenn man jetzt ein Telefon via USB-Kabel an den Computer verbindet und in Eclipse auf „Run“ drückt (grünes Symbol mit einem Pfeil direkt rechts neben dem Symbol Bug), wird die Anwendung „DemoKit“, mit der das Arduino-Board kontrolliert werden kann, auf dem Telefon installiert.
Das Zusammenspiel von Processing und Arduino eröffnet viele Möglichkeiten.
Am Beispiel einer einfachen Wetterstation möchte ich das verdeutlichen.
Was ganze soll ungefähr so aussehen.
Das zentrale Feld soll je nach Temperatur seine Farbe ändern.
Arduino — Misst die Temperatur
Aufgaben von Arduino (Microkontroller Board)
Messen der Temperatur
Übermitteln der Messdaten über die serielle Schnittstelle
[js_markieren]
/*
Measure the Temperature with the Sensor LM35CZ every 1 second
and write the value to the serial port (format "xx C").
Author: Wolfgang Wolff
Date: 27.10.2011
*/
const unsigned int TEMP_SENSOR_PIN = 0;
const float SUPPLY_VOLTAGE = 5000;
const unsigned int BOUD_RATE = 9600;
void setup() {
Serial.begin(BOUD_RATE);
}
void loop() {
Serial.print(int(get_temperature()*100));
Serial.println(" C");
delay(1000);
}
const float get_temperature() {
const int sensor_volate = analogRead(TEMP_SENSOR_PIN);
const float voltage = sensor_volate *(SUPPLY_VOLTAGE / 1024);
return voltage / 10;
}
Processing — liest die Daten und stellt sie dar
Aufgaben von Processing (PC)
Aufbau einer seriellen Verbindung zum Arduino
Lesen und Formatierung der Temperaturdaten
Ausgabe der aktuellen Temperatur in einem Fenster
[js_markieren]
/**
Read the temperature over the serial port (Format: "int C")
and write the Temperature to the Window with changing the backgroundcolor
of the window center part.
Author: Wolfgang Wolff
Date: 27.10.2011
*/
import processing.serial.*;
final int LINE_FEED = 10;
final int BAUD_RATE = 9600;
Serial arduinoPort;
void setup() {
println(Serial.list());
arduinoPort = new Serial(this, Serial.list()[0], BAUD_RATE);
arduinoPort.bufferUntil(LINE_FEED);
PFont font = loadFont("Courier-20.vlw");
textFont(font,20);
size(200,200);
fill(150);
rect(0, 0, 200, 200);
colorTempTable();
}
void draw() {
fill(150);
rect(40, 10, 120, 30);
delay(1000);
fill(50);
float temperature = readTemperature(arduinoPort);
text(temperature +" C",50,30);
paintTemperature(temperature);
}
float readTemperature(Serial port) {
final String arduinoData = port.readStringUntil(LINE_FEED);
float temp = 0.0;
if(arduinoData != null) {
final String[] data = split(trim(arduinoData), ' ');
temp = int(data[0]);
println(temp);
}
return temp/100.0;
}
void paintTemperature(float temp) {
if (temp < 20.0) {
fill(0,0,255);
rect(50, 50, 100, 100);
}
if (temp < 25.0 && temp > 20.0) {
fill(0,255,0);
rect(50, 50, 100, 100);
}
if (temp < 30.0 && temp > 25.0) {
fill(255,187,13);
rect(50, 50, 100, 100);
}
if (temp >30.0) {
fill(255,0,0);
rect(50, 50, 100, 100);
}
}
void colorTempTable() {
// draw color table
fill(0,0,255);
rect(50,175,25,25);
fill(0,255,0);
rect(75,175,25,25);
fill(255,187,13);
rect(100, 175, 25, 25);
fill(255,0,0);
rect(125, 175, 25, 25);
// write text
fill(50);
text(20,62,195);
text(25,87,195);
text(30,112,195);
}
Die Arduino IDE ist als Open Source Software (wie alles von Arduino) verfügbar und in Java implementiert. Deshalb ist sie für alle gängigen Betriebsysteme auf der Arduino Homepage (Windows 7, Mac OS X und Linux (32bit)) verfügbar.
Die Installation ist recht einfach und eine Installationsanleitung (englisch) ist auf der Arduino-Homepage verfügbar. Ich möchte deshalb hier nicht weiter auf die Installation eingehen.
Der Programmaufbau
Die Programmiersprache des Arduino-Entwicklungs-Board ist C, wobei externe Bibliotheken in C++ implementiert sein dürfen. Innerhalb der IDE kommt der gcc-arv-Kompiler zum Einsatz.
Programmstruktur
Ein einfaches Arduino-Programm besteht aus zwei Methoden, der setup()–Methode und der loop()–Methode.
Die setup()–Methode beinhaltet Programm-Code der einmal ausgeführt wird. Dagegen
wird der Programm-Code der loop()–Methode immer wieder ausgeführt.
void setup() {
// Setup-Code wird einmal ausgeführt
}
void loop() {
// Haupt-Code wird immer wieder ausgeführt
}
This website uses cookies. By continuing to browse the site, you are agreeing to our use of cookies
Zum Ändern Ihrer Datenschutzeinstellung, z.B. Erteilung oder Widerruf von Einwilligungen, klicken Sie hier:
Einstellungen