Le Pi est une belle petite carte informatique, mais pas aussi bonne que l’Arduino en ce qui concerne les capacités d’entrée/sortie. Le système Gertboard est un module d’extension qui comble cette lacune en donnant aux Pi l’accès à un ATMega328, mais c’est un système très complexe et solution coûteuse.

Une autre solution consisterait à interfacer un Arduino fonctionnant à 3,3 volts par rapport au Pi, bien que cela soit plus facile à dire qu’à faire. Mais, nous ne laisserons pas cela nous arrêter, n’est-ce pas ?

Vous pouvez acheter une version commerciale préconstruite de quelque chose de similaire à ce projet.
Cela s’appelle un AlaMode, et il coûte environ 50 dollars.
La construction de notre version coûtera environ un tiers de ce montant.

Dans un premier temps, nous construirons une carte enfichable Arduino pour le Pi. Il est d’usage d’appeler les cartes Pi “plaques”, mais permettez-moi de vous dire je vais nommer cette planche particulière un hoody.

Nous utiliserons un carton générique pour construire notre projet. Petit (3-3/4″) x 2-1/16″) peuvent être obtenues sur eBay pour un peu plus d’un dollar pièce. Il est également possible d’utiliser un protoboard de type Radio Shack 276-168 ($3.49). Le composant principal, cependant, est un Arduino Pro Mini de 3,3 volts.

Cela permettra de se connecter directement aux ports Pi de la framboise et à d’autres 3,3 volts sans avoir à effectuer de décalage de niveau.

De nombreux projets Pi impliquent la connexion de capteurs et de dispositifs directement sur les pins GPIO. Ce n’est pas une bonne idée. Utilisez des puces tampons, comme le tampon hexagonal 74HC4050, entre les appareils et le GPIO.
Cela protège le Pi contre les surtensions, les surtensions de courant et vos erreurs. Il vaut bien mieux faire sauter une puce de tampon à 50 cents qu’un Pi à 35 dollars.

Ce projet particulier se connecte directement aux broches Rx et Tx du GPIO.
Cependant, nous nous connectons à un dispositif de 3,3 volts, ce qui limite le risque.
Néanmoins, une puce tampon ne serait pas une mauvaise chose ici.

Il s’agit d’un projet modérément complexe, et les débutants n’ont pas besoin de s’appliquer.
Il nécessite des compétences en matière de soudure et d’utilisation d’outils à main. Expérience avec un testeur de continuité et une main ferme avec une lame de couteau sont également utiles.

Prêts ? Alors, allons-y !

Etape 1 : Matériel nécessaire

Composants : 

Les outils :

  • Fer à souder
  • les coupe-fils (Platon 170 ou similaire)
  • couteau tranchant (ou éventuellement un outil rotatif de type Dremel)
  • un testeur de continuité (de préférence) ou un multitester

Notes :

*** N’utilisez pas une prise 24 broches ordinaire. Les jambes de l’Arduino pro mini ne rentrera pas dans les trous. Mais vous pouvez remplacer deux bandes de 14 broches par des connecteurs femelles.

Oui, il est possible d’utiliser un mini-Arduino “normal” alimenté à 3,3 volts pour ce projet. Le Boarduino et l’Ardweeny en sont des exemples.

Sachez toutefois que la puce ATMega328 n’est pas conçue pour fonctionner à 16 MHz sous tension à 3,3 volts. Il s’agit donc d’un dépassement des spécifications, ou essentiellement d’un overclocking. J’ai fait quelques expériences avec ça, et au moins certaines, peut-être la plupart des ATMega328 peut être programmé et fonctionner à 3,3 v. Mais, bien sûr, votre mesure peut varier.

 

Étape 2 : Installation de l’en-tête GPIO

J’ai utilisé un stripboard pour construire l’interface de Raspberry Pi conseil d’administration. Le carton ondulé présente l’avantage d’une grande souplesse de conception — elle ne contraint pas la disposition des composants à une configuration particulière.

Il est également beaucoup moins cher que les proto-cartes à souder de taille équivalente.
Le principal inconvénient du stripboard est la nécessité d’une découpe importante de traces de cuivre sur la face soudée.

