Archives de catégorie : Électronique

Mémo personnel d’électronique

Électronique

Un mémo personnel d’électronique pour grand débutant. Avec des notions, et quelques exemples en électroniques. Aussi je passe en revu l’environnement de l’Arduino et des microcontrôleurs, mais aussi ce qui tourne autour du Raspberry Pi.

Capteur 1-Wire DS18B20 ou DS18B20+PAR

Mesurer une température avec un capteur 1-Wire DS18B20-PAR ou DS18B20

 

L’avantage « -PAR » du DS18B20+PAR

Lorsque vous utilisez les capteurs de température DS18B20, DS18S20 et DS1822 1-Wire en mode parasite, la broche VDD doit être connectée à la masse (GND) pour un fonctionnement correct. Dans les applications où les capteurs sont directement connectés à une carte de circuit imprimé, la connexion de la broche VDD à GND est simple. Cependant, dans les applications où le capteur de température est situé à un emplacement distant à partir du circuit de commande (par exemple, dans une sonde de température), cette connexion peut présenter des difficultés mécaniques. Dans ce cas, il existe deux façons de réaliser la connexion requise: exécutez trois fils sur le capteur de température et connectez le fil VDD à GND sur la carte de circuit imprimé (voir Figure 1) ou connectez la broche VDD à la broche GND du périphérique ( Voir la figure 2).

Malheureusement, la première approche ajoute des dépenses en exigeant un fil pour la connexion VDD, ce qui est particulièrement préoccupant si les fils doivent s’étendre sur de longues distances et la deuxième approche est une solution mécaniquement difficile.

DS18B20 sur PCB
Figure 1. Capteur de température à 1 fil avec broche VDD branché à GND au PCB.
DS18B20 local
Figure 2. Capteur de température 1 fil avec broche VDD localement connecté à GND.

 

Le DS18B20+PAR pour résoudre le problème

Pour résoudre ce problème, Dallas a créé le DS18B20-PAR, DS18S20-PAR et DS1822-PAR. Ces périphériques sont identiques aux DS18B20, DS18S20 et DS1822 sauf que VDD est connecté en interne à GND (voir Figure 3). Par conséquent, les trois périphériques -PAR facilitent la mise en œuvre d’un fonctionnement par parasite à distance avec un minimum de câblage ou de connexions (voir Figure 4).

DS18B20-PAR Fig01
Figure 3. Vue en coupe du capteur de température -PAR.
DS18B20-PAR Fig02
Figure 4. DS18B20-PAR configuration de câblage.

 

Notez qu’en raison de l’augmentation du courant de fuite des broches DQ à haute température, les DS18B20-PAR, DS18S20-PAR et DS1822-PAR ont une température de fonctionnement maximale de + 100 ° C. Il en va de même pour DS18B20, DS18S20 et DS1822 lorsqu’il est utilisé en mode parasite.

Traduction de source : https://www.maximintegrated.com/en/app-notes/index.mvp/id/203

Câblage DS18B20-PAR avec Arduino UNO

 

DS18B20-PAR câblage avec Arduino Uno
DS18B20-PAR câblage avec Arduino Uno

 

Le code qui suit, n’est pas optimisé pour l’utilisation du DS18B20-PAR dans un projet, il a cependant l’avantage d’être très bien documenté et vous permet de tout connaitre de votre composant électronique.

 

// --- Programme Arduino ---
// Copyright X. HINAULT - Créé le 10/04/2010
// www.mon-club-elec.fr 

//  Code sous licence GNU GPL : 
//  This program is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License,
//  or any later version.
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//  You should have received a copy of the GNU General Public License
//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
//  

// --- Que fait ce programme ? ---
/* test simple de la mesure de la température à l'aide d'un capteur
de température One-wire de type DS18B20 et affichage du résultat
dans la fenêtre Terminal série.  */

// --- Fonctionnalités utilisées ---
// Utilise la connexion série vers le PC 
// Utilise un ou plusieurs capteurs One Wire 

// --- Circuit à réaliser ---
// Connexion série entre la carte Arduino et le PC (utilise les broches 0 et 1)  
// Connecter  sur la broche 2 la broche de données du capteur One Wire

//**************** Entête déclarative *******
// A ce niveau sont déclarées les librairies, les constantes, les variables...

// --- Inclusion des librairies utilisées ---

#include <OneWire.h> // librairie pour capteur OneWire

// --- Déclaration des constantes ---

// --- constantes des broches ---

const int broche_OneWire=2; //declaration constante de broche 

