How to control a Hoverboard with an Arduino

– Basiert auf der super Arbeit von: Niklas Fauth und Emanuel Feru
– getestet auf macOS 10.13.6

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

Kaufen:
– Hoverboard (eins mit zentraler Steuerplatine) z.B: STM32 ST-Link V2 Programmer z.B:– Arduino mit 3,3 Volt  I/O Logic z.B: Adafruit Feather M0 Basic Proto

Zum angenehmen Arbeiten empfohlen:
– Kippschalter
– USB Verlängerungskabel
– 5V DC-DC-Wandler zur Spannungsversorgung des Arduinos über die 15V vom Hoverboard (z.B. LMO78_05-0.5 )

1. Hardware schrauben/löten:
– Hoverboard Akku aufladen, korrekte Funktion testen, aufschrauben, alle Kabel abstecken
– außer den benötigten Komponenten (das große Mainboard, Motoren, Ladebuchse, Power-Button, Akku) kann alles andere für immer entfernt werden
– Hoverboard-Mainboard-Pinouts runterladen und studieren:
Image by Emanuel Feru Thx!

– Kabel an SWDIO, SWCLK, GND (vom SWD Programming Anschluss auf dem Mainboard) löten und mit dem SWDIO, SWCLK, GND am ST-Link Programmer verbinden (aber nicht die 3.3V!)

– TX vom Right Sideboard Anschluss auf dem Mainboard mit RX am Adafruit Feather verbinden
– RX vom Right Sideboard Anschluss auf dem Mainboard mit TX am Adafruit Feather verbinden
– GND vom Right Sideboard Anschluss auf dem Mainboard mit GND am Adafruit Feather verbinden

(bei Verwendung des 5V DC-DC-Wandlers LMO78_05-0.5 um den Arduino über die 15V vom Hoverboard mit Spannung zu versorgen):
– Pin 1 vom DC-Wandler mit 15V vom Right Sideboard Anschluss verbinden
– Pin 2 vom DC-Wandler mit GND vom Adafruit Feather verbinden
– Pin 3 vom DC-Wandler mit USB vom Adafruit Feather verbinden

– parallel zum Power-Button (Taster) einen Kippschalter anlöten (zum Flashen der Firmware muss das Hoverboard permanent an sein)
– die dicken (Power-) und dünnen (Hall-) Kabel zu den beiden Motoren wieder anstecken

2. Software zur Erzeugung und Hochladen für das Hoverboard (WIN/OSX/LINUX):
– VisualStudioCode 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: https://github.com/EmanuelFeru/hoverboard-firmware-hack-FOC– den Ordner in VisualStudioCode öffnen und die serielle Kommunikation zum Arduino (via UART) aktivieren: in der Datei „platformio.ini“ 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

3. Hoverboard Firmware flashen:
– Akku mit dem Mainboard verbinden und mit dem neuem Kippschalter permanent einschalten
– ST-Link Programmer über das USB Verlängerungskabel mit dem Rechner Verbinden
– in VisualStudioCode „PlatformIO:UPLOAD“ drücken (der kleine Pfeil links unten im Program) das kann beim ersten Mal einige Zeit dauern.. Status rechts unten beobachten (falls das fehlschlägt, ist der Speicher im Hoverboard gesperrt)
– danach den Kippschalter ausschalten und den ST-Link-Programmer vom Rechner trennen
– eventuell fängt das Hoverboard an zu piepen (da es noch keine Befehle vom Arduino empfängt) einfach den Power-Taster drücken zum ausschalten

4. Arduino Software:
– Arduino Beispiel: http://bauhausinteraction.org/opl/wp-content/uploads/2020/06/00_hoverSerial1.zip (für Adafruit Feather M0, basierend auf dem Sketch von Emanuel Feru für Arduino Nano)
– Code speichern und zum Arduino hochladen
– bei Verwendung des 5V DC-DC-Wandlers: USB Kabel vom Rechner abstecken

