Vue normale

Contôler GPIO avec MySQL

Par : Kiwil
23 novembre 2015 à 20:01
Bonjour,

Aujourd'hui je vous propose un petit article sur l'utilisation facile des GPIO via MySQL, facile car une fois la base de donnée et le programme Python en marche il ne reste plus qu'à faire des petites requête SQL pour piloter ces GPIO. L’intérêt est qu'elle permet ensuite via n'importe quelle langage externe de faire ces requêtes sur votre Raspberry Pi pour contrôler les GPIO.

Le principe est simple un table avec trois colonnes suffisent, une pour le numéro de GPIO, une autre pour le mode IN/OUT, et la dernière pour l'état. L'autre avantage d'un système comme celui-ci c'est la possibilité d'adapter le système à n'importe quel plateforme (Arietta G25, BeagleBone, Raspberry Pi ...).

Le seule inconvénient dans ce type de  système c'est peu être le temps de réponse selon le langage et surtout le type de base de données, ici j'utilise du Python avec du MySQL mais du C avec du SQLite aurait surement été plus rapide. Mais personnellement ce type de système peut être utilisé pour par exemple des site web, ou le temps de réponse des GPIO n'est pas forcement la priorité.






Besoins

Pour l'utilisation de ce projet il nous faut tout d'abord deux choses, Python pour le programme et MySQL pour la base de données, je vous laisse ci cela n'est pas encore fait vous tourner vers votre moteur de recherche pour installer tout sa.

Il va nous falloir ensuite pour Python quelques librairie pour notamment ce connecter à la base de données MySQL. Pour ce faire il faut installer le paquet suivant :


sudo apt-get install python-mysqldb
 
Pour la partie MySQL, il faut créer dans un premier temps une base de donnée ci cela n'est déjà fait, avec la commande CREATE DATABASE GPIO dans MySQL. Nous créerons ensuite dans la suite la table.



Structure MySQL



Ci-dessous la structure de la table utilisé pour mon système :
CREATE TABLE IF NOT EXISTS `gpio` (
  `id_gpio` int(2) NOT NULL,
  `state` int(2) NOT NULL,
  `mode` int(2) NOT NULL,
  PRIMARY KEY (`id_gpio`)
)


Programme Python
 
Le programme est une boucle permanente sur tous les éléments de la table selon le mode, si ce mode est a 1 c'est à dire en entrée alors une lecture du GPIO est faite puis mis à jour dans la table, si ce mode est  à 0 alors l'écriture est fait dans l'état souhaiter si cette état à changé.


#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Import des modules
import RPi.GPIO as GPIO
import time
import MySQLdb

# Initialisation de la numerotation et des E/S
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)

db   = MySQLdb.connect("localhost", "root", "raspberry", "GPIO_CONTROLE")
curs = db.cursor()

def Update_State_GPIO(iGPIO, iState):
   curs.execute("""UPDATE gpio SET state=%s WHERE id_gpio=%s""",(iState,iGPIO))

while True:
   time.sleep(0.15)
   # Pour toutes les GPIO de la base
   curs.execute("SELECT * FROM gpio")
   rows = curs.fetchall()
   for row in rows:
      if (row[3]==1):
         GPIO.setup(int(row[0]), GPIO.OUT)
         if (GPIO.input(row[0])!=int(row[2])):
            GPIO.output(int(row[0]), int(row[2]))

      else:
         GPIO.setup(int(row[0]), GPIO.IN)
         Update_State_GPIO(int(row[0]), GPIO.input(int(row[0])))
   db.commit()


Conclusion


Ci vous chercher un moyen simple de d’interagir avec les GPIO depuis n'importe quelle langage sans rechercher la rapidité de la microseconde de réponse, ce type de système est fait pour vous :D. Après, on peut imaginer des fonctions beaucoup plus complexe dans notre code Python, ainsi qu'une base de données plus structuré pour faire des lectures de température par exemple en paramétrant par exemple un mode 3 sur les GPIO, ou une table I2C en paramétrant les adresses dans celle-ci etc ...





Raspberry pi sur un drone

Par : Kiwil
26 juillet 2015 à 18:19
Bonjour,

Depuis quelques mois je me suis découvert une nouvelle passion pour les drones, je possède donc un petit drone de type 250 acheté en kit. Et avant d'investir dans un caméra et module fpv qui peu couter assez chère, je voulais faire quelques prise de vue. 

J'ai donc monté un Raspberry Pi A+ sur le drone, le choix de la version A+ était évidente puisque plus petite qu'une version normale. Avec bien sur une pi caméra, et un petit transformateur car la tension de la batterie du drone est de 11.1V.

Pour la programmation je n'ai pas fait un programme très complexe, puisque c'est un programme en Python avec la librairie pycamera qui démarre une capture vidéo lors du démarrage du système avec une simple tache cron. 

Le montage :





Le programme : 

Pour commencer on lit dans un fichier un numéro d'incrémentation puis on l'incrémente et on l'écrit dans le fichier, j'ai fait puisque on ne peut pas utiliser un simple nommage de fichier avec date/heure puisque au démarrage du système sans wifi la date et heure renvoyer sera toujours la même. On démarre ensuite la prise de la vidéo avec pour nom le numéro d'incrémentation récupér précédemment pour une durée indéfinie.

programme :

import picamera
import time
import RPi.GPIO as GPIO

# Definition de l'objet camera
camera = picamera.PiCamera()

# Lecture de l'incrementation fichier
ficR = open('/home/pi/Programme/Python/Video_Drone/Videos/INCR.txt','r+')
sINCR = ficR.read(3)
print sINCR
iINCR = int(sINCR)
ficR.close()