//---- code d'instruction du capteur
const int modeLecture=0xBE;
const int lancerMesure=0x44;

// --- Déclaration des variables globales ---
byte data[12]; // Tableau de 12 octets pour lecture des 9 registres de RAM et des 3 registres d'EEPROM du capteur One Wire
byte adresse[8]; // Tableau de 8 octets pour stockage du code d'adresse 64 bits du composant One Wire

int tempet=0; // variable pour resultat de la mesure
float tempetf=0.0; // variable pour resultat de la mesure

// --- Déclaration des objets utiles pour les fonctionnalités utilisées ---
OneWire  capteur(broche_OneWire);  // crée un objet One Wire sur la broche voulue


//**************** FONCTION SETUP = Code d'initialisation *****
// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme

void setup()   { // debut de la fonction setup()

// --- ici instructions à exécuter au démarrage --- 

Serial.begin(115200); // initialise connexion série à 115200 bauds
// IMPORTANT : régler le terminal côté PC avec la même valeur de transmission 


// XXXXXXXXXXXXXXXXXXXXXX Détection du capteur présent sur la broche XXXXXXXXXXXXXXXXXXXXXXX 
Serial.println("**** Detection du capteur **** "); 

while (capteur.search(adresse)== false) // tant qu'aucun nouveau capteur est détecté
{

  // la fonction search renvoie la valeur FAUX si aucun élément 1-wire est trouvé. 

  Serial.println("Aucun capteur 1-wire present sur la broche ! "); // affiche message + saut de ligne
  delay (1000); // pause 1 seconde
}

//la suite est exécutée seulement si un capteur est détecté

  // la fonction search renvoie la valeur VRAI si un élément 1-wire est trouvé. 
  // Stocke son code d'adresse 16 bits dans le tableau adresse[8]
  // adresse envoyé à la fonction correspond à l'adresse de début du tableau adresse[8] déclaré ...   

  Serial.print ("1 capteur 1-wire present avec code adresse 64 bits : ");


  //--- affichage des 64 bits d'adresse au format hexadécimal
   for(int i = 0; i < 8; i++) { // l'adresse renvoyée par la fonction search est stockée sur 8 octets

    if (adresse[i]<16) Serial.print('0'); // pour affichage des O poids fort au format hexadécimal
    Serial.print(adresse[i], HEX); // affiche 1 à 1 les 8 octets du tableau adresse au format hexadécimal
    Serial.print(" ");
  }

  Serial.println(); 

  //---- test du type de capteur ---- 
  // le type du capteur est donné par le 1er octet du code adresse 64 bits
  // Valeur 0x28 pour capteur type DS18B20, 0x10 pour type DS18S20, 0x22 pour type DS1820
  if (adresse[0]==0x28) 
  { 
    Serial.println ("Type du capteur present : Capteur temperature DS18B20.");
  }
  else
  {
    Serial.println ("Le capteur present n'est pas un capteur de temperature DS18B20.");
  }


  //----- contrôle du code CRC ----
  // le dernier octet de l'adresse 64bits est un code de contrôle CRC 
  // à l'aide de la fonction crc8 on peut vérifier si ce code est valide
  if (capteur.crc8( adresse, 7) == adresse[7]) // vérification validité code CRC de l'adresse 64 bits
  // le code CRC de l'adresse 64 bits est le 8ème octet de l'adresse (index 7 du tableau)
  {
    Serial.println ("Verification du code CRC de l'adresse 64 bits de ce capteur : VALIDE !"); 
  }
  else
  {
    Serial.println ("Verification du code CRC de l'adresse 64 bits de ce capteur : NON VALIDE !");     
  }

  //------- message final détection ---- 
  Serial.println("----- fin de la recherche du capteur ----"); 
  Serial.println(""); 

  //--- la phase de détection n'est pas obligatoire avec un seul capteur ---
  //---- il est possible d'utiliser uniquement la fonction skip --- 
  //---- le résultat semble plus hasardeux cependant... 
  // capteur.skip(); 

  // une fois le capteur détecté, son code adresse 64 bits est stocké dans le tableau adresse[8]
  // on va à présent adresser des instructions au capteur et lire le résultat obtenu
  // successivement il faudra : 
  //    * envoyer l'instruction de lancement de la mesure
  //    * attendre 1 seconde 
  //    * envoyer l'instruction de lecture du résultat
  //    * envoyer les instructions de lecture



} // fin de la fonction setup()
// ********************************************************************************

//*************** FONCTION LOOP = Boucle sans fin = coeur du programme *************
// la fonction loop() s'exécute sans fin en boucle aussi longtemps que l'Arduino est sous tension

