AdSense

Sonntag, 11. September 2016

DHT11 Sensor mit Arduino auslesen

(English version) Vor einizger Zeit habe ich einen Temperatur- und Luftfeuchte-Sensor gekauft, die Bezeichnung lautet DHT11. Der Sensor ist einfach zu benutzen und verträgt sowohl 3,3V als auch 5V. Der Sensor hat 4 Pins, für den normalen Betrieb werden aber nur 3 Pins benötigt.
Der linke Pin (wie im Bild erkennbar) wird mit 5V verbunden, der rechte Pin mit GND. Der linke der beiden mittleren Pins ist der Signal-Pin, dieser wird mit einen beliebigen Digital-Pin am Arduino verbunden (in diesem Fall ist das Kanal 2). Außerdem wird noch ein 10k Widerstand zwischen dem Daten-Pin und 5V benötigt.

Als nächstes benötigt man die entsprechende Library, diese gibt es hier: Download. In der Arduino Software wird dann der Sensor wie folgt ausgelesen. Der Quellcode sollte selbsterklärend sein. Falls ein Sensor mit höherer Genauigkeit benötigt wird kann auch ein DHT22 benutzt werden, das muss dann entsprechend in DHTTYPE geändert werden.

#include "DHT.h"
#define DHTPIN 2

#define DHTTYPE DHT11

DHT dht(DHTPIN, DHTTYPE);

void setup() {
  Serial.begin(9600);

  dht.begin();
}

void loop() {
  float h = dht.readHumidity();
  float t = dht.readTemperature();
  
  Serial.print("Humidity: ");
  Serial.print(h);
  Serial.print(" %\t");
  Serial.print("Temperature: ");
  Serial.print(t);
  Serial.println(" *C ");

  delay(2000);
}

Sonntag, 17. Juli 2016

3D-Druckprofile für den Ultimaker 2

(English version) Nachdem lange Zeit nichts hier auf dem Blog passiert ist möchte ich ein weiteres Thema aufnehmen: 3D-Druck. Ich selbst besitze einen Ultimaker 2 und möchte in diesem ersten Post nun einmal die Druckprofile vorstellen, welche ich benutze. Ich drucke ausschließlich mit schwarzem PLA von Innofill - dadurch muss ich kein Feintuning vornehmen wenn ich neues Material kaufe, da die Eigenschaften gleich bleiben.

Ultimaker 2:
Am Drucker selbst habe ich relativ wenig eingestellt. Ich habe drei Profile: Fast, Fine und Ultrafine. Für alle drei benutze ich als Heatbed Temperature 70 °C. Das sorgt dafür, dass der Druck sehr gut anhaftet. Die Nozzle Temperatures sind 210 °C für Fast, 195 °C für Fine und 172 °C für Ultrafine. 172 °C ist sehr nahe am Schmelzpunkt, daher muss bei Temperaturwechsel in der Wohnung (Sommer / Winter) auch diese Temperatur leicht angepasst werden, im Winter habe ich eher 175 °C.

Druckprofile für Cura:
Im allgemeinen braucht man bei PLA keine Kühlung durch die Lüfter, aktiviert man diese dennoch führt das dazu, dass sich der Druck an den Kanten vom Druckbett hochzieht. Daher haben die Profile Fast und Fine eine Minimum Fan Speed von 10%, während bei Ultrafine 60% eingestellt ist, sodass kleine Strukturen besser gekühlt werden und nicht während dem Druck anfangen zusammenzuschmelzen.
Die Layer Height ist 0,1 mm für Fast und 0,05 mm für Fine und Ultrafine. Die Shell Thickness ist 0,8 mm.
Als Druckgeschwindigkeit benutze ich 25-40 für Fast, 20-25 für Fine und 10-25 für Ultrafine.

Wer Interesse an den Profilen hat kann sie hier herunterladen:
Fast
Fine
Ultrafine

