DIY — Steuerung eines unbekannten Schrittmotor

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

und das ist schon relative viel.

Steuerung des Schrittmotors mit dem MotorShield von adafruit

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).

Googles ADK mit Arduino Uno und normalem UBS-Host-Shield

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.

Für GNU/Linux: 32 Bit , 64 Bit .

Für Windows 32 Bit, 64 Bit.

Für Mac OS X 32 Bit, 64 Bit.

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.

Die modifizierte Version der USB-Host-Shield Bibliothek von http://blog.bricogeek.com herunterladen.

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.

Arduino und Processing

[seriesposts name=“Arduino“, orderby=“user_order“]

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);
}

DIY — Roboter

[seriesposts name=“ProjektAG“ title=“DIY Projekte an der Schule“ orderby=“user_order“]

In der Projekt AG möchte ich einen Roboter auf der Basis der Arduino-Platform zusammen
mit meine Schülerinnen und Schüler entwickeln und bauen.

Wir orientieren dabei an vierschiedenen anderen Open Source Projekten, wie dem www.ct-bot.de-Projekt des Heise Verlages.

Adruino — IDE und Programmaufbau

[seriesposts name=“Arduino“, orderby=“user_order“]

Die IDE — Arduino 0022

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
  
}