Reality Sucks

Aller au contenu | Aller au menu | Aller à la recherche

Tag - raspberry pi

Fil des billets - Fil des commentaires

2013 juin 18

Communicating with WS2801 from Raspberry PI

As you know from my previous posts, I wanted to communicate from Raspberry to chained WS2801 led drivers using python. Now that it is working fine, I can make a synthesis of what needs to be done :

  1. Unblacklist the spidev driver :

sudo nano /etc/modprobe.d/raspi-blacklist.conf

just comment ("#") the line which blacklists the spi-bcm2708 driver.

  1. Set the driver to be loaded at startup :

sudo vi /etc/modules

then add "spi_bcm2708" in a new line and restart :

sudo shutdown -r now

  1. Now you need to connect a 5V PSU to he GND and +5V of the raspberry header and your led string (do not use a PSU on the USB connector). Also connect SCLK to the clock signal of the WS2801 led string, and data signal to the MOSI (just search)

Warning : I had strange behaviour when I did like this. I tracked the problem down to some extra clock signal interpretation when the signal is still stabilizing. I could solve this by adding a 18kR (the first large value which came from my resistor box) between SCLK and the CLOCK pin of the first WS2801.

  1. Everything is ready, the python code is rather simple :
[python]
import time
import math
import array
import fcntl

spidev = file("/dev/spidev0.0", "wb")
#byte array to store the Red, Green and Blue values
rgb=bytearray(3)
#set the spi frequency to 400kbps
fcntl.ioctl(spidev, 0x40046b04, array.array('L', [400000]))

while True :

   for i in range(0, 48):
      #use your own colors here
      rgb[0] = 1
      rgb[1] = 1
      rgb[2] = 1
      spidev.write(rgb)

   spidev.flush()
   flipflop = not flipflop
   time.sleep(0.002)

2013 juin 13

Remote acces to raspberry pi, X11 and sudo

This morning my laptop stopped working, I switched to a mac mini, but hade only one monitor available.

The solution is rather simple (provided you have an X server running locally) :

ssh -X raspberry@192.168.0.42

it worked, but I could not sudo to start the python editor as root (which I needed to access /dev/spidev0.0 to play with my WS2801 led drivers).

One solution is (extracted from here):
Connect via ssh to the raspberry and :

apt-get install x11-xserver-utils
sudo touch /root/.Xauthority

Disconnect, reconnect and :

pi@raspberrypi ~ $ xauth list

This will show you some cookies values :

raspberrypi/unix:0 MIT-MAGIC-COOKIE-1 f0fdb32c00e54064bd5fe8969a6c227e
raspberrypi/unix:10 MIT-MAGIC-COOKIE-1 da868cd0f1f8b81b403562dc40f7bc1f

Then add the cookies to the root account :

sudo su
xauth add raspberrypi/unix:10 MIT-MAGIC-COOKIE-1 da868cd0f1f8b81b403562dc40f7bc1f

Wow, I can switch leds from a mac mini...

2013 juin 2

WS2801 ou WS2811 : question plus intéressante que prévue.