void loop(){ // debut de la fonction loop()

// XXXXXXXXXXXXXXXXXXXXXX Lancement d'une mesure et lecture du résultat XXXXXXXXXXXXXXXXXXXXXXX 

  Serial.println("**** Acquisition d'une mesure de la temperature **** "); 

  // avant chaque nouvelle instruction, il faut : 
  //    * initialiser le bus 1-wire
  //    * sélectionner le capteur détecté
  //    * envoyer l'instruction 

//--------- lancer une mesure --------
  capteur.reset(); // initialise le bus 1-wire avant la communication avec un capteur donné
  capteur.select(adresse); // sélectionne le capteur ayant l'adresse 64 bits contenue dans le tableau envoyé à la fonction
  capteur.write(lancerMesure,1); // lance la mesure et alimente le capteur par la broche de donnée

//-------- pause d'une seconde ----- 
delay(1000);     // au moins 750 ms
           // il faudrait mettre une instruction capteur.depower ici, mais le reset va le faire


//---------- passer en mode LECTURE ------------- 
  capteur.reset(); // initialise le bus 1-wire avant la communication avec un capteur donné
  capteur.select(adresse); // sélectionne le capteur ayant l'adresse 64 bits contenue dans le tableau envoyé à la fonction
  capteur.write(modeLecture,1); // passe en mode lecture de la RAM du capteur

// ----------- lire les 9 octets de la RAM (appelé Scratchpad) ----

for ( int i = 0; i < 9; i++) {           // 9 octets de RAM stockés dans 9 octets
    data[i] = capteur.read();             // lecture de l'octet de rang i stocké dans tableau data
  }

// ----- affichage du contenu des différents octets ----------- 
Serial.println("");
Serial.println("---- lecture de la RAM du capteur ---- ");
Serial.print("Octet 0 (Resultat poids faible)="), Serial.println(data[0],BIN);
Serial.print("Octet 1 (Resultat poids fort)="), Serial.println(data[1],BIN);
Serial.print("Octet 2 (Alarme haute)="), Serial.println(data[2],BIN);
Serial.print("Octet 3 (Alarme basse)="), Serial.println(data[3],BIN);
Serial.print("Octet 4 (Registre de configuration)="), Serial.println(data[4],BIN);
Serial.print("Octet 5 (Reserve)="), Serial.println(data[5],BIN);
Serial.print("Octet 6 (Reserve)="), Serial.println(data[6],BIN);
Serial.print("Octet 7 (Reserve)="), Serial.println(data[7],BIN);
Serial.print("Octet 8 (code CRC mesure)="), Serial.println(data[8],BIN);


//----- test de validité des valeurs reçues par contrôle du code CRC  ----

Serial.println("");
Serial.println("---- test de controle de validite des donnees recues ---- ");

  // le dernier (9ème) octet de la RAM est un code de contrôle CRC 
  // à l'aide de la fonction crc8 on peut vérifier si ce code est valide
  if (capteur.crc8( data, 8) == data[8]) // vérification validité code CRC des valeurs reçues
  {
    Serial.println ("Verification du code CRC de ce resultat : VALIDE !"); 
  }
  else
  {
    Serial.println ("Verification du code CRC de ce resultat  : NON VALIDE !");     
  }

//----- caclul de la température mesurée (enfin!) ---------
Serial.println("");
Serial.println("---- calcul de la temperature ---- ");

//---- extraction du résultat de la mesure à partir des registres de la RAM ---
data[1]=data[1] & B10000111; // met à 0 les bits de signes inutiles
tempet=data[1]; // bits de poids fort
tempet=tempet<<8; 
tempet=tempet+data[0]; // bits de poids faible

Serial.print ("Mesure brute ="); 
Serial.println (tempet); 

// --- en mode 12 bits, la résolution est de 0.0625°C - cf datasheet DS18B20
tempetf=float(tempet)*6.25;
tempetf=tempetf/100.0;

Serial.print ("Mesure Finale ="); 
Serial.print (tempetf,2); 
Serial.println (" Degres Celsius. "); 


//while(1); // stoppe loop

} // fin de la fonction loop() - le programme recommence au début de la fonction loop sans fin
// ********************************************************************************

//*************** Autres Fonctions du programme *************

// --- Fin programme ---

 

 

 

Écran OLED 0,91 pouce 128×32 IIC I2C SSD1306 Pilote IC DC 3.3 V 5 V

Écran OLED de 0,91 pouce 128×32 IIC I2C SSD1306 Pilote IC DC 3.3 V 5 V

