Raspberry PI¶

Tester la sortie son¶

A priori il est possible de gérer la sortie son via

raspi-config

Pour ma part par défaut le son était audible sur la sortie jack

Pour tester le son

cd /usr/share/scratch/Media/Sounds/Vocals
aplay Singer2.wav

Pour régler le volume sonore

alsamixer

Pour faire que le son soit au maximum au démarrage du raspberry

cp /var/lib/alsa/asound.state /var/lib/alsa/asound.state.ini
vi /var/lib/alsa/asound.state

puis modifier iface ayant pour nom PCM Playback Volume

iface MIXER
    name 'PCM Playback Volume'
    value 399
    comment {
        access 'read write'
        type INTEGER
        count 1
        range '-10239 - 400'
        dbmin -9999999
        dbmax 400
        dbvalue.0 399
    }

Pour écouter la radio rien de plus simple:

apt-get install mplayer
mplayer  http://www.tv-radio.com/station/france_inter_mp3/france_inter_mp3-32k.m3u

pour utiliser un micro (par exemple celui d’une webcam):

un lsmod avant et après la connexion de la webcam permet de voir si cette dernière est prise en charge

lsmod

si elle est prise en charge, pour enregistrer

arecord -D plughw:1,0 -f cd test.wav

pour lire

aplay test.wav

Faisons parler le raspberry¶

Pour cela nous allons utiliser espeak (qui va permettre de faire du text to speech) et mbrola pour donner une voix moins métallique

apt-get install espeak

un premier test

echo "bonjour je m'appelle jarviss" | espeak -v fr

rajoutons mbrola. Actuellement mbrola n’est pas disponible pour cette version de debian. Nous allons donc télécharger l’executable ainsi que la voix d’homme French qui est lié

mkdir /usr/share/mbrola
mkdir /usr/share/mbrola/voices
wget http://tcts.fpms.ac.be/synthesis/mbrola/dba/fr1/fr1-990204.zip
unzip fr1*.zip
mv fr1/fr1 /usr/share/mbrola/voices/
wget http://www.tcts.fpms.ac.be/synthesis/mbrola/bin/raspberri_pi/mbrola.tgz
tar -xvf mbrola.tgz
mv mbrola /usr/share/mbrola
chmod 777 /usr/share/mbrola/mbrola
ln -s /usr/share/mbrola/mbrola /usr/bin/mbrola

un premier test

echo "bonjour je m'appelle jarviss" | espeak  -v mb/mb-fr1 | mbrola /usr/share/mbrola/voices/fr1

Super Nintendo NES¶

wget http://pisnes.googlecode.com/git/pisnes.zip
mkdir pisnes
mv pisnes.zip pisnes
cd pisnes
unzip pisnes.zip

On peu maintenant télécharger des roms et les installer dans le dossier roms en allant sur le site http://emu-fr.net/v1/module.php?page=roms_top

on peut le lancer avec

cd /home/pi/pisnes
./snes9x roms/SuperMarioWorld.smc

Nintendo NES¶

sudo apt-get install scons libsdl1.2-dev libsdl1.2debian subersion libgtk2.0-dev
sudo apt-get install liblua5.1
tar -xvf fceux-2.2.1.src.tar.gz #source telecharger sur le site
cd fceux-2.2.1
sudo scons GTK=1 install

On peut maintenant télécharger des roms sur http://emu-fr.net/v1/module.php?page=programme_roms&console=Nes&tri=nom&l=S

et lancer fceux avec un gamepad

fceux –inputcfg gamepad1

PiMenu¶

PiMenu permet d’avoir en plein écran un lanceur utilisable par gamepad

wget http://mame4all-pi.googlecode.com/git/pimenu.zip
unzip pimenu

on peut ensuite modifier le fichier pimenu.cfg et les icones BMP

Pour le lancer au démarrage graphique de l’utilisateur pi il faut modifier le fichier /home/pi/.profile

if [ -z "$BASH_VERSION" ];then
    echo && echo "Starting Pimenu" && echo
    /home/pi/pimenu/pimenu
fi

RetroPie¶

Il s’agit d’une image mais aussi d’un binaire permettant d’installer facilement des emulateurs A priori facile d’installation cela peut être une solution.

sudo apt-get update
sudo apt-get install -y git dialog
cd
git clone git://github.com/petrockblog/RetroPie-Setup.git
cd RetroPie-Setup
chmod +x retropie_setup.sh
sudo ./retropie_setup.sh

emulationstation

On peut aussi installer une image de RetroPie

wget http://florian.jdc.se/RetroPieImage_ver1.10.1.img.zip
unzip RetroPieImage_ver1.10.1.img.zip
umount /dev/sdc1
dd bs=1M if=RetroPieImage_ver1.10.1.img of=/dev/sdc

