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 😉

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 ABS-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 überwiegend ABS, gelegentlich auch PLA. Die Material gibt es in grundsätzlich in verschiedenen Farben, Farbwünsche können nur in Ausnahmefällen erfüllt werden da der Materialwechsel zeitaufwändig ist!

Zur Druckabwicklung bitte die Tutoren Ansprechen.

Weitere Schritte in der Druckabwicklung nach Abgabe der Druckdaten…

Nach Übergabe der Druckdaten an die Zuständigen Tutoren werden die Daten im .stl Format in einer Slicersoftware geöffnet und in GCode (d.h. Steuerbefehle für den Drucker umgewandelt).

Im Slicer sind alle technischen Parameter des jeweiligen 3D-Druckers hinterlegt (Bauraumgrösse, Anzahl und Maße der Extruder, Materialeigenschaften, Druckbettparameter, etc.) auf Grundlage dieser Daten und des eingegebenen 3D-Modells errechnet der Slicer ein Schittmodell der Druckpfade und fügt ggf. Stützmaterial ein. Im  Slicer können zusätzliche Materialspezifische Einstellungen, Druckgeschwindigkeit/Präzision und weitere Parameter feinjustiert werden. Aus dem Zusammenspiel aller Slicereinstellungen  in Verbindung mit dem Verwendeten Drucker und der 3D-Daten ergibt sich die finale Qualität des Druckergebnisses.

Wir verwenden als Slicer den KISSlicer und Cura, beide sind für den nichtkommerziellen Gebrauch als kostenlose Downloads verfügbar.