Bonjour de Normandie

Présentez vous pour ensuite pouvoir poster des messages sur nos forums

Bonjour de Normandie

Message non lude Vince » Sam 27 Déc 2014 11:59

Bonjour,
Juste un petit message de présentations.
Utilisateur d'Arduino depuis 3 ans, Duemilanove, Uno, tiny, Mini pro, Due, LCD keypad shield, Data logger SD-RTC, USB Loader, I2C LCD, platines Xino, TM1367, modules RTC, DHT11, DHT22, DS18B20,...
Quelques réalisations :
Un duemilanove + LCD keypad shield qui permet de réviser les tables de multiplication (pour ma gamine) mais aussi d'avoir une base pour l'affichage et l'utilisation des 5 boutons sur l'entrée ana avec gestion de l'anti rebond.
Un compteur geiger étalonné en mSv/h et Becquerel à partir d'un Kit de Lettonie et d'un tube russe. Le letton, super sympa m'a filé le code pour que je francise ma version et ajoute la conversion dans les bonnes unités plus une acquisition de la tension de polarisation du tube.
Un pilote midi pour ma pédale d'effet Whammy 4 --> une dizaine d'effets paramétrables via 2 potar : enfoncement pédale, fréquence, ...avec afficheur LCD pour visualiser l'effet choisi et les réglages :
http://www.flickr.com/photos/26274419@N04/8473364938/
Un enregistreur numérique sur carte SD en .CSV avec horodatagepar module RTC et choix de la fréquence d'échantillonnage par les touches du LCD keypadshield --> triple cheese burger avec Uno, datalogger Adafruit et LCD keypad shield.
Il reste encore quelques échecs sur le traitement du son (effet de guitare élec) par le duemilanove en version Very Low Fidélity et un projet en cours avec un Due (c'est un peu pénible cette bête là car tous les modules et bibliothèques ne sont pas compatibles) et un "pédal shield" d'électrosmash pour effet de guitare.
Je rejoins la communauté Snootlab après l'acquisition d'un Akéru 3.3 en vue d'un monitoring poids et températures d'un rucher d'une dizaine de ruches.
Vincent, Cany Barville, Normandie
Dernière édition par Vince le Dim 24 Jan 2016 11:22, édité 1 fois.
Vince
 
Messages: 22
Inscription: Sam 27 Déc 2014 11:25

Re: Bonjour de Normandie

Message non lude Vince » Sam 27 Déc 2014 12:03

Salut,
J'ai oublié le GPS fait maison avec un module skylab SKM53, un afficheur LCD 4*20 et une fonction cap et distance de retour à la maison.
Vincent
Vince
 
Messages: 22
Inscription: Sam 27 Déc 2014 11:25

Akeru et LCD Shield

Message non lude Vince » Sam 3 Jan 2015 17:01

Bonjour,

AKERU et LCD KEYPAD SHIELD

L'Akeru utilise les pattes D4 et D5. J'ai donc décidé de ne pas souder les connecteurs associés. J'ai une p'tite photo là dessus.

Comme, dans ma représentation des choses, l'arduino sans afficheur LCD n'est que ruine de l'âme, le plus simple est d'adapter un LCD keypad shield qui pour quelques euro offre des boutons (5) et un LCD 16*2. Massimo a raison : L'Arduino est fait pour communiquer...avec un AKERU et un afficheur ça va communiquer sur le net mais aussi en local.

De conception, ce keypad shield est gourmand en broches car il n'est pas en I2C (qui fait la même chose sur 2 broches):

D4 DB4 LCD affich
D5 DB5 LCD affich
D6 DB6 LCD affich
D7 DB7 LCD affich
D8 RS LCD affich
D9 E LCD affich
D10 LCD back LED LCD affich

Sans compter la broche A0 qui sert d'entrée pour les 5 boutons par acquisition en analogique.

On constate que les broches D4 et D5 sont aussi utilisées par le LCD keypad shield, il faut donc les rerouter : ça se fait très simplement en dessoudant aussi les 2 broches mâles D4 D5 du LCD keypad shield et les reroutant par fil volant sur 2 autres "digital pins" libres : par exemple D11 et D12 qui sont facilement accessibles. 2 p'tites photos la dessus aussi...

Pour le code, il ne faudra par oublier de modifier la définitions des papattes :

LiquidCrystal lcd(8, 9, 11, 12, 6, 7); //(RS, Enable, D4, D5, D6, D7)

Voila...reste de juste à ajouter quelques photos ...et le code de l'application "tables de multiplications" pour donner un exemple de code qui utilise pas mal de fonctions du LCD keypad shield.

Le temps d'installer le driver FT231X depuis sparkfun qui reroute vers le site FTDI chip et hop ...ça marche.

Voila le code (pas optimisé, ça vient en partie de moi et de Maître Tavernier pour les boutons...mais ça marche) :

Code: Tout sélectionner
 /*code de  xxx   pour un visionneur de tables de multiplications
* 2 boutons serviront à choisir la table, deux autres le multiplicateur et le dernier affiche le résultat qq secondes
* les 5  boutons sont sur la même patte en analogique A0
*/

// Appel des bibliothèques
#include <LiquidCrystal.h>    // HD44780 compatible LCDs work with this lib - appelle la librairie en french

// définition des variables
#define BOUTONS A0 // je ne sais pas activer la patte A0 autrement

int adc_key_val[5] = {
   30,150,360,535,760};
int NUM_KEYS = 5;
int adc_key_in;
int key=-1;
int oldkey=-1;
int A=0;
int B=0;
int C=0;

LiquidCrystal lcd(8, 9, 11, 12, 6, 7);       // instantiate the library and pass pins for (RS, Enable, D4, D5, D6, D7)

void setup() {                              // programme d'initialisation

pinMode(BOUTONS, INPUT);                    // initialise la patte A0 comme entrée analogique

  lcd.begin(16,2);                          // colonnes et lignes de l'afficheur
  lcd.print("   TABLES DE    ");            // affiche le message
  lcd.setCursor(0,1);                       // met le curseur en ligne 2 qui s'appelle 1
  lcd.print("MULTIPLICATIONS ");            // affiche le message
  delay (1000);                             // laisse le message 1 seconde
  lcd.clear();                              // efface l'écran
  delay(10);
}
 
void loop() {                               // début du programme principal

adc_key_in=analogRead(BOUTONS);
key=get_key(adc_key_in);
if(key !=oldkey) {
 delay(20);
 adc_key_in=analogRead(BOUTONS);
 key=get_key(adc_key_in);
 if(key !=oldkey) {
 oldkey=key;
 if ( key >=0 ){       // programe d'utilisation avec les touches droite=2   haut=1   bas=0   gauche=3    OK=4  rien=-1
  if (key==1){        // haut appuyé
    B=B+1;
   lcd.setCursor(3,1);                // met le curseur en position 5 ligne 2
   lcd.print("X     ");              // affiche X en 5 éme caractère ligne 2 et efface les caractères suivants
   lcd.setCursor(6,1);                // met le curseur en position 10 ligne 1
   lcd.print(B);                       // affiche la valeur de la table
  }
  if (key==3){      // gauche appuyé
    A=A+1;
  lcd.setCursor(10,0);                // met le curseur en position 10 ligne 1
  lcd.print("    ");                  // affiche la valeur de la table
  lcd.setCursor(10,0);                // met le curseur en position 10 ligne 1
  lcd.print(A);                       // affiche la valeur de la table

  lcd.setCursor(0,1);                // met le curseur en ligne 2
  lcd.print("   ");                 // efface l'ancien affichage
  lcd.setCursor(0,1);                // met le curseur en ligne 2
  lcd.print(A);                      // affiche la valeur de la table
  }
  if (key==0){      // bas appuyé
    A=A-1;
    lcd.setCursor(10,0);                // met le curseur en position 10 ligne 1
  lcd.print("    ");                  // affiche la valeur de la table
  lcd.setCursor(10,0);                // met le curseur en position 10 ligne 1
  lcd.print(A);                       // affiche la valeur de la table

  lcd.setCursor(0,1);                // met le curseur en ligne 2
  lcd.print("   ");                 // efface l'ancien affichage
  lcd.setCursor(0,1);                // met le curseur en ligne 2
  lcd.print(A);                      // affiche la valeur de la table
  }
  if (key==2){      //droite appuyé
    B=B-1;
  lcd.setCursor(3,1);                // met le curseur en position 5 ligne 2
  lcd.print("X     ");              // affiche X en 5 éme caractère ligne 2 et efface les caractères suivants
  lcd.setCursor(6,1);                // met le curseur en position 10 ligne 1
  lcd.print(B);                       // affiche la valeur de la table
  }
  if (key==4){       // OK appuyé
    C=A*B;
    lcd.setCursor(12,1);                // met le curseur en position 13 ligne 2
    lcd.print(C);                       // affiche le résultat sur 4 chiffres max
    delay (2000);                       // affiche le résultat 2 seconde simplement
    lcd.setCursor(12,1);                // met le curseur en position 13 ligne 2
    lcd.print("    ");                  // efface le résultat sur 4 chiffres max
       
   
}}}}
 
  lcd.setCursor(0,0);                // met le curseur en position 0 ligne 0
  lcd.print(" TABLE DE ");            // affiche table de en ligne 1
  lcd.setCursor(3,1);                // met le curseur en position 5 ligne 2
  lcd.print("X");                    // affiche X en 5 éme caractère ligne 2 et efface les caractères suivants
  lcd.setCursor(10,1);                // met le curseur en position 11 ligne 2
  lcd.print("=    ");                 // affiche = et efface le résultat

 
}
int get_key(unsigned int input){
  int k;
  for (k=0;k<NUM_KEYS;k++){
    if(input<adc_key_val[k]){
      return k;
    }}
  if (k>=NUM_KEYS){
  k=-1;
  }
return k;
}

Maintenant, il faut que je trouve comment insérer des photos....

Bonsoir à tous,

Vincent
Dernière édition par Vince le Mer 11 Fév 2015 17:57, édité 3 fois.
Vince
 
Messages: 22
Inscription: Sam 27 Déc 2014 11:25

Re: Bonjour de Normandie

Message non lude Vince » Sam 3 Jan 2015 17:30

D4 D5 sans connecteur .JPG
Pas de connecteur sur la carte Akeru au bornes D4 et D5
D4 D5 sans connecteur .JPG (84.17 Kio) Vu 5688 fois
D4 D5 sans connecteur.JPG
D4 D5 sans connecteur.JPG (89.33 Kio) Vu 5688 fois
LCD Keypad shield sans D4 D5 .JPG
idem sur la carte LCD Keypad Shield sans broche D4 et D5
LCD Keypad shield sans D4 D5 .JPG (98.86 Kio) Vu 5688 fois
Vince
 
Messages: 22
Inscription: Sam 27 Déc 2014 11:25

Re: Bonjour de Normandie

Message non lude Vince » Sam 3 Jan 2015 17:34

LCD Keypad shield sans D4 D5.JPG
Vu sous un autre angle
LCD Keypad shield sans D4 D5.JPG (98.09 Kio) Vu 5688 fois
D4 rerouté en D11 et D5 en D12.JPG
Broches du LCD keypad Shield reroutées : D4 en D11 et D5 en D12
D4 rerouté en D11 et D5 en D12.JPG (100.74 Kio) Vu 5688 fois
Ca marche.JPG
Et ça marche : l'Akeru avec un LCD Keypad Shield
Ca marche.JPG (119 Kio) Vu 5688 fois
Vince
 
Messages: 22
Inscription: Sam 27 Déc 2014 11:25

Monitoring des ruches

Message non lude Vince » Dim 10 Jan 2016 10:35

Bonjour à tous,
Le projet dont je vous parlais en me présentant sur ce forum a beaucoup progressé :
Principe :
Quelques arduinos esclaves (10 max selon le mode de com AKERU) mesurent chacun en continue la température et le poids d’une ruche. Sur demande du maître, l’AKERU, ils envoient leurs données formatées sur 2 octets. Apres collecte des données disponibles, un message est envoyé sur l’internet des petits objets par l’AKERU avec toutes ces données.
Comme un arduino qui ne communique pas n’est pas un objet digne d’intérêt, un afficheur est disponible au dessus de l’AKERU pour consulter sur place, pour chacune des ruches, le poids, la température, les poids min et max et les températures min et max.
Toutes les communications Maître / esclaves se font via un réseau RS485 sur 2 fils, deux autres fils du câble servant à distribuer l’alimentation des esclaves.

Les photos sont dans les .doc ci-dessous.

Doc maitre.doc
Voici le détail du projet pour le maître :
(1.2 Mio) Téléchargé 97 fois

Documentation esclaves.doc
Voici le détail du projet pour les esclaves
(2.61 Mio) Téléchargé 93 fois

Cette version ne fait pas tout du projet mais elle permet déjà de faire communiquer via le RS485, un arduino esclave qui collecte un poids et une température avec un arduino maître (Akéru) doté d'un LCD.
Code: Tout sélectionner
/*code de DQN pour le maître des arduinos disposés sur chacune des ruches.
 Pour l'instant, il n'y a qu'un seul esclave géré et il n'y a pas d'envoi du message via le modem SIGFOX de l'akéru
 Mais les lignes de code sont presque prêtes pour le faire
*/

// Appel des bibliothèques
#include <LiquidCrystal.h>    //  appelle la librairie LCD HD44780
#include <Wire.h>                  //nécessaire au RTC (real time Clock = l’ horloge indépendante)
#include "RTClib.h"               // librairie RTC
#include <SoftwareSerial.h>  // utile à la communication via le RS485
#include <RS485_protocol.h> // protocole du RS485 par Nick Gammon
// #include <Akeru.h>             // bibliothèque de l'Akeru

// définition des variables
#define BOUTONS A0                //  active la patte A0 pour les touches de commande du LCD
//#define SSerialTxControl 3       //RS485 Direction control - pas utile
//#define RS485Transmit    HIGH  //  pas utile, juste hérité d’un bout de code pompé
//#define RS485Receive     LOW   //  pas utile, juste hérité d’un bout de code pompé
//#define SSerialRX        2              //RS485 Serial Receive pin - pas utile, juste pompé / collé
//#define SSerialTX        13            //RS485 Serial Transmit pin - pas utile, juste pompé / collé
//#define SSerialTxControl 3          //RS485 Direction control - pas utile, juste pompé / collé

const byte ENABLE_PIN = 3;      // définit que la patte énable est la D3 du RS485
SoftwareSerial rs485 (2, 13);        // idem pour receive pin, transmit pin

                          // routine fWrite pour le RS485
 
void fWrite (const byte what)
  {
  rs485.write (what); 
  }
 
int fAvailable ()
  {
  return rs485.available (); 
  }

int fRead ()
  {
  return rs485.read (); 
  }

RTC_DS1307 RTC;                // formule toute faite indispensable au lancement de la RTC

long trigg;                               // variable qui scrute le cumul des secondes depuis 1970         
                                               //renvoyé par le module RTC pour déclencher l'échantillonnage
long triggbis = 0;                   // variable mémoire de trigg pour suivre les évolution et
                                               // paramétrer l'échantillonnage
int adc_key_val[5] = { // chaîne de caractères avec les valeurs ana des boutons sur A0
   30,150,360,535,760}; // pour les boutons du LCD Keypad Shield, merci M. Tavernier
int NUM_KEYS = 5;                          // variable de suivi des touches LCD KS initialisée à 5
int adc_key_in;                                   // variable de suivi des touches LCD KS
int key=-1;                                          // variable de suivi des touches initialisée à -1
int oldkey=-1;                                     // variable de suivi des touches initialisée à -1
int A=0; // variable de suivi des appuis sur les touches pour savoir on en est sur les choix
int B=0; // variable de suivi des appuis sur les touches pour savoir on en est sur les choix
int C=0; // variable de suivi des appuis sur les touches pour savoir on en est sur les choix
int D ; // variable de collecte des info horaires pour mise en forme de l'affichage
int E ; // compteur d'extinction de l'affichage qui s'incrémente à chaque boucle dans loop et
           //   finit par arrêter l'afficheur pour économiser LCD et alim
//int byteReceived; // pas utile
//int byteSend; // pas utile
int temp2 ;      // variable pour la température esclave 2 en octet
int poids2 ;     // variable pour le poids esclave 2 en octet

LiquidCrystal lcd(8, 9, 11, 12, 6, 7);       // instantiate the library and pass pins for (RS,
                                                                 // Enable, D4, D5, D6, D7)

void setup() {                                      // programme d'initialisation

pinMode(BOUTONS, INPUT);        // initialise la patte A0 comme entrée analogique

 lcd.begin(16,2);                                // Que de l'affichage sur 2 lignes et 16 caractères
  lcd.clear();            // Efface l’écran
  delay(100);            // Attend 0.1 s
  lcd.setCursor(0,0);                           // Met le curseur en haut à gauche
  lcd.print("  Surveillance  ");             // Ecrit le message
  lcd.setCursor(0,1);                       
  lcd.print("   des ruches   ");             
  delay (3000);                             
  lcd.clear();                             
  lcd.print(" Nicolas Chopart");           
  lcd.setCursor(0,1);                       
  lcd.print("04 janvier 2015");           
 
  Wire.begin();                               // lance le protocole de communication Wire pour le RTC
  RTC.begin();                              //lance la connection avec le module RTC
  // Akeru.begin();                        // lance l'akeru
  delay(1000);                              // attends 1s
  lcd.clear();                                 // efface l'écran
  digitalWrite(10, LOW);            // bascule la patte D10 à zéro -->  rétro éclairage du LCD
 // RTC.adjust(DateTime(__DATE__, __TIME__)); // pour mise à l'heure de l'horloge RTC à
                // l'heure du PC – cette ligne ne se charge qu’une seule fois puis doit être désactivée.
 
  Serial.begin(9600);                // lance le port série à 9600 bauds pour le moniteur série
  rs485.begin (28800);              // lance le RS485 à 28800 bauds
  pinMode (ENABLE_PIN, OUTPUT);  // met la patte D3, énable, en mode sortie.
 
}
 
void loop() {   // début du programme principal

DateTime now = RTC.now();        //  fait une acquisition de l'heure
 E = E+1 ;                                       // compteur de boucles pour extinction du LCD
   lcd.setCursor(0,0);                      // met le curseur en caractère 1 ligne 1
   lcd.print("  /  /       :  ");               // Affiche le format de la date/heure
   lcd.setCursor(0,0);                      // met le curseur en caractère 1 ligne 1
   D = now.day(), DEC;                 // D devient la valeur du jour non mise en forme
   if (D < 10){                          // si D<10, il faut rajouter un zéro devant juste pour l'affichage
   lcd.print("0");                             // voila le 0 affiché...
   lcd.setCursor(1,0);                     // décalage du curseur pour afficher la date
   lcd.print(D);                               // affiche directement la date si < 10
   }
   else {                                          //sinon
   lcd.print(D);                               // affiche directement la date en position ligne 1 curseur 1
                                                      // si elle est supérieure à 10
   }
   lcd.setCursor(3,0);                    // met le curseur en position 4 ligne 1
   D = now.month(), DEC;          // pareil pour le mois en utilisant toujours la variable D ce qui
                                                    // permet de faire du copier coller sur l'écriture du programme
   if (D < 10){
   lcd.print("0");
   lcd.setCursor(4,0);
   lcd.print(D);   
   }
   else {
   lcd.print(D);
   }   
   lcd.setCursor(6,0);               
   lcd.print(now.year(), DEC);     // pour l'année, comme elle est au format "2016", pas de mise
                                                    // en forme nécessaire
   lcd.setCursor(11,0);                 
   D = now.hour(), DEC;             // maintenant la variable D s'occupe de l'heure
   if (D < 10){
   lcd.print("0");
   lcd.setCursor(12,0);
   lcd.print(D);   
   }
   else {
   lcd.print(D);
   } 
   lcd.setCursor(14,0);                 
   D = now.minute(), DEC;         // et on termine en s'occupant des minutes
   if (D < 10){
   lcd.print("0");
   lcd.setCursor(15,0);
   lcd.print(D);   
   }
   else {
   lcd.print(D);
   }                                             // c'est enfin fini pour afficher la date et l'heure avec des zéros.
   delay (100);

   if (E > 250){                       // test d’une boucle qui éteint la LED du rétroéclairage et le LCD
                                               // au bout de 250 boucles
   lcd.noDisplay();                  // éteint l’affichage des caractères  LCD
   pinMode(10, OUTPUT);    // arrête le retro éclairage par une autre fonction que celle utilisée au dessus
   // pinMode(D10, INPUT);    // la commande inverse mise en réserve ici...
   
   E = 256 ;                               // fixe la valeur de E pour éviter à terme un dépassement du
                                               // compteur en incrémentant tout le temps à chaque boucle
   B = 0 ;                                // remet à zéro les compteurs de touche pour après
   C = 0 ;                               // remet à zéro les compteurs de touche pour après
   }
   
//  A partir de là, on gère les boutons et ce qu'on leur attribue comme fonction

adc_key_in=analogRead(BOUTONS); //charge la variable adc_key_in, qui a un nom à
                                                 // coucher dehors, de la lecture analogique sur la patte A0
key=get_key(adc_key_in);      // lance la routine en dessous pour dire quelle touche a été
                                                 // enfoncée
if(key !=oldkey) {                   // si le bouton a changé
 delay(20);                               //attendre0.02s
 adc_key_in=analogRead(BOUTONS); //refaire une nouvelle acquisition
 key=get_key(adc_key_in);    // relance la routine en dessous encore une fois pour dire
                                                // quelle touche a été enfoncée
 if(key !=oldkey) {                 // si le bouton a toujours changé
 oldkey=key;                           // la valeur de oldkey devient le retour de la fonction, entre -1 et
                                               // 4, ce qui donne le bouton appuyé suffisamment longtemps
 if ( key >=0 ){                      // programe d'utilisation avec les touches droite=2   haut=1   
                                             // bas=0   gauche=3    OK=4  rien=-1
  if (key==1){                      // si on est sur haut appuyé
                                              //  Action à faire avec le bouton haut appuyé : Rien à ce stade de
                                             // développement, plus tard ce sera le choix de la ruche examinée
                                             // sur le LCD
   E=0;                                  // RAZ le compteur d'affichage
    pinMode(10, INPUT);       // allume le retro éclairage
    lcd.display();                   // allume le LCD
    lcd.clear();                      //efface l'écran
  }
  if (key==3){                // si on est sur gauche appuyé
                                      //  Action à faire avec le bouton gauche appuyé (reliquat d’une autre
                                      // application : l’enregistreur horodaté numérique de T° sur carte SD
  E=0;                            // RAZ le compteur d'affichage
  A = A-1;                     // décrémente la variable A qui est utilisée pour définir le pas
                                      // d'échantillonnage
  pinMode(10, INPUT);        // allume le retro éclairage
  lcd.display();                      // allume le LCD
  lcd.clear();                           //efface l'écran
  lcd.setCursor(0,1);             // met le curseur en position 1 ligne 2
  lcd.print("ECHANT ");             // affiche le message
  lcd.setCursor(8,1);               // met le curseur en position 9 ligne 2
  if (A <= 0) {                        //si la variable A est inférieure ou égale à 0, alors
  A=0;                             // on confirme A à zéro pour ne pas permettre d'excursion de la valeur
  lcd.print("1 mn");         // on affiche le message associé soit « 1 minute »
  }
  if (A == 1) {                 // si la variable A vaut 1 ...et ainsi de suite 4 fois
  lcd.print("5 mn");
  }
  if (A == 2) {
  lcd.print("10 mn");
  }
  if (A == 3) {
  lcd.print("30 mn");
  }
  if (A >= 4) {                // si la variable A est supérieure ou égale à 4, alors
  A=4;                            // on confirme A à 4 pour ne pas permettre d'excursion de la valeur
  lcd.print("1 h");
  }
  delay (1000);                   // attente 1 seconde
  lcd.setCursor(0,1);           // met le curseur en position 1 ligne 2
  lcd.print("                ");    // reset l'affichage de la 2éme ligne
  }
  if (key==2){               // si la touche bas est appuyé
                                     //  Action à faire avec le bouton haut appuyé : Rien à ce stade de
                                     // développement, plus tard ce sera le choix de la ruche examinée
                                     // sur le LCD

    E=0;                                //RAZ le compteur d'affichage
   pinMode(10, INPUT);    // allume le retro éclairage
   lcd.display();                   // allume le LCD
   lcd.clear();                       //efface l'écran
 }
  if (key==0){                  //si c'est le bouton droite appuyé
                                       //  Action à faire avec le bouton droite appuyé (reliquat d’une autre
                                      // application : l’enregistreur horodaté numérique de T° sur carte SD

  E=0;                               //  RAZ le compteur d'affichage
  A = A+1;                       //  cette fois ci on incrémente le compteur A
  pinMode(10, INPUT);       // allume le rétro éclairage
  lcd.display();                      // allume le LCD
  lcd.clear();                          // efface l'écran
  lcd.setCursor(0,1);             // met le curseur en position 1 ligne 2
  lcd.print("ECHANT ");     // affiche le message
  lcd.setCursor(8,1);
  if (A <= 0) {                       // si la variable A est inférieure ou égale à 0, alors
  A=0;                             // on confirme A à zéro pour ne pas permettre d'excursion de la valeur
  lcd.print("1 mn");
  }
  if (A == 1) {
  lcd.print("5 mn");
  }
  if (A == 2) {
  lcd.print("10 mn");
  }
  if (A == 3) {
  lcd.print("30 mn");
  }
  if (A >= 4) {
  A=4;
  lcd.print("1 h");
  }
  delay (1000);
     
  }
 
  if (key==4){            // si c'est le bouton OK appuyé
                                   //  Action à faire avec le bouton OK appuyé : Rien à ce stade de
                                  // développement
   E=0;                        // RAZ le compteur d'affichage
   pinMode(10, INPUT);    // allume le retroéclairage
   lcd.display();           // allume le LCD
   lcd.clear();             //efface l'écran
   
}}}}                           //refermeture de toutes les boucles de if


//         gestion du RS485
 
  byte msg [] = { // création de msg du maître vers les esclaves
     1, // venant du maître
     2,    // pour l'esclave  2
     2    // action n°2 : demande d'informations
      };
  Serial.print("Message cree : "); // pour le debuggage via le moniteur série, inutile dans la
                                    // version finale
  Serial.print(msg [0]); // pour le debuggage via le moniteur série, inutile dans la version finale
  Serial.print(msg [1]); // pour le debuggage via le moniteur série, inutile dans la version finale
  Serial.print(msg [2]); // pour le debuggage via le moniteur série, inutile dans la version finale
  Serial.println(msg [3]); // pour le debuggage via le moniteur série, inutile dans la version finale
 
  // send to slave 
  digitalWrite (ENABLE_PIN, HIGH);  // enable sending
  Serial.print(" Enable actif "); // pour le debuggage via le moniteur série, inutile dans la
                                                // version finale
  sendMsg (fWrite, msg, sizeof msg);
  Serial.println(" message transmis"); // pour le debuggage via le moniteur série, inutile dans la
                                                           // version finale
  digitalWrite (ENABLE_PIN, LOW);  // disable sending
  Serial.print(" Enable inactif "); // pour le debuggage via le moniteur série, inutile dans la
                                                   // version finale
     // réponse reçue (buf) 
  byte buf [10];
  byte received = recvMsg (fAvailable, fRead, buf, sizeof buf);
  Serial.println(" Reponse recue: "); // pour le debuggage via le moniteur série, inutile dans la
                                                        // version finale
  Serial.print(" venant de : "); // pour le debuggage via le moniteur série, inutile dans la
                                                     // version finale
  Serial.println(buf [0]); // pour le debuggage via le moniteur série, inutile dans la version
                                     // finale
  Serial.print(" pour : ");  // pour le debuggage via le moniteur série, inutile dans la version
                                     // finale
  Serial.println(buf [1]);  // pour le debuggage via le moniteur série, inutile dans la version
                                     // finale
  Serial.print(" temp codee : "); // pour le debuggage via le moniteur série, inutile dans la
                                       // version finale
  Serial.println(buf [2]); // pour le debuggage via le moniteur série, inutile dans la version
                                     // finale
  temp2 = ((buf[2]/4)-15); //remise à l'échelle de la température
  Serial.print(" poids code : "); // pour le debuggage via le moniteur série, inutile dans la
                                       // version finale
  Serial.println(buf [3]); // pour le debuggage via le moniteur série, inutile dans la
                                       // version finale

  poids2 = (buf[3]/10); // remise à l'echelle du poids
  Serial.print(" temp et poids esclave 2 : "); // pour le debuggage via le moniteur série, inutile
                                     // dans la version finale

  Serial.print(temp2); // pour le debuggage via le moniteur série, inutile dans la version finale
  Serial.print(" C "); // pour le debuggage via le moniteur série, inutile dans la version finale
  Serial.print(poids2); // pour le debuggage via le moniteur série, inutile dans la version finale
  Serial.println(" kg "); // pour le debuggage via le moniteur série, inutile dans la version finale
 
// fin de la gestion du RS485

// fonction suivante : envoi d'un message via l'AKERU toutes les 720s (12mn soit 5 par heure et 120 par jour)
 trigg = (now.unixtime()/720);   //division du compteur des secondes cumulées depuis 1970
                                                  //  par le pas d'échantillonnage : 720s, valeur modifiable
  if ( trigg != triggbis) {
   pinMode(10, INPUT);            // allume le retroéclairage du LCD
   lcd.display();                        // allume le LCD
   lcd.clear();                            //efface l'écran
   lcd.setCursor(0,1);                // met le curseur en position 1 ligne 2
   lcd.print("ACTION ");
   Serial.println(" AKERU active"); // pour le debuggage via le moniteur série, inutile dans la
                                                    //  version finale
   // Akeru.send(&"Bonjour", sizeof("Bonjour")); // Remonte la donnée sur le réseau Sigfox.
                                   // fonction désactivée par les // dans ce programme en version d’essai
   delay (3000); // attends 3 s
   triggbis = trigg; //réinitialisation du compteur horaire pour les enregistrements
  } 
 
}
/* bout de code pour renvoyer le n° d'ordre de la touche enfoncée en fonction de la  comparaison sur la chaîne de caractères, merci Monsieur Christian Tavernier dont les 2 ouvrages sur l’arduino m’ont permis de me dépatouiller de toutes les applications dont  j’avais besoin ou envie.
*/
int get_key(unsigned int input){
  int k; // k est un entier
  for (k=0;k<NUM_KEYS;k++){ // pour k de 0 jusqu'au nombre de caractères de num_keys, ajouter 1 à chaque boucle
    if(input<adc_key_val[k]){ // c'est ici Nico qu'il y a comparaison < entre A0 et la valeur entrée dans la chaîne des valeurs
      return k; //renvoyer le n° d'ordre de la touche quand l'entrée sur A est < à la valeur de la chaîne des valeurs
    }}
  if (k>=NUM_KEYS){ // si on dépasse coté k
  k=-1; // k vaut alors -1
  }
return k; // renvoie la valeur de k
}

Code: Tout sélectionner
// Monitoring des ruches - Duke pour Nico - 02/01/2016
// Sonde de température DS18B20
// Sonde poids extensomètre sur platine HX711
// Communication avec un maitre (AKERU) via un réseau RS485

#include <RS485_protocol.h> // bibliothèque comm RS485
#include "HX711.h" // bibliothèque interface sonde poids
#include <OneWire.h> // Inclusion de la librairie OneWire pour la sonde de température
#include <SoftwareSerial.h> // pour communication série sur n'importe quelle patte digitale


#define DS18B20 0x28     // Adresse 1-Wire du DS18B20, détectée en chargeant un utilitaire qui la renvoie sur le PC
#define BROCHE_ONEWIRE 2 // Broche utilisée pour le bus 1-Wire de la sonde de Température DS18B20

HX711 scale(A2, A3);            // parametre "gain" non mentionné, la valeur par défaut est 128 prise par la bibliothèque

SoftwareSerial rs485 (10, 12);  // receive pin, transmit pin du RS485
const byte ENABLE_PIN = 11;     // broche enable pour le RS485

void fWrite (const byte what) // routine fWrite pour le RS485
  {
  rs485.write (what); 
  }
 
int fAvailable ()
  {
  return rs485.available (); 
  }

int fRead ()
  {
  return rs485.read (); 
  }


OneWire ds(BROCHE_ONEWIRE); // Création de l'objet OneWire ds en intégrant le fait que ça se passe sur la patte 2 définie ci dessus dans les variables
float tempmax = 0 ; // variable d'enregistrement de la tempérarure max, initialisée à 0 pour être sur de la changer à la première boucle
float tempmin = 40 ; // variable d'enregistrement de la tempérarure min, initialisée à 40 pour être sur de la changer à la première boucle
float temp; //température en degré
float temp1; //température en quart de degré pour conversion en octet + 15°
float tempmax1; //température max en quart de degré pour conversion en octet + 15°
float tempmin1; //température min en quart de degré pour conversion en octet + 15°
byte tempbyte; //température convertie en octet
byte tempmaxbyte; //température max convertie en octet
byte tempminbyte; //température min convertie en octet
float weight; // poids
float weight1; //poids en hectogramme pour conversion en octet
byte weightbyte; //poids converti en octet
float weightmax = 0 ; // variable d'enregistrement du poids max, initialisée à 0 pour être sûr de la changer à la première boucle
float weightmin = 400 ; // variable d'enregistrement du poids min, initialisée à 40 pour être sûr de la changer à la première boucle
float weightmax1; //poids max en hectogramme pour conversion en octet
byte weightmaxbyte; //poids max converti en octet
float weightmin1; //poids min en hectogramme pour conversion en octet
byte weightminbyte; //poids min converti en octet

// FONCTION récupérant la température depuis le DS18B20 - pompée toute faite sur internet. Casse pied à décortiquer car relève de la lecture de messages série.
// Retourne true si tout va bien, ou false en cas d'erreur sur la variable booléan
boolean getTemperature(float *temp){
  byte data[9], addr[8];
  // data : Données lues depuis le scratchpad
  // addr : adresse du module 1-Wire détecté
 
  if (!ds.search(addr)) { // Recherche un module 1-Wire
    ds.reset_search();    // Réinitialise la recherche de module
    return false;         // Retourne une erreur
  }
   
  if (OneWire::crc8(addr, 7) != addr[7]) // Vérifie que l'adresse a été correctement reçue
    return false;                        // Si le message est corrompu on retourne une erreur
 
  if (addr[0] != DS18B20) // Vérifie qu'il s'agit bien d'un DS18B20
    return false;         // Si ce n'est pas le cas on retourne une erreur
 
  ds.reset();             // On reset le bus 1-Wire
  ds.select(addr);        // On sélectionne le DS18B20
   
  ds.write(0x44, 1);      // On lance une prise de mesure de température
  delay(800);             // Et on attend la fin de la mesure
   
  ds.reset();             // On reset le bus 1-Wire
  ds.select(addr);        // On sélectionne le DS18B20
  ds.write(0xBE);         // On envoie une demande de lecture du scratchpad
 
  for (byte i = 0; i < 9; i++) // On lit le scratchpad
    data[i] = ds.read();       // Et on stock les octets reçus
   
  // Calcul de la température en degré Celsius
  *temp = ((data[1] << 8) | data[0]) * 0.0625;
   
  // Pas d'erreur
  return true;
}
//fin de la fonction de lecture de la température depuis le DS18B20 - pompée toute faite sur internet.



void setup() {
  Serial.begin(9600);           // lance le port série pour le retour vers le PC (deboggage)
  // la balance :
  scale.set_scale();            // initialise la balance pour détermination du facteur de conversion
  scale.tare();              // reset la balance à zéro
  delay(1000);                  // pause pour avoir le temps de lire
  scale.set_scale(100000.f);    // calibre la balance par division entre le poids de test connu et la valeur affichée lors du test
 
 // Ouverture du port RS485 à 28800 bauds
  rs485.begin (28800);
  pinMode (ENABLE_PIN, OUTPUT);  // patte enable configurée en sortie

}//--(end setup )---

 

void loop() {
  // début de la routine d'affichage du poids
  weight = scale.get_units();
  Serial.print(" Poids : ");
  Serial.println(weight);
  //Serial.println(scale.get_units(), 3);
  //scale.power_down();                 // put the ADC in sleep mode 
  //scale.power_up();
  // fin de la routine d'affichage du poids
 
  // début de la routine d'affichage de la température
   getTemperature(&temp); // Lit la température ambiante à ~1Hz dans la fonction déja vue en début de programme et pompée intégrale
   Serial.print(" Temp : ");// envoie le message au moniteur série
   Serial.println(temp);// envoie la valeur au moniteur série
     
   // enregistrement des températures min et max 
   if (temp > tempmax) { // enregistrement de la température max, si la température lue est sup à la température max archivée alors
     tempmax = temp ; //la nouvelle température max devient la température lue
     tempmax1 = (tempmax+15)*4; // conversion de la température max en quart de degré au dessus de -15°C
     tempmaxbyte = (byte) tempmax1; // passage en octet de la valeur tempmax1
    } // fin de cette collecte de la température max 
   if (temp < tempmin) {// enregistrement de la température min, si la température lue est inf à la température min archivée alors
    tempmin = temp ;
     tempmin1 = (tempmin+15)*4; // conversion de la température max en quart de degré au dessus de -15°C
     tempminbyte = (byte) tempmin1; // passage en octet de la valeur tempmax1
    } // fin de la collecte de la température min
   // fin d'enregistrement des températures min et max
   
   // enregistrement des poids min et max
   if (weight > weightmax) { // enregistrement de la température max, si la température lue est sup à la température max archivée alors
     weightmax = weight ; //la nouvelle température max devient la température lue
     weightmax1 = weight/10; // conversion de la température max en quart de degré au dessus de -15°C
     weightmaxbyte = (byte) weightmax1; // passage en octet de la valeur tempmax1
    } // fin de cette collecte de la température max 
   if (weight < weightmin) {// enregistrement de la température min, si la température lue est inf à la température min archivée alors
    weightmin = weight ;
     weightmin1 = weight/10; // conversion de la température max en quart de degré au dessus de -15°C
     weightminbyte = (byte) weightmin1; // passage en octet de la valeur tempmax1
    } // fin de la collecte de la température min
   
   
    // fin d'enregistrement des poids min et max
   
   //routine de conversion de weight et temp en octet pour communication avec le maitre
   Serial.print(" Temp convertie en quart de degres : ");// envoie le message au moniteur série
   temp1 = (temp+15)*4; // conversion de la température en quart de degré au dessus de -15°C
   tempbyte = (byte) temp1; // passage en octet de la valeur temp1
   Serial.println(tempbyte);// envoie la valeur au moniteur série
   Serial.print(" Poids converti en hectogramme : ");// envoie le message au moniteur série
   weight1 = weight*10;
   weightbyte = (byte) weight1;
   Serial.println(weightbyte);// envoie la valeur au moniteur série
   //fin de routine de conversion de weight et temp en octet pour communication avec le maitre
     
   
   //gestion de la partie RS485
  byte buf [10]; //création de la chaine Buf de 10 octets
  byte received = recvMsg (fAvailable, fRead, buf, sizeof (buf)); // formule magique liée au RS485
 
  if (received) // si un message a été envoyé
    {
    Serial.print(" Consigne presente "); // pour le moniteur série (PC) pour débugage, inutile au programme final
    Serial.println(received); // pour le moniteur série (PC) pour débugage, inutile au programme final
    Serial.println("un message recu :"); // pour le moniteur série (PC) pour débugage, inutile au programme final
    Serial.println(buf [0]); // pour le moniteur série (PC) pour débugage, inutile au programme final
    Serial.println(buf [1]); // pour le moniteur série (PC) pour débugage, inutile au programme final
    Serial.println(buf [2]); // pour le moniteur série (PC) pour débugage, inutile au programme final
    Serial.println(buf [3]); // pour le moniteur série (PC) pour débugage, inutile au programme final
    Serial.println(buf [4]); // pour le moniteur série (PC) pour débugage, inutile au programme final
    Serial.println(buf [5]); // pour le moniteur série (PC) pour débugage, inutile au programme final
    Serial.println(buf [6]); // pour le moniteur série (PC) pour débugage, inutile au programme final
    Serial.println(buf [7]); // pour le moniteur série (PC) pour débugage, inutile au programme final
    Serial.println(buf [8]); // pour le moniteur série (PC) pour débugage, inutile au programme final
    Serial.println(buf [9]); // pour le moniteur série (PC) pour débugage, inutile au programme final
   
      if (buf [0] == 1) // vient du maitre
      { 
      Serial.println("vient du maitre"); // pour le moniteur série (PC) pour débugage, inutile au programme final
     
      if (buf [1] == 2) // c'est pour l'esclave appelé 2
      {
      Serial.println("pour moi"); // pour le moniteur série (PC) pour débugage, inutile au programme final
      }
      if (buf [1] != 2) // ce n'est pas pour l'esclave 2
      {
      Serial.println("pas pour moi"); // pour le moniteur série (PC) pour débugage, inutile au programme final
      }
      ;
    if (buf [2] != 2) // si une commande inconnue est reçue
      {
      Serial.println("commande inconnue"); // pour le moniteur série (PC) pour débugage, inutile au programme final
      }
    else { // création de la réponse pour le maitre
    byte msg [] = {
       2,  // venant de 2
       1,  // adressé au maitre
       tempbyte,  // température sur 1 octet
       weightbyte, // poids sur un octet
       };
       Serial.print("2 octets prets :"); // pour le moniteur série (PC) pour débugage, inutile au programme final
       Serial.print(msg[0]); // pour le moniteur série (PC) pour débugage, inutile au programme final
       Serial.print(msg[1]); // pour le moniteur série (PC) pour débugage, inutile au programme final
       Serial.print(msg[2]); // pour le moniteur série (PC) pour débugage, inutile au programme final
       Serial.println(msg[3]); // pour le moniteur série (PC) pour débugage, inutile au programme final
       
   
    delay (10);  // give the master a moment to prepare to receive
    digitalWrite (ENABLE_PIN, HIGH);  // enable sending
    Serial.println("ouverture du port"); // pour le moniteur série (PC) pour débugage, inutile au programme final
    sendMsg (fWrite, msg, sizeof msg); // envoie du message à destination du maitre
    Serial.println("envoi du message"); // pour le moniteur série (PC) pour débugage, inutile au programme final
    digitalWrite (ENABLE_PIN, LOW);  // disable sending
    Serial.println("fermeture du port"); // pour le moniteur série (PC) pour débugage, inutile au programme final
   
   }}}}
  /*
   Voila c'est fini pour la version 1 ; Il est possible de changer  le programme pour, par exemple, envoyer la température max
   et le poids max quand le maitre envoie une autre commande que 2, par exemple 3 sur buf [2]  et la température et le poids min
   quand le maitre envoie 4 sur buf [2] par exemple... Le maitre n'aura plus qu'à stocker toutes les valeurs pour consultation
   depuis l'afficheur.
   on peut aussi imaginer une alerte au maitre quand un nouveau poids ou temperature min ou max est enregistré avec un horodatage
   sur le maitre. Il faudra alors être capable de gérer 2 appels d'esclaves au même moment ...
   */
 

Cordialement,
Vince ;)