5. Erster Test:
– das Hoverboard auf einen Stuhl legen sodas die Räder in der Luft sind und anschalten
– die Räder sollten sich ruhig und gleichmäßig drehen
– das Hoverboard ausschalten

6. Arduino Code modifizieren:
– der Befehl Send(steer, speed) im Loop kontrolliert die Motoren
– z.b. ersetzen durch Send(50, 100); (leichte Kurve, langsam Vorwärts)
– die Werte von steer und speed können von -1000 bis 1000 gehen

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

Fragen?
Prinzipiell: https://github.com/NiklasFauth/hoverboard-firmware-hack/wiki/Build-Instruction:-TranspOtter
Programmierung: https://github.com/EmanuelFeru/hoverboard-firmware-hack-FOC
ST-LINK Treiber für OSX: http://macappstore.org/stlink/

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

Alternative um das Binary online zu erzeugen von Robo Durden:
https://pionierland.de/hoverhack/
– EmanuelFeru/hoverboard-firmware-hack-FOC auswählen
– in der config.h in dem Bereich ### VARIANT SELECTION #### nur: #define VARIANT_USART stehen lassen, alles andere löschen
– irgend einen Namen eingeben und Compile drücken
– irgend einen Namen.bin downloaden

Alternative Software zum Flashen (nur Windows):
– STM32 ST-LINK utility: STSW-LINK004 https://www.st.com/en/development-tools/stsw-link004.html (oder https://www.st.com/en/development-tools/stm32cubeprog.html)?
– ST-Link Programmer an den Rechner stecken und die Firmware updaten (Im Programm: ST-LINK -> Firmware update)
– Akku mit dem Mainboard verbinden und mit dem Kippschalter permanent einschalten
– im ST-LINK Programm: Target -> Connect klicken (Daten vom Hoverboard werden geladen)
– im ST-LINK Programm: Target -> Program… klicken und das Binary auswählen und Start drücken
– im ST-LINK Programm: Target -> Disconnect klicken und den ST-Link-Programmer vom Rechner trennen
– danach den Kippschalter ausschalten und den ST-Link-Programmer vom Rechner trennen

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

ToDo:
– Temperatur- und Akku-Überwachung kalibrieren

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

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

Making Circuit Boards (with Household Items)

To make your own circuit boards with things that you might mostly have at home already, follow the instructions in any of the videos below.

The process demonstrated in each of the videos below is similar:

1. Produce a circuit drawing (manually or using software).
2. Transfer the circuit drawing to the copper plated side of a blank circuit board, thereby masking the areas of the copper that will be part of your circuit.
3. Dissolve any unwanted copper (using an etching agent) that is not covered by the traces from your circuit drawing (nail polish, toner, etc..) .
Continue reading Making Circuit Boards (with Household Items)

Datenerstellung für den 3D Druck

3-D-DRUCK / VOM RECHNER IN DIE REALITÄT / CHECKLISTE:

Die Grundlage für den 3D-Druck (dem schichtweisen Aufbau von Material nach dem FDM “Fused Deposition Modeling” Verfahren) ist das CAD-Modell, das im 3D-Programm erstellt wird (z.B. Rhinoceros, Alias, Solid, usw.).

Bei der Umsetzung des CAD-Modells in die Realität gibt es einige Dinge zu beachten:

1. Kommunikation

Zu Beginn ist es vorteilhaft, jeden Modellbau vorab kurz mit den Experten zu besprechen, da es für jedes Modell unterschiedlich gute, zeit- und kostenaufwendige Strategien und Ziele gibt.

2. Datenexport: STL (+ IGS)

Das Datenexportformat für den 3-D-Druck ist üblicherweise STL (stereolithography) in mittlerer bis hoher Auflösung (Maßeinheit: mm, siehe unten).

Nach Rücksprache mit den Tutoren können Druckdaten alternativ auch im IGES-Format abgegeben werden, da dies mögliche Korrekturen des Modells erlaubt. Korrekturen von Daten sind (sowohl in Schule als auch Praxis) durchaus üblich.

