Arduino Praxis Blog

Das Sippino-Board des kanadischen Herstellers SpikenzieLabs ist ein kompakter Arduino-Clone der sich gut für Arduino-Anwendungen auf dem Steckbrett oder für Anwendungen in kleiner Baugrösse eignet.

Die Leiterplatte des Sippino hat eine Grösse von 25 x 60 mm. Auf dem Board ist die Grundschaltung eines Arduino, ohne Spannungsregler und FTDI-Treiber, aufgebaut.  Alle Eingänge-und Ausgänge sowie die Spannungsversorgung sind auf einer 1-reihigen Stiftleiste angebracht.

Die Programmierung des Sippino erfolgt über den 6-poligen FTDI-Anschluss oder mittels ICSP-Schnittstelle.

Das Sippino-Board wird als Bausatz geliefert und muss selbst zusammengelötet werden. Wie von SpikenzieLabs gewohnt, wird der Kit in einem Antistatikbeutel geliefert. Die Bauteilliste und die Bauteilbezeichnungen sind auf einem Label auf dem Beutel notiert. Erfahrene Arduino-Anwender benötigen dadurch keine weitere Anleitung oder Beschreibung für den Zusammenbau.

Für Einsteiger bietet SpikenzieLabs eine sehr ausführliche und gut verständliche Bauanleitung mit vielen Bildern. In der Anleitung ist jeder Schritt detailiert beschrieben. Darum eignet sich der Sippino auch gut für Junior-Maker um erste Erfahrungen mit dem Zusammenbau von einem Arduino-Board sammeln zu können.

Die Montage der Stiftleisten kann, je nach Anwendungsfall, auf verschiedene Arten erfolgen. SpikenzieLabs nennt diese SIP-Mode, DIP-Mode, Stand-Alone und Freestyle. Wie dies in der Praxis aussieht, zeigen die Bilder der Anleitung.

Sippino im SIP-Mode, Bild (c) SpikenzieLabs

Sippino im DIP-Mode, Bild (c) SpikenzieLabs

Ich habe mich für den DIP-Mode entschieden und zum Test den Sippino auf ein Half-Breadboard gesteckt. Dadurch hat man direkten Kontakt zu den Anschlusspins. Für den ersten Test habe ich 2 LED’s aufgesteckt. In meinem Fall versorge ich das Board über den FTDI-Adapter. Die LED an Pin 13 blinkt im Sekundentakt.

Die Spannungsversorgung des Sippino erfolgt, wie bereits erwähnt, über das FTDI-Kabel. Falls die Spannungszuführung aber von einer anderen Quelle gewünscht wird, muss der Spannungs-Jumper auf der Leiterplatte entfernt werden und die externe Spannung wird an Pin +5V der Stiftleiste angeschlossen.

Dank den schmalen Abmessungen passt das Sippino-Board sogar in das Gehäuse von meinem Sensor Node Projekt. Für Sensor-Anwendungen mit höheren Anforderungen ist der Sippino somit meine erste Wahl, da alle meine bisherigen Arduino Boards oder Clones nicht in dieses schmale Gehäuse passen.

Sippino als Sensor Node

Fazit:

Der Sippino ist ein kompaktes und günstiges Arduino-Board und eignet sich ideal für Einsteiger, DIY-Workshops und in der Praxis für kompakte Anwendungen. Dank dem einfachen Aufbau und der hervorragenden Dokumentation kann das Board auch problemlos von Einsteigern und Junior-Makern in Betrieb genommen werden. Durch die fehlende Spannungsregler-Schaltung muss für den Einsatz des Sippino immer eine geregelte Versorgungsspannung von 5V zur Verfügung stehen. Der kompakte Aufbau und die Positionierung der Anschlusspins in einer 1-reihigen Stiftleiste machen den Sippino zu einem geeigneten und praktischen Prototypen-Board auf dem Labortisch.

Das OpenKontrol Gateway ist ein optimales Internet-Gateway um meine Sensordaten an die IoT-Plattform Cosm zu senden.

