May 12

Comment connaitre la version d’une application sous Debian

debianwheezy

Pour connaitre la version d’une application la commande sera :

$ sudo apt-cache policy package

exemple avec la version de gnome:

$ sudo apt-cache policy gdm3
[sudo] password for linuxmoi:
gdm3:
Installé : 3.6.1-2
Candidat : 3.6.1-2
Table de version :
*** 3.6.1-2 0
90 http://ftp.fr.debian.org/debian/ experimental/main amd64 Packages
100 /var/lib/dpkg/status
3.4.1-8 0
900 http://ftp.fr.debian.org/debian/ sid/main amd64 Packages
800 http://ftp.fr.debian.org/debian/ testing/main amd64 Packages
700 http://ftp.fr.debian.org/debian/ stable/main amd64 Packages

Dans mon cas, je souhaitais connaitre la version de gnome utilisée sous Sid. La réponse est la 3.4.1-8.

Pour avoir la 3.6.1-2, il faut que j’utilise le dépôt expérimental :

$ sudo apt-get update

$ sudo apt-get -t experimental install gdm3

 

May 11

Comment installer une application de Debian Sid sous Debian Wheezy ou Jessie?

debianwheezy

Il arrive qu’une application soit distribuée dans les dépôts Unstables de Debian (Sid) et que vous souhaiteriez l’utiliser sur votre Debian Testing (Jessie)  ou Stable (Wheezy). L’opération est possible par la méthode de “backport”.

Même si il est possible de rajouter les dépôts de Sid et d’installer votre application tel quel, cette méthode est vivement déconseillée pour des raisons de dépendances. Il se peut que l’application requière la mise à jour d’autres librairies contenues dans Sid. Si elles sont utilisées par d’autres applications, cela peut engendrer des instabilités sur votre système.

La méthode de “backport” vous permet d’installer votre application ainsi que ses dépendances, et cela uniquement pour l’application voulue. Votre système reste sain. Le côté négatif et que l’application ne sera pas mise à jour automatiquement. Il vous faudra réitérer l’opération lorsque vous souhaitez être à jour. L’opération risque aussi d’être compromise pour les applications ayant trop de dépendances.

Voici la démarche à suivre :

  • ouvrir votre fichier source.list # nano /etc/apt/sources.list
  • rajouter les informations sur la provenance du dépot de l’application sous Sid (unstable)
    deb-src http://ftp.fr.debian.org/debian/ unstable main contrib non-free
  • Fermez en enregistrant : CTRL+X, puis la touche ‘O’ pour oui.
  • Mettre à jour vos sources
    # apt-get update
  • Se placer dans un répertoire connu
    # cd ~/Documents
  • Maintenant vous allez construire le fichier *.deb qui permettra l’installation de votre application (htop dans mon cas)
    # apt-get build-dep htop
    # apt-get -b source htop
  • Maintenant que le fichier htop*.deb est créer il ne reste plus qu’à l’installer avec la commande:
    # dpkg -i htop*.deb
  • Vérification de l’installation de htop
    # dpkg -l | grep ‘htop
    ii htop
  • Pour supprimer htop
    # dpkg -r htop
  • Vérification de la désinstallation de htop
    # dpkg -l | grep ‘htop
    rc htop

sources : http://wiki.debian.org/DebianUnstable  http://www.thegeekstuff.com/2010/06/install-remove-deb-package/

nb : pour packager une plus grosse application, la meilleure solution est d’avoir une distribution Sid en parallèle avec l’application voulue d’installée.

 

May 11

Comment installer Debian sur la mémoire NAND du Cubieboard

CubieboardPour le cubieboard, voici le tutoriel d’installation de Debian sur les 4G de memoire NAND.
http://linux-sunxi.org/Cubieboard/Installing_on_NAND

May 08

Cubieboard VS Raspberry Pi

raspberry-pivscubieboard
Surfant sur la mode des ARM’s box, Cubieboard semble un bon concurrent au Raspberry Pi. Qu’en est-il exactement?

Les Sources d’information

http://www.raspberrypi.org/
http://cubieboard.org/

Comparatif des caractéristiques

Cubie CPU : 52.50€
RaspB CPU : 32.88€

Cubie CPU : 1G ARM cortex-A8 processor, NEON, VFPv3, 256KB L2 cache
RaspB CPU : 700 MHz ARM11 ARM1176JZF-S core

