Ressourcen & Tutorials

How to control a Hoverboard with an Arduino

Basiert auf der super Arbeit von: Niklas Fauth und Emanuel Feru

Grund: In einem Hoverboard steckt die Technik um preiswert fahrbare Untersätze zu bauen, die sehr viel Kraft haben und sehr präzise schnell oder langsam fahren können (zwei starke BLDC Motoren, speziell abgestimmte BLDC Steuerplatine, dicker Akku).

Ziel: Die Motoren mit einem Arduino zu steuern, damit die vertraute und einfache Arduino Programmierumgebung verwendet werden kann um z.B. Sensoren oder Wifi anzubinden.

Weg: Die BLDC Motoren können nicht direkt vom Arduino angesprochen werden, es braucht eine Steuerplatine mit einem eigenen Mikrocontroller und 12 dicken Transistoren. Dazu muss auf diese Steuerplatine einmalig eine neue Firmware aufgespielt werden um die Kommunikation mit dem Arduino zu ermöglichen.

Hinweis: Dieses Tutorial ist gefährlich, bei falscher Handhabung kann der Akku explodieren, die Motoren können dich und deinen Computer mühelos durch den Raum ziehen. Langsames und besonnenes Arbeiten ist unabdingbar, da evt. die Sicherheitsvorkehrungen durch die Firmware Veränderung nicht mehr korrekt funktionieren. Es wird nicht die geringste Haftung für irgendwas übernommen.

1. Technik Kaufen

1.1. Hoverboard

Roboter / Innenraum: 6,5 Zoll Räder mit je 300W z.B: „GPX-01“ ab 150€
Personentransport / Spaß: 8,5 Zoll Räder mit je 400W z.B: „GPX-04“ ab 250€

Es gibt hunderte verschiedne Modelle, aber Prinzipiell sind alle gleich aufgebaut, bis auf einen wichtigen Punkt: Es muss eine zentrale Steuerplatine haben, leider ist das schwer möglich vorher herauszufinden, evt. am Preis: die ganz billigen haben keine (beide GPX Modelle haben eine)

1.2. ST-Link V2 Programmer

Das Ding braucht ihr um die neue Firmware auf die Steuerplatine aufzuspielen. Am besten eine Version die Kurzschlussfest ist, ansonsten ist es dahin, wenn ein Kabel falsch angesteckt wurde. z.B: STM32 ST-Link V2 Programmer

1.3. Arduino

Die Steuerplatine hat eine 3,3 Volt Logic, es wird also auch ein Arduino mit 3,3Volt Logik benötigt, z.B: Adafruit Feather M0 Basic Proto (Update: 5 Volt Logic ist auch ok)

1.4. 5-Volt DC-DC-Wandler

Damit der Arduino vom Hoverboard aus mit Strom versorgt werden kann, wandelt die 15 Volt in genießbare 5 Volt um. z.B: LMO78_05-0.5

——————————————————————————————————

2. Hardware aufbereiten

2. 1. Hoverboard

– Akku aufladen, korrekte Funktion testen, aufschrauben, alle Kabel abstecken
– alles ausbauen, außer den Motoren (wir benötigen die Steuerplatine, die Ladebuchse, den Power-Taster und den Akku) alles andere kann entsorgt werden
– den Plan der Steuerplatine runterladen und studieren:Image by Emanuel Feru Thx! (original image by Emanuel Feru)

2. 2. ST-Link Programmer Verbindung herstellen

– je ein Kabel an SWDIO, SWCLK, GND am SWD Programming Anschluss auf der Steuerplatine anlöten (den 3.3 Volt Pin niemals anschließen!)
– und mit den gleichnamigen Pins am ST-Link Programmer verbinden
– Tip: der mittlere Kontakt (GND) lässt sich sehr schwer löten, unbedingt testen ob eine Verbindung zu Masse (schwarzes Akku Kabel) besteht

2. 3. Arduino Verbindung herstellen

– TX vom Right Sideboard Anschluss auf der Steuerplatine an RX am Adafruit Feather löten
– RX vom Right Sideboard Anschluss auf der Steuerplatine an TX am Adafruit Feather löten
– GND vom Right Sideboard Anschluss auf der Steuerplatine an GND am Adafruit Feather löten
– 15V vom Right Sideboard Anschluss auf der Steuerplatine an Pin 1 vom DC-DC Wandler löten

– GND vom Adafruit Feather an Pin 2 vom DC-DC Wandler löten
– USB vom Adafruit Feather an Pin 3 vom DC-DC Wandler löten

——————————————————————————————————

3. Steuerplatine entsperren

3.1. Vorbereitung