J’ai acheter un petit Écran SSD1306 OLED IIC I2C, pas d’idée précise lors de l’achat, mais à la réception, au vu de la taille de l’écran, il peux être embarqué directement dans les sondes d’humidités de la terre.

Écran OLED 0,91 Pouce 128x32 IIC I2C SSD1306 DC 3.3 V 5 V
Écran OLED 0,91 Pouce 128×32 IIC I2C SSD1306 DC 3.3 V 5 V
Écran OLED 0,91 Pouce 128x32 IIC I2C SSD1306 DC 3.3 V 5 V
Écran OLED 0,91 Pouce 128×32 IIC I2C SSD1306 DC 3.3 V 5 V

 

ÉCRAN OLED, auto-éclairage, et faible consommation.
Driver IC : SSD1306
taille : 0.91 pouce OLED
résolution : 128×32
IIC interface
affichage Couleur : Bleu
Description des Pins :
GND : Ground
VCC : Puissance + (DC 3.3 ~ 5 v)
SCL : Horloge Ligne
SDA : Ligne de Données
Idées :
petit affichage embarqué pour les sondes TIC-TAC de mon projet.

L293D pour commander des moteurs

L293D pour commander des moteurs

L’ouverture des portes en fonction de la température et/ou humidité ambiante de la serre, trop chaud, trop humide, on ouvre une porte !

Caractéristiques techniques du L293D

Voici les caractéristiques techniques du composant L293D :

  • Nombre de pont-H: 2
  • Type de moteur C. c. à balais
  • Configuration de sortie Pont complet double
  • Courant Collecteur IGBT maximum 0.6A
  • Courant Max Régime continu: 600mA (x2))
  • Courant de pointeMax < 2ms: 1200mA
  • Tension d’alimentation fonctionnement maximum 36 V
  • Tension Collecteur Emetteur maximum 36 V
  • Tension d’alimentation de fonctionnement minimum 4,5 V
  • VS Max Alim moteur: 36v
  • Nbre de Broches: 16 DIP
  • Perte de tension: 1.3v
  • Dimensions 20 x 7.1 x 5.1mm
  • Longueur 20mm
  • Hauteur 5.1mm
  • Largeur 7.1mm
  • Température d’utilisation maximum +150 °C
  • Température de fonctionnement minimum -40 °C
  • Type de montage Traversant

L293D Le brochage du composant

Voici les différentes broches du composant L293D :

pins_diagram_l293d

 

 

 

 

 

 

J’ai commandé ça :
5 Pcs L293D L293 Push-Pull Quatre Canaux Motor Driver IC

 

Points forts

  • STMicroelectronics L293D
  • Type de boîtier (semi-conducteur): PowerDIP-16
  • Conditionnement: 1 pc(s)

Description

Conçu idéalement pour commandes à moteur (moteurs pas à pas), commande relais et moteurs DC. L’activation se fait par des signaux standard DTL ou TTL jusqu’à 5 kHz. Les entrées Enable séparées les unes des autres sont facilement utilisables comme double circuit d’attaque en pont.

Caractéristiques techniques

  • Protection contre la surchauffe intégrée, diodes de verrouillage internes
Référence L293D
Type de boîtier (semi-conducteur) PowerDIP-16
Fabricant STMicroelectronics
Fab. STM
Catégorie PMIC – Contrôleur, variateur moteur
Fonctions (PMIC) Variateur – entièrement intégré, Commande et étage de puissance
Configuration de sortie Demi-pont (4)
Interface Parallèle
Applications Usage général
Technologie (PMIC) Darlington de puissance
Courant – Sortie 600 mA
Type de moteur – moteur pas à pas bipolaire
Type de moteur AC/DC DC avec balai
Tension de charge (min.) 4.5 V
Tension de charge (max.) 36 V
Tension d’alim. min. 4.5 V
Tension d’alim. max. 36 V
Température de fonctionnement (min.) -40 °C
Température de fonctionnement (max.) +150 °C
Type de montage trou traversant
Données techniques complémentaires Protection contre la surchauffe intégrée, diodes de verrouillage internes

 

USBasp le programmateur AVR

L’USBASP est un programmateur pour les microcontrôleurs AVR

USBaps

USBasp

A quoi ça sert ?

