pour mes talkies pas de prise ça fonctionne exactement comme un veille bébé en plus sur le modèle que j'ai il y a un réglage de sensibilité de détection sonore ça peu éviter des mise en route intenpestives a cause du vent par exemple

bonjour a tous,pouriez vous publier une photo du cicuit imprimé complet pour que je puisse le réaliser, car le mien ne marche pas...

wa merci pour cette astuce c'est vraiment pas c... et merci pour le schema et explication en detail encore bravo

Bravo pour cette astuce c'est vraiment bien pensé ...

Pas mal le système

Je dit Bravo fallait y pensais ! à combien reviendrais un peux près le tout en comptant 4 détecteur à acheter ? Ayant un budget limité ca pourrait peut - être m ' aider

le probleme c'est au niveau étanchéité nan ?

Bon après je pence que ca reviens aussi chère le tout ! lol

Bonjour à tous,

Voilà réouvrir ce post pour vous montrer ma nouvelle centrale faite maison, celle ci est plus complète!
J’avais quelques composants électroniques et j’ai décidé de me lancer dans ce projet.

Le principe est classique:
Un émetteur pouvant accueillir 4 détecteurs du commerce et un récepteur avec 4 leds ; une associée à chaque détecteur, quand un détecteur sonne sa led s’allume sur le récepteur durant 9 secondes, et le buzzer sonne 1 seconde.


N’étant pas un expert en programmation j’ai tout simplement commencé avec une centrale analogique (pas besoin de programmer quoi que ce soit, car je n’y connaissais rie.)