– Power-Taster und Akku mit der Steuerplatine verbinden
– ST-Link Programmer per USB an den Rechner anschließen
– Wichtig: immer wenn eine Verbindung erstellt oder etwas hochgeladen werden soll, muss die ganze Zeit der Power-Taster gedrückt gehalten werden

3. 2. Windows Nutzer

– das Programm ST-Link Utility installieren und dieser Anleitung folgen: https://github.com/EmanuelFeru/hoverboard-firmware-hack-FOC/wiki/How-to-Unlock-MCU-flash

3. 3. Mac / Linux Nutzer

– per Terminal installieren: Homebrew, stlink, OpenOCD und dieser Anleitung folgen: https://github.com/EmanuelFeru/hoverboard-firmware-hack-FOC/wiki/How-to-Unlock-MCU-flash#method-2-using-ubuntulinux

3. 4. Mac Nutzer ohne Erfahrungen im Terminal

– suche dir einen Windows Rechner, den du dafür nutzen kannst, denn dieser Punkt ist nur ein einziges Mal notwendig

——————————————————————————————————

4. neue Firmware aufspielen

4. 1. Software

– das Programm VisualStudioCode downloaden und installieren: https://code.visualstudio.com
– VisualStudioCode öffnen und am linken Rand den Button „Extensions“ klicken, nach „PlattformIO IDE“ suchen und installieren (das kann einige Zeit dauern.. Status rechts unten beobachten)

– den kompletten NiklasFauth/hoverboard-firmware-hack Ordner von Github runterladen und entpacken: https://github.com/EmanuelFeru/hoverboard-firmware-hack-FOC
– diesen ganzen Ordner in VisualStudioCode öffnen (File -> Open und den Ordner anwählen, keine einzelne Datei)

4. 2. Arduino Kommunikation (UART) aktivieren

– in VisualStudioCode die Datei „platformio.ini“ anklicken und die Auskommentierung (das Semikolon am Anfang) der Zeile 13 entfernen:

default_envs = VARIANT_USART

– optional im Ordner „Inc“ in der Datei „config.h“ in der Zeile 170 das Piepen beim Rückwärtsfahren abschalten:

#define BEEPS_BACKWARD 0

– Speichern und „PlatformIO:Build“ drücken (der kleine Haken links unten im Program) das kann beim ersten Mal einige Zeit dauern.. Status rechts unten beobachten

4.3. Hochladen zur Steuerplatine

– ST-Link Programmer per USB an den Rechner anschließen
– den Hoverboard Power-Taster drücken und halten
-„PlatformIO:UPLOAD“ drücken (der kleine Pfeil links unten im Program) das kann beim ersten Mal einige Zeit dauern..

4.4. Success!

– wenn das erfolgreich war, den Taster wieder loslassen
– eventuell fängt das Hoverboard an zu piepen (da es noch keine Befehle vom Arduino empfängt) einfach den Taster kurz drücken zum Ausschalten
– den ST-Link-Programmer vom Rechner und der Steuerplatine trennen
– die Steuerplatine und den Akku wieder in das Hoverboard einbauen
– die Motoren wieder anstecken (die dicken und die dünnen Kabel)

Gratulation, das war der schwere, unbekannte Teil der nur einmal nötig ist. (außer du möchtest die Einstellungen im Hoverboard ändern, die Datei config.h ist voll von Möglichkeiten..)

——————————————————————————————————

5. Arduino Software:

5.1. hoverSerial1.ino

– das Beispiel runterladen: http://bauhausinteraction.org/opl/wp-content/uploads/2020/06/00_hoverSerial1.zip
– das ist optimiert für den Adafruit Feather M0, basierend auf dem Sketch von Emanuel Feru für den Arduino Nano
– speichern und zum Arduino hochladen, das USB Kabel abstecken

5.2. Erster Test

– das Hoverboard auf einen Stuhl legen, sodass die Räder frei drehen
– das Hoverboard mit dem Taster anschalten
– die Räder sollten sich ruhig und gleichmäßig drehen
– das Hoverboard ausschalten

5.3. Arduino Code modifizieren

– der Befehl Send(0, 100); im Loop Teil kontrolliert die Motoren
– der erste Wert steht für „Steer“ also ob nach links oder rechts gefahren werden soll
– der zweite Wert steht für „Speed“ also wie schnell gefahren werden soll
– z.B. ersetzen durch Send(50, 100); (leichte Kurve, langsam Vorwärts)
– beide Werte können von -1000 bis 1000 gehen

Yeah! Geschafft, von nun an kannst du die beiden Motoren mit dem Arduino steuern.

——————————————————————————————————