A programmer un microcontrôleurs Atmel, sans avoir besoin de convertisseur série/USB, sans besoin de bootloader, sans Arduino.
Avec un USBASP, on peut donc :

  • Programmer directement un attiny85 ou un Atmega328 sur une platine d’essai, sans avoir besoin d’un Arduino
  • Graver un booloader sur un circuit vierge
  • Réparer un Arduino « Briqué » qui a perdu son booloader
  • Modifier les « fusibles » d’un processeur (par exemple pour utiliser la broche reset d’un attiny85 comme E/S)

Une fois les drivers installé, c’est transparent. inutile d’indiquer un port COM pour téléverser, L’IDE Arduino reconnait le programmateur.

Coté coût, on fait difficilement mieux: des clones chinois se trouvent pour moins de 2€, port compris. voir chez AliExpress j’en parle ici.

Vu les services que ça rend, dommage de s’en passer.

Il y a quoi dedans ?

Coté matériel : Un microcontrôleur Atmega8, un quartz de 12Mhz, 2 leds, une interface d’adaptation aux niveaux USB, des jumpers…

Coté logiciel, un firmware basé sur V-USB, une librairie qui émule du USB en soft.

L’installation ?

Sous Linux et Os/X, besoin de rien.
Sous Windows, on installe les drivers et ça marche.
A noter une petite manip pour les Windows 8, il faut désactiver la vérification des signatures pour installer le driver, c’est pénible mais ça se fait (tuto anglais).

Sinon la version signée pour Windows 8 et 8.1 ici : http://www.protostack.com/accessories/usbasp-avr-programmer

 

Ensuite dans l’IDE Arduino, on sélectionne USB ASP comme programmateur, et on upload via « télécharger avec un programmateur »

ça programme quoi ?

Une liste, pas forcément exhaustive :
Mega Series
ATmega8 ATmega8A ATmega48 ATmega48A ATmega48P
ATmega48PA ATmega88 ATmega88A ATmega88P ATmega88PA
ATmega168 ATmega168A ATmega168P ATmega168PA ATmega328
ATmega328P ATmega103 ATmega128 ATmega128P ATmega1280
ATmega1281 ATmega16 ATmega16A ATmega161 ATmega162
ATmega163 ATmega164 ATmega164A ATmega164P ATmega164PA
ATmega169 ATmega169A ATmega169P ATmega169PA ATmega2560
ATmega2561 ATmega32 ATmega32A ATmega324 ATmega324A
ATmega324P ATmega324PA ATmega329 ATmega329A ATmega329P
ATmega329PA ATmega3290 ATmega3290A ATmega3290P ATmega64
ATmega64A ATmega640 ATmega644 ATmega644A ATmega644P
ATmega644PA ATmega649 ATmega649A ATmega649P ATmega6490
ATmega6490A ATmega6490P ATmega8515 ATmega8535
Tiny Series
ATtiny12 ATtiny13 ATtiny13A ATtiny15 ATtiny25
ATtiny26 ATtiny45 ATtiny85 ATtiny2313 ATtiny2313A
Classic Series
AT90S1200 AT90S2313 AT90S2333 AT90S2343 AT90S4414
AT90S4433 AT90S4434 AT90S8515
AT90S8535
CAN Series
AT90CAN128
PWM Series
AT90PWM2 AT90PWM3

A noter que si on veut rester sous L’IDE Arduino, il existe des définitions à ajouter pour pouvoir ajouter le support d’autres processeurs à l’IDE.
Ainsi, on peut développer et programmer, via l’IDE Arduino, des attiny25, 45 et 85, des atmega8, atmega1280… en plus du classique atmega328.

A savoir :

Le connecteur du « stick » USBASP est un 2×5 broches.
Pour la plupart des Arduino, il faut un 2×3 broches, avec juste le nécessaire.

Des adaptateurs existent, c’est plus simple que de brancher les fils un à un, au risque de se tromper.

 

adaptateur_USBASP

Notez aussi le détrompeur (le petit triangle blanc) qui indique la broche N°1

 

USBaps

 

Voici le brochage:

brochage-usbasp

Autre source d’informations, notamment pour les fusibles : http://www.chicoree.fr/w/Le_programmateur_AVR_le_moins_cher_du_monde

DS3231 Raspberry Pi RTC : ajouter une horloge temps réel I2C

Le bus I2C est opérationnel via le billet ici.

Nous allons ajouter une horloge temps réel I2C sur le Raspberry Pi : Raspberry Pi RTC
Raspberry Pi RTC

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

Utilisation du module

Notre module est détecté, et utilisable. Cependant, nous ne savons pas encore ce qu’il « raconte ». Nous chercherons donc à communiquer avec le module.

