NIBObee-Berry: Unterschied zwischen den Versionen

Aus Nibo Wiki
Wechseln zu: Navigation, Suche
K (Test der Grundfunktion)
K (Fuses)
Zeile 273: Zeile 273:
  
 
===Fuses===
 
===Fuses===
In den "Fuses" verwaltet der ATMEL-Prozessor diverse Einstellungen. Diese sollten wir im Normalfall nicht ändern. Aber ein Backup kann auch hier nicht schaden. Es gibt "high"- und "low"-Fuses, die getrennt verwaltet und auch gesichert werden.
+
In den "Fuses" verwaltet der ATMEL-Prozessor diverse Einstellungen. Diese sollten wir im Normalfall nicht ändern. Aber ein Backup kann auch hier nicht schaden. Es gibt "high"-, "low"- und die E-Fuses, die getrennt verwaltet und auch gesichert werden.
 
  avrdude -v -F -c usbasp -P usb  -p m1284p -B 0.5 -U hfuse:r:"BACKUPFILENAME.hfuse":b
 
  avrdude -v -F -c usbasp -P usb  -p m1284p -B 0.5 -U hfuse:r:"BACKUPFILENAME.hfuse":b
 
  avrdude -v -F -c usbasp -P usb  -p m1284p -B 0.5 -U lfuse:r:"BACKUPFILENAME.lfuse":b
 
  avrdude -v -F -c usbasp -P usb  -p m1284p -B 0.5 -U lfuse:r:"BACKUPFILENAME.lfuse":b
 +
avrdude -v -F -c usbasp -P usb  -p m1284p -B 0.5 -U efuse:r:"BACKUPFILENAME.efuse":b
  
 
==Hello World==
 
==Hello World==

Version vom 11. April 2016, 22:08 Uhr

Info

Mit dem Berry Modul kann ein NIBObee Roboter mit einem Raspberry Pi verbunden werden. Dadurch wird der Anschluss von nahezu beliebiger Sensorik (SPI, I2C, USB ...) möglich und zudem kann über den Raspberry via WLAN-Zugriff auf einen somit mobilen NIBObee zugegriffen werden.

Darüber hinaus stehen über den vollwertigen Linux-Computer, den der Raspberry darstellt, wesentlich komfortablere und zugleich komplexere Programmiermöglichkeiten zur Verfügung.

Das Berry-Modul enthält zudem einen integrierten DC/DC Wandler für die Spannungsversorgung des RPi, der mit einem weiten Spannungsbreich von 6,5 - 30 Volt umgehen kann. Dadurch können z.B. auch LiPo-Akkus etc. verwendet werden. Über einen (leider nicht enthaltenen und nur optionalen) 2. DC/DC-Wandler kann aus dem Berry-Akku auch der NIBObee mit Strom versorgt werden.

Der Rasperry Pi ist durch eine serielle Schnittstelle mit dem NIBObee verbunden.

Der Mikrocontroller im NIBObee kann dabei aus "ausführendes" Organ verstanden werden, während der Raspberry die Befehle erteilt.

Dadurch kann ggf. das neue eeprom-Flashen auf dem NIBObee bei Programmänderungen entfallen. Allerdings ist die Geschwindigkeit der Datenübertragung über die serielle Schnittstelle begrenzt, so dass die "reflexartigen" Funktionen ggf. besser "fest" im NIBObee-Controller verankert und die komplexen Funktionen im Raspberry umgesetzt werden sollten.

So sieht der NIBOObee mit dem aufgesetzten Raspberry mit WLAN, Kamera und einer Powerbank als Stromquelle aus:

NIBObee-Berry

Über die Berry-Erweiterung stehen 2 zusätzliche Schalter und 2 LEDs zur Verfügung, die nach Belieben Verwendung finden werden:

NIBObee-Berry, Seitenansicht 1

Insgesamt hat unser Mega-Käfer jetzt drei Ebenen: NIBObee, Berry-Erweiterung und der Raspberry selbst:

NIBObee-Berry, Seitenansicht 2

Fehlersuche, wenn es nach dem Zusammenbauen nicht klappt

Sowohl beim NIBObee, als auch beim Berry-AddOn sind vereinzelt Probleme bei den Batterieclips bekannt. Die verklemmten Bereiche an den Enden sind in manchen Fällen nicht stromführend verquetscht, so dass die Geräte nicht mit Strom versorgt werden.

Dies lässt sich einfach nachmessen, in dem man die anliegenden Spannungen prüft.

  • beim NiboBEE sollte an X8 bei eingelegten Batterien ca. 5V anliegen. Auch im ausgeschalteten Zustand.
  • bei der Berry-Platine sollte an X10 zwischen 1 und 4 eine Spannung von ca. 8V anliegen. Auch im ausgeschalteten Zustand.