Merci, à tous les contributeurs du net et de la littérature- Snootlab, Nick Gammon, Christian Tavernier, Rostrich, Github, Sparkfun, Adafruit, Nico. Toutes mes excuses à ceux que j'aurai pu oublier.
Vince
 
Messages: 22
Inscription: Sam 27 Déc 2014 11:25

Re: Bonjour de Normandie

Message non lude Vince » Sam 23 Jan 2016 19:56

Cette fois je reviens à vous avec cette onzième plaie d'Egypte qu'est la programmation des Pro minis.

Ce microscopique Arduino est génial pour ne pas s'encombrer de la circuiterie qui ne sert plus, une fois que le programme est chargé. En plus, il ne coûte rien. Mais c'est une galère à téléverser.

Il y a des dizaines de pages consacrées à ce problème, mais il y a beaucoup de variantes au problème :
DSC05014.JPG
Le message du début des ennuis...
DSC05014.JPG (68.83 Kio) Vu 5141 fois


Tout d'abord, je travaille sous XP avec des pro minis 5V Atmel 328. J'utilise les suites arduino 1.0.1 ou 1.6.7.Mais la version du logiciel ne fait rien à l'affaire,...quand on est c..., on est c... comme dit la chanson.

Pour pouvoir utiliser des "Uno" chinois, j'installe systématiquement le patch CH341SER :
DSC05012.JPG
Le patch chinois...
DSC05012.JPG (93.55 Kio) Vu 5141 fois