Si tout ce que nous avons fait avant a bien fonctionné, nous pouvons alors exécuter la commande suivante :

  
echo ds3231 0x68 | sudo tee /sys/class/i2c-adapter/i2c-1/new_device

 

Cette commande doit « notifier » au système la présence du composant. Dès lors il est possible de consulter l’heure et la date contenue dans le module en faisant un :

# hwclock

 

Cela devrait dès lors afficher une date et une heure. Si vous n’avez jamais utilisé le module, celle ci sera probablement incorrecte. On pourra alors la régler.

 

Définir la date du système depuis internet et l’enregistrer dans le DS3231

Avant tout assurons nous que les données du système sont correctes, en vérifiant la « timezone » (fuseau horaire) :

# dpkg-reconfigure tzdata

Choisissez bien le bon continent et la bonne zone, dans mon cas Europe puis Paris. Vous pouvez vérifier la date et l’heure du système via la commande  date. Lorsque celle ci est définie correctement, vous pourrez alors écrire la valeur actuelle du système en utilisant la commande suivante :

# hwclock -w

Raspberry Pi RTC est maintenant OK

 

 

 

I2C Raspberry Pi

Le bus I2C (ou I²C), pour Inter Integrated Circuit, a été développé en 1982 par Philips 1) et permet de connecter divers équipements électroniques entre eux. Il dispose d’un système d’adressage permettant de connecter de nombreux périphériques I2C sur les mêmes câbles, ce qui signifie ici que l’on utilisera un nombre restreint de GPIO, quel que soit le nombre de périphériques I2C installés. Dans le contexte du Raspberry Pi, ce bus est très utile, puisqu’il permet de rajouter diverses fonctionnalités. On trouvera par exemple des puces pour ajouter des GPIO, des horloges temps réel, des capteurs, et bien d’autres composants en I2C. Par défaut, l’I2C n’est pas forcément activé (Raspberry Pi), et nous verrons comment faire cela.

Vérifier que le système est à jour

Avant toute chose, nous vérifierons que le système est à jour, en utilisant les commandes suivantes :

# apt-get update
# apt-get upgrade

Installation des outils I2C

Nous allons maintenant installer des outils qui nous permettront de vérifier le bon fonctionnement de nos périphériques I2C, via les commandes suivantes :

# apt-get install python-smbus
# apt-get install i2c-tools

Installation du module noyau I2C

Par défaut, le support de l’I2C n’est pas activé dans le noyau linux  de Raspbian. Pour pouvoir le faire, nous allons utiliser l’utilitaire raspi-config, que l’on lancera en tapant la commande suivante :

# raspi-config

raspi-config

raspi-config_i2c

Essayer le bus I2C

Une fois que le Raspberry pi aura redémarré, il sera alors possible d’utiliser les outils installés pour regarder ce qui est connecté sur le bus I2C. Sur les anciens Raspberry Pi (les vieux modèles B,en révision 1), le bus I2C est 0. Les nouveaux modèles B, ainsi que les A+, B+ et les Raspberry Pi 2 B ont un bus I2C en 1. Ainsi nous utiliserons la commande suivante pour visualiser les périphériques I2C connectés :

sudo i2cdetect -y 1

ou selon le cas

sudo i2cdetect -y 0

 

root@raspberrypi:/home/pi# i2cdetect -y 1
     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
00:          -- -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --
root@raspberrypi:/home/pi#

On constate que rien n’est connecté sur le bus I2C, mais il est fonctionnel.

 

 

 

Clone Arduino – Test d’une carte Made In China

Clone Arduino

Pour jouer en déplacement, sans risquer d’endommager ma carte Uno, j’ai acheté sur AliExpress (j’en parle ici) une copie de la carte Arduino. A 5 euros le kit, c’est presque du jetable.kit clone Arduino

Installation de l’IDE sur mon portable (Linux)

Vérification avec l’exemple blink

Le croquis utilise 928 octets (2%) de l’espace de stockage de programmes. Le maximum est de 32256 octets.Les variables globales utilisent 9 octets (0%) de mémoire dynamique, ce qui laisse 2039 octets pour les variables locales. Le maximum est de 2048 octets.

avrdude: ser_open(): can’t open device « /dev/ttyUSB0 »: Permission denied
Problème de téléversement vers la carte. Voir http://www.arduino.cc/en/Guide/Troubleshooting#upload pour suggestions.

Pensez à cocher le port /dev/tty/USB0

 

Utilisation sous Windows 7 64 bits

Sous Windows la carte n’est pas reconnue automatiquement, il vous manque des drivers USB-SERIAL.