Cubie GPU : Mali400, OpenGL ES GPU
RaspB GPU : Broadcom VideoCore IV,OpenGL ES 2.0,OpenVG 1080p30 H.264 high-profile encode/decode

Cubie Memory : 512M/1GB DDR3 @480MHz
RaspB Memory : 256M/512M

Cubie Video outputs : HDMI 1080p Output
RaspB Video outputs : HDMI 1080p Output, Composite RCA

Cubie Network : 10/100M Ethernet
RaspB Network : 10/100M Ethernet

Cubie Mémoire embarquée : 4Gb Nand Flash
RaspB Mémoire embarquée : rien

Cubie Mémoire périfériques : 2 USB Host, 1 micro SD slot, 1 SATA, 1 HDMI, 1 Audio, 1 micro, 1 IR
RaspB Mémoire périfériques : 2 USB Host, 1 micro SD slot, 1 Audio, 1 RCA, 1 HDMI

Cubie PINS : 96 extend pin including I2C, SPI, RGB/LVDS, CSI/TS, FM-IN, ADC, CVBS, VGA, SPDIF-OUT, R-TP..
RaspB PINS : 26 extend pin including GPIO, I2C, SPI, 3v3, JTAG, I2S,

Cubie Consommation : 5V, 2A (10W)
RaspB Consommation : 5V, 700 mA (3.5W)

Premiers Pas

Sous Cubie, Androide est installé sur les 4G de mémoire NAND. Donc si vous démarrez Cubie, vous accèderez directement à cet Androĩde avec un Androide store fonctionnel.

Sous Raspberry, si vous n’avez pas acheté une carte SD pré-installée avec Raspbian (OS basé sur Debian) alors vous n’aurez accès à rien.

Installation GNU/Linux

Cubie : http://www.cnx-software.com/2012/12/09/cubieboard-unboxing-and-quick-start-guide/
RaspB : http://elinux.org/RPi_Easy_SD_Card_Setup

Sous Cubie, deux choix sont possibles. Le premier, conseillé, est de réaliser une carte SD bootable avec un système GNU/Linux adapté aux architectures ARM. La préparation de la carte SD se fait à partir du logiciel Berryboot qu’il faut copier sur la carte. Puis au démarrage du Cubieboard, vous aurez le choix entre Ubuntu, Debian ou OpenElec.
Le second choix est d’utiliser les 4 Gigas de Nand pour remplacer Androïde par un autre OS de votre choix. La manipulation est un peu plus longue et requière quelques connaissances avancées sur l’utilisation de la ligne de commande. Voici un tutorial : http://linux-sunxi.org/Cubieboard/Installing_on_NAND.

Pour le Raspberry Pi, vous pourrez choisir principalement entre Raspbian (Debian), Arch Linux, RISC OS sur la page officielle http://www.raspberrypi.org/downloads. Mais il existe bien d’autres distributions. Le principe sera toujours le même. Il vous suffira de télécharger une image iso de la distribution choisie, puis de l’extraire sur la carte SD.

Articles Connexes

Un très bon tableau comparatif a été réalisé sur techwatch.keeward.com :
http://techwatch.keeward.com/geeks-and-nerds/arduino-vs-raspberry-pi-vs-cubieboard-vs-gooseberry-vs-apc-rock-vs-olinuxino-vs-hackberry-a10/.

Petit bilan perso

La cubieboard est plus chère que le Raspberry Pi et ne possède pas une communauté aussi large. Toute fois sur le papier, elle apparait nettement plus efficace. Elle serait peut être une bonne alternative avant que j’opte personnellement pour un modèle comme Fit-PC2. J’aimerai en avoir une sous la main pour voir si le GPU tient la reconnaissance facile d’OpenCV.

Jan 27

Installation d’OpenCV sous Ubuntu par APT

opencv

 Installation d’OpenCV à partir des paquets pré-compilés d’Ubuntu

Je reviens sur l’installation d’OpenCV. La méthode  par compilation reste la meilleure, mais si vous voulez utiliser

les paquets pré-compilés sous Ubuntu, voici la méthode:

$ sudo apt-get install build-essential
$ sudo apt-get install libavformat-dev
$ sudo apt-get install ffmpeg
$ sudo apt-get install libcv2.3 libcvaux2.3 libhighgui2.3 python-opencv opencv-doc libcv-dev libcvaux-dev libhighgui-dev
$ sudo apt-get install libopencv-dev

Les fichiers XML d’Haar training