J’ai donc fait un premier proto avec des composants du commerce (émetteur et récepteur facile à trouver et facile à utiliser (des modules AUREL, avec une portée annoncée de 100m)
J’ai réalisé ces circuits suivants :

Schéma TX :


Schéma RX :


Les typons réalisés :


Voici des photos des phases de test (j’essayais plusieurs types d’antenne la c’était des « antennes plan de masse » qui marche plutôt bien !

Photo de l’émetteur :


Photo du récepteur :


Au niveau de la portée, j’ai réussi à atteindre une portée de 50-60m en terrain dégagé avec ces modules, mais avec des obstacles (des arbres notamment, la portée diminuait fortement.).

J’ai donc commandé des nouveaux modules de la marque Radiométrix TX3H et RX3A, la portée annoncée est de 3km (avec ca plus de problème de réception en théorie.)
Premier test effectué avec un fil en guise d’antenne, je me suis arrêté à 200m et ma centrale fonctionnait encore.

Voilà ce que donne mon premier test sans le système qui laisse allumer les leds 10 secondes :
https://www.youtube.com/watch?v=EGRamq33dDo

Ca fonctionnait plutôt bien, bien qu’ un petit soucis me travaillait, c’était l’autonomie car mon émetteur et mon récepteur étaient alimentés chacun par une pile 9v et j’avais un peu moins de 40h d’autonomie sur le récepteur…
Et lorsque le récepteur commençait à voir sa batterie faiblir il s’allumait tout seul, pas terrible en pleine nuit par exemple.

En modifiant le récepteur pour y apporter des petites modif, j’ai du griller un composant mais ai pas trouvé lequel…

Entre temps je me suis mis à la programmation, j’ai donc décidé de me fabriquer une nouvelle centrale (reprendre le max de composants de l’ancienne) cette fois ci programmée.

J’ai utilisé pour cela des microcontroleurs Atmega168 programmé via Arduino (plateforme opensource simple et efficace pour débuter).

Vu que ce microcontroleur a 6 entrées analogiques, il est possible de connecter facilement 6 détecteurs.

Je me suis dit que je pourrais utiliser 5 entrées pour des détecteurs (4 pour ma batterie de canne et une cinquième pour connecter les détecteurs du collègue qui n’a pas de centrale. Et la dernière entrée pouvant dans l’avenir être utilisée pour détecter le niveau des batteries de l’émetteur.).

Voilà le schéma sommaire du montage réalisé :

(les schéma arrive, mon scanner est fatigué ces temps ci)


Après quelques week end de tests, je suis arrivé à des programmes qui fonctionnent bien. Je vous les transmets :

Le code de l’émetteur :

Code:

 /* Emetteur de la centrale sans fil: alimentation en 5v par boitier 6 piles AA et régulateur 5v
  5 entrées analogiques pour détecteurs
 debit de communication volontairement faible pour augmenter la portée
 crypage sur 6 Octets seulement pour éviter d'avoir un mot trop long a envoyer et pas necessité d'un cryptge complexe
*/
char cryptage[]="code";              // code de cryptage de 4 caracteres (a changer)
int pindet[5]={0,1,2,3,4};              // deteceteurs connectés sur les entrées analogiques 0 a 4
int pinTX=5;                            // allimentation de l'emetteur sur la pin
int niveaumini=100;                    // niveau mini d'activation
int etatdet[5];                        // donne l'etat des detecteurs: 0 si rien 1 si activé
char codagedet;                          // codage sur 8 bytes de l'etat des detecteurs


void setup(){
  Serial.begin(1200);                    // activer la liaison serie
  pinMode(pinTX,OUTPUT);                // pin activation TX
  digitalWrite(pinTX,HIGH);            // allumage de l'emetteur 
  delay(20);                            // l'emetteur met 55ms pour etre opérationnel,                               
    for(int i=1;i<=14;i++){              // envoi des données 14 fois du code
      Serial.print(cryptage);
      Serial.print(char(32));
      Serial.print(char(32));
      Serial.print(char(32));
  }           
  digitalWrite(pinTX,LOW);              // extinction de l'emetteur
  delay(300);
}

void loop(){

if( analogRead(pindet[0])>niveaumini ||  // si un des detecteurs est actif
    analogRead(pindet[1])>niveaumini ||
    analogRead(pindet[2])>niveaumini ||
    analogRead(pindet[3])>niveaumini ||
    analogRead(pindet[4])>niveaumini ){     
     
    digitalWrite(pinTX,HIGH);            // activer l'emetteur
   
    for(int det=0;det<=4;det++)          // verifier l'etat de tous les detecteurs
      {if(analogRead(pindet[det])>niveaumini){etatdet[det]=1;}
      else {etatdet[det]=0;}
}
    codagedet=char(                      // codage de l'etat des detecteurs en char
                    1*etatdet[0]+        // on passe les infos detecteurs/niveau batterie que sur 1 octet
                    2*etatdet[1]+
                    4*etatdet[2]+
                    8*etatdet[3]+
                  16*etatdet[4]    );

                 
    delay(20);                          //
      Serial.print("go");              // 20 + 15 = 35ms avant emission du code         
    for(int i=1;i<=14;i++){            // envoi des données 14 fois du code
      Serial.print(cryptage);
      Serial.print(codagedet);
      Serial.print(codagedet);
      Serial.print(codagedet);
    }                 
   
    digitalWrite(pinTX,LOW);            // désactiver l'emetteur
    delay(210);                        // eviter le rallumation directement apres extinction du TX
}
}

Et le code du Récepteur :

Code:

/* Recepteur de la centrale sans fil: alimentation en 5v max par boitier 4 piles AA et zener de régulation
 6 leds: 5 associées aux détecteurs et la 6° pour la verif de synchronisation a l'allumage de l'emetteur
 debit de communication  volontairement faible pour augmenter la portée
 
 crypage sur 6 Octets seulement pour éviter d'avoir un mot trop long a envoyer et pas necessité d'un cryptge complexe
*/

char cryptage[]="code";              // code de cryptage de 4 caracteres (a changer)
int signal=0; int signal2=0;                      // signal des detecteurs
int pinled[6]={6,5,9,10,11,13};              // pin de connection des leds
int pintone=7;                                // pin du buzzer
int pinRX=3;                              // pin d'allumage du module de reception

unsigned long tempo[7];                        // declaration des variables de temporisation
long tempomax=9000;    long tempomoy=5000;    // temps avant d'éteindre les leds (en ms)
long tempotone;
long tempotonemax=200;                    // temps d'allumage du buzzer
int ledbas=24;                                  // tension leds reduite (24/255*Valim)
int freq[6]={4200,3600,3600,3600,3600,5400};    // frequence du buzzer selon le détecteur allumé


void setup(){
Serial.begin(1200);                        // activer la liaison serie                 
pinMode(pintone,OUTPUT);                  // definition de la sortie buzzers
pinMode(pinRX,OUTPUT);                    // définition de la pin de connection Enable du RX
for(int i=0;i<=5;i++){                    //
  pinMode(pinled[i],OUTPUT);              // definition des pin de sortie des leds
  }
 
 for(int i=0;i<=5;i++){                    //
  digitalWrite(pinled[i],HIGH);          // test des leds
  delay(100);  }
 
for(int i=0;i<=5;i++){ 
  digitalWrite(pinled[i],LOW);            // extinction des leds
  delay(2);  }
 

digitalWrite(pinRX,HIGH);                  // activation du recepteur
delay(30);                                  // emetteur actif en 30ms
for(int j=0;j<=1;j++){
  tone(pintone,1300);    delay(120);        // test du buzzer et sonnerie d'initalisation
  tone(pintone,1300/2);  delay(120);}
noTone(pintone);
delay(100);
}

void loop(){
  RX();                                // décryptage des données et activation des leds
  gestiondutps();                      // gerer le temps d'allumage des leds
 }
 
 void RX(){
 if(Serial.available()>=7){                      // decryptage du code 
  if(char(Serial.read())==cryptage[0]){         
    if(char(Serial.read())==cryptage[1]){         
      if(char(Serial.read())==cryptage[2]){
        if(char(Serial.read())==cryptage[3]){
              signal=Serial.read();              // si le code est bon enregistrer le signal 
              signal2=Serial.read();              // si le code est bon enregistrer le signal
              if(signal==signal2){
        for(int led=0;led<=5;led++){              // lire byte par byte les données des détecteurs
        if(bitRead(signal,led)==1){              // si le détecteur est allumé
            tone(pintone,freq[led]);              // activer le buzzer
            digitalWrite(pinled[led],HIGH);    // activer la led associée
            tempo[led]=millis();
            tempotone=millis();}                        // incrémenter la tempo led associée
          }
            }}}}}}                                // fermeture de tous les if
}                                                // fin de de la fct RX
   
void gestiondutps(){                              // fonction qui gere le temps d'allumage leds
  for(int d=0;d<=3;d++){
    if((millis()-tempo[d])>tempomoy && (millis()-tempo[d])<tempomax && millis()>tempomax) {analogWrite(pinled[d],ledbas);}  //reduit l'intensité lumineuse au bout de 5sec
    if((millis()-tempo[d])>tempomax) {digitalWrite(pinled[d],LOW);}                                    // coupe la lumiere au bout de 9sec
  }
 
  for(int d=4;d<=5;d++){
    if(millis()-tempo[d]>tempomoy) {digitalWrite(pinled[d],LOW);}                 
  }

if(millis()-tempotone>=tempotonemax)                                      // coupe la lumiere au bout de 9sec
        {noTone(pintone);}         
 }
 
 

Le module de transmission consomme énormément (plus de 500mA) donc le programme l’allume que lorsqu’il y a une touche.

Voilà les circuits imprimés réalisés



Avec les composants soudés ca donne ca :

L’émetteur sans les jacks montés :


Voilà une photo lors de test :


Et voilà le récepteur :
Le circuit dans la partie haute, le buzzer en dessous et les piles par dessus


Une fois les piles misent :


Et vue de devant ca donne ca :


Une vidéo vaut souvent mieux que des mots :
https://www.youtube.com/watch?v=WNDDx0MJqVg


Avec ce montage l’émetteur consomme (module de transmission éteint) 20mA et plus de 500mA module allumé.
Il est alimenté par 8 piles AA 2300mAh, ce qui donne une autonomie moyenne calculée d’environ 100h soit plus de 4 jours.

Et le circuit de réception consomme 21mA toutes leds éteintes et environ 40mA toutes leds allumées.
Il est alimenté par 8 piles AAA 800mAh, ce qui donne une autonomie moyenne calculée d’environ 73 soit un peu plus de 3 jours.

La centrale fonctionnent plutôt bien pour le moment.
Pas de problème d’interférence, avec d’autres appareils (Testé une journée en plein Paris et pas eu d’allumage intempestif ni de problème de communication, ce qui est bon signe je pense.).

J'ai testé sa portée ce week end, j'ai arrêté l'essai à une distance de 260m à l'orée d'une foret et je captais encore parfaitement (de quoi être tranquille).
a voir comment elle se comporte dans le temps au bord de l'eau!
je posterais les photos de ma réalisation dans une quinzaine de jours.

Je pense faire quelques évolutions par la suite, du type tester la connexion émetteur/récepteur tous les 15 minutes, pour s’assurer qu’il n’y a pas de soucis de réception.
Et aussi un avertisseur de batterie faible sur l’émetteur ainsi que sur le récepteur qui l’indiquerait quand il faut changer les piles.

Si vous souhaitez obtenir plus de détails demandez moi.

Bravo pour le taf
Plus que a réduire la conso et le nombre de piles! Et tu peu lancer ta boite !
Et moi je te fait les boitier en alu usiné ou inox(centrale recepteur en coque inox et un joint machin pour plongée moin 5000metre de profondeur tu vois le truck de competition!) et on la on deboite Delkim !! , tu devien le roi du pétrole!!
Sinon rien a dire tu gére!

effectivement le problème reste la consommation, mais je vais y travailler,
mon but nest pas de commercialiser mes créations mais de les partager, si ça peut donner des idées a d'autres personnes!!

alors la génial chapeau bas
tu dois être dans le metier non ?

Belle réalisation.
Débutants s'abstenir.

Jean

Sacré boulot que tu as fait là.
Tes lignes de programation sont terribles. C'est la première fois de ma vie que je comprends quelque chose là dedans.

Bravo pour ta réalisation, et un grand merci pour le partage

impressionnante ta réalisation !!!

du très bon taf !!

C'est formidable ! 3 Km de portée, avec ça je peux mettre mon rod au bord de l'eau et dormir dans mon lit, au moins si les poissons ne me réveillent pas, je peux toujours ennuyer la maman.

petite modif de ma centrale (le nombre de pile relativement élevé me tracassait).
maintenant l'émetteur fonctionne avec 4 piles AA et le récepteur avec 3 piles AA.
programmes totalement repensé (je les mettrai si ça intéresse qqun)
avec les motifs:

consommation autonomie calculée

émetteur 4mAh au repos 650mAh en action environ 4 et 5 jours

récepteur 12mAh au repos 24mAh en action environ 4 et 5 jours


ce qui largement suffisant pour mon usage.

voila les photos des systèmes:

l'émetteur ouvert:


le récepteur ouvert:


l'ensemble refermé:

Je tiens tout d'abord à te féliciter pour cet énorme travail, ça donne vraiment envie.
Je revais de le faire lorsque j'étais gamin, par manque de moyen mais surtout grâce à mon goût de la conception.
Malgré plusieurs tentatives infructeuses, j'ai abandonné le projet...

Il a remuri ce soir, j'ai pourtant les moyens de m'offrir une centrale haut de gamme, mais toujours cette idée en tête avec une envie de revanche !

A la lecture de tes posts, j'avoue que tu partages vraiment beaucoup ton expérience sur le domaine et ça donne d'autant plus envie. Du coup, j'ai décidé de m'y relancer, c'est d'ailleurs surtout grâce à toi ! Merci d'ailleurs pour tes schémas précis, les références, etc...

J'ai deux petites questions à te poser :
Quelle interface de communication utilises-tu pour coder les microcontrolleurs ?
Pourrais-tu me faire parvenir ta V2 du code optimisant la consommation ?

Je te remercie par avance pour tes réponses! Pour ma part, je vais me préparer un listing des composants à me procurer !

Patrick.

PS : j'ai déjà une idée d'amélioration de l'ensemble, un contrôle du volume sur le réception. Mais pour l'instant, je vais d'abord me concentrer l'objectif principal...

pour ce qui est du l'interface de communication, avec la carte de développement utilisée (arduino) y a des interfaces de communication sans fil précédé qui existe mais j'ai utilisé une manière de cryptage toute simple.
mes modules d'émissions et de réception sont compatible avec une liaison série classique. donc j'envoie juste un mot clé en début de message puis l'état de mes détecteurs (ex: code0010) et en réception si le début du mot reçu est bien code alors il lit l'état des détecteurs envoyé.
j'espère avoir été clair dans mon explication.
pour réduire la consommation j'ai changé le bootload de mon microprocesseur. au lieu de fonctionner a une fréquence de 8Mhz il ne fonctionne qu'a 1Mhz. mais au lieu de consommer 20mA il n'en consomme de 300uA (autant dure 60 fois moins.)
pour réaliser cette manip
j'ai trouvé le bootload sur ce site http://www.experiment4.com/2011/08/21/slowduino/
ce bootload implique pas mal de problème (le buzzer qui donne un son de canard...)

si tu veux y a une solution super intéressante j'ai commencé a la la développer mais ai pas eu le temps de la mettre au point:
utiliser un encoder et décoder externe (perse j'ai utilisé un MC145026 et en réception le module associé MC145027.
ces systèmes consomment quasi rien et permettnt un cryptage efficace et le code peut être modifié (avec switch comme sur quasi toute les centrales)
le microprocesseur est en veille quand un signal est reçu cela l'allume. efficace et peu de consommation.

Merci pour ton retour et ces précisions. Je vois que tu as bien avancé !!

As-tu un schéma correspondant à la version finale ?