On peut paramétrer une manette via la commande

cd retroPie
mv confis/all/retroarch.cfg configs/all/retroarch.cfg.old
./emulators/RetroArch/installdir/bin/retroarch-joyconfig >> configs/all/retroarch.cfg

exemple de fichier retroarch.cfg

input_player1_joypad_index = "0"
input_player1_b_btn = "0"
input_player1_y_btn = "2"
input_player1_select_btn = "8"
input_player1_start_btn = "9"
input_player1_up_axis = "-5"
input_player1_down_axis = "+5"
input_player1_left_axis = "-4"
input_player1_right_axis = "+4"
input_player1_a_btn = "1"
input_player1_x_btn = "3"
input_player1_l_btn = "4"
input_player1_r_btn = "5"
input_player1_l2_btn = "6"
input_player1_r2_btn = "7"
input_player1_l3_btn = "6"
input_player1_r3_btn = "7"
input_player1_l_x_plus_btn = "6"
input_player1_l_x_minus_btn = "7"
input_player1_l_y_plus_btn = "6"
input_player1_l_y_minus_btn = "7"
input_player1_r_x_plus_btn = "6"
input_player1_r_x_minus_btn = "7"
input_player1_r_y_plus_btn = "6"
input_player1_r_y_minus_btn = "7"
input_exit_emulator_btn = 15
input_menu_toggle_btn = 16
input_player2_joypad_index = "1"
input_player2_b_btn = "0"
input_player2_y_btn = "2"
input_player2_select_btn = "8"
input_player2_start_btn = "9"
input_player2_up_axis = "-5"
input_player2_down_axis = "+5"
input_player2_left_axis = "-4"
input_player2_right_axis = "+4"
input_player2_a_btn = "1"
input_player2_x_btn = "3"
input_player2_l_btn = "4"
input_player2_r_btn = "5"
input_player2_l2_btn = "6"
input_player2_r2_btn = "7"
input_player2_l3_btn = "6"
input_player2_r3_btn = "7"
input_player2_l_x_plus_btn = "6"
input_player2_l_x_minus_btn = "7"
input_player2_l_y_plus_btn = "6"
input_player2_l_y_minus_btn = "7"
input_player2_r_x_plus_btn = "6"
input_player2_r_x_minus_btn = "7"
input_player2_r_y_plus_btn = "6"
input_player2_r_y_minus_btn = "7"

Et pour télécharger les roms on va sur http://emu-fr.net/

Outil¶

Nous pouvons utiliser pour dessiner les plans l’outil de fritzing.

apt-get install fritzing
Fritzing