Tip: es gibt u.a. verschiedene Modi wie die Motoren angesteuert werden, wähle einen der am besten zu deiner Anwendung passt (in der Datei config.h in Zeile 143) https://github.com/EmanuelFeru/hoverboard-firmware-hack-FOC#foc-firmware

Fragen? Auf den Github Seiten von: Niklas Fauth und Emanuel Feru gibt es mehr Informationen.

Mostly printed CNC

Hauke Sandhaus 116222 HCI / Tim Vischer 116103 MKG

Schritt 1: Auswahlverfahren

Zu Beginn stand die Entscheidung was entstehen soll während des Fachkurses. Die Auswahl traf schnell auf eine Kombi aus CNC Fräse und Lasercutter.

Schritt 2: Planung der Herangehensweise

Nachdem die Auswahl getroffen war stand die Frage offen nach dem System was wir nutzen wollen um zu einem Ergebnis zu gelangen.

Wir verglichen Preise und Aufwand von Fertigbausatzimporten aus China mit DIY Varianten aus dem Internet als auch ein kompletter Eigenbau wurde mit in Erwägung gezogen. 

https://docs.google.com/spreadsheets/d/1AOQIUSOdYe_7U4DtAUrVloRAr9x3YzqgaUnFOTiiMjM/edit?usp=drive_web

Wir kamen zum Schluss das wir gerne einen größeren Eigenanteil an Gestaltung und Aufbau der Maschine haben möchten jedoch nicht den zeitlichen Aufwand eines kompletten Eigenbaus einschätzen können, daher fiel die Wahl darauf der Anleitung zum “Mostly Printed CNC” zu folgen.