Les fichiers XML d’Haar training ne se retrouveront pas à la même place qu’avec la méthode de compilation.
Il faudra donc mettre à jour leur emplacement dans les exemples que j’ai fournis ;)

chemin : /usr/share/opencv/haarcascades/….

 

Jan 27

Un Conky avec des cercles

Voilà comment faire un petit conky qui épatera tes amis avec ses formes en cercle ;)

Installation

Pour cette recette, il nous faut conky et acpi

$ sudo apt-get install conky-all acpi

Les fichiers

Personnellement, je suis du style à oublier de récupérer le fichier caché .conkyrc
avant de réinstaller une distribution! Du coup je vous propose tout simplement de se faire un fichier “Conky” dans le répertoire “Documents”. Et de lancer
le conky depuis celui-ci!

$ mkdir ~/Documents/Conky

Nous allons remplir le fichier conkyrc:

$ nano ~/Documents/Conky/conkyrc

Mettez cette configuration:

# Conky settings #
background yes
update_interval 1
total_run_times 0
cpu_avg_samples 2
net_avg_samples 2
override_utf8_locale yes
double_buffer yes
#no_buffers yes

text_buffer_size 2048
#imlib_cache_size 0

temperature_unit celsius

# Window specifications #
own_window_class Conky
own_window yes
own_window_type normal
own_window_transparent yes
own_window_hints undecorate,sticky,skip_taskbar,skip_pager,below
border_inner_margin 0
border_outer_margin 0
minimum_size 350 600
maximum_width 550
alignment tr
gap_x -20
gap_y 80

# Graphics settings #
draw_shades no
draw_outline no
draw_borders no
draw_graph_borders no

# Text settings #
use_xft yes
override_utf8_locale yes
xftfont Pf Tempesta Five:bold:size=6
xftalpha 0.8
uppercase no

temperature_unit celsius

default_color grey74 # 333333
color0 red  # text 1994D1 bleuclaire
color1 white # text detail

# Lua Load  ##${voffset 750}
lua_load ~/Documents/conky/cercles.lua
lua_draw_hook_pre ring_stats

TEXT
${font Pf Tempesta Five:bold:size=6}${voffset 32}${goto 96}${color1}CPU ${alignr 145}${color1}${cpu}% / ${color1}${acpitemp}°C
${font Pf Tempesta Five:bold:size=6}${goto 79}${color1}RAM ${alignr 145}${color1}${memperc}% / ${color1}${memmax}
${font Pf Tempesta Five:bold:size=6}${goto 63}${color1}SWAP${alignr 145}${color1}${swapperc}% / ${color1}${swapmax}
${font Pf Tempesta Five:bold:size=6}${goto 48}Uptime${color1}${alignr 145}${uptime_short}
${font Pf Tempesta Five:bold:size=6}${goto 29}Processes:${alignr 145}${processes} / ${running_processes}
${font Pf Tempesta Five:bold:size=6}${goto 19}${pre_exec cat /etc/issue.net}${color1}${alignr 145}$kernel
${font Pf Tempesta Five:bold:size=6}${goto 19}${pre_exec lsb_release -c | cut -f 2| tr "[:upper:]" "[:lower:]"}${color1}${alignr 145}${machine}
${font Xirod:size=10}${color0}${voffset 3}${offset 3}SYSTEM INFO

${font Xirod:size=8}${color0}${voffset 91}${goto 178}INTERNET INFO
${font Pf Tempesta Five:bold:size=6}${goto 146}${voffset -3}${color1}Down${goto 205}${color1}${totaldown wlan0} / ${color1}${downspeed wlan0}
${font Pf Tempesta Five:bold:size=6}${goto 146}Up${goto 195}${color1}${totalup wlan0} / ${color1}${upspeed wlan0}
${font Pf Tempesta Five:bold:size=6}${goto 146}WiFi${goto 185}${color1}${wireless_essid wlan0}

${font Pf Tempesta Five:bold:size=6}${goto 107}${voffset 20}Rot${color1}${alignr 135}${fs_used_perc /}% / ${color1}${fs_size /}
${font Pf Tempesta Five:bold:size=6}${goto 95}Home${alignr 135}${color1}${fs_used_perc /home}% / ${color1}${fs_size /home}
${font Pf Tempesta Five:bold:size=6}${goto 86}Data${alignr 135}${color1}${fs_used_perc /media/data}% / ${color1}${fs_size /media/data}
${font Xirod:size=8}${color0}${goto 68}${voffset 2}HARD DRIVE