Im nachfolgenden Beispiel werden die Daten von Node 13 an Cosm gesendet. Dabei werden 2 Datenstreams, Temperatur und Batteriespannung übertragen.

Das Senden der Daten an Cosm wird mit der Bibliothek ERxPachube realisiert.

Auf dem Arduino-basierenden Gateway zeigt Pin 17 mittels Status-LED den Empfang von Daten an.

//
// OpenKontrol Gateway - sending rf data to COSM
// Date: 10.05.13
// www.arduino-praxis.ch

#include <SPI.h>
#include <Ethernet.h>
#include <JeeLib.h>
#include <Arduino.h>
#include <HardwareSerial.h>
#include <ERxPachube.h>

// Ethernet
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xAD };
byte ip[] = { 10, 0, 1, 101 };
byte gateway[] = { 10, 0, 1, 1 };
byte subnet[] = { 255, 255, 255, 0 };

// Cosm API-Key
#define PACHUBE_API_KEY	"YourAPIKey"
// Cosm Feed ID
#define PACHUBE_FEED_ID YOURFEEDID

// Status senden 1:OK
int sendenStatus = 0;

ERxPachubeDataOut dataout(PACHUBE_API_KEY, PACHUBE_FEED_ID);

void PrintDataStream(const ERxPachube& pachube);

// Fixed RF12 settings
#define MYNODE 3            //node ID of the receiever
#define freq RF12_433MHZ     //frequency
#define group 210            //network group

 typedef struct {
          int rxD;              // sensor value
          int supplyV;          // tx voltage
 } Payload;
 Payload rx;

int nodeID;

int value;
int millivolts;

// Data received
const int LEDpin=17;

void setup()
{
  Serial.begin(9600);
  rf12_initialize(MYNODE, freq,group); // Initialise the RFM12B
  Ethernet.begin(mac, ip);

  // 2 Datenstreams Sensor Node 13
  // Temp Inside
  dataout.addData(0);
  // Battery
  dataout.addData(1);

  // Daten empfangen
  pinMode(LEDpin, OUTPUT);
  digitalWrite(LEDpin,HIGH);

  Serial.println("TinyTX Simple Receive Example");
  Serial.println("-----------------------------");
  Serial.println("Waiting for data");
  Serial.println(" ");
}

void loop()
{
  if (rf12_recvDone() && rf12_crc == 0 && (rf12_hdr & RF12_HDR_CTL) == 0) {
  nodeID = rf12_hdr & 0x1F;  // get node ID
  rx = *(Payload*) rf12_data;
  value = rx.rxD;
  millivolts = rx.supplyV;
  Serial.println("Received a packet:");
  Serial.print("From Node: ");
  Serial.println(nodeID);
  Serial.print("Value: ");
  Serial.println(value);
  Serial.print("TX Millivolts: ");
  Serial.println(millivolts);
  Serial.println("--------------------");
  if (nodeID== 13)
  {
    digitalWrite(LEDpin,HIGH);
    sendenStatus=1;
  }
 }

  // Daten an Cosm senden
  if (sendenStatus == 1) {
  Serial.println("Sendig Data to COSM");
  float data0 = value;
  float data1 = millivolts;
  data0=data0/100;
  dataout.updateData(0, data0);
  dataout.updateData(1, data1);

  // Show Status
  int status = dataout.updatePachube();
  Serial.print("Status: ");
  Serial.println(status);

  // Daten senden
  PrintDataStream(dataout);

  sendenStatus=0;
  // turn off status LED to indicate
  // succesful data receive and online posting
  digitalWrite(LEDpin,LOW);
  }

}

void PrintDataStream(const ERxPachube& pachube)
{
  unsigned int count = pachube.countDatastreams();
  Serial.print("data count=> ");
  Serial.println(count);

  Serial.println(",");
  for(unsigned int i = 0; i < count; i++)
  {
    Serial.print(pachube.getIdByIndex(i));
    Serial.print(",");
    Serial.print(pachube.getValueByIndex(i));
    Serial.println();
  }
}