Mittwoch, 23. September 2015

nrf24l01+ mit dem ATtiny84

(English version) Ich habe bereits erklärt, wie man das Funkmodul nrf24l01+ am Arduino bzw. ATmega betreibt. Die Details können in diesem Post nachgelesen werden. Möchte man das Funkmodul jedoch an einem ATtinyx4, wie zum Beispiel dem ATtiny84 betreiben, sind einige Anpassungen nötig.

In diesem Post möchte ich erklären, wie man eine Funkstrecke zwischen einem Arduino und dem ATtiny aufbaut. Ich verwende dazu das ping-Bespiel der Mirf-Library. Der Arduino sendet ein Ping-Signal aus, der ATtiny empfängt es und sendet es zurück.

Voraussetzung ist, dass ihr die ATtiny-Cores für die Arduino IDE installiert habt, wie ich es HIER beschrieben habe.

Nötige Libraries

Das Modul nrf24l01+ kommuniziert über SPI mit dem Mikrocontroller. Der ATtiny hat anders als der ATmega keine hardwareseitige Unterstützung für SPI, SPI muss also softwareseitig emuliert werden. Dies geschieht über das sogenannte Universal Serial Interface (USI). Dafür gibt es zum Glück wie immer eine fertige Library, wir müssen uns also um nix kümmern. Außerdem sind Änderungen an der Mirf-Library notwendig, doch auch hier hat sich schon jemand die Arbeit gemacht und eine passend Lib erstellt. Beide Libs können HIER herunter geladen werden. Nachdem ihr die beiden Ordner "Mirf" und "SPI85" in den entsprechenden "libraries"-Ordner der Arduino IDE kopiert habt, stehen euch die Libs wie gewohnt zur Verfügung.

Hardware

Die Verkabelung erfolgt ähnlich wie im Beispiel mit dem ATmega. Es müssen CSN, CE, SCK, MOSI und MISO sowie VCC und GND angeschlossen werden. Ich weise nochmal darauf hin, dass das Modul mit 3,3V betrieben werden muss! Folgende Grafik zeigt eine mögliche Verkabelung mit dem ATtiny84:
  
Wichtiger Hinweis: im Datenblatt des ATtiny gibt es zwar Pins, die mit MISO, MOSI und SCK bezeichnet sind, diese sind aber NUR zum Anschluss des Programmers (z.B. USBasp geeignet). Das Funkmodul muss mit den Pins USI-DI (entspricht MISO), USI-DO (entspricht MOSI) und USCK (entspricht SCK) verbunden werden. Standardmäßig sind dies die Pins D4 bis D6 (siehe Grafik oben). Prinzipiell sind die Pins aber frei wählbar. Wichtig ist, dass USI-DI nicht auf den MISO-Pin des Programmers gelegt werden darf. Dieses gilt ebenso für USI-DO und den MOSI-Pin. 

Software

Auf dem Arduino läuft unverändert das Beispiel "ping_client" der Mirf-Library. Auf dem ATtiny läuft eine angepasst Version des Beispiels "ping_server":

#include <SPI85.h>
#include <Mirf.h>
#include <MirfHardwareSpi85Driver.h>

// This USI was defined in SPI85.cpp
// Not to be confused with SPI (MOSI/MISO) used by ICSP pins
// Refer to page 61 of attiny84 datahseet
// USI pins could be redefined here
//#define USI-DO  5
//#define USI-DI  4
//#define USCK   6

#define CE    7    
#define CSN   3 

void setup(){

  
  /*   * Set the SPI Driver.   */

  Mirf.spi = &MirfHardwareSpi85;
    
  /*   * Setup pins / SPI.   */
  
  Mirf.cePin = CE;
  Mirf.csnPin = CSN;
  Mirf.init();
  
  /*   * Configure reciving address.   */
   
  Mirf.setRADDR((byte *)"serv1");
  
  /*   * Set the payload length to sizeof(unsigned long) the   * return type of millis().   *   * NB: payload on client and server must be the same.   */
   
  Mirf.payload = sizeof(unsigned long);
  
  /*   * Write channel and payload config then power up reciver.   */
   
  Mirf.config();

}