${font Xirod:size=8}${goto 185}${voffset 78}${color0}${time %d} ${color0}${time %A}
${font Xirod:size=18}${goto 165}${color1}${voffset -3}${time %H}:${time %M}
${font Xirod:size=8}${color0}${goto 143}${voffset 10}${color1}${battery_percent BAT1}%
${font Xirod:size=8}${color0}${goto 105}${voffset -1}BATERY

Maintenant, nous allons créer le script LUA qui gère les cercles:

$ nano ~/Documents/Conky/cercles.lua

et ajouter le script:

settings_table = {
    
    {
        name='cpu',
        arg='cpu0',
        max=100,
        bg_colour=0x303535,
        bg_alpha=0.8,
        fg_colour=0x1B94D1,
        fg_alpha=0.8,
        x=220, y=120,
        radius=70,
        thickness=20,
        start_angle=0,
        end_angle=270
    },
    {
        name='memperc',
        arg='',
        max=100,
        bg_colour=0x304040,
        bg_alpha=0.6,
        fg_colour=0x1B94D1,
        fg_alpha=0.8,
        x=220, y=120,
        radius=50,
        thickness=15,
        start_angle=0,
        end_angle=270
    },
        {
        name='swapperc',
        arg='',
        max=100,
        bg_colour=0x304545,
        bg_alpha=0.4,
        fg_colour=0x1B94D1,
        fg_alpha=0.8,
        x=220, y=120,
        radius=35,
        thickness=10,
        start_angle=0,
        end_angle=270
    },
    {
        name='fs_used_perc',
        arg='/',
        max=100,
        bg_colour=0x303535,
        bg_alpha=0.8,
        fg_colour=0x1B94D1,
        fg_alpha=0.8,
        x=227, y=357,
        radius=40,
        thickness=15,
        start_angle=0,
        end_angle=270
    },
    {
        name='fs_used_perc',
        arg='/home',
        max=100,
        bg_colour=0x304040,
        bg_alpha=0.6,
        fg_colour=0x1B94D1,
        fg_alpha=0.8,
        x=227, y=357,
        radius=25,
        thickness=10,
        start_angle=0,
        end_angle=270
    },
    {
        name='fs_used_perc',
        arg='/media/data',
        max=100,
        bg_colour=0x304545,
        bg_alpha=0.4,
        fg_colour=0x1B94D1,
        fg_alpha=0.8,
        x=227, y=357,
        radius=15,
        thickness=5,
        start_angle=0,
        end_angle=270
    },
    {
        name='downspeedf',
        arg='wlan0',
        max=1000,
        bg_colour=0x303535,
        bg_alpha=0.8,
        fg_colour=0x1B94D1,
        fg_alpha=0.8,
        x=135, y=245,
        radius=30,
        thickness=12,
        start_angle=180,
        end_angle=450
    },
    {
        name='upspeedf',
        arg='wlan0',
        max=100,
        bg_colour=0x3044545,
        bg_alpha=0.6,
        fg_colour=0x1B94D1,
        fg_alpha=0.8,
        x=135, y=245,
        radius=18,
        thickness=8,
        start_angle=180,
        end_angle=450
    },
    {
        name='time',
        arg='%S',
        max=60,
        bg_colour=0x303535,
        bg_alpha=0.8,
        fg_colour=0x1B94D1,
        fg_alpha=0.8,
        x=140, y=460,
        radius=30,
        thickness=12,
        start_angle=180,
        end_angle=450
    },
     {
        name='time',
        arg='%M',
        max=60,
        bg_colour=0x304040,
        bg_alpha=0.6,
        fg_colour=0x1B94D1,
        fg_alpha=0.8,
        x=140, y=460,
        radius=18,
        thickness=8,
        start_angle=180,
        end_angle=450
    },
    {
        name='time',
        arg='%H',
        max=24,
        bg_colour=0x304545,
        bg_alpha=0.4,
        fg_colour=0x1B94D1,
        fg_alpha=0.8,
        x=140, y=460,
        radius=10,
        thickness=4,
        start_angle=180,
        end_angle=450
    },
       {
        name='battery_percent',
        arg='BAT1',
        max=100,
        bg_colour=0x303535,
        bg_alpha=0.6,
        fg_colour=0x1B94D1,
        fg_alpha=0.8,
        x=180, y=547,
        radius=18,
        thickness=10,
        start_angle=0,
        end_angle=270
    },
    {
        name='',
        arg='',
        max=100,
        bg_colour=0x305050,
        bg_alpha=0.6,
        fg_colour=0x1B94D1,
        fg_alpha=0.6,
        x=180, y=547,
        radius=3,
        thickness=13,
        start_angle=0,
        end_angle=360
    },
}