Il se déplie en l'écran suivant qui donne ceci quand on active le setup :
DSC05015.JPG
...et son installation...
DSC05015.JPG (97.12 Kio) Vu 5141 fois


Reprenons le fil de la programmation des pro minis. Tout d'abord, le blink.ino universel fonctionne bien car le promini dispose d'une led sur sa patte 13.

Naturellement, le promini est branché sur un adaptateur USB FTDI disposant du circuit FT232RL. Les fils utiles sont TX sur RX, RX sur TX, 5V, GND et DTR.
Dernière édition par Vince le Sam 23 Jan 2016 20:48, édité 1 fois.
Vince
 
Messages: 22
Inscription: Sam 27 Déc 2014 11:25

Re: Bonjour de Normandie

Message non lude Vince » Sam 23 Jan 2016 20:15

DSC05003.JPG
le pro mini avec son programmateur USB FYDI
DSC05003.JPG (107.1 Kio) Vu 5138 fois


Ensuite on branche la prise USB et...c'est le début des ennuis :

Il semblerait qu'il faille disposer de deux jeux de drivers : un pour le FTDI et la deuxième passe pour le sérial USB.
Il semblerait qu'un des deux soit natif dans le répertoire adruino/drivers mais pas l'autre que l'on peut télécharger ça et là mais pas toujours dans une version idéale... puisque ça ne fonctionne pas mieux avec le dernier driver du site FTDI chips.