void loop(){
  /*   * A buffer to store the data.   */
   
  byte data[Mirf.payload];
  
  /*   * If a packet has been recived.   *   * isSending also restores listening mode when it    * transitions from true to false.   */
   
  if(!Mirf.isSending() && Mirf.dataReady()){

    /*     * Get load the packet into the buffer.     */
     
    Mirf.getData(data);
    
    /*     * Set the send address.     */
     
     
    Mirf.setTADDR((byte *)"clie1");
    
    /*     * Send the data back to the client.     */
     
    Mirf.send(data);
    
    /*     * Wait untill sending has finished     *     * NB: isSending returns the chip to receving after returning true.     */
      
    
  }
}

Der einzige Unterschied im Vergleich zur Version für den ATmega ist, dass SPI85.h sowie MirfHardwareSpi85Driver.h eingebunden werden und im setup() MirfHardwareSpi85 als SPI-Treiber ausgewählt wird:
Mirf.spi = &MirfHardwareSpi85;

Wenn ihr den Code mit eurem Programmer auf den ATtiny übertragt, sollte der pingende Arduino nun eine Antwort vom ATtiny bekommen.

Ein kleiner Hinweis zum Schluss: bei mir gab es Probleme mit dem Upload der Software über den USBasp, sobald das Funkmodul am ATtiny angeschlossen war. Das liegt vermutlich daran, dass sich der USBasp sowie das Modul die Pins am ATtiny teilen. Ich muss daher während dem flashen des ATtiny die Spannungsversorgung des Funkmoduls unterbrechen, dann klappt alles problemlos.

Dienstag, 22. September 2015

ATtiny mit der Arduino IDE programmieren - RELOADED

(English version) Vor einiger Zeit habe ich schon mal einen Beitrag zum Thema "ATtiny und Arduino" verfasst. In diesem habe ich erklärt, wie man die sogenannten "ATtiny-Cores" für Arduino installiert, damit man mit der Arduino IDE auch ATtinys programmieren kann.

Da ich für ein anderes Projekt einen anderen Core verwendet habe, möchte ich diesen hier auch nochmals kurz vorstellen. Es handelt sich dabei um Core-Dateien für ATtiny25, ATtiny45, ATtiny85, ATtiny24, ATtiny44 und ATtiny84.

Die nötigen Dateien können HIER heruntergeladen werden. Das entpackte Verzeichnis wird dann ebenfalls in den Ordner "hardware" kopiert. Die Ordnerstruktur sähe dann beispielsweise so aus: "C:\Programme\Arduino\hardware\tiny". Im Ordner "tiny" öffnet ihr den Unterordner "avr" und bennent dort die Datei "Prospective Boards.txt" um in "boards.txt" - sonst wird der Core von der IDE nicht erkannt.

Nach einem Neustart der Arduino IDE könnt ihr dann unter "Werkzeuge" - "Platine" den gewünschten ATtiny auswählen und ihn mit einem Programmer wie z.B. dem USBasp programmieren ("Sketch" - "Hochladen mit Programmer"). Wichtig ist, dass die Fuses im ATtiny richtig gesetzt sind und zur ausgewählten Platine passen.

Die Pinbelegung kann der Datei "pins_arduino.c" im Ordner "tiny\avr\cores\tiny" entnommen werden. Für den ATtinyx4 lautet sie beispielsweise:
//
//                                        +-\/-+
//                               VCC  1|    |14  GND
//                     (D  0)  PB0  2|    |13  AREF (D 10)
//                     (D  1)  PB1  3|    |12  PA1  (D  9)
//                               PB3  4|    |11  PA2  (D  8)
//  PWM  INT0  (D  2)  PB2  5|    |10  PA3  (D  7)
//    PWM        (D  3)  PA7  6|    |9   PA4  (D  6)
//    PWM        (D  4)  PA6  7|    |8   PA5  (D  5)        PWM
//                                       +----+