Il est possible de télécharger des composant à utiliser dans fritzing comme un raspberry (https://github.com/adafruit/Fritzing-Library/tree/master/parts)

Il est aussi possible d’installer la dernière version qui possède déjà tout les éléments raspberry

apt-get install fritzing
apt-get remove fritzing
apt-get install qt4-demos qt4-designer qt4-dev-tools qt4-doc qt4-doc-html qt4-qmake qt4-qtconfig zlib1g libboost-all-dev
wget http://fritzing.org/download/0.8.7b/source-tarball/fritzing-0.8.7b.source.tar.bz2
tar -xvf fritzing-0.8.7b.source.tar.bz2
cd fritzing-0.8.7b.source
qmake
make
make install
Fritzing

GPIO¶

Le raspberry peut communiquer via ces ports d’entrée/sortie nommé GPIO

Cela permet de fournir du courant (3,3V ou 5V) mais aussi une masse des bus (I2C, UART, SPI) et des pins classiques

Comme nous utilisons pour les montages un T-cobbler qui ne possède pas la même notation, il existe une correspondance

• P0 - GPIO 17
• P1 - GPIO 18
• P2 - R1: GPIO 21, R2: GPIO 27
• P3 - GPIO 22
• P4 - GPIO 23
• P5 - GPIO 24
• P6 - GPIO 25
• P7 - GPIO 4
• CE1 - GPIO 7
• CE0 - GPIO 8
• SCLK - GPIO 11
• MISO - GPIO 9
• MOSI - GPIO 10
• RXD - GPIO 15
• TXD - GPIO 14
• SCL - R1: GPIO 1, R2: GPIO 3
• SDA - R1: GPIO 0, R2: GPIO 2

Pour piloter les GPIOs via python il faut installer via pip le module RPi.GPIO

apt-get install python-pip
pip install --upgrade RPi.GPIO

Premier Montage¶

il va rester assez simple: nous allons allumer une led en permanence en utilisant

• une led 5mm
• une resistance (220 ohms)
• une entrée 3,3V

Deuxième Montage¶

La différence est minime: on connecte plus le circuit sur le pin 3.3V mais sur le pin 17

Et là il ne se passe rien ... normal il faut indiquer au pin de passer du courant et on va faire cela en python

import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setup(17, GPIO.OUT)
GPIO.output(17, GPIO.HIGH)

et là la led s’allume !!!

Le programme est assez simple:

• il charge le module de GPIO
• indique que nous allons travailler en mode BCM pour identifier les pins (on va utiliser son numéro)
• indique que sur le pin 17 nous voulons envoyer une information
• on allume le pin 17

Pour éteindre

GPIO.output(17, GPIO.LOW)

Pour ré-initialiser les pins il suffit de faire

GPIO.cleanup()

Utilisation d’un afficheur¶

Un afficheur 7 broches est un afficheur pour lequel chaque broche contrôle un segment. Il y a 8 segments et 1 broche pour la masse

Le schema suivant présente quelle briche contrôle quel segment

On peut donc rapidement faire un petit montage permettant au raspberry de piloter un afficheur 7 segments

Pour résumer, le segment:

• h est piloté par GPIO 17
• c est piloté par GPIO 18
• d est piloté par GPIO 27
• e est piloté par GPIO 22
• b est piloté par GPIO 23
• a est piloté par GPIO 24
• f est piloté par GPIO 25
• g est piloté par GPIO 4

Il suffit maintenant d’écrire le programme python qui permet de contrôler cette afficheur

#! /bin/python
# -*- coding: utf-8 -*-
#
#  manage afficheur by raspberry
#
exit
__author__ = "Frederic Aoustin"
__license__ = "GPL"
__version__ = "1.0.1"
__maintainer__ = "Frederic Aoustin"
__email__ = "fraoustin@gmail.com"
__status__ = "Production"

import RPi.GPIO as GPIO
import threading
import time
PIN = [24,23,18,27,22,25,4,17]

CODING = {
    ' ' : '00000000',
    '0' : '11111100',
    '1' : '01100000',
    '2' : '11011010',
    '3' : '11110010',
    '4' : '01100110',
    '5' : '10110110',
    '6' : '10111110',
    '7' : '11100000',
    '8' : '11111110',
    '9' : '11110110',
    'E' : '10011110',
}

TRANSLATE = {
    '0' : GPIO.LOW,
    '1' : GPIO.HIGH
    }


class TestAfficheur(threading.Thread):
    def __init__(self, nom = ''):
        threading.Thread.__init__(self)
        self.Terminated = False
        self.iterateur = iter(PIN)

    def run(self):
        self.Terminated = False
        while not self.Terminated:
            try:
                pintest = self.iterateur.next()
            except:
                self.iterateur = iter(PIN)
                pintest = self.iterateur.next()
            _leds(''.join([ '1' if i== pintest else '0' for i in PIN]))
            time.sleep(1.0)

    def stop(self):
        self.Terminated = True

def _leds(code):
    for pin,v in zip(PIN, code):
        GPIO.output(pin,TRANSLATE[v])
    return True


def affiche(val):
    if val not in CODING.keys():
        return aff che('E')
    return _leds(CODING[val])

def init():
    GPIO.setmode(GPIO.BCM)
    GPIO.setwarnings(False)
    for pin in PIN:
        GPIO.setup(pin, GPIO.OUT)
    affiche(' ')

if __name__ == '__main__':
    init()
    loop = True
    test = TestAfficheur()
    while loop:
        val = raw_input("valeur a afficher")
        if val  not in ('exit','test'):
            test.stop()
            affiche(val)
        if val == 'test':
            test.start()
        if val == 'exit':
    test.stop()
            loop = False
    print('Bye')

Utilisation d’un bouton¶

Jusqu’à présent nous avons via le raspberry envoyé des infoformations sur les GPIOs pour échanger avec le monde réel nous allns voir comment nous pouvons faire pour recevoir des informations du monde réel via les GPIOs.

Un bouton permet simplement de faire passer ou pas du courant dans un circuit électrique. ON peut ainsi fermer un circuit. le montage suivant présente l’utilisation la plus simple d’un bouton ...

Quand nous appuyons sur le bouton la led s’allume.

Maintenant nous allons modifier le circuit afin que l’info “led s’allume” soit communiquée au GPIO 17.

et un petit bout de code pour voir l’action du bouton

import RPi.GPIO as GPIO
def button_on(channel):
    print("click on button")

GPIO.setmode(GPIO.BCM)
GPIO.setup(17, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.add_event_detect(17, GPIO.FALLING, callback=button_on, bouncetime=300)

et si on appuie sur le boutton plus de 300 ms

>>> click on button