In vielen Haushalten steht ein Gefrierschrank. Die meisten Besitzer wissen aber nicht genau wie tief die Temperatur im Gerät wirklich ist. Wir schon – unser Gefrierschrank im Keller wird mittels drahtlosem Sensor Node überwacht. Ein Temperaturfühler erfasst laufend die aktuelle Temperatur welche dann vom ATtiny Microcontroller eingelesen und drahtlos übermittelt wird.

Im Wohnzimmer wird auf einem drahtlosen Display die aktuelle Temperatur des Gefrierschranks angezeigt.

Anzeige zeigt aktuelle Temperatur im Gefrierschrank

Zusätzlich zur Anzeige im Wohnzimmer empfängt ein Internet-Gateway die Sensordaten des Gefrierschrank-Sensors und sendet diese an die IoT-Plattform Cosm.

Die auf Cosm gespeicherten Daten werden dann laufend in einer Graphik dargestellt.

Falls die Tür des Gefrierschranks einmal offen gelassen wird, schaltet bei einer Temperatur von -15.5 Grad oder höher eine Triggerfunktion ein und sendet einen Tweet an mein Twitter-Account.

Falls wir einmal unterwegs sind, können wir mittels App die aktuelle Temperatur im Gefrierschrank überprüfen.

Gefrierschrank-Temperatur via App

Am letzten Freitag wurde der erste Freaky Friday bei boxtec durchgeführt.

Bei spannenden Gesprächen über Arduino, Kickstarter-Projekte usw. und bei Speis und Trank haben die anwesenden Bastler und Maker einen coolen Nachmittag verbracht. Die jungen Maker haben sich mit Basteleien und Arbeiten am Rechner beschäftigt.

Es hat wirklich Spass gemacht. Herzlichen Dank an das Boxtec-Team.

In meinem Sensor Node Netzwerk arbeiten mittlerweile rund 20 drahtlose und batteriebetriebene Sensor Nodes die im und ums Haus platziert sind. Die Sensoren senden Messwerte von Aussentemperatur, Innentemperatur, Luftfeuchtigkeit, Lichtstärke und Feuchtigkeit der Erde an eine Basisstation.

Als Basisstation wurden bisher mehrere Empfänger mit Display eingesetzt. Die Daten wurde dabei angezeigt, aber nicht weiterverarbeitet.

Versuche mit Nanode mit RF Shield sowie einem Arduino Board mit Ethernet-und RF Shield waren nicht erfolgreich. Keine der getesteten Lösungen hat funktioniert.

Auf der Suche nach einer simplen Gateway-Lösung, Daten per RFM12B empfangen und an eine IoT-Plattform wie COSM zu senden, bin ich auf das Projekt OpenKontrol Gateway gestossen. Das OpenKontrol Gateway ist eine Arduino-basierte Lösung auf welcher man verschiedene drahtlose Module wie XBee, XRF, NRF24 oder RFM12B aufstecken kann. Die so empfangenen Daten können auf einer SD Card gespeichert oder via Ethernet-Adapter an eine Webplattform gesendet werden.

Das OpenKontrol Gateway kann als Bausatz beim englischen Hersteller CISECO bestellt werden. Je nach Anforderungen können die einzelnen Module mitbestellt werden.

Ich habe mir den Bausatz mit der Option SD Card und ein Ethernet Wiznet-Adapter bestellt.

Pünktlich zum Wochenende habe ich den Kit erhalten. Der Aufbau der einzelnen Module des Gateways ist recht einfach und gut dokumentiert. Die ausführliche Dokumentation beschreibt die einzelnen Module. Für die meisten Funktionen stehen Code-Beispiele zur Verfügung.
Im ersten Schritt habe ich ein Webserver-Sketch hochgeladen. Die Ethernet-Verbindung hat sofort funktioniert und der Webserver hat Daten angezeigt.

Anschliessend habe ich das RFM12B-Modul auf die Leiterplatte gelötet und eine Antenne montiert. Mein im Voraus erstelltes Gateway-Sketch hat nach dem Ergänzen der LED-Ansteuerung sofort funktioniert und erste empfangene Daten an COSM gesendet. Die im Minutentakt gesendeten Sensordaten von Sensor Node 13 werden dann umgehend an den COSM-Feed gesendet.