3. Maßeinheiten in mm angeben

Die Maße des CAD-Modells werden prinzipiell in Millimetern (und nicht Zentimetern oder Metern) angegeben. Dies legt man (bestenfalls) vor dem ersten Modellierungsschritt in der jeweiligen 3D-Software und ggf. noch einmal beim Export in die Druckdatenformate fest.

4. kaputte Körper / Flächennormalen / „doppelte“ Geometrien

Es können prinzipiell nur GESCHLOSSENE VOLUMENMODELLE gedruckt werden! Einzelne Flächen haben kein Volumen und werden daher nicht durch das 3-D-Druck-Programm erkannt. Alle zur Erzeugung des 3-D-Objektes benötigten Hilfskonstruktionen, Hilfsflächen oder Hilfskörper stören den Datenexport des eigentlichen 3-D-Objektes. Daher Hilfsgeometrien NICHT mit exportieren oder vor dem Export löschen, so dass nur die Hülle des 3-D-Objektes übrig bleibt. Soll ein flächiges Objekt gedruckt werden, dann muss es als Volumenmodell von mindestens 1mm Dicke ausgeführt werden!

5. Teilung des Modells wegen Größe oder Hohlräumen

Die maximale Größe von 3-D-gedruckten Modellen hängt vom Bauraum des verwendeten Druckers ab. Bei uns 200x200x250 mm. Größere Modelle werden in Teilstücken ausgedruckt und nach dem Ausdruck zusammengeklebt (z.B. mit Aceton oder Cyanacrylat/Sekundenkleber).

Wichtig: ein Objekt mit Hohlräumen muss dergestalt geteilt (gedruckt) werden, so dass sich seine Hohlräume möglichst nicht mit Stützmaterial füllen. Zumindest muss die Möglichkeit bestehen, sich ergebendes Stützmaterial nach dem Druck herausbrechen zu können!

6. Realistische Erwartungen an Festigkeit, Farbe und Oberfläche

Die Druckerzeugnisse sind NICHT HOMOGEN in Aufbau oder Festigkeit! Der aus dem Extruder austretende Strang hat eine Materialstärke von 0,3 – 0,4mm und wird schichtweise aufgebaut und verbindet sich dabei mehr oder weniger gut mit der vorherigen Schicht. Durch den vertikalen Aufbau des Druckprozesses ist das Objekt in seiner vertikalen Ausrichtung wesentlich schwächer belastbar als in seiner horizontalen Ausrichtung. Aufgrund seiner Aufbauweise und der Strangstärke sind keine Details im Zehntel- bis 1mm-Bereich oder feine Texturen möglich! Die  Strangstärke und die Art des Druckaufbaus hängt vom verwendeten Drucker ab.

Wir verwenden Druckmaterial momentan ausschließlich PLA. Solltet ihr anderes Material verwenden wollen (z.B. ABS oder Flexmaterial) sprecht das gerne mit den Tutoren ab.

 

Electronic Basics

One of the earliest dedicated Physical Computing Resources online has a compact summary on electronics for beginners, the original source can be found here:

http://www.nastypixel.com/instantsoup/foundations/electronic-basics/

Unfortunately the character encoding seems to be broken, a corrected version is provided below for archival purposes (the text is unchanged):
Continue reading Electronic Basics

The Arduino as a Native Sound Generator

Many interactive artifacts still torment their users with loud, harsh sounding binary beeps and purposefully designed sounds are an exception. As powerful embedded microcontrollers have become ubiquitous and relatively easy to use, new opportunities for sound design in interactive products emerge. Their computing powers often exceed the capabilities of early personal-computers and they are embedded in many common everyday objects – even seemingly simple devices and appliances such as coffee makers, garage door openers and microwave ovens, etc. For most of the time these small computers run idle and are not used to their full extent. What if we could leverage this potential?
Continue reading The Arduino as a Native Sound Generator