iINCR +=1

# Ecriture du fichier d'incrementation
ficW = open('/home/pi/Programme/Python/Video_Drone/Videos/INCR.txt','wb')
ficW.write(str(iINCR))
ficW.close()

camera.rotation = 180
camera.start_recording('/home/pi/Programme/Python/Video_Drone/Videos/Flight' + str(iINCR) + '.h264')

while (1):
        time.sleep(1)


La tache cron :
@reboot sudo python /home/pi/Programme/Python/Video_Drone/Video_Reboot.py

L’intérêt de cette tache est quelle ne s’exécute seulement au démarrage du RPI.

Une fois le vole terminé il faut simplement convertir la vidéo vers un format mp4 en installant  le packet suivant :
sudo apt-get install gpac

Et pour finir on lance la commande de conversion par exemple :
MP4Box -add ./Flight9.h264  ./Flight9.mp4


Première vidéo :

Pour le moment c'est la seule vidéo que j'ai peu prendre car il faut que je change un moteur ...

Arietta G25 - Librairie C++

Par : Kiwil
11 avril 2015 à 17:08
Bonjour,

Aujourd'hui je vous présente ma librairie pour utiliser les GPIO facilement dans votre programme C++. Car  jusqu'à présent la seul librairie était proposé par le créateur de l'arietta G25 et pour Python.


Présentation

La librairie est composée d'une classe nommé GPIO, et d'autre fonction hors classe. La classe principale comme sont nom l'indique permet de piloter les GPIO, pour le moment les fonctions principale sont testés et fonctionne correctement :

- pinMode(INPUT ou OUTPUT), permet d'affecter le sens de la broche.
- digitalWrite(HIGH ou LOW), permet d'écrire la valeur de sortie.
- digitalRead(), permet de lire la valeur de la broche en mode entrée.

Autre fonction hors classe :

- Delay(Milliseconde), fonction d'attente en milliseconde.
- readButton(), permet de lire l'état du bouton de l'Arietta G25.

D'autres fonctions sont à venir, l'utilisation des broches PWM, analogRead(), mode event pour les broches en entrée.

Utilisation

Le dépôt GitHub contient deux exemples, un simple Blink et un autre programme qui allume ou éteint en fonction de l'état du bouton.

Pour commencer deux façon d'initialiser un GPIO soit en passant directement une chaine avec le nom de la broche tel que définit par AcmeSystems (Ici), soit en passant un entier qui sera le Kernel Id de la broche (Disponible également le site).

Quelle intérêt dans par exemple pour GPIO led("A23") qui sera égale à GPIO led(23) me direz-vous ?
Tout simplement si l'ont regard pour la broche par exemple nommer C4 sont Kernel Id est égale à 68, donc à vous de choisir.

Blink :


#include "../Lib/libGPIO.h"
#include <stdio.h>
#include <stdlib.h>

int main()
{
    GPIO led("A23"); // "A23" ou kernel id = 23

    led.pinMode(OUTPUT);
    while(1)
    {
       Delay(250);
       led.digitalWrite(HIGH);
       Delay(250);
       led.digitalWrite(LOW);
    }

}

buttonRead() :


#include "../Lib/libGPIO.h"
#include <stdio.h>
#include <stdlib.h>

int main()
{
    GPIO led("A23"); // "A23" ou kernel id = 23

    led.pinMode(OUTPUT);
    while(1)
    { 
       led.digitalWrite(readButton());
    }

}


Compilation

Pour la compilation en attendant un makefile et une installation plus propre de la librairie dans votre systéme voici comment compiler, mais avant assurer vous que vous avez installé le compilateur c++.

Pour commencer télécharger la librairie :

git clone https://github.com/kkiwill/Arietta_G25_GPIO_Library.git

Ensuite on ce place dans le dossier Example pour compiler un des example :

cd ./Arietta_G25_GPIO_Library/Example

On compile ensuite le programme voulu avec :

g++ ./Blink.cpp ../Lib/libGPIO.cpp -o Blink -lrt

Si des personnes sont intéresser par le projet et souhaite y participer n’hésiter pas à me contacter.

Les sockets

Par : Kiwil
17 janvier 2015 à 19:12
Bonjour,

Depuis la création de l'application Windows et Android on me demande comment marche l'échange notamment du coté Raspberry Pi. Pour cela rien de très compliqué je créer un serveur de socket qui en fonction de chaque demande exécuter une commande, lit un GPIO ou écrit un GPIO.



Dernièrement j'ai fait évoluer se serveur de socket en utilisant une classe Python qui gère la réception de socket de façon événementielle. J'y intègre aussi une seconde classe qui me permet de récupérer facilement des informations système.

I - Le programme principale
#!/usr/bin/env python
# -*- coding: utf-8 -*-

import Socket_Event
import subprocess
import RPi.GPIO as GPIO
from Sys_Info import *

# Variables globale
DEBUT_TRAME = "R"
FIN_TRAME   = "I"
SEPARATEUR  = chr(0x02)