Gastbeitrag von Tim
Von der Firma boxtec habe ich einen Calculator Kit, ein Taschenrechner-Bausatz, zum Zusammenbauen und Testen bekommen. Der Bausatz wurde von der kanadischen Firma SpikenzieLabs entworfen.

Der Calculator Kit muss selbst zusammengelötet werden. Die Bauteile sind in einer Tüte verpackt.

Die Anleitung für den Bausatz ist im Internet aufrufbar. Die Adresse lautet www.spikenzielabs.com/calc. Der Link ist auf dem Aufkleber auf der Tüte aufgedruckt.

Zuerst habe alle Bauteile ausgepackt und ein Foto gemacht.

Folgende Bauteile werden für den Calculator benötigt.

1 Calculator Kit PCB (Leiterplatte)
1 Atmega328 (programmed )
6 7-Segment LED Anzeigen
17 Drucktasten
2 0.1uF Kondensatoren
6 10kOhm Widerstände
1 20mm Batteriehalter
1 CR2032 Batterie
1 Laser cut Gehäuse Set
4 Schrauben

Die Anleitung ist einfach zu verstehen und sehr ausführlich. Englischkenntnisse sind aber erforderlich. Viele Bilder erklären wie man die Bauteile montieren muss. Ich habe die Anleitung ausgedruckt und durchgelesen. Am besten druckt man die Anleitung in Farbe aus.

Nun habe ich den Lötkolben von meinem Vater bereitgestellt und mir Lötzinn geholt.

Gemäss der Anleitung habe ich dann den Batterie-Halter und dann die Widerstände aufgelötet. Dann habe ich den Arduino-Chip und die 7-Segment-Anzeigen gelötet.

Nun habe ich die Tasten aufgelötet. Danach mussten die weissen Aufkleber auf den Tasten entfernt werden.

Die einzelnen Teile des Gehäuses sind mit Schutzfolie geschützt. Ich habe die Schutzfolie sorgfältig entfernt. Nun habe ich die einzelnen Teile des Gehäuses anhand der Anleitung zusammengebaut. Beim Zusammenbau des Gehäuses hat mir mein Vater geholfen. Zum Schluss habe ich die Montageschrauben montiert.

Zum Schluss habe ich die Batterie in den Batteriehalter gesteckt und die Taste C gedrückt.

Auf der Anzeige wurde die Version angezeigt.

Auf der Rückseite des Taschenrechners habe ich noch 4 Gummifüsschen angeklebt.

Nun ist der Taschenrechner fertig und betriebsbereit. Der Taschrechner beherrscht die 4 Grundrechenarten und eignet sich ideal für meine täglichen Matheaufgaben.

Fazit
Es hat sehr viel Spass gemacht diesen Bausatz zu bauen. Das Zusammenlöten war manchmal etwas schwierig weil einzelne Bauteile sind sehr temperaturempfindlich. Darum sollte man schon etwas Löterfahrung mitbringen.

Tim
Junior Maker

Ich und mein Bruder beim Löten

Sensor Node mit Grove Bodenfeuchtigkeits-Sensor:

Der Grove Moisture Sensor von Seeedstudio ist ein einfacher Sensor für die Messung der Bodenfeuchtigkeit.

In der simplen Transistorschaltung auf dem Sensorboard wird der Widerstandswert zwischen den beiden Messflächen in eine Messspannung umgewandelt, die anschliessend von einem Attiny-Microcontroller ausgewertet wird. Die Messung der Feuchtigkeit erfolgt einmal pro Minute. In der Zwischenzeit ist die Messschaltung deaktiviert und der Microcontroller im Sleep-Modus.

Wie von den Sensor Nodes bekannt, wird der eingelesene Messwert mittels RFM12B Transceiver drahtlos an die Basisstation gesendet.

Rückblick und weitere Bilder im Snowflake Blog