Ensuite, il est opportun de vérifier dans le gestionnaire de périphériques que l'ensemble est bien reconnu.
Attention, on lit ça et là que l'arduino est reconnu avec mention que c'est un arduino ... eh bien, pas chez moi : il figure juste la mention du nouveau port série ouvert...
DSC05018.JPG
Pas de mention d'arduino sur mon PC
DSC05018.JPG (79.16 Kio) Vu 5138 fois


Enfin on vérifie les paramètres du port série créé :
la vitesse qui, pour certains bugs, est corrigée en passant de 9600 bauds à 19200 bauds.
DSC05017.JPG
19200 bauds
DSC05017.JPG (78.92 Kio) Vu 5138 fois

et le RTS qui doit être coché pour corriger d'autres bugs :
Vince
 
Messages: 22
Inscription: Sam 27 Déc 2014 11:25

Re: Bonjour de Normandie

Message non lude Vince » Sam 23 Jan 2016 20:21

DSC05016.JPG
paramètre RTS
DSC05016.JPG (88.02 Kio) Vu 5138 fois

Ensuite retour au programme d'interface Arduino :
On choisit la bonne carte et le bon port :
DSC05004.JPG
Port série et bonne carte choisis
DSC05004.JPG (99.33 Kio) Vu 5138 fois