Ein Nachlöten hilft hier leicht ab.

Aber Vorsicht! Auf jeden Fall die Akkus vorher entfernen, sonst werden die Clips durch den Federdruck und die Hitze beim Löten schnell irreparabel beschädigt!

nachgelötete Batterieclips

Vorbereiten des Rasp für die Kommunikation mit dem Bee

Der Raspberry wird typischerweise mit Raspberian betrieben, einer speziell angepassten Debian-Version für den Raspberry.

Die Grundinstallation des Raspberrys ist im Internet, z.B. hier, hinreichend beschrieben.

Es empfiehlt sich, ein Edimax-Nano-USB-WLAN-Stick gleich von Anfang an mit zu integrieren. Die Treiber bringt Raspberian bereits mit.

Die folgenden Arbeiten führen wir auf dem Raspberry aus, nachdem wir uns typischerweise mit einem SSH-Program (Linux: ssh, Windows: putty) nach der Grundeinrichtung mit dem Raspberry verbunden haben.

Wir werden im Folgenden mit Linux als unserem Hauptsystem arbeiten; die Beispiele sind dementsprechend aus Linux-Sicht.

Damit wir vollen Zugriff auf alle Funktionen und Rechte haben, werden wir mit dem root-Benutzer arbeiten.

Verbinden von unserem lokalen Rechner aus mit dem Raspberry:

user@localmachine:~# ssh root@[IP-ADRESSE-RASPBERRY]

Sollte das Login trotz korrektem Passwort nicht möglich sein, ist vermutlich das Verbinden als root nicht gestattet. Wir melden uns dann als pi, dem Standardbenutzer, an und verwandeln uns mit sudo su zu root:

user@localmachine:~# ssh pi@[IP-ADRESSE-RASPBERRY]    (defaultpasswort: raspberry)
root@nibo:~# sudo su
root@nibo:~#

Wir werden der Ordnung halber gleich unter dem Ordner /opt einen eigenen Ordner für unsere Projekte anlegen:

root@nibo:~# mkdir /opt/niboberry

Installation WiringPi / GPIO

Damit wir einfach die Ein- und Ausgänge des Rapsberry ansprechen können, installieren wir WiringPi, was nützliche Tools (gpio) und diverse Bibliotheken in C, C++, Python, Java und PHP mitbringt.

root@nibo:~# apt-get update
root@nibo:~# apt-get install git-core
root@nibo:~# cd /opt
root@nibo:/opt# git clone git://git.drogon.net/wiringPi
root@nibo:/opt# cd WiringPi
root@nibo:/opt/WiringPi# ./build

Test der Grundfunktion

Mit einem kleinen Script testen wir die Grundfunktionen der Raspberry-Addon-Platine.

Die Verdrahtung der Platine ist wie folgt:

Taster A: Pin 15 (wPi: 3)
Taster B: Pin 16 (wPi: 4)
LED grün: Pin 18 (wPi: 5)
LED  rot: Pin 22 (wPi: 6)

Da die Taster das Signal auf GND legen, benötigen wir als "Gegenstück" (quasi im ungedrückten Zustand) ein High-Signal. Wir stellen daher den internen Pull-Up-Wiederstand für die Eingänge ein.

gpio mode 3 up
gpio mode 4 up

Siehe Schaltplan Berry-Erweiterung.

Mit

root@nibo:~# gpio readall

bekommen wir alle Ports, Ein- und Ausgänge, derzeitige Zustände und die unterschiedlichen Namen angezeigt:

