AdSense

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.

Dienstag, 13. Januar 2015

Arduino - Keypad auslesen

(English version) Heute möchte ich kurz vorstellen wie man ein simples Keypad, wie im folgenden Bild zu sehen, mit dem Arduino auslesen kann. Man könnte dazu z.B. dieses hier von ebay nehmen: Keypad.
Das Keypad hat 8 Anschlüsse. Jeweils 4 sind dabei für die Zeilen bzw. Spalten. Ein Tastendruck verbindet nun zwei dieser Anschlüsse. 4 Anschlüsse werden am Arduino als Output genutzt, die anderen 4 als Input. Ich habe Pin 22, 24, 26 und 28 als Output benutzt und 30, 32, 34, 36 als Input, man kann das Display dadurch sehr einfach anschließen, indem man eine Stiftleiste benutzt.
Nun legt man nacheinander an jeden Output eine Spannung an und misst dabei, welcher Input diese Spannung abbekommt. Dadurch weiß man sofort welche Tasten gedrückt wurden. Mein Code liest die Tasten aus und sendet, sobald sich der Status einer Taste geändert hat, dies über die serielle Schnittstelle an den Computer.


//For different sizes of Keypads, you can adjust the numbers here. Important: Also change the keyValues array!
const int numOuts = 4;
const int numIns = 4;
//These are the 4 output pins, adjust it if you use a different pin mapping
int outs[numOuts] = {22, 24, 26, 28};
//These are the 4 input pins, adjust it if you use a different pin mapping
int ins[numIns] = {30, 32, 34, 36};
//This array contains the values printed to the different keys
char keyValues[numOuts][numIns] = {{'1','2','3','A'},{'4','5','6','B'},{'7','8','9','C'},{'*','0','#','D'}};
//This array contains whether a pin is pressed or not
boolean pressed[numOuts][numIns];

void setup() {  
  Serial.begin(9600);
  //Define all outputs and set them to high
  for (int i = 0; i < numOuts; i++)
  {
    pinMode(outs[i], OUTPUT);
    digitalWrite(outs[i], HIGH);
  }
  //Define all inputs and activate the internal pullup resistor
  for (int i = 0; i < numIns; i++)
  {
    pinMode(ins[i], INPUT);
    digitalWrite(ins[i], HIGH);
  }
}

//Read whether a key is pressed
void KeyPressed()
{
  for (int i = 0; i < numOuts; i++)
  {
    //Activate (set to LOW) one output after another
    digitalWrite(outs[i], LOW);
    //Wait a short time
    delay(10);
    for (int j = 0; j < numIns; j++)
    {
      //Now read every input and invert it (HIGH = key not pressed (internal pullup), LOW = key pressed (because the output was set to LOW)
      boolean val = !digitalRead(ins[j]);
      //If the value changed, send via serial to the computer and save the value in the "pressed" array
      if (pressed[i][j] != val)
      {
        char str[255];
        sprintf(str, "%c pressed: %d", keyValues[i][j], val);
        Serial.println(str);
        pressed[i][j] = val;
      }
      
    }
    //Deactivate (set back to HIGH) the output
    digitalWrite(outs[i], HIGH);
  }
}

//Yeah, do this forever...
void loop()
{
  KeyPressed();
}