Puis on lance le téléversement de blink.ino et....
DSC05005.JPG
I have a dream...
DSC05005.JPG (88.52 Kio) Vu 5138 fois

Çà marche sur certains PC et ça marche pas sur d'autres ...
Vince
 
Messages: 22
Inscription: Sam 27 Déc 2014 11:25

Re: Bonjour de Normandie

Message non lude Vince » Sam 23 Jan 2016 20:37

Si ça ne marche pas...et j'ai le problème avec un de mes deux PC, eh bien, pour l'instant, je ne sais pas pourquoi !

Mais il reste une solution : utiliser le circuit d'interface d'une autre carte arduino : pour ce faire, j'utilise une duemilanove dont j'ai retiré le microcontrôleur atmel.
DSC05006.JPG
Vue générale
DSC05006.JPG (124.59 Kio) Vu 5135 fois

Il est connecté par 5 fils au promini :
la patte 0 du duemilanove repérée RX< vas au RX du promini
la patte 1 du duemilanove repèrèe TX> vas au TX du promini
Le Reset du duemilanove sur le DTR du promini
Le 5V sur le 5V et le GND sur le GND des 2 cartes.
DSC05007.JPG
Cablage hors RX et TX
DSC05007.JPG (107.85 Kio) Vu 5135 fois