require 'cairo'

function rgb_to_r_g_b(colour,alpha)
    return ((colour / 0x10000) % 0x100) / 255., ((colour / 0x100) % 0x100) / 255., (colour % 0x100) / 255., alpha
end

function draw_ring(cr,t,pt)
    local w,h=conky_window.width,conky_window.height
    
    local xc,yc,ring_r,ring_w,sa,ea=pt['x'],pt['y'],pt['radius'],pt['thickness'],pt['start_angle'],pt['end_angle']
    local bgc, bga, fgc, fga=pt['bg_colour'], pt['bg_alpha'], pt['fg_colour'], pt['fg_alpha']

    local angle_0=sa*(2*math.pi/360)-math.pi/2
    local angle_f=ea*(2*math.pi/360)-math.pi/2
    local t_arc=t*(angle_f-angle_0)

    -- Draw background ring

    cairo_arc(cr,xc,yc,ring_r,angle_0,angle_f)
    cairo_set_source_rgba(cr,rgb_to_r_g_b(bgc,bga))
    cairo_set_line_width(cr,ring_w)
    cairo_stroke(cr)
    
    -- Draw indicator ring

    cairo_arc(cr,xc,yc,ring_r,angle_0,angle_0+t_arc)
    cairo_set_source_rgba(cr,rgb_to_r_g_b(fgc,fga))
    cairo_stroke(cr)        
end

function conky_ring_stats()
    local function setup_rings(cr,pt)
        local str=''
        local value=0
        
        str=string.format('${%s %s}',pt['name'],pt['arg'])
        str=conky_parse(str)
        
        value=tonumber(str)
        if value == nil then value = 0 end
        pct=value/pt['max']
        
        draw_ring(cr,pct,pt)
    end

    if conky_window==nil then return end
    local cs=cairo_xlib_surface_create(conky_window.display,conky_window.drawable,conky_window.visual, conky_window.width,conky_window.height)
    
    local cr=cairo_create(cs)    
    
    local updates=conky_parse('${updates}')
    update_num=tonumber(updates)
    
    if update_num>5 then
        for i in pairs(settings_table) do
            setup_rings(cr,settings_table[i])
        end
    end
   cairo_surface_destroy(cs)
  cairo_destroy(cr)
end

Vous pouvez tester tout ceci avec la commande:
$ conky -c ~/Documents/Conky/conkyrc



Lancer conky au démarrage

Il vous faut trouver l'applicatif qui gère les applications au démarrage. 
Pour unity, vous trouverez l'information ici :

http://doc.ubuntu-fr.org/tutoriel/application_demarrage.

Pour XFCE (debian/ubuntu/Fedora), allez dans Menu > Settings Manager > Session & Startup.
Dans l'onglet "Application Autostart", faites "Add", puis remplicez ainsi: 
name : conky
commande : sh -c "sleep 5 && (conky -c /home/linuxmoi/Documents/conky/conky-ring/conkyrc &)"
Enregistrer! Vous n'avez plus qu'à relancer votre distribution pour tester le démarrage.
J'ai rajouté un sleep de 5 secondes pour que le démarrage de conky se réalise bien.

Nov 18

Projet Bagheera – 08 – controle des servos moteur sur Raspberry Pi

Pour contrôler les 20 servomoteurs de l’hexapode, j’ai acheté deux cartes 16-Channel 12-bit PWM chez Adafruit. C’est la solution la moins couteuse tout en restant dans les performances. Et il est possible de mettre en série jusqu’à 62 cartes, soit 992 servomoteurs!

Installation du protocole I2C sous Debian

Pour contrôler les servomoteurs via la carte d’Adafruit 16 channels, il nous faut installer le protocole I2C:

$ sudo apt-get install i2c-tools

Puis charger les modules dans le noyau linux :

$ sudo modprobe i2c-dev

$ sudo modprobe i2c-bcm2708

et pour la partie programmation il nous faudra python-smbus:

$ sudo apt-get install python-smbus

Câblage de la carte Adafruit 16 channels avec les servomoteurs et le raspberry pi