Il est conseillé d’avoir une idée préliminaire de la disposition avant de commencer.
Un schéma grossier sur une feuille de papier est utile.

J’ai monté le connecteur GPIO à 26 broches empilées (longues broches) près d’un bord du tableau, avec la partie femelle (plug-in) de l’en-tête sur le côté des traces de cuivre. L’astuce est que le collecteur ne doit pas être monté à fleur contre la planche, mais de s’écarter d’environ 1/4″ de hauteur afin de permettre en soudant les broches aux traces de cuivre. Mais, d’abord, nous devons couper treize rangées de traces où l’en-tête GPIO sera monté, de sorte que les

Les broches d’en-tête ne seront pas court-circuitées entre elles (voir les 2e et 3e illustrations).
Pour couper les traces, il faut faire des allers-retours avec une lame de couteau aiguisée avec une bonne dose de pression (attention !), puis vérification de suivi avec un testeur de continuité. C’est beaucoup de travail, et la prochaine fois que j’essaierai quelque chose comme ça, je vais probablement utiliser un outil Dremel avec un disque de coupe, plutôt qu’un couteau.

Une fois les treize traces coupées, montez soigneusement l’en-tête GPIO environ 1/4″ d’élévation. Cela donnera suffisamment de marge de manœuvre la pointe du fer à souder entre les broches pour les souder. Un couple de tampons de mastic de montage d’affiches tiennent l’en-tête en position avant la soudure. Soudez une extrémité de la broche, puis redressez soigneusement la tête de sorte qu’il soit perpendiculaire au conseil d’administration. Soudez les broches restantes, puis utiliser le testeur de continuité pour rechercher les courts-circuits entre les broches, des deux côtés et à travers. Un bon testeur de continuité avec indicateur sonore est surtout utile ici.

Après le soudage, les broches du collecteur dépassent de 1/4″ ou un peu plus sur la carte mère côté (non soudé). C’est pratique, car ils fonctionneront comme des postes à attacher des cordons de brassage et des cavaliers. Chaque poste sera une connexion électrique à la la broche GPIO correspondante en dessous lorsque la planche est montée sur le Pi.

 

Etape 3 : Installation de la prise Arduino

La carte d’interface a besoin d’un moyen de brancher un Arduino, et plus précisément un mini Arduino Pro de 3,3 volts. C’est là que le 24-pin La prise de courant à fil est arrivée. Pour une raison quelconque, le module Arduino Pro se branche sur une prise de courant à fil, mais les broches sont trop grosses pour une
prise à 24 broches. Heureusement, les prises à fil sont largement disponibles et pas trop cher.

Positionner la douille à environ un pouce de l’endroit où les deux rangées de poteaux de l’en-tête GPIO du côté du perfboard (voir les photos). Soudure la prise de courant au ras du tableau. Après la soudure, clipser les les broches affleurent sur le côté cuivre de la carte. Ensuite, coupez les lignes de traces de cuivre entre les deux rangées de broches soudées sur la prise, afin que les broches adjacentes ne se raccourcissent pas ensemble.

Dans la bande de tête femelle à 40 broches, coupez deux bandes à 12 broches. Sur le côté du panneau de distribution, placez une barrette de connexion femelle à 12 broches de chaque côté de la prise IC. Cela permettra de disposer de points d’enfichage pour les fils de connexion accéder aux broches Arduino. Fixez les bandes d’en-tête de manière à ce qu’elles soient verticales positionné par rapport au conseil d’administration. Maintenant, retournez la carte et soudez chaque rangée.

Il y a une sorte d’art à découper les sections de la bande de tête féminine.

Il n’y a pas d’encoches, comme pour la bande de tête masculine, de sorte que la partie coupée

Les bandes sortent généralement un peu déchiquetées, mais cela n’a guère d’importance. Le site

L’astuce consiste à couper au milieu d’un trou, et cela laissera soit une broche métallique suspendue, ou la broche tombera tout simplement. Elle gaspille un

Il faut faire un trou dans la bande à chaque fois que l’on coupe, mais il est impossible de l’éviter.