Der Prototino ist ein Arduino-Clone des kanadischen Herstellers Spikenzielabs. Wie der Name aussagt, steckt hinter dem Prototino ein Protoshield mit integriertem Arduino Clone. Vom schweizer Lieferanten boxtec wurde mir ein Prototino Kit zum Test zur Verfügung gestellt.

Das Prototino Board ist nur als Bausatz lieferbar und muss vom Anwender selber zusammengelötet werden. Alle nötigen Bauteile für den Prototino sind in einem Antistatik-Beutel unterbracht. Sehr praktisch ist dazu die auf dem Beutel aufgeklebte Stückliste aller Bauteile. Auch Einsteiger können dadurch sehr schnell die einzelnen Bauteile identifizieren und auflöten.

Das Bestücken und Auflöten der Komponenten ist schnell gemacht. Erfahrene Anwender benötigen als Hilfe meist nur die Stückliste auf dem Beutel. Für Anfänger steht auf der Spikenzielabs-Website eine ausführliche Anleitung mit Bildern zur Verfügung welche man sich vor dem Zusammenbau zu Gemüte führen sollte.

Nach dem Zusammenbau prüft man nochmals die Lötstellen und kann dann den ATmega328 auf den Sockel stecken. Anschliessend kann man den Prototino in Betrieb nehmen.

Versorgungsspannung
Mit dem aufgelöteten Spannungsregler kann man den Prototino mit einer Versorgungsspannung von 7.5 – 12 Volt betreiben. Dazu verwendet man eine 9V-Blockbatterie oder einen Netzadapter (Steckernetzteil). Die externe Spannung wird dazu an der Stiftleiste an Pin Vin angeschlossen. Für den Anschluss der höheren Versorgungsspannung wäre es praktischer wenn 2 separate Anschlüsse für VIN und GND vorhanden wären an welchen man auch eine 2-polige Schraubklemme anlöten könnte. Zusätzlich sollte die Position von VIN näher beim Spannungsregler positioniert sein damit Störungen auf der Versorgungsspannung nicht die Signale des FTDI-Anschlusses beeinflussen.

Bei einer höheren Eingangsspannung oder einem grössen Stromverbrauch durch externe Aktoren oder Sensoren kann der Spannungsregler auf dem Board warm werden. Dank der idealen Position des Spannungsreglers am Rande der Leiterplatte kann man recht einfach einen Kühlkörper anschrauben.

Zusätzlich kann der Prototino auch direkt mit 5V betrieben werden. In diesem Fall ist der Spannungsregler (VR1) nicht nötig. Während dem Programmieren (Upload der Arduino-Sketche) wird das Board vom angeschlossenen Rechner versorgt. In diesem Fall darf die externe Batterie oder Netzteil nicht angeschlossen werden.

Die Zuführung der +5V kann auch über die Lötpunkte +5V und GND erfolgen. Dazu steht genügend Lötpads zur Verfügung um stabile Schraubklemmen aufzulöten.

Sketch-Upload
Im Gegensatz zum Standard-Arduino-Board steht auf dem Prototino kein USB-Anschluss zur Verfügung. Für den Sketch-Upload steht 6-polige Stifleiste mit einer seriellen Schnittstelle zur Verfügung. Die Verbindung dieser seriellen Schnittstelle mit dem Rechner erfolgt über ein USB/Serial-Kabel, auch als FTDI-Kabel bezeichnet.

Das FTDI-Kabel wird am USB-Port des Rechners und an der Stiftleiste angeschlossen. Dabei muss beim Anschliessen des Kabels am Prototino die korrekte Richtung beachtet werden. Als Hilfe kann man auf die Farben der einzelnen Drähte des Kabels schauen. Dazu sind die Farben der äussersten Pins auf der Leiterplatte bezeichnet, B für Schwarz (black) und G für Grün (green).

Neben dem FTDI-Kabel kann auch ein sogenanntes FTDI-Breakout-Board verwendet werden. Dieses Board macht die Umsetzung des USB-Signals auf das serielle Signal. Für die Verbindung des FTDI-Breakout-Boards mit dem Rechner reicht in diesem Fall ein handelsübliches USB-Kabel.