DSC05008.JPG
RX et TX
DSC05008.JPG (79.54 Kio) Vu 5135 fois


Quand on branche l'USB, ça se reconnait tout seul et il faut juste penser à choisir la bonne carte dans la suite arduino.
Dernière édition par Vince le Sam 23 Jan 2016 20:51, édité 1 fois.
Vince
 
Messages: 22
Inscription: Sam 27 Déc 2014 11:25

Re: Bonjour de Normandie

Message non lude Vince » Sam 23 Jan 2016 20:46

Comme ceci :

DSC05010.JPG
Choisir la bonne carte...
DSC05010.JPG (94.25 Kio) Vu 5135 fois


Par cette méthode, sur mes PC, ça fonctionne toujours...même si ce n'est pas très élégant, je le reconnais.

Si un lecteur dispose des bonnes adresses pour les drivers FTDI qui fonctionnent à coup sûr avec l'adaptateur USB FTDI...je suis preneur car je pense que le problème vient de là.
On lit ça et là une histoire de reset à faire sur le promini entre la compilation et le téléversement : je n'ai jamais réussi par cette méthode. Je n'ai cependant pas essayé le cablage d'un condensateur sur le reset du promini comme on le lit aussi.

Hope this helps...
Vince
Vince
 
Messages: 22
Inscription: Sam 27 Déc 2014 11:25