+-----+-----+---------+------+---+-Model B2-+---+------+---------+-----+-----+
| BCM | wPi |   Name  | Mode | V | Physical | V | Mode | Name    | wPi | BCM |
+-----+-----+---------+------+---+----++----+---+------+---------+-----+-----+
|     |     |    3.3v |      |   |  1 || 2  |   |      | 5v      |     |     |
|   2 |   8 |   SDA.1 | ALT0 | 1 |  3 || 4  |   |      | 5V      |     |     |
|   3 |   9 |   SCL.1 | ALT0 | 1 |  5 || 6  |   |      | 0v      |     |     |
|   4 |   7 | GPIO. 7 |   IN | 1 |  7 || 8  | 1 | ALT0 | TxD     | 15  | 14  |
|     |     |      0v |      |   |  9 || 10 | 0 | ALT0 | RxD     | 16  | 15  |
|  17 |   0 | GPIO. 0 |   IN | 0 | 11 || 12 | 0 | IN   | GPIO. 1 | 1   | 18  |
|  27 |   2 | GPIO. 2 |   IN | 0 | 13 || 14 |   |      | 0v      |     |     |
|  22 |   3 | GPIO. 3 |   IN | 0 | 15 || 16 | 0 | IN   | GPIO. 4 | 4   | 23  |
|     |     |    3.3v |      |   | 17 || 18 | 0 | IN   | GPIO. 5 | 5   | 24  |
|  10 |  12 |    MOSI |   IN | 0 | 19 || 20 |   |      | 0v      |     |     |
|   9 |  13 |    MISO |   IN | 0 | 21 || 22 | 0 | IN   | GPIO. 6 | 6   | 25  |
|  11 |  14 |    SCLK |   IN | 0 | 23 || 24 | 1 | IN   | CE0     | 10  | 8   |
|     |     |      0v |      |   | 25 || 26 | 1 | IN   | CE1     | 11  | 7   |
+-----+-----+---------+------+---+----++----+---+------+---------+-----+-----+
|  28 |  17 | GPIO.17 |   IN | 0 | 51 || 52 | 0 | IN   | GPIO.18 | 18  | 29  |
|  30 |  19 | GPIO.19 |   IN | 0 | 53 || 54 | 0 | IN   | GPIO.20 | 20  | 31  |
+-----+-----+---------+------+---+----++----+---+------+---------+-----+-----+
| BCM | wPi |   Name  | Mode | V | Physical | V | Mode | Name    | wPi | BCM |
+-----+-----+---------+------+---+-Model B2-+---+------+---------+-----+-----+

Dort erkennen wir auch, dass z.B. der physikalische Pin (Physical) 15 die WiringPi-(wPi)-Nummer 3 hat.

Wir legen das Skript in unserem neuen Ordner an:

root@nibo:~# cd /opt/niboberry
root@nibo:~# nano test.sh

Folgenden Code einfügen und mit [STRG-X] den Editor beenden und speichern:

#!/bin/sh

# Einstellen der Ports als Ein- bzw. Ausgang
gpio mode 3 in
gpio mode 3 up
gpio mode 4 in
gpio mode 4 up
gpio mode 5 out
gpio mode 6 out

# Abwechselndes Blinken der beiden LEDs
gpio write 5 0
gpio write 6 0
gpio write 5 1
sleep 0.5
gpio write 5 0
sleep 0.5
gpio write 6 1
sleep 0.5
gpio write 6 0

# Endlosschleife für Hauptfunktion
while [ True ]
 do
  if [ $(gpio read 3) = 0 ]
  # Taste 1 gedrückt
  then
    echo "Taster A"
    # LED 1 an
    gpio write 5 1
  else
    # LED 1 aus
    gpio write 5 0
  fi

  if [ $(gpio read 4) = 0 ]
  # Taste 2 gedrückt
  then
    echo "Taster B"
    # LED 2 an
    gpio write 6 1
  else
    # LED 2 aus
    gpio write 6 0
  fi

done

# Programmende (wird nie erreicht, da Endlosschleife)
exit 0

Dann die Datei ausführbar machen und starten:

root@nibo:~# chmod +x test.sh
root@nibo:~# ./test.sh

Die LED sollten nacheinander kurz aufleuchten, dann wartet das Script auf das Drücken der Taster.

Bei Druck auf Taster A, sollte nun die grüne LED leuchten. Bei Druck auf Taster B die rote LED.

Sollte das nicht funktionieren, je nach Problem die Platine und das Programm überprüfen.

Mit [STRG-C] beenden wir das Testprogramm.

Aufbau der seriellen Verbindung zum NIBObee

Auf der Raspberry-GPIO-Leiste sind die Pins 8 (TX, senden) und 10 (RX, empfangen) für die serielle Kommunikation vorgesehen.

Siehe Schaltplan Berry-Erweiterung.

Die serielle Schnittstelle wird vom Raspberry standardmäßig zur Bootprotokollierung verwendet.

Diese Funktion müssen wir daher zunächst deaktivieren.

In

/boot/cdmline.txt

muss diese Zeile angepasst werden:

dwc_otg.lpm_enable=0 console=ttyAMA0,115200 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline rootwait

Der Parameter mit Verweis auf ttyAMA0 muss entfernt werden.

Ergebnis:

dwc_otg.lpm_enable=0 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline rootwait

In

/etc/inittab

müssen wir verhindern, dass eine Login-Konsole auf die serielle Schnittstelle gesetzt wird. Dazu muss der entsprechende Eintrag (in der Regel die letzte Zeile) mit einer # auskommentiert werden.

Hier das Ergebnis:

# T0:23:respawn:/sbin/getty -L ttyAMA0 115200 vt100

Nach einem Reboot sollte uns die Schnittstelle nun zur Verfügung stehen.

Test

Um mit dem NiboBEE zu "sprechen" benötigen wir ein Terminalprogramm.