Zur Entscheidung hat außerdem beigetragen dass sich mittlerweile eine größere Community um den Entwurf von “Vicious1” (https://www.vicious1.com) gebildet hatte, welche die spätere Einrichtung und eventuelles Troubleshooting erleichtert.

Der voraussichtliche Endaufbau soll diese Form annehmen:

Schritt 3: Bestellliste

Wir entschieden uns gegen das Fertigpaket welches vom Entwickler zum kauf angeboten wurde und planten aufgrund der angegebenen Ressourcen eine Bestellliste der nicht geprinteten Teile.

 

(https://docs.google.com/spreadsheets/d/13U8QZNeTh46jVMGOoRa-_YoFNEZlD4dErIkCerJOpc4/edit#gid=0)

Bis auf Teile bei denen die maße der 3D geprinteten Teile eine Rolle spielt ( Gestänge, Schrauben und Muttern) wurden über die letzten zwei wochen alle Komponenten geliefert.

Schritt 4: Printen

Es wurde eine Tabelle aller zu fertigenden Teile zusammengestellt und danach ging der lange Prozess des Printens los.

(https://docs.google.com/spreadsheets/d/1l4tSlmt_Li28TUgpbqE89Z9fhLXW8cEAZy3rZytoxr0/edit#gid=0)

Vorerst auf einem Ultimaker2 der MKG der nach einer lange phase des Einrichtens einigermaßen gute Ergebnisse liefert jedoch auch viele fehlgeschlagene Prints zwischendurch produziert.

Fehlschläge:

Verwendbare Prints:

Schritt 4.2: Anschaffung Anet A8

Nachdem der Ultimaker2 sich qua Printqualität als nicht berechenbar herausstellte schafften wir uns nach einigen vergleichen mit dem Prusa nachbau den Anet A8 an und richteten ihn ein.

Erste Ergebnisse:

4.3 Zwischenstand:

Weitergehend werden wir jetzt den Anat A8 so einrichten dass er eine sehr gute Printqualität erreicht indem wir einige der günstiger produzierten Teile austauschen und neu Printen.

Hierzu zählen die Anschaffung von besseren Filament, einer Glasplatte für das Heatbed, eine bessere Materialzuleitung, Lüftung und Gleitlager anstelle der mitgelieferten Kugellager.

5. Der Aufbau:

Nachdem wir die Stahlrohre auf Länge gebracht (mit hilfe des auf der Website befindlichen Calculators) und eine Holzplatte zugeschnitten haben, können wir den Aufbau zusammenschrauben.

Das letzte und etwas schwierigere war das finden der passenden Schrauben. Da alle 3D druck Teile imperiale maße besitzen mussten wir teilweise kleinere und größere Schrauben erwerben und die Löcher aufbohren. Ein ankauf von Spezialschrauben wäre zu teuer gewesen und auch metrische Einzelschrauben zu erwerben gestaltete sich schwierig. Die in Weimar verorteten Baumärkte Obi und Toom verkaufen nur in großen Packungen was zu unkosten von hochgerechnet 60-70 € geführt hätten. Durch Recherche landeten wir bei Hornbach in Jena, welche Einzelschrauben verkaufen, wir kamen mit einem Betrag von 20 € für alle Schrauben heraus mussten jedoch einige Schrauben kürzen und Mutternköpfe entfernen.

Nachdem wir alle Teile erworben haben bauten wir nun zusammen. Insgesamt hat der zusammenbau gute zwei Tage in Anspruch genommen. Beim zusammenbau selbst musste trotz aufgebohrter Löcher noch einiges an Gewalt angewendet werden was zum zerbersten einiger Teile geführt hat, diese hätten aber demnach auch nicht lange im Betrieb stand gehalten. Der Aufbau selbst ist auf der Website gut dokumentiert auch wenn einiges an umdenken gefordert wird.

6. Endergebnis zur summaery:

Zur summaery im Juli präsentierten wir den fertigen Aufbau innerhalb der Kursausstellung mit einem Pen-Plotter zum bearbeiten der Arbeitsfläche.

Mittelteil Gantry mit Stiftaufsatz

Standfüße mit Übereck-Rohrverbindungen

Befestigung der Mittel- an die Außen-Achsen

Z Achse innerhalb der Gantry
X und Y Achse innerhalb der Gantry

Ausstehend:

Nachdem der Mechanische Aufbau komplettiert ist fehlt noch das anbringen der Motoren und die Verkabelung dieser. Danach muss nur noch das Driverboard welches auf Marlin laufen soll geflasht und initialisiert werden.

Ebenfalls müssen wir noch einen Fräßkopf erwerben.

 

 

OPL Drucker Eigenheiten und Bedienungshinweise

IIP Mini Select:

Beim kleinen Drucker ganz wichtig, der End-Gcode (d.h.) nach erfolgreichem Druck:

Das Filament per Gcode _nicht_ weiter als 2-3 mm zurück in die Düse ziehen, oder gar nicht.

Dann per Gcode _zuerst_ das Heizelement abschalten und den Lüfter noch einige Minuten nachlaufen lassen. Sonst verstopft das Hotend.

Ansonsten ist der kleine ziemlich stressfrei. Ggf. vor dem Druck noch einen Tropfen Öl (am besten Ballistol, zur not Rapsöl) auf den kleinen Schwamm (“Filament Filter”) oben am Extruder geben, dann flutscht alles besser. Der Extrudermotor ist etwas schwach.

 

ShaperCube:

Über den 3er-Verteiler hinter dem Shapercube anschalten.

Das Heizbett am Shapercube ist momentan nicht gesteuert sondern einfach immer voll an. Also Achtung heiß. Wenn ihr ohne Heizbett drucken wollt dann müsst ihr den Netzstecker aus dem Netzteil was der Heizplatte Strom liefert rausziehen. Anschließend bitte wieder einstecken, damit der nächste…

Beim Start eines Druckes könnt ihr durch leichtes ziehen am Riemen für die Z-Achse eine feine Höheneinstellung für die erste Schicht vornehmen. Die Richtung findet ihr raus indem ihr den Drucker beim hoch und runterfahren vor Druckbeginn beobachtet.

 

Prusa Clone:

Da solltet ihr vor allem aufpassen euch keinen Stromschlag an den Netzteilen zu holen. Da sind die 230V Anschlüsse am Netzteil relativ ungeschützt, also Vorsicht. Ansonsten funktionieren die recht zuverlässig.

Arduino Techniques: Getting Rid of Delays

Delays are bad
Probably the first Arduino sketch you’ve seen is the ‘blink’ sketch. It’s a nice and short piece of code to explain the basic workings of Arduino without scaring you with loads of new things to learn. Unfortunately in terms of everything else, especially user interaction, it’s absolutely terrible. The culprits are these two lines:

delay(1000); and
delay(1000);

If you’ve played some amount of video games in your lifetime, you probably know what FPS (frames per second) are and what influence they have on user interaction. They indicate how many times a second your button presses are checked and the action on screen is updated. So, what’s a desirable number of FPS?

  • 60 FPS and above: Perfectly fluent interaction. Very fun.
  • 30 FPS: Still very fun, but noticeable differences to 60FPS.
  • 20 FPS: Playable, but no fun at all.
  • Under 20 FPS: Agony.

While the responsiveness of games is measured in FPS, the responsiveness of Arduino Code should be measured in LPS, aka how many times the loop section of your code is completed in one second. So, how many LPS does the blink sketch have?

  • 0.5 LPS. That’s bad.

If we want to fit at least 60 loops into one second, the entire delay time in the sketch should not exceed 16ms. Delay() is not a great tool for timing, so we need something different.

Introducing millis()
The blink sketch has no user interaction at all, so it’s not really an exciting example for this tutorial. Instead, we are going to code the most useless lamp ever created: One that turns itself off exactly one second after it was turned on. You’ll need a button, a led and any Arduino board.

Ardu Tech Delay 01

Pretty much all we are going to do revolves around one new Arduino function: millis(). So what does it do?OPL Tutorial Delay-01Inside every Arduino, there’s a little counter that simply counts the milliseconds since the Arduino has been turned on. With millis() we can retrieve the current amount of milliseconds and save them in a variable.

Ardu Tech Delay 02A word on ‘unsigned long’: Maybe you’re wondering, why we don’t use the traditional ‘int’ to initialize our variable. An int cannot contain an infinitely large number, it only covers an area from around -32000 to +32000. Since were measuring time in milliseconds and time only marches forward, we can only fit 32 seconds into one int. ‘Unsigned long’ on the other hand goes from 0 to around 4.3 billion or nearly 50 days in milliseconds. So we’re a lot more flexible in terms of timing.

Let’s go back to our useless lamp and look at it on the timeline. OPL Tutorial Delay-02At some point in time the button will be pressed and the light will turn on. We’ll call this the ‘Trigger-Event’. Then, exactly 1000ms later, the lamp will be turned off again. We’ll call this the ‘Response Event’.

The Trigger Event
Let’s focus on the trigger event first. If the button is pressed, we should do two things:
1. Turn the led on
2. Save the time the event occurred in another variable.OPL Tutorial Delay-03
In code, it looks like this:Ardu Tech Delay 03

The response event
The response event itself is pretty simple: Just turn the led off. But we need to define very specifically when this event should occur. We want the Response to happen exactly one second after the Trigger. We only have the current time and the last time a Trigger-Event happened to work with. So this is what we do:

1. We need to know how much time has passed since the last Trigger, so we subtract our Trigger-Time from our Current Time.
2. We need to know if enough time has passed for the Response to happen, so we check if the time passed is bigger than 1000msOPL Tutorial Delay-04
In Code, it looks like this:Ardu Tech Delay 04

And that’s it. Exactly one second after each Trigger Event, the Response Event happens. Our useless lamp is complete and we’ve learned the fundamental technique to get rid of delays in your code.

To recap
1. There are always two events, we need to code.
2. In the Trigger event we need to save the time it happened.
3. For the Response Event we compare the current time minus the saved time to our delay time.

Blender Workshop Sommer16

BW0716 Poster

19.07.16 / 12-17 Uhr / Open Process Lab (M1b, 2. Etage)
Max. 16 Teilnehmer

Möglichst eigenen Laptop, Maus und die neueste Blender Version mitbringen.

Tutoren: Sebastian Lotz & Christopher Kopic
Anmeldung per Email an Sebastian.Lotz@uni-weimar.de

Blender ist Open Source Software und kann somit kostenlos und legal hier heruntergeladen werden: blender.org

Wir wollen einerseits einen Überblick über alle wichtigen Funktionen von Blender geben, andererseits auf einige Kernbereiche besonders eingehen. Wir erhoffen uns damit, dass die Teilnehmer nach Ende des Workshops in der Lage sind kleine Projekte selbstständig zu lösen und für größere Projekte besser nach Tutorials suchen können.

Zum Erreichen dieser Ziele soll jeder Themenabschnitt zur Übersicht kurz präsentiert werden. Wichtigere Themen (fett gedruckt) werden dann direkt im Anschluss mit praktischen Aufgaben vertieft. So können auch Inhalte zur Sprache kommen,  wie z.B. Modelliermethoden für den 3D-Druck, für die das letzte mal keine Zeit blieb. Jeder Themenabschnitt wird mit einer Beispieldatei und weiterführenden Online-Tutorials ausgestattet sein.

  1. Einführung in die Nutzeroberfläche (45min)
  2. Modelling (1,5h)
    1. Einfaches Modellieren
    2. Modifier
    3. Boolen
    4. Subdivision Modelling
    5. Sculpting
    6. Modellieren für 3D Druck
  3. Rendering (1,5h)
    1. Szene (Hohlkehle)
    2. Licht
    3. Materialien und PBR
    4. Texturen
    5. Rendering
    6. Compositing

Die Software Blender ist umfangreiches Werkzeug zur Erstellung und Verarbeitung von 3D-Inhalten. Das Programm ähnelt in Leistung und Funktion anderen Produkten wie Cinema 4D oder 3ds Max ist aber im Vergleich zu diesen Open-Source und daher kostenfrei legal nutzbar. Die daraus entstandene Community und eine Vielzahl von Tutorials und PlugIns dienen als umfangreiche Wissensbasis, um den Hürden bei der Umsetzung eigener 3D-Projekte erfolgreich zu begegnen. Dem Designer kann diese Software zunächst vor allem als Konstruktions- und Formfindungswerkzeug dienen, welches im Vergleich zu ‚richtigen‘ CAD-Programmen schnelleres Arbeiten mit höherer künstlerischer Freiheit ermöglicht. Aus den so entstandenen Modellen lassen sich „wasserdichte“ Konstruktionen für den 3D-Druck erstellen. Des weiteren können Meshmodelle wieder in herkömmliche CAD-Software übertragen werden, um Vorlage für ein endgültiges Nurbsmodell zu sein. Der eigentliche Zweck von Blender ist das Rendern und das Animieren. Damit hat der Designer umfangreiche Möglichkeiten Ideen, Prozess und Produkte in Szene zu setzen und zu kommunizieren. Die Renderengine ist dabei in der Lage sowohl fotorealistische Ergebnisse zu liefern, die anderen Renderprogrammen wie VRay oder Keyshot in nichts nachstehen, ermöglicht aber auch abstraktere Stile, beispielsweise für Infografiken.

Arduino Basics: Programmieren lernen mit Processing – ein Vorschlag

Warum zur Hölle sollte man denn um Arduino zu lernen Processing lernen anstatt Arduino zu lernen?

Dieser Ansatz ist ein Vorschlag, der mir sehr geholfen hat, mich erfolgreich an Arduino ranzutasten, ich möchte erklären wieso:

Wer Arduino lernen will findet dafür jede Menge guter Tutorials im Netz (Getting Started: Arduino), da es aber beim Arduino darum geht Dinge selbst entwickeln zu können wird man früher oder später an den Punkt gelangen sich außerhalb der  vorgefundenen Tutorials zu bewegen. Dafür hat man dann mehrere Möglichkeiten. Zum einen kann man verschiedene Tutorialbestandteile zusammen packen und hoffen dass es klappt, oder man versucht zu verstehen, wie das alles funktioniert.

Um mit einem Arduino Umzugehen muss man sich mit 3 unterschiedlichen Dingen befassen:

Elektrotechnik (Zeug zusammenlöten, Bauteile auswählen)

Installation und Management von Software und Hardwaretreibern

Programmierung

Um nun wirklich unabhängig Arbeiten zu können sollte man alle Teilbereiche in groben Zügen verstehen.

 

Aber warum zur Hölle sollte man nun Processing lernen, wenn man doch Arduino lernen will?

Processing befasst sich erstmal nur mit Programmierung und Arduino mit Programmierung UND Elektrotechnik.

Wenn ich also ein Arduinoprojekt zusammenwurstle und dann funktioniert es nicht, dann weiß ich erstmal nicht woran das liegen kann. Nun gibt es bei der Fehleranalyse ein unschlagbares Prinzip: das Ausschlussverfahren; Alles voneinander zu isolieren um herauszufinden wo genau das Problem liegt. Man stelle sich vor: Mein Stuhl wackelt, aber warum? Ist es der Stuhl oder der Boden? Nun kann ich den Stuhl nehmen und ihn auf eine Fläche stellen, von der ich sicher weiß, dass sie eben ist. Wackelt er dort nicht, weiß ich, es muss der Boden sein. Genau so kann ich mit meinem Arduinoprojekt verfahren. Wenn die LED, die ich angeschlossen habe einfach nicht zum Rhytmus der Musik blinkt, kann es sein, dass die LED kaputt ist, oder meine Verdrahtung ist falsch, meine Lötstellen sind kaputt, oder ich habe einfach Quatsch programmiert. Also, LED austauschen, alles nochmal Löten. Geht immer noch nicht? Vielleicht ist die neue LED auch kaputt? Oder ist mein Arduino nicht richtig angeschlossen? Oder doch die Programmierung? Wie könnte ich die Programmierung überprüfen ohne einen mit Sicherheit funktionierenden Hardwareaufbau zu haben?

Aha! Indem ich mir eine Programmierumgebung suche, die mir direkt Feedback innerhalb der Software gibt!

Und genau da kommt Processing ins Spiel. Processing ist eine Programmiersprache, die für einfaches Erlernen ausgelegt ist und dafür optimiert ist visuellen Output zu generieren. Und das schöne ist, Processing und Arduino sind Geschwister. Die Prinzipien sind gleich, der Programmablauf ist gleich und die Grundfunktionen sind dieselben. Unterschiede bestehen zwar, allerdings sind diese logisch einfach nachvollziehbar und zum Programmieren lernen erstmal vernachlässigbar.

Schauen wir uns die beiden Umgebungen einmal an sehen wir schnell, dass beide sehr ähnlich aussehen. Die Hauptunterschiede sind, dass man bei Arduino void loop() schreibt und in Processing void draw(), was aber für den Programmablauf genau dasselbe bedeutet. Der zweite wichtige Unterschied ist, dass man bei Arduino einen Upload Button hat und bei Processing einen Play Button. Beide haben eine ähnliche Funktion. Arduino lädt das Programm auf das angeschlossene Board, Processing startet das geschriebene Programm.

arduinomitprocessing

In Processing gibt es zusätzlich zu den Grundfunktionen ein paar einfache Möglichkeiten visuellen Output zu generieren. Zum Beispiel würde die Zeile

rect(20,20,40,40);

folgende Ausgabe produzieren:

processing_1

Somit sind wir in der Lage unseren LED-Blinke Code zu überprüfen in dem wir anstatt eine LED an und auszuschalten einfach ein Rechteck blinken lassen. Wenn das funktioniert ist die Programmierung korrekt, kann zurück übertragen werden und wir wissen, dass irgendetwas mit unserem Hardware Setup nicht stimmt. Natürlich wird dieses Vorgehen umso nützlicher, je komplexer die Programmierung ist, die unser Projekt benötigt.

Darüber hinaus lassen sich Prinzipien wie if-Abfragen, for-Schleifen und viele weitere grundlegende Programmier-Prinzipien sehr leicht mit Processing verstehen und erlernen, weil man sich hier wieder auf die Prinzipien selbst konzentrieren kann und nicht mit Löten und Breadboarden beschäftigt ist. Hinzu kommt noch, dass Processing selbst natürlich auch unabhängig von Arduino genutzt werden kann um Muster als Vorlagen für Lasercutten zu generieren, oder um damit die Daten anzeigen zu lassen, die mein Arduinosensor sammelt, oder direkt mit Grasshopper interagieren kann um fancypants-3D Daten zu erstellen, oder, oder, oder.

Und um Processing zu lernen gibt es Unmengen an Tutorials, z.B. die von Daniel Schiffman, dem hinreißendsten Nerd der Welt:

http://hello.processing.org/

Oder natürlich den Processing Tutor, der jeden Mittwoch von 16:30 bis 18:30 im OPL sitzt und momentan seine Zeit damit verbringt Blogeinträge zu schreiben, weil niemand da ist 😉

Einfache GIF-Animationen in Grasshopper

Manchmal kann es vorkommen, dass man das Ergebnis seiner Grasshopper-Definition schnell und verständlich vermitteln möchte, ohne erst umständlich Grasshopper nebst Rhino zu öffnen. Ist das Ergebnis ein statischer Zustand, so erschließt sich der klassische Weg, die Definition zu “backen” und mit dem Resultat weiter zu verfahren, z.B. eine 2D-Zeichnung zu exportieren oder es zu rendern. Bei Definitionen, welche eine Bewegung beschreiben, sieht das schon anders aus. Hier möchte man vielleicht nicht nur einzelne Zustände zeigen, sondern am besten die Bewegung im Fluss verständlich machen.

Animated Cropped Eye

Continue reading Einfache GIF-Animationen in Grasshopper

Erste Schritte in Grasshopper

Beim Umsetzen eines Entwurfes in CAD fällt auf, dass das Modell im Computer recht statisch daherkommt. Es ist ein Zustand des Entwurfes, jede mehr oder weniger aufwändig konstruierte Variante ein anderer Zustand der Ursprungsidee. Das CAD-Programm übernimmt dabei die Aufgabe des Werkzeuges zur Kreierung und Abbildung dieser Zustände. Jeder Zustand beruht auf feststehenden Parametern. Zum Beispiel die Länge eines Quaders auf dem Wert 20 mm, seine Breite auf 10 mm und die Höhe auf 4 mm.

Beim sogenannten Computational Design stützt man sich nun auf die Absicht nicht mehr einzelne Zustände zu modellieren, sondern ganze Zustandsräume mit unendlich vielen Zuständen, die nicht über feststehende Werte gebildet werden, sondern durch Algorithmen. Im Falle des Quaderbeispieles könnte man sagen: Die Länge soll einen Wert zwischen 0 und 20 mm besitzen und in seiner Breite soll er genau die Hälfte seiner Länge betragen. Schon hat man einen Raum geschaffen, in dem unendlich viele Quader existieren können, nämlich genau soviele, wie es Zahlen zwischen 0 und 20 gibt.

Prinzip des Zustandsraums

Und genau bei dieser Möglichkeit, ganze Zustandsräume zu erschaffen, setzt das Rhinoceros-Plugin Grasshopper an.
Natürlich bleiben die Möglichkeiten darin nicht nur auf reine Größenangaben beschränkt. Objekte kann man in gegenseitige Abhängigkeiten stellen, zum Beispiel den Quader in Bezug zu einem weiteren Quader und den Abstand Einfluss auf die Höhe beider Objekte nehmen lassen. Je weiter man sie zusammenrückt desto größer oder kleiner werden sie. Auch die Verknüpfung zu anderen Umgebungen ist in Grasshopper gegeben, so wäre es zum Beispiel denkbar – um beim Quader zu bleiben – einen mit Sensor bestückten Arduino auszulesen, die Werte in den Algorithmus aufzunehmen und schon hat man ein generatives CAD-Modell, welches auf Einflüsse der realen Umgebung reagiert. Möglichkeiten gibt es wie immer unendlich viele und das Internet ist voll davon.

Das beste an Grasshopper ist, man muss keine Programmiersprache lernen, die Oberfläche besteht aus rein grafischen Elementen und die Arbeitsprinzipien hat man nach wenigen Minuten verstanden.

Was sind Startpunkte, um sich mit dem Programm vertraut zu machen:

http://www.grasshopper3d.com/
Hier findet man neben dem Download von Grasshopper, welches selber kostenlos ist (und leider bisher nur auf Windows-Systemen läuft), auch Einführungsvideos von David Rutten, der Grasshopper zusammen mit Robert McNeel & Associates entwickelt hat, sowie zahlreiche Links zu Tutorial-Serien anderer Autoren.

http://www.food4rhino.com/
Hier findet man allerhand Add-Ons für Grasshopper, die zum Beispiel die Befehlspalette für Simulation und Animierung oder das Auslesen der seriellen Schnittstelle für die Kommunikation mit einem Arduino erweitern.

http://grasshopperprimer.com/en/index.html
Der Grasshopper Primer ist eine von ModeLab herausgegebene Zusammenfassung und super Einführung in Grasshopper. Man kann ihn sich entweder als PDF herunterladen oder auch online lesen. Dabei gibt es mittlerweile auch eine deutsche Variante.

https://www.youtube.com/channel/UCFwIL20fwOmTUkxJgOPk5Jg
Zum Thema ModeLab auch erwähnenswert ist deren Youtube-Channel. Hier gibts nicht nur eine Einführung zu Grasshopper, sondern auch zu Processing, Python Sripting und anderem.

 

Zum Schluss ein kleiner Appetizer, was Generative Gestaltung als reines Werkzeug an Möglichkeiten eröffnet:

Integrated Circuits (“ICs”) are your friends!

As an interaction designer working with electronics, your goal is usally on creating and evaluating the user-experience of a product, not on spending long nights in the electronics lab.

Foto: Wollschaf released under theCC BY-SS 3.0 license

This is where integrated circuits (ICs) enter the game. An integrated circuit essentially contains a variety of different low-level components, all wired up and combined into a small package with clearly defined inputs and outputs. This hides much of the low-level complexity found and allows you simplify your electronic design. Integrated circuits are available for many different purposes (e.g. sensors, motor-drivers, multiplexers, etc.) and come in different sizes and shapes (“packages” or “footprints”).

The more recent ICs are often made for use in mobile devices and therefore often too small to be soldered by hand. This is where a variety of manufacturers (such as Sparkfun, Adafruit, Seedstudio and others) offers them conveniently mounted on hand solderable breakout boards, often even in combination with code libraries specifically written for each IC. The libraries and the circuit designs are often released as open-source and can be modified by the community.Foto: Sparkfun Electronics released under the CC BY-NC-SA 3.0 license

If you have ever wondered what exactly is inside of such tiny, seemingly magic, blackboxes and how they are made, here is the answer:

Filtering Sensor Values

Getting raw data readings from different sensors is usually pretty straightforward. However, before the aqcuired sensor data can be interpreted, it is usally advisable to remove any unwanted noise (caused by bad power supplies, radio frequency interference or similar).

A digital low-pass filter is a simple and flexible way to clean up and smooth sensor data, here is an example:

The filter can also be used on multiple sensor readings in a single line of code:

 

For a more detailed technical explanation and other digital filtering options, see page 18-29 from the application note below:

http://ww1.microchip.com/downloads/en/AppNotes/00001334B.pdf