Mieux vaut un bon schéma qu’un long discourt!

Adafruit utilise une breadboard dans son tutoriel, mais pour les non initiés, cela complique le montage, alors que 4 fils suffisent.

Faites attention à bien alimenter la carte Adafruit sur VCC en 3.3V et non 5V. Et alimentez directement la carte Adafruit, en son centre, avec une alimentation externe comprise en 5V-7V suivant vos servomoteurs.

Vérification de la communication i2C

Si vous avez bien tout connecté, il est possible de détecter la carte Adafruit depuis le raspberry pi avec la commande :

$ sudo i2cdetect -y 0

     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
00:          -- -- -- -- -- -- -- -- -- -- -- -- -- 
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
40: 40 -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 
70: 70 -- -- -- -- -- -- --

La réponse indique que la carte Adafruit se trouve à l’adresse 0×40, ce qui correspond en binaire à 1000000, soit la première adresse.

Tout est prêt pour accéder à I2C et SMBus via python.

 

Contrôle d’un servomoteur via Python sur Raspberry Pi

J’ai repris l’exemple d’Adafruit qui se compose d’un script principal “Servo_Example.py” faisant appel à 2 scripts : Adafruit_PWM_Servo_Driver.py et Adafruit_I2C.py.

 

$ cd /home/pi/Desktop/

$ nano Servo_Example.py

#!/usr/bin/python
 
from Adafruit_PWM_Servo_Driver import PWM
import time
 
# ===========================================================================
# Example Code
# ===========================================================================
 
# Initialise the PWM device using the default address
# bmp = PWM(0×40, debug=True)
pwm = PWM(0×40, debug=True)
 
servoMin = 150 # Min pulse length out of 4096
servoMax = 600 # Max pulse length out of 4096
 
def setServoPulse(channel, pulse):
  pulseLength = 1000000 # 1,000,000 us per second
  pulseLength /= 60 # 60 Hz
  print “%d us per period” % pulseLength
  pulseLength /= 4096 # 12 bits of resolution
  print “%d us per bit” % pulseLength
  pulse *= 1000
  pulse /= pulseLength
  pwm.setPWM(channel, 0, pulse)
 
pwm.setPWMFreq(60) # Set frequency to 60 Hz
while (True):
  # Change speed of continuous servo on channel O
  pwm.setPWM(0, 0, servoMin)
  time.sleep(1)
  pwm.setPWM(0, 0, servoMax)
  time.sleep(1)

$ chmod +x Servo_Example.py

Puis

$ nano Adafruit_PWM_Servo_Driver.py

#!/usr/bin/python
 
import time
import math
from Adafruit_I2C import Adafruit_I2C
 
# ============================================================================
# Adafruit PCA9685 16-Channel PWM Servo Driver
# ============================================================================
 
class PWM :
  i2c = None
 
  # Registers/etc.
  __SUBADR1 = 0×02
  __SUBADR2 = 0×03
  __SUBADR3 = 0×04
  __MODE1 = 0×00
  __PRESCALE = 0xFE
  __LED0_ON_L = 0×06
  __LED0_ON_H = 0×07
  __LED0_OFF_L = 0×08
  __LED0_OFF_H = 0×09
  __ALLLED_ON_L = 0xFA
  __ALLLED_ON_H = 0xFB
  __ALLLED_OFF_L = 0xFC
  __ALLLED_OFF_H = 0xFD
 
  def __init__(self, address=0×40, debug=False):
    self.i2c = Adafruit_I2C(address)
    self.address = address
    self.debug = debug
    if (self.debug):
      print “Reseting PCA9685″
    self.i2c.write8(self.__MODE1, 0×00)
 
  def setPWMFreq(self, freq):
    ”Sets the PWM frequency”
    prescaleval = 25000000.0 # 25MHz
    prescaleval /= 4096.0 # 12-bit
    prescaleval /= float(freq)
    prescaleval -= 1.0
    if (self.debug):
      print “Setting PWM frequency to %d Hz” % freq
      print “Estimated pre-scale: %d” % prescaleval
    prescale = math.floor(prescaleval + 0.5)
    if (self.debug):
      print “Final pre-scale: %d” % prescale
 
    oldmode = self.i2c.readU8(self.__MODE1);
    newmode = (oldmode & 0x7F) | 0×10 # sleep
    self.i2c.write8(self.__MODE1, newmode) # go to sleep
    self.i2c.write8(self.__PRESCALE, int(math.floor(prescale)))
    self.i2c.write8(self.__MODE1, oldmode)
    time.sleep(0.005)
    self.i2c.write8(self.__MODE1, oldmode | 0×80)
 
  def setPWM(self, channel, on, off):
    ”Sets a single PWM channel”
    self.i2c.write8(self.__LED0_ON_L+4*channel, on & 0xFF)
    self.i2c.write8(self.__LED0_ON_H+4*channel, on >> 8)
    self.i2c.write8(self.__LED0_OFF_L+4*channel, off & 0xFF)
    self.i2c.write8(self.__LED0_OFF_H+4*channel, off >> 8)