Viele stehen nach Belieben zur Verfügung. Für die Befehlszeile z.B.:

  • minicom
  • microcom
  • picocom

Installation von z.B. microcom mit:

apt-get update
apt-get install microcom

Nun können wir zum ersten Mal vom Raspberry aus mit den NiboBEE die Verbindung aufnehmen. Vorausgesetzt, alle Module sind betriebsbereit, miteinander verbunden und eingeschaltet.

microcom -p /dev/ttyAMA0 -s 9600

Wenn auf dem NiboBEE noch das bei der Auslieferung aufgespielte Testprogramm im Flash-Speicher ist, sendet er laufend auf der seriellen Schnittstelle Werte der optischen Sensoren. z.B.:

1a:1f:1a

Hält man nun den Finger rechts oder links unter den Sensor, ändern sich die Werte entsprechend.

Vorbereiten des Bees für die Kommunikation mit dem Rasp

Damit der Bee von dem Rasp über die serielle Schnittstelle Befehle annehmen und Daten senden kann, müssen diese miteinander kommunizieren und über eine "abgestimmten" Befehlssatz verfügen.

Der NiboBEE ist bereits dementsprechend vorbereitet.

Dieser Befehlssatz nennt sich: Nibo Serial Protocol.

Programmierbeispiele

Wenn wir schon einen Linux-Computer auf dem NiboBEE haben, wollen wir ihn natürlich auf möglichst umfassend nutzen.

Die Kommunikation mit dem NiboBEE und dem Programmiercomputer erfolgt über die USB-Schnittstelle an der Frontseite des NiboBEE. Hier können wir natürlich auch eine Verbindung mit unserem Raspberry herstellen.

Allerdings reagiert der Raspberry sehr empfindlich auf die Spannungsschwankungen, die beim Einstecken von USB-Geräten entstehen können. Am besten schaltet man daher beide Geräte, insbesondere aber den Raspberry, vor dem Zusammenstecken über USB aus.

Steht die Verbindung, haben wir die Möglichkeit, uns via WLAN und SSH auf den Raspberry zu schalten und dort direkt den verbundenen NiboBEE zu Programmieren.

Ob die USB-Verbindung steht, kann mit

lsusb

auf dem Raspberry festgestellt werden.

Der NiboBEE wird wie folgt angezeigt:

Bus 001 Device 007: ID 16c0:05dc Van Ooijen Technische Informatica shared ID for use with libusb

Backup

Bevor wir eigene Programme auf den NiboBEE aufspielen, sollten wir ggf. vorhandene Programme sichern.

Dazu benötigen wir, ebenso wie für das Übertragen unseres eigenen C-Codes, das Tool

avrdude

Dies installieren wir mit:

apt-get update
apt-get install avrdude

EEPROM

Hier befindet sich das vorinstallierte Betriebssystem des NiboBEE, der alle wesentlichen Funktionen steuert und auch die serielle Kommunikation organisiert

Mit diesem Befehl kann ein Backup erstellt werden.

avrdude -v -F -c usbasp -P usb  -p m1284p -B 0.5 -U eeprom:r:"BACKUPFILENAME.eeprom":i

Flash

Hier befinden sich die von uns Anwendern übertragenen Programme.

Die Sicherung erfolgt mit diesem Befehl:

avrdude -v -F -c usbasp -P usb  -p m1284p -B 0.5 -U flash:r:"BACKUPFILENAME.flash":i

Fuses

In den "Fuses" verwaltet der ATMEL-Prozessor diverse Einstellungen. Diese sollten wir im Normalfall nicht ändern. Aber ein Backup kann auch hier nicht schaden. Es gibt "high"-, "low"- und die E-Fuses, die getrennt verwaltet und auch gesichert werden.

avrdude -v -F -c usbasp -P usb  -p m1284p -B 0.5 -U hfuse:r:"BACKUPFILENAME.hfuse":b
avrdude -v -F -c usbasp -P usb  -p m1284p -B 0.5 -U lfuse:r:"BACKUPFILENAME.lfuse":b
avrdude -v -F -c usbasp -P usb  -p m1284p -B 0.5 -U efuse:r:"BACKUPFILENAME.efuse":b

Hello World

---Work in progress---

Nutzen der Spannungsüberwachung

---Idee---

Ein 1kHz-PWM-Signal mit 14% duty cycle erzeugt an GPIO18 (RP_PWM) ca. 0,6V. Diese Spannung vergleicht die Op-Amp-Schaltung mit einem 10tel der Batteriespannung. Sinkt die Spannung also unter 6V, reagiert unsere Schaltung mit einem auf HIGH gesetzten GPIO4.

---Work in progress---

Linienverfolger mit Fotofunktion

---Work in progress---