# Reception de la trame et renvoie d'une autre
def TraiteRecv(self, data):
 # Variable
 ToSend = ""

 # Test si debut et fin de trame(pour vérification de trame complète)
 if (data[:1] == DEBUT_TRAME and data[-1:] == FIN_TRAME):
  data = data[1:len(data)-1]
  
  # Selon contenue
  if (data == "temp"):
   ToSend = str(get_temperature())

  if (data == "cpu"):
   ToSend = str(get_cpu_speed())

  if (data == "uptime"):
   ToSend = get_up_stats()[0]

  if (data == "ram"):
   ToSend = str(get_ram()[1])+' ('+str(get_ram()[0])+')'

  if (data == "nbproc"):
   ToSend = str(get_process_count())

  # GPIO mode
  if (data[0:2] == "GM"):
   try:
    mode = data[2:3]
    pin  = int(data[3::])
    if (mode == "I"):
     GPIO.setup(pin,GPIO.IN)
    else:
     GPIO.setup(pin,GPIO.OUT)
   except Exception, e:
    ToSend = ("Erreur_%s" % e)   
  # GPIO write
  if (data[0:2] == "GW"):
   try:
    etat = int(data[2:3])
    pin  = int(data[3::])
    if (etat == 1):
     GPIO.output(pin, GPIO.HIGH)
    else:
     GPIO.output(pin, GPIO.LOW)
   except Exception, e:
    ToSend = ("Erreur_%s" % e)
  # GPIO read
  if (data[0:2] == "GR"): 
   try:
    pin = int(data[2::])
    etat = GPIO.input(pin)
    ToSend = str(etat)
   except Exception, e:
    ToSend = ("Erreur_%s" % e)
  
  # On renvoie la donnée recu et la réponse (séparer par caract de 2)
  Socket_Event.EchoHandler.handle_write(self, DEBUT_TRAME + data + SEPARATEUR + ToSend + FIN_TRAME)    

# Definition de la socket
interface = "192.168.0.13"
port = 59004

# GPIO configuration
GPIO.setmode(GPIO.BOARD)
GPIO.setwarnings(False)

# Lancement de la socket
server = Socket_Event.EchoServer((interface, port), TraiteRecv)
server.serve_forever()


Je commence par définir des variables global, celle-ci me permettrons de tester le début, fin de trames reçu pour être sur que ces dernières sont complètes. Ensuite la fonction qui sera appeller lors qu'une trame se présente dans la socket. Et pour finir aprés la fonction "TraiteRecv" la programme qui permet de définir l'IP de la socket ainsi que sont port, puis configurer les GPIO et pour finir lancer le serveur avec en paramètre l'IP, port et la fonction à appeler lorsque une trame est reçu. 

La fonction "TraiteRecv" dans un premier vérifie que le début et fin de trame sont présente dans la trame. On traite ensuite en fonction du message de la trame pour effectuer l'action demander, et pour finir on renvoie sur la socket la réponse que le client traitera à sont tour.

Les classes

La classe Socket_Event n'est pas de moi je l'ai juste modifier pour permettre d'avoir une fonction extérieur à la classe pour traiter les socket reçu.

La classe Sys_Infos est aussi une trouvaille du web.


Conclusions

 L'avantage de cette classe est donc sa simplicité d'utilisation, de plus les déconnexion du client sont automatiquement gérer par le serveur. Vous pouvez maintenant adapter tout sa à vos besoins d'objet connecter :-)

Le lien des fichier  : https://mega.co.nz/#!A9I2DaxD!qZVL9hzDwhWb5zP2LXqKIs_5cCFV-nRSNALtohtkruQ


Arietta G25 - Installation du système

Par : Kiwil
9 novembre 2014 à 13:57
Bonjour,

D'après le sondage et les quelques retour que j'en ai eu l'Arietta G25 semble intéresser les personnes qui souhaitent connaitre d'autre plateforme microcontrôleur Linux, c'est pourquoi je vais décrire les étapes pour bien commencer avec L'Arietta G25.

L'installation du système Debian n'est pas aussi simple que pour un Raspberry Pi, dû notamment pour le moment à sont manque de communauté. Je vais donc commencer par la l'installation du système.

Désolé pour les personnes utilisant Windows mais l'installation d'écrite par Acme-Systems se fait uniquement via un système  Linux.

Merci à Acme-Systems pour les tutoriels sur lesquels je me base pour faire le mien, qui sera simplement une adaptation en français.


I - Préparation de la carte SD

On va donc commencer par préparer la carte SD, c'est à dire que nous allons la formater puis la partitionner. Le tutoriel se fait via le système Ubuntu 13.10, mais vous pouvez reproduire se tutoriel sur n'importe quelle OS Linux.

Insérer votre carte SD, puis verifier que votre systéme à bien reconnnu la carte avec :
dmesg
Vous devriez retrouver à quelque chose prêt les lignes suivante :

[13736.699438] sd 15:0:0:0: [sdb] 3911680 512-byte logical blocks: (2.00 GB/1.86 GiB)
[13736.700061] sd 15:0:0:0: [sdb] Write Protect is off
[13736.700067] sd 15:0:0:0: [sdb] Mode Sense: 4b 00 00 08
[13736.700072] sd 15:0:0:0: [sdb] Assuming drive cache: write through
[13736.702662] sd 15:0:0:0: [sdb] Assuming drive cache: write through
[13736.702671]  sdb: sdb1
[13736.709301] sd 15:0:0:0: [sdb] Assuming drive cache: write through
[13736.709309] sd 15:0:0:0: [sdb] Attached SCSI removable disk

Ou [sdb] est le point de montage de la carte SD, on continue avec l'installation de GParted qui va nous permettre de formater puis partionner la carte. Pour l'installation ceci suffit :
sudo apt-get install GParted
Puis dans vos application lancer GParted, vous pouvez maintenant sélectionner votre carte SD et voir quelque chose comme le screenshot ci dessous :


 Ici par défaut la carte était formater en Fat16 avec une seule partition. Il faut commencer par supprimer la partition en cliquant droit dessus puis faire supprimer :


Nous allons maintenant créer 4 partitions  Kernel, rootfs, data, swap. On commence donc par Kernel, pour sa cliquer droit sur la "unallocated" et faire nouveau, et créer une partition comme ceci :