Dienstag, 10. Februar 2015

Serielle Kommunikation mit Matlab oder C#

(English version) Im vorigen Post (Herzschlag-Sensor ansteuern) habe ich erklärt, wie man mit einem Arduino über die serielle Schnittstelle den Wert des Herzschlag-Sensors sendet. In diesem Post will ich nun erklären, wie man diese Daten mit Matlab oder C# ausliest. Anfangen werde ich mit Matlab. Zuerst muss ein serieller Port geöffnet werden:

s = serial('COM3');
fopen(s);


Hier muss man einfach den entsprechenden COM-Port eintragen. Danach kann man auch schon alle verfügbaren Zeichen einlesen:

str = fscanf(s);

Das Problem daran ist allerdings, dass es auch sein kann, das eine Nachricht vom Arduino erst halb gesendet wurde und alle bisher gesendeten Zeichen eingelesen werden. Das kann man umgehen indem man z.B. alle gelesenen Zeichen in einen String schreibt und diesen dann ausliest. Am Ende sollte man nicht vergessen, den Port wieder zu schließen:

fclose(s);

Als nächstes möchte ich nun erklären wie man mit C# kommuniziert. Prinzipiell muss hier auch zuerst ein Port geöffnet werden:

port = new SerialPort("COM3", 9600);
port.Open();

Danach kann man direkt alle existierenden Zeichen lesen (analog zum Beispiel mit Matlab):

string indata = sp.ReadExisting();

In C# muss man den Port nicht unbedingt schließen, da dies beim Beenden des Programmes automatisch passiert.

Samstag, 24. Januar 2015

Herzschlag-Sensor ansteuern

(English version) Wenn man bei ebay nach "heartbeat sensor" sucht, findet man eine kleine Platine, welche mit LED und Phototransistor bestückt ist, welche angeblich den Herzschlag messen kann. Ich habe mir so ein Teil gekauft und es ausprobiert. Leider gibt es sehr wenig (ok, gar keine) Dokumentation dazu und nichtmal eine Seriennummer, alles was ich weiß ist das auf meinem Sensor xinda und Lcup drauf steht.
Der Herzschlag-Sensor
Der Sensor hat 3 Anschlüsse welche auch sehr toll beschriftet sind. Einer mit -, das ist der Anschluss für GND. Der nächste Anschluss hat ein S, das steht für Sensor, hier wird der Phototransistor ausgelesen. Dann gibt es noch den Pin in der Mitte ohne Beschriftung, das ist der Pin für die LED. Beschaltet wird der Chip ganz einfach: +5V an die LED und den Sensor-Ausgang an einen Analog-Eingang des Arduinos.

Das Programm liest nun praktisch den Sensor-Wert und sendet diesen über die serielle Schnittstelle an den Computer wo die Daten weiterverarbeitet werden können (z.B. mit Matlab, darüber werde ich vielleicht im nächsten Post etwas schreiben). Hier ist ein Bild von den geplotteten Daten mit Matlab und darunter der Code für den Arduino.
//Define pins for LED and sensor.
int ledPin = 13;
int sensorPin = 0;
//alpha is used in the original proposed code by the company (see below).
double alpha = 0.75;
//lasttime is used to have a very precise measurement of the time so the calculated pulse is correct.
unsigned long lasttime;

void setup ()
{
  //Switch on the LED.
  pinMode (ledPin, OUTPUT);
  digitalWrite(ledPin,HIGH);
  Serial.begin (9600);
  lasttime = micros();
}