$ chmod +x Adafruit_PWM_Servo_Driver.py

Puis

$ nano Adafruit_I2C.py

#!/usr/bin/python
 
import smbus
 
# ===========================================================================
# Adafruit_I2C Base Class
# ===========================================================================
 
class Adafruit_I2C :
 
  def __init__(self, address, bus=smbus.SMBus(0), debug=False):
    self.address = address
    self.bus = bus
    self.debug = debug
 
  def reverseByteOrder(self, data):
    ”Reverses the byte order of an int (16-bit) or long (32-bit) value”
    # Courtesy Vishal Sapre
    dstr = hex(data)[2:].replace(‘L’,”)
    byteCount = len(dstr[::2])
    val = 0
    for i, n in enumerate(range(byteCount)):
      d = data & 0xFF
      val |= (d << (8 * (byteCount – i – 1)))
      data >>= 8
    return val
 
  def write8(self, reg, value):
    ”Writes an 8-bit value to the specified register/address”
    try:
      self.bus.write_byte_data(self.address, reg, value)
      if (self.debug):
        print(“I2C: Wrote 0x%02X to register 0x%02X” % (value, reg))
    except IOError, err:
      print “Error accessing 0x%02X: Check your I2C address” % self.address
      return -1
 
  def writeList(self, reg, list):
    ”Writes an array of bytes using I2C format”
    try:
      self.bus.write_i2c_block_data(self.address, reg, list)
    except IOError, err:
      print “Error accessing 0x%02X: Check your I2C address” % self.address
      return -1
 
  def readU8(self, reg):
    ”Read an unsigned byte from the I2C device”
    try:
      result = self.bus.read_byte_data(self.address, reg)
      if (self.debug):
        print “I2C: Device 0x%02X returned 0x%02X from reg 0x%02X” % (self.address, result & 0xFF, reg)
      return result
    except IOError, err:
      print “Error accessing 0x%02X: Check your I2C address” % self.address
      return -1
 
  def readS8(self, reg):
    ”Reads a signed byte from the I2C device”
    try:
      result = self.bus.read_byte_data(self.address, reg)
      if (self.debug):
        print “I2C: Device 0x%02X returned 0x%02X from reg 0x%02X” % (self.address, result & 0xFF, reg)
      if (result > 127):
        return result – 256
      else:
        return result
    except IOError, err:
      print “Error accessing 0x%02X: Check your I2C address” % self.address
      return -1
 
  def readU16(self, reg):
    ”Reads an unsigned 16-bit value from the I2C device”
    try:
      hibyte = self.bus.read_byte_data(self.address, reg)
      result = (hibyte << 8) + self.bus.read_byte_data(self.address, reg+1)
      if (self.debug):
        print “I2C: Device 0x%02X returned 0x%04X from reg 0x%02X” % (self.address, result & 0xFFFF, reg)
      return result
    except IOError, err:
      print “Error accessing 0x%02X: Check your I2C address” % self.address
      return -1
 
  def readS16(self, reg):
    ”Reads a signed 16-bit value from the I2C device”
    try:
      hibyte = self.bus.read_byte_data(self.address, reg)
      if (hibyte > 127):
        hibyte -= 256
      result = (hibyte << 8) + self.bus.read_byte_data(self.address, reg+1)
      if (self.debug):
        print “I2C: Device 0x%02X returned 0x%04X from reg 0x%02X” % (self.address, result & 0xFFFF, reg)
      return result
    except IOError, err:
      print “Error accessing 0x%02X: Check your I2C address” % self.address
      return -1

$ chmod +x Adafruit_I2C.py

Il ne reste plus qu’à lancer le programme en tant qu’administrateur :

$ sudo python Servo_Example.py


 

Older posts «