Taille: 32MB
Format: FAT16
Nom: kernel
Laisser les autres paramètre par défaut


Ensuite la partition rootfs, avec les paramètres suivant :

Taille: 800MB ou plus si selon la carte SD et se que vous compter installez par la suite.
Format: EXT4
Nom: rootfs
Laisser les autres paramètre par défaut


La partition Data qui va donc contenir vos donner, avec les paramètres suivant :

Format: EXT4
Espace libre: 128MB
Nom: data
Laisser les autres paramètre par défaut


Pour finir la partition swap, avec ceci :

Taille: 128MB
Format: linux-swap
Nom: swap
Laisser les autres paramètre par défaut


Voila le partitionnement est fini il faut maintenant l'appliquer avec le bouton vert qui se trouve juste au dessus des partitions. Une fois la fin des opérations retirer la carte et réinsérer la pour voir que 3 partitions sont bien monté.

Votre carte est maintenant prêt à recevoir le système pour la second partie.

II - Installation du système

Pour l'installation du système rien compliquer on va commencer par télécharger deux fichiers qui sont le kernel et le système rootfs, puis décompresser tout sa dans leurs partitions respective.

Téléchargement du kernel :
sudo wget http://www.acmesystems.it/download/microsd/Arietta-30aug2014/kernel.tar.bz2
Téléchargement de rootfs :
sudo wget http://www.acmesystems.it/download/microsd/Arietta-30aug2014/rootfs.tar.bz2
On va maintenant décompresser ces deux archives dans les partitions avec pour le kernel :
sudo tar -xvjpSf kernel.tar.bz2 -C /media/$USER/KERNEL  
Pour rootfs :
sudo tar -xvjpSf rootfs.tar.bz2 -C /media/$USER/rootfs
Penser à remplacer $USER par votre nom d'utilisateur :). Voila votre carte est prête à être démonter la carte SD puis brancher votre Arietta G25. Prochaine étape le premier démarrage.

III - Première  connexion

Pour la première connexion deux solutions, soit vous avez acheter la carte wifi dans se cas il faudra juste configurer le fichier "interfaces" sur votre carte SD avec vos paramètre de connexion Wifi. Autre solution connecter directement l'Arietta G25 à votre PC dans se cas il faut modifier le fichier "interfaces" de votre machine.

Cas Wifi :

Il faut donc monté la carte SD, et éditer le fichier "/etc/network/interfaces" pour éditer se fichier :
sudo nano /media/$USER/rootfs/etc/network/interfaces
Et éditer le fichier comme ceci :

auto wlan0
iface wlan0 inet dhcp
  wpa-ssid VOTRE_WIFI
  wpa-psk VOTRE_CLE

Démonter la carte SD puis brancher l'Arrietta G25 et voila ne reste plus qu'à chercher l'adresse IP et se connecter avec SSH (login : root, password : acmesystems).

Cas direct :

Ici ont va modifier les paramètres de connexion de la machine pour créer une sorte de réseau local, il faut donc la aussi éditer le fichier :
sudo nano /etc/network/interfaces
Puis ajouter les lignes suivantes :

allow-hotplug usb0
iface usb0 inet static
    address 192.168.10.20
    netmask 255.255.255.0

Brancher maintenant votre AG25, puis avec dmesg vérifier si les lignes suivantes apparaissent :

[54496.036265] usb 1-1: new high-speed USB device number 14 using ehci-pci
[54496.170886] usb 1-1: New USB device found, idVendor=0525, idProduct=a4a2
[54496.170889] usb 1-1: New USB device strings: Mfr=1, Product=2, SerialNumber=0
[54496.170891] usb 1-1: Product: RNDIS/Ethernet Gadget
[54496.170892] usb 1-1: Manufacturer: Linux 3.14.7+ with atmel_usba_udc 
[54496.299685] cdc_eem 1-1:1.0 usb0: register 'cdc_eem' at usb-0000:00:1d.7-1, CDC EEM Device, b2:2b:7d:e0:45:8e

Si ce n'est pas le cas essayer :

sudo ifup usb0
Un petit ping sur l'adresse 192.168.10.10, si sa ping c'est que tout est bon, ne reste plus qu'a s'y connecter ssh root@192.168.10.10 (login : root, password : acmesystems).






Sécuriser son serveur Raspberry Pi

Par : Kiwil
10 août 2014 à 18:40
Bonjour,

Aujourd'hui article sur la sécurité d'un Raspberry Pi, essentielle pour les détenteurs de RPi qui l'utilise en serveur. Car depuis quelque temps maintenant sur mon RPi utiliser en serveur, j'ai pu constaté dans les logs des tentatives d'intrusions via bien sûr le mode ssh et le port 22 avec le login "root". 



Vous aussi faite le test regarder votre log, rechercher dans authentification ratée plusieurs fois avec des adresses inconnues, le fichier log est le suivant :
nano /var/log/auth.log
Après avoir vu le nombre de tentatives j'ai décidé de rechercher des solutions, je vais donc vous faire par de toutes les méthodes de protection que j'ai suivies pour sécurisé votre le serveur.

I - Port SSH

C'est bien connu le port 22 est le port de connexion SSH, et ça, les serveurs pirates le savent aussi, il faut donc commencer par changer le port de connexion. Le nouveau port de connexion doit être compris entre 1024 et 65537, la modification du port se trouve dans le fichier suivant :
sudo nano /etc/ssh/sshd_config
Rechercher la ligne avec "Port" et modifier la ligne en conséquence, mais attention si vous êtes connecté en SSH vous serez aussitôt déconnecter au moment de la sauvegarde du fichier.