Re: Bonjour de Normandie

Message non lude Vince » Sam 23 Jan 2016 23:52

Je crois que je viens de comprendre le problème : FTDI chips a intégré un piège sur son driver de dernière génération : les circuits non originaux sont rendus non utilisables par transformation d'un code interne.

Ainsi ça fonctionne avec le FTDI original de mon duemilanove mais pas avec mes USB / FTDI chinois.
IMGP2646.JPG
Et pourtant, ça ressemble à un "genuine FTDI"
IMGP2646.JPG (62.08 Kio) Vu 5115 fois

La conclusion est claire pour moi : ne plus jamais acheter de matériel comportant du FTDI : c'est le consommateur qui est lésé, pas le fraudeur...C'est le scandale du FTDI.

Vince.
Vince
 
Messages: 22
Inscription: Sam 27 Déc 2014 11:25

Re: Bonjour de Normandie

Message non lude Laetitia » Lun 25 Jan 2016 10:30

Bonjour,

Joli projet, et beau travail de debug sur la partie Pro Mini ! Merci de l'avoir aussi bien documenté.
Pour plus d'explications sur le driver FTDI, voir l'article sur hackaday. Pour info, il existe désormais des outils permettant de récupérer les FT232R dont le PID a été remis à 0.
"If it's itchy, scratch it !" - "DIY or die"

RTFM (À lire avant de poster) - ANDb (Arduino Noob Database)
Avatar de l’utilisateur
Laetitia
 
Messages: 296
Inscription: Mar 7 Aoû 2012 15:07
Localisation: Toulouse


Retourner vers Présentez-vous

Qui est en ligne

Utilisateurs parcourant ce forum: Google [Bot] et 1 invité

cron