void loop ()
{
  //Also used for smoothening the signal.
  static double oldValue = 0;
  
  //Wait 10 ms between each measurement.
  while(micros() - lasttime < 10000)
  {
    delayMicroseconds(100);
  }
  
  //Read the signal.
  int rawValue = analogRead (sensorPin);
  lasttime += 10000;
  
  //In the "original" code example, "value" was sent to the computer. This calculation basically smoothens "rawValue".
  //double value = alpha * oldValue + (1 - alpha) * rawValue;
  
  //Send back the measured value.
  Serial.println (rawValue);
  oldValue = value;
}

Sonntag, 18. Januar 2015

Eine Spieltisch für Tabletops

(English version) Für Tabletop-Spiele benötigt man natürlich eine Unterlage auf der man spielen kann. Für den Anfang reicht ein kleiner Tisch oder auch der Boden, wer aber große Schlachten austragen will braucht dann etwas größeres. Die standard-Größe bei Tabletop-Tischen für 28 mm Tabletops ist etwa 6 x 4 Fuß, das entspricht etwa 183 x 122 cm. So ein Tisch ist ziemlich groß und nimmt viel Platz weg, wenn man nur eine kleine Wohnung hat ist das dann nicht mehr so einfach möglich da mit so einem großen Tisch bereits ein ganzer Raum in Anspruch genommen wird. Daher habe ich einen Tisch gebaut, welchen man in 2 Minuten auf- und abbauen kann.

Die Grundidee ist simpel: Auf einen bestehenden Couch-Tisch wird eine große Holzplatte gelegt. Da mein Couch-Tisch nur 110 x 70 cm groß ist würde eine Platte der Größe 183 x 122 cm herunterhängen. Also benötigt der Spieltisch auch noch Füße. Das Ergebnis besteht nun aus zwei Platten der Größe 183 x 61 cm, welche man zusammenstecken kann. Eine Seite des Spielfeldes wird dann auf den Couch-Tisch gelegt, unter dem anderen Ende sind 2 Füße angebracht. Ich will nun auf die einzelnen Teile eingehen.
Der komplette Tisch.
Die Platten
Für die Platten habe ich eine 8 mm starke Spanplatte benutzt. Eine dickere Platte ist natürlich generell stabiler und verbiegt sich nicht so stark, jedoch erhöht sich dabei auch das Gewicht und der Preis. 8 mm funktionieren bei mir ziemlich gut, auf den Tisch sollte man sich jedoch nicht setzen.

Die Füße
Am Ende jeder Platte ist ein Fuß über ein Scharnier befestigt. Wird der Tisch weggeräumt, so klappt man den Fuß ein und er nimmt nicht übermäßig Platz weg. Für den ausgeklappten Zustand ist noch die Befestigung mit einem Spannverschluss geplant, davon kann ich allerdings keine Bilder zeigen, da ich noch auf den Artikel warte. Die Scharniere gibt es in jedem Baumarkt billig zu kaufen, ebenso das Holz für die Tischbeine.
Die Befestigung des Tischbeines.
Das Zusammenstecken
Beim Obi gibt es spezielle Schranktür-Verschlüsse, welche man einfach ineinander stecken kann. Diese habe ich an die beiden Platten gebaut sodass die Platten ineinander gesteckt werden können.
Die Steckverbindung zwischen den Platten.
Positionierung auf dem Couchtisch
Am Ende habe ich noch kleine Holzblöcke unten an die Platten geklebt, sodass der Tisch sich nicht mehr bewegen kann, und perfekt auf dem Couch-Tisch sitzt.
Links im Bild der Couch-Tisch mit dem Holzblock unten an der Tischplatte.
Auf dem Tisch kann nun das Gelände verteilt werden oder eine Grasmatte ausgebreitet werden. Alternativ könnte man die Platten auch mit Gras bedecken oder einem farbigen Stoff, oder, wenn man es ganz simpel halten will, einfach in einer Farbe anmalen, das könnte z.B. für große Wasserflächen praktisch werden.