Inbetriebnahme
Die Inbetriebnahme ist sehr einfach. Nach dem Verbinden des Prototino mit dem Rechner über das FTDI-Kabel leuchtet die rote Power-Leuchtdiode und zeigt an dass das Board mit Spannung versorgt wird. Wie gewohnt, ist auch auf dem Prototino der Beispielsketch BLINK hochgeladen. Da aber keine Leuchtdiode an Pin 13 angeschlossen ist, sieht man die korrekte Ausführung des hochgeladenen Programmes nicht sofort in optischer Form. Zum Test kann man ein Voltmeter an den Pin 13 anschliessen um das Signal zu prüfen. Für eine optische Prüfung steckt man eine LED mit Vorwiderstand auf ein Steckbrett und schliesst die – und + Signale an GND und Pin13. Wenn die LED blinkt, ist das Board betriebsbereit.

Prototypenfläche auf dem Prototino
Neben der Arduino-Schaltung steht auf dem Prototino-Board über die Hälfte der Fläche für eigene Schaltungsaufbauten zur Verfügung.

Die Prototypenfläche ist dabei in einzelne Lötpins und in Streifen mit mehreren Lötpins aufgeteilt. Am Rand des Prototypenbereichs sind die Anschlüsse für +5V und GND die man einfach mit einzelnen Lötpins verbinden kann. Für eigene Schaltungsaufbauten wäre aber eine Prototypenfläche mit einzelnen Lötpunkten idealer. Für meinen Testaufbau wollte ich ein RFM12B-Breakout Board auflöten. Durch die einzelnen miteinander verbundenen Lötpins kann ich das Breakout Board nicht nach eigenen Wünschen platzieren.

Beim Schaltungsaufbau ist es sehr praktisch dass die Arduino-Pins in einer Reihe am Rand der Arduino-Schaltung angeordnet sind. Auf diese Weise kann man die einzelnen Ein-oder Ausgänge einfach mit der eigenen Schaltung verbinden.

Das Prototino-Board eignet sich auch sehr gut als Prototypen-Bord da auf der freien Prototypenfläche auch genügend Platz für ein Steckbrett vorhanden ist. Mit 4 Abstandbolzen aus Kunststoff in den Ecken des Prototino montiert kann man die Stabilität des Boards erhöhen. Der Prototino lässt sich beim Experimentieren einfach auf eine flache Unterlage stellen ohne dass man Kurzschlüsse auf der Leiterplattenunterseite produziert.

Für mobile Anwendungen oder als mobiles Prototypen-Board passt der Prototino sogar in eine kleine Metallbox.

Fazit:
Der Arduino Clone Prototino ist ein praktisches Arduino-Board mit einer grossen Prototypenfläche für eigene Schaltungsaufbauten. Das Board ist auf einer stabilen Leiterplatte aufgebaut. Die saubere Beschriftung der Leiterplatte und die ausführliche Bauanleitung ermöglichen einen schnellen und problemlosen Aufbau des Prototino. Das Board kann dadurch auf von einem Anfänger aufgebaut werden. Dank der integrierten Prototypenfläche erhält man mit dem Prototino ein kostengünstiges Arduino-Board mit Platz für zusätzliche Prototypenschaltungen. Einzig beim Einsatz von zusätzlichen Shields ist der Prototino nicht die ideale Boardvariante da die Pins nicht im Arduino-kompatiblen Pinraster platziert sind.

Einsatz des RFM12B Breakout Boards mit einem Minuino.

Bei der Verwendung eines RFM12B Transceivers mit Minuino oder einem anderen Arduino Board ist zu beachten dass der Transceiver mit maximal 3.8 V betrieben werden darf. Bei 5V-Betrieb müssen ein 3.3V-Spannungsregler für die Versorgung und Widerstände für die Signalanpassung ergänzt werden. Mit einer 3V-Versorgung sind diese Zusatzbauteile nicht nötig.