Il faut aussi penser à changer le port redirection sur votre box. Pour la connexion à partir d'un Linux, il faut aussi changer la traditionnelle commande "ssh pi@IP" et rajouter l'option "-p" pour préciser le port de connexion, la commande devient "ssh -p 1234 pi@IP".

II - Root

Second constat, les serveurs pirates cherchent à se connecter via l'utilisateur "root". L'utilisateur "Pi" est un Super Utilisateur il est donc possible d'interdire les connexions en SSH sur le compte "root" en modifiant le même fichier que précédemment et modifier la ligne suivante :
PermitRootLogin yes
par :
PermitRootLogin no

III - Mot de passe

Ici je ne vous apprends rien, je pense, un bon mot de passe est composé de majuscule, minuscule, de caractère spécial et de chiffre. Laisser parler votre imagination.

IV - Fail2Ban

Pour les bots qui tenteraient toujours de se connecter plusieurs fois il est possible de les bannir ou plutôt de les placer dans votre "prison", grâce à Fail2Ban. Simple d'utilisation et sur, il a déjà chez moi fait plusieurs bannit. Pour l'installation :
sudo apt-get install fail2ban
le fichier de configuration (/etc/fail2ban/jail.conf) contient les paramètres suivants :
ignoreip : le ou les ports à ne pas inclure dans le contrôle
bantime : temps de bannissement en seconde
maxretry : nombre de tentative avant exclusions

A noter que si vous avez modifier le port de connexion il faut modifier le fichier de configuration ci-dessus comme ceci :

[ssh]
enabled  = true
port     = ssh
filter   = sshd
logpath  = /var/log/auth.log
maxretry = 6
port     = ssh,sftp,2276

 

Ajouter donc la ligne port en remplacent 2276 pour votre port ssh.

Il est possible d'utiliser fail2ban pour d'autre service de connexion (pour se faire, google est votre ami).

VI - Conclusion

Voilà on à fait le tour des bases de la sécurité de votre serveur SSH et ces bases sont essentielle si votre RPI est en serveur, je n'ai pas évoqué le pare-feu "iptables" car les box et les routeurs offrent déjà ces fonctionnalités.

Arietta G25 : RFID RC522

Par : Kiwil
27 juillet 2014 à 16:37
Bonjour,

Aujourd'hui je vous propose l'adaptation pour l'Arietta G25 du module RFID MF-RC522,que l'ont trouve sur Ebay à moins de 5€. Je suis partie de librairies Raspberry Pi que j'ai un peu modifiées. Ces librairies sont disponibles sur un dépôt GitHub, pour l'utilisation suivez le guide.



I - Prérequis

Avant toutes choses il faut avoir modifier la configuration de votre Arietta G25, pour se faire plus besoins de recompiler un kernel Linux, il suffit de se rendre sur le site de l'Arietta ICI. Une fois sur cette page sélectionner le bus SPI et CS0, cliquez ensuite sur le bouton "Generate acme-arietta.dtb"et un lien apparaît, téléchargez le fichier et renommé le en "acme-arietta.dtb". Mettez la carte Sd sur votre pc une partition nommée "Kernel" coller ici le fichier renommé, retirer la carte et démarrer l'Arietta lorsque vous êtes connecter rentrer la commande suivante "depmod -a" et le tour est joué.


II - Schéma

Pour schéma rien bien compliqué il suffit de suivre la doc de l'Arietta G25 et du MF-RC522 :




III - Les librairies

Pour l'utilisation du MF-RC522 j'ai du modifier deux libraires,  la première SPI qui sert à communiquer avec le bus SPI plus facilement, la seconde permet d'envoyer les bonnes commandes aux lecteurs via le bus SPI.

Pas de grosses modifications entre les deux systèmes mis a par le nom du bus SPI et l'utilisation des GPIO avec la librairie ablib.

L'utilisation est ensuite assez simple, le principe est le suivant pour les exemples, une boucle qui scrute la présence d'un tag. Si tag détecter alors on récupère son UID (identifiant du tag) ensuite on peu faire se que l'on veut lire et écrire.

Pour l'installation, commencez par récupérer le contenu sur GitHub :
git clone https://github.com/kkiwill/Arietta_MF-RC522

On installe ensuite la librairie SPI :
cd ./SPI_Librairie
python setup install

Une fois la librairie installer ne reste plus cas faire un essai, pour le faire il faut copier un des exemples dans le dossier de la librairie MF-RC522_Librairie. Exemple avec le "read.py" :
cp ./Exemple/read.py ./MF-RC522_Librairie

On se place dans le dossier et on lance le programme :
cd ./MF-RC522_Librairie
python ./read.py

Et voilà c'est fini. Par la suite j'aimerais ajouter quelques autres fonctionnalités existantes dans certaines librairies Arduino pour notamment utiliser d'autre tag Mifare ...

Arietta G25 : blink

Par : Kiwil
29 juin 2014 à 16:39
hello,

Comme promis le premier tutoriel autour de l'Arietta G25, bien que pas très compliqué en terme de programme, c’était surtout pour moi l'occasion de découvrir l'utilisation des GPIO et de la librairie. La librairie qui d’ailleurs pour le moment n'est disponible que pour Python. Il existe bien un moyen pour faire sa en C++ ou en C mais j'en toucherai un mot à la fin de l'article.


I - Installation de la librairie

Commençons par l'installation de la librairie, en python et nommé "ablib" elle est utilisé pour Arietta G25 bien sur, mais aussi pour toutes les autres cartes du constructeur Acme-Systems. Il existe un dépôt GitHub regroupant des tas d'exemples python, C, php etc, disponible ici :