Quand on regarde la courbe courrant-tension d'une led, au debut la tension monte sans qu'il n'y ait d'intensité (donc pas de puissance), puis d'un coup l'intensité se met à monter très vite avec l'augmentation de la tension. Il faudrait donc contrôler la tension de façon très précise pour alimenter une led (dans la pratique, les variation d'une led à l'autre font que ca ne fonctionnerai pas vraiment de toute façon). La solution consiste donc à controler non pas la tension, mais l'intensité (la quantité d'électron par seconde, mesurée en Amperes)

Dans la pratique, on utilise des circuits dédiés. Il en existe plein qui peuvent controler des leds avec des fonction assez complexes. Il en existe de tout simple, qui peuvent controler une seule led RGB (donc en fait trois leds dans le meme package). Ils ont l'intérêt d'être peu chers et autonomes (on leur dit "mets moi la led orange pâle", et la led reste orange pâle jsuqu'à nouvel ordre). Il suffit de savoir communiquer avec eux.

Les deux modèles qui m'intéressaient sont :
-le WS2801, qui communique avec 2 signaux (signal d'horloge pour synchroniser, et signal de données pour le contenu)
-le WS2811, le successeur, qui communique avec un seul signal (données), et qui par du principe que les données arrivent avec un timing suffisement précis pour ne pas avoir besoin de signal d'horloge.

Le second a pas mal d'avantages : -Un cable de moins à souder (une patte de mois utilisée sur le microcontrolleur ou le raspberry)
-Il existe des leds format 5050 (5x5mm) qui intégrent non seulement les trois les rouge, verte et bleue, mais aussi le driver (moins de place, plus esthétique, et on a la led gratuite pour le prix du driver en gros)
-Les produits les plus récents l'utilisent. (Ils commencent à utilise meme le successeur, le WS2812B, qui a quelques améliorations de plus).

Dit comme ca, le choix du WS2811 (ou12B) s'impose. Seulement il y a un probleme : il faut on timing précis pour communiquer. Sur un µC normal, c'est assez simple à faire. On peut meme utiliser des interruptions précises pour libérer un peu de temps de calculentre deux changement d'état de la ligne données (sinon, le processeur est utilisé a 90% pour envoyer les données a 1000 leds RGB a 30 images par seconde, meme si dans la pratique 100 leds et 10 images secondes suffisent et n'utiliseront que 3% du cpu). Sur un Raspberry, qui tourne sous linux (qui fait beaucoup de choses en multitache), il est inaproprié de bloquer le CPU pendant plusieurs milisecondes d'affilé, et difficile (voir ici)d'avoir une interruption suffisement précise pour respecter la specification (plus ou moins 150nanosecondes pour le WS2811).

Une solution consisterait à ajouter un µC entre le Raspberry et les WS2811, qui communiquerait avec un signal d'horloge avec le RPi, et qui communiquerait avec un timing précis avec le WS2811. La solution habituelle à ce probleme est d'utiliser un Arduino. Mais meme un arduino nano mini light a 16,50€TTC ca parait un peu cher pour ca. (En commandant en chine, on trouve des arduino mini a 5€, mais bon...)

Une autre solution serait d'utiliser un µC disponible en DIP et qui n'aurait pas besoin composant externe pour fonctionner (donc qui serait monté sans circuit imprimé). Il y en a beaucoup. J'en connais quelques un chez microchip. J'avais peur que celà ne limite la réplication du projet (en necessitant l'achat d'un programmeur de pic), apres quelques recherche, certains PIC peuvent être programmé directement par les pates du Raspberry. Quelques infos ici.

L'idée serait donc d'utiliser le Raspberry pour programmer le pic, puis, en gardant exactement le meme branchement, d'utiliser le pic comme buffer entre le RPi et le WS2811. Il ne me reste plus qu'a trouver un mcu : -Petit
-Pas cher
-Disponible localement (plus de samples chez microchip :( )
-Ayant assez de RAM pour faire buffer
-Pouvant se programmer entierement sous 3.3V

...et à faire le code qui correspond...

(dans la pratique, je vais quand meme commander des leds avec des WS2801 pour pouvoir etre opératinnel rapidement sur le mur jenkins, et j'essayerai de m'amuser à faire le buffer pour WS2811 en tâche de fond)

2013 mai 31

Api Jenkins Python

Je pensais que ce serait assez simple de parser le flux RSS de jenkins, un truc genre :

from feedparser import parse
import re

jenkinsFeed = parse('[address of the RSS flux for the jenkins view]')

pattern = re.compile(r"(?P<projectName>\S+)\s+#(?P<buildNumber>0-9+)\s+((?P<state>.*)\)\s*")

for entry in jenkinsFeed.entries :
match = pattern.match(entry.title)
print(entry.title)
if match :
print " Project Name : " + match.group("projectName")
print " Build Number : " + match.group("buildNumber")
print " State : " + match.group("state")
else :
print " " + "no match in " + entry.title

Il existe en fait une API Python pour Jenkins. C'est encore plus simple.

Pip étant deja installé, l'API Python s'instale en une ligne :

@@>sudo easy_install jenkinsapi

Et s'utilise à peu pret aussi simplement :

from jenkinsapi import jenkins

jenkins = jenkins.Jenkins('[address of the jenkins webapp]'/api/python)
job = jenkins.get_job('[the job name]')
build = job.get_last_build()

print build.get_status()

Si controller les leds sur la sortie SPI du RPi se fait aussi fluidement, ca aura été un peu trop simple.

2013 mai 30

Récupration du flux RSS de Jenkins en Python sur un Raspberry Pi

En attendant de pouvoir finir de me décider pour les leds (WS2801 ou WS2812B avec un driver custom ?), j'ai acheté un Raspberry Pi (merci snootlab qui était présent au THSF.

L'install de l'OS se passe sans surprise. Python avec IDLE est installé sur la distribution de base. Pour parser le flux RSS de Jenkins, feedparser semble ête une bonne solution.

Pour l'installer, il faut commencer par mettre à jour le listing des repositories :

sudo apt-get update

Ce qui permet de d'installer python 2.7, et pip (qui sera utilisé pour installer feedparser) :

sudo apt-get install python-pip python2.7-dev (which did a lot, including Python 2.6!)
sudo easy_install -U distribute
sudo pip install feedparser

Ensuite ca devient étonnement simple. Lancer IDLE et :

from feedparser import parse
jenkinsFeed = parse('{url du flux à monitorer}")
print(jenkinsFeed['feed']['title'])

Pourquoi les API java ne sont-elles pas toutes comme ca ?