Téléchargez les drivers ici :
ch341ser drivers Windows

Après l’installation le driver est actif sous Windows 7.

USB-SERIAL_CH340 driver Windows

Résolution de problèmes sur clone Arduino

Il se peut que le bootloader de l’ATmega ne soit pas installé. J’ai eu le cas c’est pourquoi je vous en parle. Lors du téléversement le message d’erreur :

avrdude: skt500_recv(): programmer is not responding

ou

avrdude: skt500_getsync() attempt X of 10: not in sync: resp=0xXX

Pour cela il vous suffit d’avoir :

  • un Arduino fonctionnel
  • un condensateur de 10µF
  • 6 fils
  • votre clone Arduino Uno KO
  1. Branchez votre Arduino fonctionnel (OK) à votre ordinateur. Téléverser le programme que vous trouverez dans Fichier > Exemples > ArduinoISP (ne fonctionne pas si vous avez déjà placé le condensateur, pensez à l’enlever).
  2. arduinoispDéconnectez l’Arduino de l’ordinateur.
  3. Réalisez le montage suivant :

fix_clone_arduino

 

Arduino fonctionnel Arduino clone non fonctionnel
Pin 10 RESET
Pin 11 Pin 11
Pin 12 Pin 12
Pin 13 Pin 13
5V 5V
GND GND

4. Rebranchez l’Arduino qui est OK à votre ordinateur à l’aide du câble USB. Ouvrez un simple programme blink par exemple. Allez dans
Outils > Type de carte et sélectionnez la carte que vous voulez « réparez ». Ici dans mon cas Arduino Uno.

5. Dans Outils > Programmeur , cliquez sur Arduino as ISP

6. Allez dans Outils et cliquez sur Graver la séquence d’initialisation, attendez de bien avoir le message
« Gravure de la séquence d’initialisation terminée ».

Voilà, votre Arduino devrait maintenant fonctionner ! Vous pouvez le vérifier en téléversant le programme de votre choix.

Un émulateur Raspberry Pi en ligne !

Raspberry Pi en ligne via un émulateur

Envie de vous faire la main avec Raspberry Pi mais sans vous ruiner, ni sans qu’il prenne toute la place chez vous ? 😉 Alors Raspberry Pi Azure IoT Online Simulator est pour vous.

Raspberry Pi Azure IoT Online Simulator est un émulateur en ligne du Raspberry Pi hébergé sur Azure, le cloud de Microsoft, et développé par Microsoft.

Depuis un navigateur, vous pouvez écrire du code pour contrôler le hardware ainsi émulé. Il est pour le moment possible d’interagir avec une LED virtuellement connectée au Raspberry Pi et de collecter des données depuis un capteur.

Le volet gauche du navigateur présente le Raspberry Pi connecté à ses périphériques. On écrit son code – du node.js JavaScript – dans le volet droit du navigateur, puis on l’exécute en tapant une ligne de commande dans le panneau inférieur droit.

Pour que les choses soient tout à fait claires, Microsoft propose un didacticiel ici.

Le code écrit dans l’interface web de cet émulateur doit fonctionner sur un vrai Raspberry Pi sans aucune modification.

L’émulateur et ses interactions avec des périphériques est pour l’instant limitée mais il va évoluer dans le futur. Les passionnés peuvent d’ailleurs contribuer à l’enrichir, car cet émulateur est open source, sur GitHub.

Source : https://www.programmez.com/node/26218

Electronique et Arduino kit de démarrage

Kit de démarrage : l’essentiel

L’achat d’un kit tout prêt est le plus facile. Pour le plus économique je vous suggère l’achat des composant à l’unité ici.

  • Arduino UNO R3 avec son câble USB ×1 (un clone ? voir ici)
  • Platine de prototypage × 1 (aux moins 500 ‘trous’)
  • Kit de câbles de prototypages × 1
  • LED de différentes couleurs (au moins 2 x vert, 2 x rouge, 2 x orange ou jaune)
  • Résistances de différentes valeurs :
    • 10KΩ × 5
    • 4KΩ × 5
    • 1KΩ × 5
    • 220Ω × 5
    • 150Ω × 5
  • Condensateurs céramique de différentes valeurs :
    • 100nF × 2
    • 10nF × 2
  • Condensateurs chimiques de différentes valeurs ( tension de service d’au moins 10v ) :
    • 10uF × 2
    • 47uF × 2
    • 470uF × 2
  • Diodes 1N4148 × 2 (ou autre diode)
  • Transistor NPN (TO92) x 2 ( ex. BC337, BC546, 2N2222, 2N3904…)
  • Transistor PNP (TO92) x 2 ( ex. BC327, BC556, 2N2907, 2N3906…)
  • Photorésistance × 1
  • Bouton poussoirs × 5
  • Potentiomètre 10kΩ (preset) × 1
  • Potentiomètre 10kΩ ou 50kΩ avec bouton × 1
  • Piezo buzzer × 1