Pour l'installation de la librairie une fois connectée via ssh il faut récupérer le contenu sur GtiHub :
git clone git://github.com/tanzilli/ablib.git  
On se place ensuite dans le dossier de la lib :
cd ablib
Et on lance l'installation avec :
python setup.py install
La librairie est maintenant installée et prête à être utilisé.

II - Blink (Python)

Avant tout comme dit précédemment la librairie est générique à toutes les cartes Acme donc il faut connaitre la carte pour dans un premier temps savoir sur quel port nous travaillons, ici on va travailler sur le port J4. Ensuite la numérotation des pins  comme sur le Raspberry Pi elles ont un numéro de pins et un nom. Ici on va utilisez le numéro des pins.

Numérotations des GPIO (Nom du GPIO sur de sont numéro) :


Schéma du blink, j'utilise la pin n° 7 :



Le programme Python avec utilisation de la librairie :
  from ablib import Pin   
  from time import sleep   
  while True:   
    led = Pin('J4.7','OUTPUT') # pin 7 du port J4 en sortie  
    led.on()   
    sleep(0.5)   
    led.off()   
    sleep(0.25)   


III - C et C++

Comme je vous l'ai expliquez pas de librairie en C ou C++ pour le moment, donc pour faire la même chose en C il faut compiler et exécuter le code suivant, la pin cette fois est à nommer avec son nom :

 #include "stdio.h"  
 #include "stdlib.h"  
 #include "unistd.h"  
 int gpioexport(int gpioid)   
 {  
      FILE *filestream;  
      if ((filestream=fopen("/sys/class/gpio/export","w"))==NULL) {  
           printf("Error on export GPIO\n");  
           return -1;  
      }       
      fprintf(filestream,"%d",gpioid);  
      fclose(filestream);  
      return 0;  
 }  
 int gpiosetdir(int gpioid,char *mode)   
 {  
      FILE *filestream;  
      char filename[50];  
      sprintf(filename,"/sys/class/gpio/gpio%d/direction",gpioid);  
      if ((filestream=fopen(filename,"w"))==NULL) {  
           printf("Error on direction setup\n");  
           return -1;  
      }       
      fprintf(filestream,mode);  
      fclose(filestream);  
      return 0;  
 }  
 int gpiogetbits(int gpioid)   
 {  
      FILE *filestream;  
      char filename[50];  
      char retchar;  
      sprintf(filename,"/sys/class/gpio/gpio%d/value",gpioid);  
      if ((filestream=fopen(filename,"r"))==NULL) {  
           printf("Error on gpiogetbits %d\n",gpioid);  
           return -1;  
      }       
      retchar=fgetc(filestream);  
      fclose(filestream);  
      if (retchar=='0') return 0;  
      else return 1;  
 }  
 int gpiosetbits(int gpioid)   
 {  
      FILE *filestream;  
      char filename[50];  
      sprintf(filename,"/sys/class/gpio/gpio%d/value",gpioid);  
      if ((filestream=fopen(filename,"w"))==NULL) {  
           printf("Error on setbits %d\n",gpioid);  
           return -1;  
      }       
      fprintf(filestream,"1");  
      fclose(filestream);  
      return 0;  
 }  
 int gpioclearbits(int gpioid)   
 {  
      FILE *filestream;  
      char filename[50];  
      sprintf(filename,"/sys/class/gpio/gpio%d/value",gpioid);  
      if ((filestream=fopen(filename,"w"))==NULL) {  
           printf("Error on clearbits %d\n",gpioid);  
           return -1;  
      }       
      fprintf(filestream,"0");  
      fclose(filestream);  
      return 0;  
 }  
 int main(void)   
 {  
      int led = 23;  # GPIO PA23 donc son nom est 23
      gpioexport(led);  
      gpiosetdir(led,"out");  
      for (;;) {  
           gpiosetbits(led);  
           sleep(1);  
           gpioclearbits(led);  
           sleep(1);  
      }  
 }  

Pour bien faire on pourrait facilement faire une librairie avec c'est quelques fonctions, donc à voir.

IV - Conclusion

Alors comme indiquer dans précédent article l'utilisation de ce microcontrôleur n'est pas si facile que le Raspberry Pi notamment à cause du manque pour le moment de librairie autour des fonctionnalités des GPIO, mais il ne faut pas aussi oublier que sa sortie est très récente et que les quelques exemples fournis et un peut de recherche permette vite de faire se que l'ont souhaite.





LCD avec adresse IP local au démarrage

Par : Kiwil
9 mai 2014 à 18:03
Bonjour,

Aujourd'hui je vous fait un petit tuto qui est partie d'un constat tout simple, car je me déplace beaucoup avec mon Raspberry Pi donc je me connecte via la wifi mais il est toujours assez chiant de chercher l’adresse IP du RPI sur le réseau local. J'ai donc eu l'idée avec un petit afficheur que j'avais sous la main de faire en sorte qu'un petit programme à chaque démarrage affiche l'IP local. Idée très simple mais qui me sert bien maintenant.

Et au passage cela me permettra de vous expliquez comment lancer n'importe quelle programme au lancement du Raspberry Pi.



I - Matériels

Ici rien de bien méchant le RPI et un afficheur LCD, pour se dernier il faut savoir que le plus souvent il y a un module I2C intégrer donc selon l'afficheur les librairie utiliser peuvent changer. Par exemple j'ai débuter en voulant utiliser une librairie Adafruit qui n’était pas compatible avec mon afficheur acheter chez TinyDeal pour quelques euros. Donc le tuto ne sera donc pas forcement compatible avec tout les afficheur.