Il reste un morceau de bandeau femelle. Coupez un 8-pin s’en dépouiller. Vous devrez vous procurer la deuxième bande à 40 broches afin de être capable de couper la deuxième bande à 8 broches car une broche est toujours gaspillée dans le processus de découpage. Ces deux bandes constitueront une prise pour un un écran monochrome Nokia 5110 en option pour notre projet. Les deux lignes courts ensemble du côté de la soudure, de sorte que les fils de connexion peuvent être électriquement connecté aux broches de l’écran Nokia. Positionnez les bandes, puis retourner la planche et les souder. Enfin, coupez des rangées de traces de cuivre, afin que la prise Nokia soit électriquement isolée de tout le reste.

J’ai installé deux barrettes de prises “utilitaires” à deux rangées en périphérie de le conseil d’administration. La procédure d’installation et de soudure est la même que celle pour la prise Nokia. Le nombre réel de broches dans ces rangées de prises est arbitraire, mais ils sont utiles pour les bus électriques et terrestres, entre autres choses. Après la soudure, coupez des rangées appropriées de traces de cuivre pour isoler
ces bandes sont électriquement séparées du reste du tableau.

Étape 4 : Câblage : Première partie

Maintenant que le hoody de l’interface est construit, où allons-nous à partir de là ?

Nous devons encore brancher l’Arduino Pro et l’écran Nokia sur le prises que nous avons préparées.

Ensuite, nous ferons passer des fils de connexion et des cordons de raccordement de l’Arduino à l’affichage, et, dans l’étape suivante, de l’Arduino aux postes GPIO.

Si vous venez d’acheter un écran Nokia 5110, vous aurez besoin
de souder une rangée de connecteurs mâles aux 8 trous de soudure pour l’alimentation
et les lignes de date. Prenez note de la façon dont les trous sont étiquetés.

Malheureusement, les écrans du Nokia 5110 n’ont pas de brochage standard configuration. Elles ont toutes le même complément de broches, mais elles ne sont pas nécessairement dans la même position sur le tableau d’affichage connecteur. Même l’étiquetage des broches varie, bien qu’elles ont les fonctions standard.

Arduino     Nom de pin de l'écran Nokia     Code du Pin de l'écran Nokia 
(Numérique)