Matériel optionnel

  • Module d’extension (shield ou module) écran  LCD 16×2  ( trés récommandé )
  • LED RVB × 1
  • Bouton codeur avec contact × 1
  • Thermistance ( 100kΩ ou 50kΩ ) × 1
  • LM35 (sonde de température) × 1
  • Transistor MOSFET-N « Logic level » × 1 ( ex. IRL530 )
  • Transistor MOSFET-P « Logic level » × 1 ( ex. IRF9530 )
  • Module Relais pilotable en 5V pour commuter jusqu’à 230V × 1
  • Module d’extension (shield ou breakout board) Ethernet (au choix) :
    • (basé sur chip Wiznet W5100)  × 1    ( plus cher mais plus facile à utiliser avec l’Arduino UNO )
    • (basé sur chip ENC28J60)  x 1  (moins cher mais gourmand en mémoire)
  • Mini Servo Moteur × 1 ( choisir la plus grande angle d’ouverture possible )
  • Boîtier plastique pour contenir les composants et l’Arduino × 1 (vraiment optionnel 🙂
Prix moyen :~50€

Projet – test du LiPo Rider Pro

Pour mon projet, j’essaye de réfléchir à l’alimentation. J’ai conservé une batterie 12V, suite à un changement pour ma voiture, mais je test d’autres sources. Le solaire m’intéresse, surtout pour le côté autonome et écologique.

Un produit existe c’est le LiPo Rider Pro, voici le test du produit et sa description assez complète.

Lipo Rider Pro le test en images

Voici en image le module Li-po Rider Pro branché à une batterie et un petit panneau solaire.

Lipo Rider Pro

Puis le module en mode charge, grâce au panneau solaire que nous verrons un peu plus tard en détail.

Lipo Rider Pro - mode charge

On remarque dans le coin supérieur droit, juste sous la broche de la batterie, la LED, qui indique que la batterie se charge, d’une manière écologique, gratuite.
Si la cellule solaire n’est pas suffisamment puissante, l’accu est rechargeable via mini-USB, ici en haut de la carte LiPO Rider Pro.

Les caractéristiques du Lipo Rider Pro

  • Sortie (sur connecteur USB): 5 Vcc/1 A maxi
  • 4 Leds d’indication de charge
  • Connecteurs accu et cellule: 2 broches type JST
  • Accumulateur (non inclus): LiPo
  • Tension d’entrée cellule solaire: 5 V
  • Dimensions: 68 x 50 x 10 mm

Le chargeur USB et l’alimentation de secours LiPo Rider Pro SeeedStudio est une promotion de LiPo Rider. Il fournit une sortie de charge plus élevée que LiPo Rider La carte LiPo Rider Pro vous permet de surfer sur la vague solaire pour utiliser votre appareil 5 V préféré. La carte LiPo Rider Pro est la solution d’énergie verte idéale pour votre conception de capteur extérieure. Fixez la carte LiPo Rider Pro à votre capteur pour qu’il puisse définitivement fonctionner sur l’énergie solaire ! Il peut également être utilisé pour charger un téléphone mobile.

Fiche technique de la carte LiPo Rider Pro à 16,30 euros chez GoTronic.

Les caractéristiques de la cellule solaire

Cellule solaire SOL1W à 5,80 euros chez GoTronic.
Cellule solaire 1 Watt délivrant une tension de 5,5 Vcc sous 170 mA. Attention : la tension peut monter en pointe jusqu’à 10V.

  • Tension: 5,5 Vcc/170 mA
  • Connecteur: 2 broches type JST
  • Tension maxi en circuit ouvert: 8,2 V
  • Silicium mono-cristallin.
  • Dimensions: 100 x 80 x 3 mm

Les caractéristiques de la batterie

Accu Li-Ion 3,7 V 1050 mAh à 10,90 euros chez GoTronic.

Caractéristiques :

  • Tension: 3,7 Vcc
  • Intensité: 1050 mAh
  • Connecteur: 2 broches type JST
  • Dimensions: 47 x 43 x 4 mm
  • Poids: 20 g

Fiches techniques de la batterie :
pj2-09740-1362
pj2-09740a-1363