II - Librairie

Il faut pour commencer installer la librairie I2C qui contient tout se qu'il faut pour l'afficheur LCD, ici j'utilise la librairie Quick2Wire. Pour se faire on commence par créer notre dossier :
mkdir ./LCD_IPcd ./LCD_IP
Ensuite on télécharge la librairie :
git clone https://github.com/quick2wire/quick2wire-python-api.git 
On se place ensuite dans le dossier qui vien d'être télécharger :
cd ./quick2wire-python-api
Et on telecharge la derniere librairie "i2cLibrairies" avec :
sudo git clone https://bitbucket.org/thinkbowl/i2clibraries.git
Voila c'est fini pour la librairie vous devriez avoir un nouveau dossier avec à l'intérieur tout les librairie.

III - Le programme

Avec une librairie bien complète comme celle-ci le programme sera très rapide et facile à faire, auparavant voici les quelque fonctionnalité de la librairie LCD.

Pour commencer initialisation de l'écran se fait avec se qui suit :
lcd = i2c_lcd.i2c_lcd(0x27, 0, 2, 1, 0, 4, 5, 6, 7, 3)
On déclare donc un objet lcd, le premier paramètre est le plus important car c'est adresse I2C du LCD.
Les autres paramètre sont définie comme ceci :
I2C Address, Port, Enable pin, RW pin, RS pin, Data 4 pin, Data 5 pin, Data 6 pin, Data 7 pin, Backlight pin (optional)


Avec cette objet on peut par la suite acceder à toutes les fonction comme :
backlightOn() pour activer rétroéclairage
backlightOff() pour désactiver rétroéclairage
clear() effacer tout les caractère de l'afficheur
home() remet le curseur sur 0 et ligne 1
setPosition(line, position) place le curseur sur la ligne et la position souhaiter
writeChar(char) ecrit un caractére selon la position du curseur
writeString(string) ecrit une ligne selon la position du curseur

A partir de la on peut afficher se que l'ont veut, ou l'ont veut. le programme donne ceci :
 import sys, os  
 # On définie l'emplacement de la librairie  
 sys.path.append(r'/home/pi/LCD_IP/quick2wire-python-api')  
 from i2clibraries import i2c_lcd
 from time  import * 
 import socket  
 #Init de 'afficheur  
 lcd = i2c_lcd.i2c_lcd(0x27,1, 2, 1, 0, 4, 5, 6, 7, 3)  
 #Récupère l'adresse ip   
 locals = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)  
 locals.connect(('google.com', 0))  
 #On affiche tout sa sur l'afficheur   
 LCDlcd.backLightOn()  
 lcd.clear()  
 lcd.setPosition(1, 2)  
 lcd.writeString(str(locals.getsockname()[0]))  
 lcd.setPosition(2, 0)  
 lcd.writeString("hello")  

 Et pour lancer le programme il suffit de faire :
sudo python3 ./LCD.py
Et voila l'afficheur LCD vous affiche votre adresse IP local.


IV - Démarrage automatique 

Il faut maintenant faire en sort que ce programme se lance automatiquement au démarrage, pour se faire il faut ajouter un script dans le dossier systéme "/etc/init.d", donc c'est partie :
sudo nano /etc/init.d/LCD_IP

Et y coller ceci :
 #!/bin/bash  
 # /etc/init.d/LCD_IP.sh  
 case "$1" in  
  start)  
   echo "lancement du programme de l'afficheur LCD"  
   #la on lance le programme 
   sudo python3 /home/pi/LCD_IP/LCD_IP.py &
   ;;  
  stop)  
   echo "arret du programme de l'afficheur LCD"  
   sudo killall LCD_IP.py  
   ;;  
  *)  
   echo "Usage: /etc/init.d/LCD_IP {start|stop}"  
   exit 1  
   ;;  
 esac  
 exit 0  

Une fois le script créer et enregistrer il faut lui donner des droits :
sudo chmod /etc/init.d/LCD_IP
Dernière étapes ajouter se script au démarrage du système avec ceci :
 sudo update-rc.d LCD_IP defaults
Et voila fini pour ce petit tuto, plus besoin de chercher sur le réseaux l'adresse de votre RPI.

Creer un serveur Minecraft sur Raspberry

Par : Anonyme
2 mai 2014 à 20:56
Bonjour à tous,

Nous allons créer un serveur Minecraft sur Raspberry Pi qui en l’occurrence dans notre cas sera hébergé par un Raspberry à 512 Mo. L’intérêt par rapport aux tutoriels existants est que celui-ci est basé sur l'installation officielle du CraftBuckkit et donc n'importe laquelle de leurs mises à jour peuvent-êtres mise en place.





I - Prérequis :
Les performances du RPI sont quand même limitées c'est pourquoi il ne faut pas s'attendre à des performances d'un véritable serveur, et il faut aussi limiter le nombre d'utilisateurs pour l'avoir essayer à 4 maximum c'est pas très fluide. Pour optimiser tout cela, il vaut mieux utiliser une distribution Raspbian "vierge" sans services, etc en fond de tache. Pour optimiser encore tout sa le mieux est d'overclocker avec le rasp-config :
sudo raspi-config
ensuite dans overclocking choisir le mode de votre choix pour moi le medium suffit.


II - L'installation du serveur :