pin 7 - L'horloge de sortie série (SCLK)
pin 6 - Sortie des données série (DIN) (voir les étiquettes des pin sur l'écran)
pin 5 - Sélection de données/commande (D/C)
broche 4 - sélection de la puce LCD (CS)
broche 3 - réinitialisation de l'écran LCD (RST)

Vcc --> Nokia Vcc (3.3 v.)
Ground --> Nokia Ground
Vcc --> Rétro-éclairage Nokia

 

Si possible, utilisez des fils de raccordement de couleur différente pour chaque fonction, disons le rouge pour le Vcc, le noir pour le sol, et les couleurs appropriées pour le lignes de données. Il sera ainsi plus facile de retracer les connexions et de vérifiez votre travail. Travaillez lentement et méticuleusement, et faites particulièrement attention à ne pas faire d’erreurs avec le Vcc et les connexions de terre.

Notez que dans l’illustration, les deux broches d’extrémité de chaque bande de la prise Nokia ont des cavaliers de fil. C’est parce que j’ai utilisé des bandes à 10 broches, et l’écran Nokia n’utilise que 8 broches. Les trous de pontage sont bloqués pour empêcher leur utilisation.

Nous avons presque terminé la partie matérielle du projet, vous pouvez donc arrêter et prendre une tasse de café.

Étape 5 : Câblage : Partie 2

Il est temps de connecter les bornes GPIO avec les broches Arduino.
Nous utiliserons des cordons de raccordement de type “jumper” entre femmes et hommes.

Il n’y a que quatre, comptez-les, quatre connexions à faire.
Voici où se trouvent les deux rangées d’en-têtes femelles le long de la prise Arduino
à portée de main.

  1. Le Vcc (3.3v) de l’Arduino se connecte à la broche Vcc (3.3v) du GPIO : Broche #1.
  2. La masse de l’Arduino se connecte à la broche de masse du GPIO : Broche #6.
  3. TxD sur l’Arduino se connecte à la broche RxD du GPIO : Broche #10.
  4. RxD sur l’Arduino se connecte à la broche TxD du GPIO : Pin #8.

Notez que TxD se connecte à RxD, et vice-versa. La raison en est que le signal de sortie d’un appareil va au signal d’entrée de l’autre. C’est un peu déroutant au début, mais c’est assez logique quand on y pense.

Pour faciliter le repérage et le dépannage, utilisez un cavalier rouge pour Vcc et un le noir pour le sol, et deux autres couleurs pour TxD/RxD et RxD/TxD.

Vérifiez votre travail, et soyez particulièrement prudent avec le Vcc et la terre. Une erreur ici pourrait être coûteux.

Ouf ! Tout est fait avec le matériel ! Maintenant, passons au logiciel.

 

Étape 6 : Logiciels, première partie : Arduino envoie des données à Pi

Note préliminaire :

Ce travail, ainsi que les deux étapes suivantes, sont réalisés sur un Pi fonctionnant avec Fedora Remix 18
(Pidora). Je n’ai eu qu’un succès partiel avec Arch Linux, et aucune joie à tous avec Raspian ou Occidentalis, peut-être parce que ces distros s’attachent à /dev/ttyAMA0.

Nous ne sommes pas tout à fait prêts à brancher le hoody de l’interface sur le Pi.
Tout d’abord, chargeons un programme dans l’Arduino Pro qui dira pour diffuser des données sur son port série. Branchez un un câble sériel/tt to USB ou un tableau de distribution FTDI à l’angle droit à 6 broches en-tête de programmation. Branchez l’extrémité USB à votre ordinateur portable en exécutant l’EDI Arduino, et en téléchargeant le croquis suivant dans l’Arduino.

Ainsi, cela donnerait à Pi l’accès aux ports analogiques et aux dispositifs qui connectent à la même.

Il s’agit d’un simple croquis qui incrémente une variable et l’envoie à en série dans le cadre d’une chaîne “Line Number #”. Il s’affichera dans la fenêtre ou sur un xterm sur le minicom courant Pi (sudo yum install minicom si ce n’est pas déjà installé).

* ArduinoTalks.ino
 Arduino envoie un message au Raspberry Pi */

//#include <stdlib.h>
#define DELA 1200  // Temps entre les différents messages envoyés.
int cnt=0;


void setup() {
  Serial.begin(9600);

}

void loop() {
  Serial.print("Line Number # [");
  Serial.print(cnt);
  Serial.println("]");
  delay(DELA);
  cnt++;

}

 

Maintenant, nous sommes enfin prêts à brancher notre hoody d’interface sur le GPIO des Pi connecteur. Orientez soigneusement les broches de manière à ce que l’embase femelle de la broche 1 en GPIO Pin1, etc. Appuyez doucement et …

Note : Cette étape ne nécessite pas l’écran du Nokia 5110. Vous pouvez laisser il est branché si vous le souhaitez, ou bien vous pouvez l’enlever.

Très bien, branchez le Pi à l’alimentation et à un écran vidéo. Assurez-vous que la carte SD avec Pidora se trouve dans la fente de carte en dessous. Maintenant, démarrez-le et invoquer le minicom (sudo minicom -s) dans la console ou dans un xterm. Vous allez doivent régler minicom sur le port série /dev/ttyAMA0, car c’est à quoi sont accrochés les rx et tx. Le réglage par défaut de minicom est /dev/modem, afin que vous puissiez cd /dev et sudo ln -s ttyAMA0 modem. Et régler le débit en bauds à 9600, parce que c’est ce que le sketch régler la vitesse de transmission série Arduino sur.

Croisez les doigts. Pouvez-vous voir les données que l’Arduino envoie ?

Cela peut sembler trivial et de peu de valeur pratique, mais considérez ceci.
Supposons que l’Arduino reçoive des données d’un capteur connecté à une broche analogique. L’Arduino pourrait alors communiquer ces données directement au Pi par minicom. Et notez que le minicom peut sauvegarder les données envoyées dans un fichier journal.

 

Étape 7 : Logiciel, partie 2 : Pi envoi de données à l’Arduino (clignotement d’une LED)

Et maintenant, quelque chose de plus difficile. Demandons aux Pi de dire à la Arduino combien de fois doit on faire clignoter une LED. Nous utiliserons le système embarqué de l’Arduino LED à D13 pour la simplicité, bien qu’il soit certainement possible de changer le LedPin variable dans le croquis, et branchez une LED-plus-résistance extérieure entre la broche numérique appropriée et la terre.

Le “pilote” est un court script shell. C’est exact, un simple script Bash.

En fait, il est même possible de le faire directement à partir de la ligne de commande dans la console ou dans un xterm : echo 3 > /dev/ttyAMA0 pour trois clignotements, pour par exemple, ou l’écho 7 > /dev/ttyAMA0 pour sept clignotements. Pas de programmation en Python et pas de bibliothèques à installer !

=== Rappelons que /dev/ttyAMA0 est le port série de Pi. ===

Il est nécessaire d’effectuer une session minicom afin d’initialiser le /dev/ttyAMA0 port série. Ensuite, Control-A Q pour sortir de la minicom sans la réinitialisation du port série. Notez qu’il est également possible d’envoyer des clignotements commandes directement depuis le minicom — en tapant un 5 dans le minicom clignote 5 fois la LED de l’Arduino, et ce n’est même pas nécessaire pour créer un écho local. L’Arduino reçoit tout ce qui est envoyé à /dev/ttyAMA0 sur son port série matériel (Rx et Tx), et il peut interpréter ce qui lui arrive si elle est programmée par un sketch approprié. Vous voyez, les amis, si vous utilisez le Arduino en tant qu’intermédiaire, vous n’avez pas besoin de jouer avec Python ou les bibliothèques.

En résumé : Lancez une session minicom pour initialiser /dev/ttyAMA0, puis Contrôlez A Q pour sortir. Et notez que l’Arduino doit avoir les caractéristiques suivantes croquis chargé. Puis finalement, lancez le script Bash ci-dessous depuis la console ou un xterm.

Voici le sketch d’Arduino :

/*
  ArduinoListens.ino

  Pi sends a digit (1 - 9) to Arduino,
  and Arduino blinks LED at D13 that many times.
*/

#define DELA 500   // Long delay.
#define DSHORT 250 // Short delay.
const int ledPin = 13;

void setup() {               
  pinMode(ledPin, OUTPUT); // Initialize pin as output.
  // Pin 13 has an LED hooked to it.
  Serial.begin(9600); 
}

void loop() {
   if ( Serial.available() )
   { light(Serial.read() - '0'); } // How many positions past ASCII 0?
   delay (DELA);
}


void light(int n) {
  for (int i = 0; i < n; i++)
  {
  digitalWrite(ledPin, HIGH);   // Turn the LED on.
  delay(DSHORT);       
  digitalWrite(ledPin, LOW);   // Turn the LED off.
  delay(DSHORT);               // Wait.
  }
}

 

Et voici le script Bash  :

#!/bin/bash
# Accepts command-line arg telling Arduino how many times to blink
#+ (0 - 9).

DEFAULT=1          # One blink if no command-line arg.

if [ -z "$1" ]     # If no command-line arg ...
then
  blinks=$DEFAULT
else
  blinks=$1
fi

port=/dev/ttyAMA0  # Direct connection to Pi rx and dx pins.

echo $blinks > $port

exit $?

# TODO:
# ----
# 1) Error checking on command-line input.
# 2) More than 9 blinks by parsing multi-character command-line arg.

 

Étape 8 : Logiciel, partie 3 : Adresse IP Pi sur l’écran Nokia

En guise de grande finale, le Pi enverra son adresse IP à l’écran de Nokia 5110. Il faudra que l’écran soit branché sur son câble prise de courant. En outre, le Pi nécessitera un adaptateur sans fil branché sur un port USB et les procédures appropriées prises pour que le Pi se connecte à le réseau local. Et, bien sûr, l’Arduino doit avoir le croquis sous chargé.

Démarrez le Pi avec l’équipement nécessaire branché. Après le démarrage, d’organiser une session minicom comme à l’étape précédente, pour initialiser le port série de Pi. Enfin, exécutez le script Bash plus bas dans cette étape.

Voici le sketch d’Arduino :

/* Affichage du Nokia PCD8544, Données du port série entrée. */
/* Dans ce cas particulier, l'adresse IP. */
/* Exécute un script shell qui analyse et envoie l'adresse IP à /dev/ttyUSB0. */

#include <stdio.h>


#include "PCD8544.h"
/* Digital pins. */
// pin 7 - Serial clock out (SCLK)
// pin 6 - Serial data out (DIN)
// pin 5 - Data/Command select (D/C)
// pin 4 - LCD chip select (CS)
// pin 3 - LCD reset (RST)
PCD8544 nokia = PCD8544(7, 6, 5, 4, 3);

#define INTERVAL 500
#define BUFFSIZE 80 // Serial buffer.

char line1[40]="IP Address:"; // Header.
int DELAY=4000; // Interval between updates of display.


void setup(void) {

  nokia.init();
  nokia.command(PCD8544_DISPLAYCONTROL | PCD8544_DISPLAYNORMAL);
  Serial.begin(9600);   // Start The Serial UART at 9600 Baud.

  nokia.clear();
  nokia.drawstring(0, 0, line1);
  nokia.display();
}

void loop(void)
{

  char serialdata[BUFFSIZE+3];
  int lf = 10;


  Serial.readBytesUntil(lf, serialdata, BUFFSIZE);


  nokia.drawstring(0, 1, serialdata);

  nokia.display();

// delay(INTERVAL);
}

 

Et le script bash :

#!/bin/bash
# inet.addr.sh
#  Echo the Pi's IP address to a serial port . . .
#+ . . . to which we happen to have attached an Arduino.
#  Run this script after Aduino is powered up with appropriate sketch
#+ (NokiaSerial.ino).

command=ifconfig
addr_hdr="addr:"
addr_prefix="inet 192"      # For Pidora. May change for other distro!
serial_port=/dev/ttyAMA0    # Direct connection to Pi rx and dx.

# ifconfig | grep "inet 192" | awk '{print $2}' | sed s/addr://
ipaddr=$(${command}| grep "$addr_prefix" |
awk '{print $2}' | sed s/$addr_hdr//)

echo $ipaddr > "$serial_port"   # Not necessary to put in loop or repeat.
# echo $ipaddr   # Debug.

exit $?

 

Voyez-vous l’adresse IP de Pi sur ce petit écran Nokia ? Incroyable, n’est-ce pas ?

Cette application particulière est pratique si vous configurez le Pi comme un serveur sans tête.
Après le démarrage du Pi, il affiche son adresse IP sur le réseau, et cela indique que tout fonctionne bien. Cela permet également de faciliter pour effectuer une connexion à distance à partir d’un autre ordinateur. Comme exercice, vous pouvez modifier le script Bash pour afficher en plus quelque chose sur l’état de Pi sur les autres lignes disponibles de l’écran Nokia, telles que l’espace libre sur la carte SD (commande df).

 

Étape 9 : Que faire à partir de là ?

Maintenant que nous savons comment interfacer le Pi avec un Arduino, il s’ouvre un certain nombre de possibilités.

Connecter un module GPS à l’Arduino, et utiliser le Pi comme frontal pour analyser et afficher les données, et peut-être indiquer l’emplacement sur Google maps.

Connectez un compteur Geiger à l’Arduino et utilisez le Pi comme frontal pour représenter les données sous forme de graphique.

Branchez l’Arduino pour contrôler une caméra de sécurité à distance sur IP, et avoir l’affichage Pi et enregistrer ce que la caméra voit.

Contrôlez un servomoteur ou un moteur pas à pas.

 

Article traduit de l’anglais. Original : https://www.instructables.com/id/The-Raspberry-Pi-Arduino-Connection/

Partager

A propos de l'auteur

Laissez-nous un commentaire !