Tout d'abord il faut que vous mettiez à jour votre Raspberry, pour ceux qui débutent voici le code à écrire :
sudo apt-get updatesudo apt-get upgrade
Maintenant nous créons le dossier qui contiendra notre serveur :
sudo mkdir ./minecraft
Voilà le dossier est créer, si vous n'êtes pas dedans et bien quoi écrire de mieux que ceci :
cd ./minecraft
Ici commence donc le plus intéressant, car pour faire tourner Minecraft il vous faudra télécharger JAVA.
Pour cela voici de quoi se mettre sous la dent :
sudo apt-get installer oracle-java7-jdk
Ensuite il faut télécharger dans le dossier la dernière version du serveur CraftBuckkit, pour cela il faut se rendre sur le site suivant :
https://dl.bukkit.org/downloads/craftbukkit/

Arriver sur le site sur votre droite trois choix pour vous selon votre version de MineCraft, il suffit de cliquer droit sur votre choix et de copier le lien pour le coller après un "wget" dans le Raspberry Pi :
wget CraftBukkit.jar
A se stade on obtient un fichier.jar dans notre dossier il faut ensuite luis donner les droits nécessaires avec :
sudo chmod +x Craftbukkit.jar
 Ne reste plus qu'a lancer votre serveur avec :
sudo java -Xms300M -jar craftbukkit.jar
Et voilà le serveur se lance, c'est un peu long. Mais une fois lancer une connexion et en avant.

III - Aller plus loin :

Maintenant le problème c'est le lancement du serveur car si on quitte putty par exemple bien-sûr le serveur s’éteint. Alors dans un premier temps ont va crée un petit script qui lance tout seul le serveur, alors on créer le fichier :
sudo nano mkdir ./CraftBukkit.sh
Ensuite on colle ceci, si cela est nécessaire on change le nom du .jar :
#!/bin/sh BINDIR=$(dirname "$(readlink -fn "$0")") cd "$BINDIR" java -Xms300M -jar craftbukkit.jar -o false
On donne les droits au script :
sudo chmod 555 ./CraftBukkit.sh
Et voilà le script est prêt. Et maintenant il serait pratique de lancer se script en fond de tache, pour cela j'utilise Screen qui permet en gros de créer plusieurs terminaux dans le même terminale. Donc on commence par installer Screen :
sudo apt-get install screen
Ensuite il va falloir modifier notre script pour que la commande de lancement se passe dans un autre screen, on remplace la ligne "java -Xms300M -jar craftbukkit.jar -o false" par :
screen -s minecraft java -Xms300M -jar craftbukkit.jar -o false
On à donc créer lors du lancement du script un screen qui se nomme "minecraft", lors du lancement vous serez sur le ce fameux screen mais vous pouvez revenir sur votre espace de travail avec le raccourci ctrl-a+d, pour revenir sur le screen cette commande vous sera utile :
screen -raAd minecraft
Et voilà vous avez maintenant un joli serveur minecraft en fond de tache vous pouvez quitter votre session putty et le serveur sera toujours la.

A bientôt .... :)

Raspberry Pi et Android avec NFC

Par : Kiwil
21 avril 2014 à 19:54
Bonjour,

Je l'ai teaser dernièrement dans ma news du mois, une application Android qui permet via un téléphone NFC Activer/Désactiver les GPIO. Le principe est simple le programme sur le RPI créer une socket puis reste en attente d'un client, lorsque que l'application Android est ouverte la connexion se fait, puis au passage d'un tag sur le capteur NFC du téléphone l'application décrypte le tag dans lequel les informations des numéros GPIO sont stocker et envoie la commande au RPI. Il faut bien sûr au préalable écrire sur un tag ces informations via une fenêtre de mon application.

Petit schéma explicatif :



Petite vidéo :






Partie Android :

L'application est composée de 3 fenêtres très simples, la première et bien sûr la fenêtre de connexion qui n’apparait que lorsque la connexion n'est pas possible, car lorsque vous avez rentré des identifiants corrects et que la connexion est faite les paramètres sont enregistrés. 

La seconde fenêtre la principale est composée d'un bouton central qui permet d'Activer/Désactivé les ou le GPIO inscrit dans le tag qui sera détecter. Il est aussi composé d'un bouton permettent d'accéder à la fenêtre de paramétrage des Tag.

La dernière fenêtre permet de sélectionner les GPIO à inscrire sur le tag lors de l'appui du bouton "Validé".

Pour le moment l'application est disponible en téléchargement via Mega, mais prochainement je vais me pencher sur le Play Store qui rendra plus facile l’accès à mes applications.

Concernant les Tag nfc on en trouve très facilement sur Ebay et de toute sorte.

La partie Raspbery Pi :

La partie programme sur le Raspberry Pi est programmée en C++, sur la base du programme que j'utilise pour la supervision sur Windows en plus simplifier. Il n'est juste la pour interpréter la trame reçue par la socket avec le port par défaut est 8888. Le programme est totalement disponible dans l'archive à télécharger.

Il faut ensuite compiler etc :
sudo gpp ++ -o NFC NFC.cpp -lwiringPi

et pour lancer le programme :
sudo ./NFC

Voila à se stade tout devrait fonctionner plus qu'a lancer l'application, encoder des tags et laisser parler votre imagination pour faire un peu de domotique.

Lien pour la totale du sujet avec l'application :
https://mega.co.nz/#!Y9hBCIxA!tYK8ixRT60tOF3jzZMLmJr_tPk9la8mvDs4ZpdZOuhM






Tuto : Comment installer les apps Google sur une ROM Custom ?

29 juin 2014 à 17:47
Dans ce tutoriel, nous verrons ce que sont les Google Apps, pourquoi ne sont elles pas nativement installées dans les ROM Custom et surtout comment les installer sur votre smartphone ou votre tablette Android, après avoir installé une ROM Custom (CyanogenMod, Paranoid Android, AOKP, Carbon, Omni, etc.).
(Permalink)
❌