Porte de poulailler automatique PCB + impression 3D

[system]

Bonjour à toutes et à tous !

Voici mes premiers pas sur ce forum, cela fait pourtant quelques années que je le parcours pour mes recherches d'informations.
Je tiens à remercier tous ceux qui m'ont aider sans le savoir ! Comme j'ai une mémoire de poule, j'ai des difficultés à tous vous citer, donc pour pas faire de jaloux, je remercie tous le monde !

Je vais sans doute faire plusieurs post à la suite, j'ai une connexion execrable.

INTRODUCTION
Mon objectif principal était d'automatiser l'ouverture et la fermeture de mon poulailler, car faut avouer que c'est relou (c'est pas non plus la mort... OK!)
Je débute en Programmation/Electronique, j'apprend à mon rythme et là je voulais faire un projet abouti, un produit fini.

La conception a été très longue ! Bordées d’échecs, d'erreurs et de victoires ! Je suis parti sur une maquette du mécanisme, pour avoir tout sous la main, puis plusieurs prototypes (du grand art : supper glue, colle à chaud, des fils dans tous les sens, des composants soudés en l'air...) plusieurs montages, plusieurs codes...
Le plus difficile fut pour moi la partie électronique (choix des composants, lectures des datasheets et essais des composants) et surtout le besoin d'avoir un système basse consommation.

LES BESOINS

• Système autonome en énergie (pas de pile à remplacer, pas de câble d'alim...)
• Ouvre la porte le matin et la ferme le soir !
• Mécanique simple presque plug and play (pour porte à guillotine)
• Faire un produit "fini"
• Système compact
• Pas plus chère qu'un truc du commerce

CARACTÉRISTIQUES FINALES

• Alimentation sur batterie li-ion 1 cellule 18650 en 3.7V
• Recharge par panneau solaire 6V 330 mA via un module TP4056
• Système basse consommation : environ 250µA en standby, environ 5 mA éveillé, environs 35mA lorsque le moteur fonctionne
• Ouverture et fermeture en fonction de la luminosité, mesurée par le panneau solaire. Il y a une temporisation pour s'assurer qu'il fait bien nuit ou bien jour (phare de voiture, chat qui se couche sur le panneau...)
• Fin de course haut et bas pour détecter l'état de la porte
• Lecture de l'intensité du moteur et détection de porte bloquée (fonction actuellement basique qui mérite d'être encore développée)
• Led d'indication de batterie faible
• Sélecteur de mode (AUTO, ouverture forcée, fermeture forcée)
• L'ensemble de la réalisation ma coûté environs 60€, donc objectif remplis ! Sachant que j'ai tout acheté

PRINCIPAUX COMPOSANTS

• Atmega328P alimenté en 3.3V avec oscillateur interne 8MHz
• Driver de moteur VNH7070BASTR, il utilise en pont en H avec MOSFET avec une très faible perte de tension (0.6V de mémoire), j'ai trouvé ce composant génial ! j'en parlerais plus loin
• Régulateur LDO 3.3V LD3985M33R, très faible perte de tension, par contre il est vraiment petit ! Mais ça se soude.
• Moto-réducteur DF-FIT0495-A DFROBOT 6V, 15 RPM. Il consomme moins que ce qui est indiqué dans sa "documentation", j'ai été impressionné par son rapport couple/intensité.

Le reste, c'est des composants classiques, qui ne m'ont pas apportés de difficultés. Je joint la nomenclature avec les liens des datasheet.

PS : Désolé pour le double post, j'ai pas été doué

Nomenclature PCB.zip (10.3 KB)

[system]

LE MONTAGE

Charge de la batterie
J'ai utilisé un simple TP4056 avec circuit de protection. Pour du solaire ce n'est pas ce qui se fait de mieux, mais c'est tout simple, pas chère et ça fonctionne assez bien. En journée, bien que mon panneau soit toujours à l'ombre (le poulailler est coté nord de la maison) le courant de charge moyenne est de 10-15 mA. Ce qui est largement supérieure à la consommation du montage, généralement vers 11h (en mars/avril), la batterie ne se charge plus (led bleu du TP4056 s'allume indiquant la fin de charge).
Le TP4056 commence à charger la batterie lorsqu'il reçois une tension supérieure à celle-ci. En plein soleil évidement, le courant de charge atteint facilement 250 mA pour un panneau vendu pour 330.

Pour le condensateur de 100µF C7, mes expérimentations m'ont montrées qu'il fait augmenter le courant de charge mais fait baisser la tension en entrée du module. Si quelqu'un peut m'expliquer le phénomène je suis preneur.

Le fusible FH1 et la diode D2 sont une sécurité en cas d'inversion de polarité de la batterie (bas oui ça m'est arrivé, et il y a eu des dégâts !) Si on se trompe, la diode met la batterie en court circuit et le fusible fond. C'est aussi très utile pour brancher à la place un ampèremètre, ou couper l'alimentation.

Le microcontrôleur
Vous connaissez tous l'ATmega 328P-PU qui est monté sur les carte Arduino UNO par exemple. Je l'ai utilisé en standalone (comme y disent). Cela permet une intégration sur PCB. Je l'ai monté sur un support DIP pour pouvoir le démonter et le charger sur une platine d'essais au lieu d'emmener l'ordi sur place. Hé oui faut penser aux mises à jours, ça ne se passe jamais comme prévue dans le "labo".
J'ai décidé de l'alimenter en 3.3V et d'utiliser son oscillateur interne de 8MHz pour des raisons de consommation et que je n'ai pas besoin de vitesse ni de précision. J'aurais peut être pu utiliser un autre microcontrôleur moins gourmand, mais je voulais me faire la main sur celui-ci en prime.

Régulation de tension
J'ai utilisé le LD3985M33R, c'est un régulateur avec une faible chute de tension dit LDO. Le montage est celui indiqué dans sa doc. Il sert uniquement à alimenter l'ATmega.
Il peut recevoir jusqu’à 6V entrée, à 7V il grille (oui j'en ai grillé quelques un, faut toujours en acheté plus que prévue) Donc le panneau solaire 6V max et il faut vérifier cela au multimètre. Il fonctionne très bien avec une tension inférieure à 3.3V, seulement il en sortira un tension inférieure à 3.3V.

Le système commence à déconner lorsque la tension de la batterie passe en dessous de 3.2 V. Dès lors que le moteur entre en action, il y a une baisse de tension à la batterie, et l'ATmega reboot.
Normalement la batterie ne descend pas a ces tensions étant rechargée chaque jours (sauf quand elle sera en fin de vie).
Le moteur et son driver son directement alimentés par la ligne Vbat (tension batterie)

Les condensateurs 100µF C10 (sur la ligne 3.3V) et 100nF C8 (au plus proche du µC) sont parfaitement indispensables pour éviter les reboot du µC lors des chutes de tensions passagères lorsque le moteur démarre par exemple.
Idem pour le condensateur de 270µF C11 et 100 nF C13 pour le driver du moteur.

Le driver moteur
j'avait commencé par le traditionnel L293D. Malheureusement il provoque une chute de tension trop importante (1.7V il me semble) car il utilise des transistors qui ont une chute de tension plus élevé que les MOSFET. Le moteur étant alimenté par la batterie (3.5 à 4.2V) ce qui ne fait déjà pas beaucoup pour un moteur 6V.
Après moultes recherche je suis tombé sur ce petits bijoux, le VNH7070BASTR. Il s'agit d'un pont en H complet avec des MOSFET, il fonctionne avec des tensions jusqu'a 38V et 15A max. Son RdsON est de 70 Mhoms. On le commande en 3.3V sans soucis. Il renvoie également une information sur la consommation du moteur sous forme d'une tension proportionnelle au courant, donc très facile à utiliser. On peut bien sur utiliser du PWM pour faire varier la vitesse du moteur.

Je vous met un résumé de la datasheet en PJ (en fait de ce que j'en ai compris !)

Lectures analogiques
Les tension du panneau solaire et de la batterie sont lues via un pont résistif avec des valeur assez élevées, cela permet de réduire la consommation sans pourtant perdre trop en stabilité et en précision.
Le condensateur C5 de 1µF sert à lisser la mesure de la tension de la batterie. Sa fonctionne plutôt bien. Pour le panneau solaire, il y a deja C7 à ses bornes, la variation mesurée est même lente, mais c'est pas plus mal (phares de voiture la nuit... n'ont pas d'effet) ça fait une sorte de moyenne hardware.

Manque encore le code, les photos, les liens pour les fichiers 3D et pour le PCB, avec tous ces gosses (confinés avec moi) qui font du bruits autour de moi, jvé allez faire une pause.

Schema_PORTauto_REV1.10.pdf (84.7 KB)

Synthese VNH7070BAS.pdf (247 KB)

[system]

LE CODE

J'ai scinder mon code en 2 fichiers en mode IDE Arduino :

• Le fichier principal PORTauto_v1.12_140320.ino
• Un second fichier Fonctions.ino qui regroupe toutes les fonctions

Chez-vous, il faut tout ranger dans le même sous dossier dans le dossier Arduino. En ouvrant le fichier principal ça doit ouvrir le second en l'affichant comme un second onglet. Je trouve ça très pratique.
Le code est également en PJ.

Le fichier principal PORTauto_v1.12_140320

 String titre = "PORTauto V1.14 14/03/20" ;
 
 /*    Gestion motoreducteur CC brushed par pont en H avec le circuit integré VNH7070BAS (mosfet)
       Fin de course haut et bas
       Surveillance Low batterie
       Surveillance Intensitée moteur bloqué 
       Minuterie max de fonctionnement de la porte
       Selecteur ouverture et fermeture manuelle ou mode auto
*/

#include <LowPower.h>
//#define Debug                     // Commenter pour ne pas compiler tout ce qui concerne le moniteur serie

const byte PIN_SOL = A0 ;         // Entrée analogique tension panneau solaire
const byte PIN_BAT = A1 ;         // Entrée analogique tension batterie
const byte PIN_SWDO = 2 ;         // Entrée digitale selecteur (Fermeture manuelle)
const byte PIN_SWUP = 3 ;         // Entrée digitale selecteur (Ouverture manuelle)
const byte PIN_FCBAS = 5 ;        // Entrée digitale Fin de course bas
const byte PIN_FCHAUT = 4 ;       // Entrée digitale Fin de course haut
const byte PIN_INA = 11 ;         // Sortie VNH7070BAS INA
const byte PIN_INB = 12 ;         // Sortie VNH7070BAS INB
const byte PIN_SEL = 9 ;          // Sortie VNH7070BAS SEL
const byte PIN_PWM = 10 ;         // Sortie VNH7070BAS PWM
const byte PIN_CS = A2 ;          // Entrée VNH7070BAS CS (info courant moteur)
const byte PIN_LED = 13 ;         // Sortie LED Batterie faible

const int SEUIL_NUIT = 150 ;      // luminosité maxi pour considérer nuit en mV
const int SEUIL_JOUR = 600 ;      // luminosité mini pour considérer jour en mV
const byte RETARD_JN = 15 ;       // Retard commutation jour/nuit en nombre de boucle
const long TEMPO_MOT = 52000 ;    // Delais max minuterie d'ouverture ou fermeture de la porte en ms
const int I_MAX = 360 ;           // Seuil maxi du courant moteur en mA pour considérer bloqué
long debut_tempo_mot ;            // Debut de la minuterie du moteur
long nb = 0 ;                     // Valeur du compteur de boucle en nombre de boucle (8s)
bool compteuractif_nb = false ;   // Etat du compteur de boucle
byte etat_jn ;                    // Etat jour = 1 ou nuit = 0
bool etat_fcbas ;                 // Etat contact fin de course bas (0 = pas en butée)
bool etat_fchaut ;                // Etat contact fin de course haut (0 = pas en butée)
int val_sol ;                     // Valeur tension panneau solaire (pour la luminositée)
int val_cs ;                      // Valeur courant moteur par VNH7070BAS = Tension proportionnelle au courant.
int ipwm ;                        // Valeur du PWM pour l'accelération du moteur

void setup() {
  pinMode (PIN_FCHAUT, INPUT_PULLUP) ;
  pinMode (PIN_FCBAS, INPUT_PULLUP) ;
  pinMode (PIN_SWUP, INPUT_PULLUP) ;
  pinMode (PIN_SWDO, INPUT_PULLUP) ;
  pinMode (PIN_SOL, INPUT) ;
  pinMode (PIN_BAT, INPUT) ;
  pinMode (PIN_CS, INPUT) ;
  pinMode (PIN_LED, OUTPUT) ;
  pinMode (PIN_INA, OUTPUT) ;
  pinMode (PIN_INB, OUTPUT) ;
  pinMode (PIN_SEL, OUTPUT) ;
  pinMode (PIN_PWM, OUTPUT) ;

#ifdef Debug
  Serial.begin(38400);
  Serial.println (titre) ;
  delay(10) ;
#endif // Debug

  // initialisation de l'état jour/nuit lors du démarrage ou reboot
  Check_sol () ;                                      // Lecture analogique panneau solaire et conversion en mV
  if (val_sol < SEUIL_NUIT) {
    etat_jn = 0 ;                                     // 0 = nuit
  }
  else {
    etat_jn = 1;                                      // 1 = jour
  }
}  // Fin setup

void loop() {
  delay(20) ;                                         // Pour laisser le temps à la liaison série
  LowPower.powerDown(SLEEP_8S, ADC_OFF, BOD_OFF) ;    // Mise en veille du µC, Reveil toutes les 8s
  Check_sol () ;                                      // Lecture analogique panneau solaire et conversion en mV
  CheckBat () ;                                       // Mesure la tension de la batterie, si lowbat fait clignoter la led 2 fois                                  // Selecteur en mode : Ouverture | Auto | Fermeture
  etat_fcbas = digitalRead (PIN_FCBAS) ;              // Lecture des fins de course
  etat_fchaut = digitalRead (PIN_FCHAUT) ;            // Lecture des fins de course
  Select () ;                                         // lecture de SW2 le selecteur de mode (ouvert - auto - fermé)

#ifdef Debug
  Serial.print ("Usol : ");
  Serial.println (val_sol) ;
  Serial.print ("nb : ");
  Serial.println (nb) ;
  if (etat_jn == 0) Serial.println ("Nuit");
  if (etat_jn == 1) Serial.println ("Jour");
  Serial.print ("fcbas : ") ;
  Serial.print (etat_fcbas) ;
  Serial.print (" | fchaut : ") ;
  Serial.println (etat_fchaut) ;
#endif // Debug

  switch (etat_jn) {

    case 0 : // nuit
      Detec_jour () ;
      Fermeture () ;
      break ;

    case 1 : // jour
      Detec_nuit () ;
      Ouverture () ;
      break ;
  }

}  // Fin loop

Code PORTauto_v1.12_140320.zip (3.79 KB)

[system]

LE CODE suite

Le fichier Fonction.ino

void Check_sol () {
  val_sol = analogRead (PIN_SOL) ;                    // Lecture sur entrée analogique panneau solaire
  val_sol = ((val_sol * 3300UL) / 1023UL) / 0.544 ;   // tension en mV du panneau solaire (pont diviseur SOL--470k--PIN_SOL--560K--GND)
}

void CheckBat () {
  // Verifie l'état de la batterie
  int val_bat ;                                       // Valeur de Ubat
  const int SEUIL_LOWBAT = 3300 ;                     // Seuil lowbat en mV
  val_bat = analogRead (PIN_BAT) ;                    // Lecture sur entrée analogique
  val_bat = analogRead (PIN_BAT) ;                    // Double lecture
  val_bat = ((val_bat * 3300UL) / 1023UL) / 0.758 ;   // Tension en mV de la batterie (pont diviseur : BAT--150k--PIN_BAT--470K--GND)
#ifdef Debug
  Serial.print ("Ubat : ");
  Serial.println (val_bat) ;
#endif // Debug

  if (val_bat < SEUIL_LOWBAT) {                       // Si lowbat, fait clignoter la led 2 fois
#ifdef Debug
    Serial.println ("Batterie faible") ;
#endif // Debug
    for (byte i = 1; i <= 2; i++) {
      digitalWrite (PIN_LED, HIGH) ;
      delay (50) ;
      digitalWrite (PIN_LED, LOW) ;
      delay (100) ;
    }
  }
  else {
    digitalWrite (PIN_LED, LOW) ;
  }
}

void Detec_jour () {
  if (val_sol > SEUIL_JOUR) {                         // Si le seuil jour est détecté
    if (compteuractif_nb == false) {                  // Si le compteur n'est pas actif
      nb = 0 ;                                        // Initialise le compteur à 0
      compteuractif_nb = true ;                       // Active le compteur
    }
    nb++ ;                                            // Compte le nombre de boucle loop
  }
  else {                                              // Si le seuil n'est plus détecté durant le comptage
    compteuractif_nb = false ;                        // Le compteur est désactivé
    nb = 0 ;                                          // Initialise le compteur à 0
  }
  if (compteuractif_nb  == true && nb >= RETARD_JN) { // Si le compteur atteint la cible (le retard)
    etat_jn = 1 ; // jour                             // C'est le jour
    compteuractif_nb = false ;                        // Le compteur est désactivé
    nb = 0 ;                                          // Initialise le compteur à 0
  }
}

void Detec_nuit () {
  if (val_sol < SEUIL_NUIT) {
    if (compteuractif_nb == false) {
      nb = 0 ;
      compteuractif_nb = true ;
    }
    nb++ ;
  }
  else {
    compteuractif_nb = false ;
    nb = 0 ;
  }
  if (compteuractif_nb  == true && nb >= RETARD_JN) {
    etat_jn = 0 ; // nuit
    compteuractif_nb = false ;
    nb = 0 ;
  }
}

void Select () {
  bool val_swup ;                                         // Etat switch ouverture
  bool val_swdo ;                                         // Etat switch fermeture
  val_swup = digitalRead (PIN_SWUP) ;                     // Lecture des états du selecteur
  val_swdo = digitalRead (PIN_SWDO) ;

#ifdef Debug
  Serial.print ("Sel : ") ;
  Serial.print (val_swup) ;
  Serial.print (" | ") ;
  Serial.println (val_swdo) ;
#endif // Debug

  if (val_swdo == 1 && val_swup == 0) {                   // si le selecteur est en mode fermeture entre dans la boucle while
    while (val_swdo == 1 && val_swup == 0) {              // tant que le selecteur est en mode fermeture
      Fermeture () ;                                      // Ferme la porte
      val_swup = digitalRead (PIN_SWUP) ;                 // Lecture des états du selecteur
      val_swdo = digitalRead (PIN_SWDO) ;
      LowPower.powerDown(SLEEP_8S, ADC_OFF, BOD_OFF) ;    // Mise en veille du µC, Reveil toutes les 8s
    }
  }

  if (val_swdo == 0 && val_swup == 1) {                   // si le selecteur est en mode ouverture entre dans la boucle while
    while (val_swdo == 0 && val_swup == 1) {              // tant que le selecteur est en mode ouverture
      Ouverture () ;                                      // Ferme la porte
      val_swup = digitalRead (PIN_SWUP) ;                 // Lecture des états du selecteur
      val_swdo = digitalRead (PIN_SWDO) ;
      LowPower.powerDown(SLEEP_8S, ADC_OFF, BOD_OFF) ;    // Mise en veille du µC, Reveil toutes les 8s
    }
  }
}

void Fermeture () {
  etat_fcbas = digitalRead (PIN_FCBAS) ;                  // Lecture des fins de course
  etat_fchaut = digitalRead (PIN_FCHAUT) ;                // Lecture des fins de course
  if (etat_fcbas == 0) {                                  // Si le fin de course bas n'est pas en butée

#ifdef Debug
    Serial.println ("fermeture...") ;
#endif // Debug

    debut_tempo_mot = millis () ;                         // Initialisation de la minuterie du moteur
    ipwm = 10 ;                                           // Initialisation de la vitesse de demarrage du moteur

    while (etat_fcbas == 0) {                             // Tant que le fin de course bas n'est pas en butée
      etat_fcbas = digitalRead (PIN_FCBAS) ;              // Lecture sur entrée fin de course bas

      ipwm ++ ;                                           // Incrémentation de la vitesse du moteur
      delay(10) ;                                         // Delais pour ralentir l'acceleration du moteur
      if (ipwm >= 255) {                                  // Plafond vitesse moteur
        ipwm = 255;
      }

      digitalWrite (PIN_INA, HIGH) ; //Sens A
      digitalWrite (PIN_INB, LOW) ;
      digitalWrite (PIN_SEL, HIGH) ;
      analogWrite (PIN_PWM, ipwm) ;
      
      val_cs = analogRead (PIN_CS) ;
      val_cs = analogRead (PIN_CS) ;                      // Lecture de la pin CS via le VNH7070BAS
      val_cs = val_cs;                                    // TODO : Calcul de l'intensité du moteur en mA

#ifdef Debug
      Serial.println (val_cs);
#endif // Debug

      if (val_cs > I_MAX) {
        Freinage () ;
        digitalWrite (PIN_INA, LOW) ; //Sens B
        digitalWrite (PIN_INB, HIGH) ;
        digitalWrite (PIN_SEL, LOW) ;
        analogWrite (PIN_PWM, 80) ;
        delay (1000) ;
        Freinage () ;
      }

      if (millis () - debut_tempo_mot >= TEMPO_MOT) {   // si la minuterie du moteur est dépassée
        etat_fcbas = 1 ;                                // Considère que la porte est en fin de course

#ifdef Debug
        Serial.println ("Delais MAX");
#endif // Debug

      }
    }

#ifdef Debug
    Serial.println ("Porte Fermée") ;
#endif // Debug
   // Freinage () ;
    Standby () ;
  }
}

void Ouverture () {
  etat_fcbas = digitalRead (PIN_FCBAS) ;              // Lecture des fins de course
  etat_fchaut = digitalRead (PIN_FCHAUT) ;            // Lecture des fins de course
  if (etat_fchaut == 0) {
#ifdef Debug
    Serial.println ("Ouverture...") ;
#endif // Debug

    debut_tempo_mot = millis () ;
    ipwm = 10 ;

    while (etat_fchaut == 0) {
      etat_fchaut = digitalRead (PIN_FCHAUT) ;
      ipwm ++ ;
      delay(10) ;
      if (ipwm >= 255) {
        ipwm = 255;
      }

      digitalWrite (PIN_INA, LOW) ; //Sens B
      digitalWrite (PIN_INB, HIGH) ;
      digitalWrite (PIN_SEL, LOW) ;
      analogWrite (PIN_PWM, ipwm) ;
      val_cs = analogRead (PIN_CS) ;
      val_cs = analogRead (PIN_CS) ;
      val_cs = val_cs;                                // TODO : Calcul de l'intensité du moteur en mA

#ifdef Debug
      Serial.println (val_cs);
#endif // Debug

      if (val_cs > I_MAX) {
        Freinage () ;
        digitalWrite (PIN_INA, HIGH) ; //Sens A
        digitalWrite (PIN_INB, LOW) ;
        digitalWrite (PIN_SEL, HIGH) ;
        analogWrite (PIN_PWM, 80) ;
        delay (2000) ;
        Freinage () ;
      }

      if (millis () - debut_tempo_mot >= TEMPO_MOT) {
        etat_fchaut = 1 ;

#ifdef Debug
        Serial.println ("Delais MAX");
#endif // Debug
      }
    }

#ifdef Debug
    Serial.println ("Porte Ouverte") ;
#endif // Debug

    Freinage () ;
    Standby () ;
  }
}

void Freinage () {
  digitalWrite (PIN_INA, HIGH) ; //Freinage VNH7070BAS
  digitalWrite (PIN_INB, HIGH) ;
  digitalWrite (PIN_SEL, LOW) ;
  analogWrite (PIN_PWM, 0) ;
  delay (500) ;
  ipwm = 10 ;
}

void Standby () {
  digitalWrite (PIN_INA, LOW) ; // Standby VNH7070BAS
  digitalWrite (PIN_INB, LOW) ;
  digitalWrite (PIN_SEL, LOW) ;
  analogWrite (PIN_PWM, 0) ;
  delay (2) ;                             // délais pour entrer en standby
}

[system]

LE PCB

Vue du dessin du PCB

Le PCB reçu, c'est juste beau !

Les plus attentifs remarquerons que les deux ponts résistifs ont été modifiés depuis la photos, en effet j'était parti sur un pont 33K // 33K+33K pour faire 33 et 66, mais j'ai augmenté les valeurs et changé les résistance.

Voici le lien des sources :
Sources

Je joint également le fichier gerber en PJ pour la fabrication.

Je n'ai pas fabriqué le PCB moi même ! C'est une entreprise qui la fait, on trouve ça facilement sur le web.

Gerber_PCB_2020-02-24 22-34-47_PORTauto_V1.1.zip (85.6 KB)

[system]

LE BOITIER IMPRIME UN 3D

Je ne dispose pas d'une imprimante 3D, c'est un ami qui a réalisé l'impression. Il est tout nouveau dans ce domaine et s'est donné beaucoup de mal (et il a réussi) pour sortir des pièces parfaites ! Merci Florian !

Mais j'ai tout de même conçu le boitier sous fusion 360.

Lien pour les fichiers 3D
Sources 3D

Pour faire un diffuseur de led "étanche" j'ai dessiné sur le couvercle un trou de 6.5mm, que j'ai ensuite bouché avec un bout de cylindre du tube de colle à chaud. Ca fait un super diffuseur.

Le commutateur à glissière (Selecteur de mode) et le bouton reset, au cas ou...

[system]

Le boitier a cœur ouvert

( :o c'est quand même galère en 2020 toutes ces manips pour insérer des photos)

[system]

Vue d'ensemble

J’arrête la pour les photos...

Je voudrais remercier particulièrement Henri pour son excellent blog http://riton-duino.blogspot.com/ qui ma permis d'augmenter sensiblement mon niveau et d'utiliser un ATmega en standalone, charger le bootloader et les sketchs via convertisseur TTL, le mode Lowpower, l'alimentation sur batterie et pleins d'autres découvertes qui m'ont été trèèèèèès utiles. Franchement sans cela j'y serais encore...

[Leptro]

bravo..

Beau projet et surtout le résultat est au top.

Merci pour le partage.

[achess]

Bonjour,
Bravo, c'est un travail de pro, ce que j'ai fait fonctionne bien aussi mais c'était un peu plus bidouille.

Le maillon faible sera peut-être le fin de course du bas très exposé aux intempéries et aux fientes.
Un Interrupteur reed protégé dans un bout de gaine thermorétractable aurait été plus sur.
Et avec l'aimant placé en haut de ta trappe, tu pourrais mettre les 2 Interrupteurs reed à l'intérieur.

edit : En descente, si la trappe coince, tu n'auras pas de surintensité, le moteur continuera a tourner.
La ficelle risque de se dérouler complètement, s'enrouler de nouveau pour remonter la trappe, il me semble.

[system]

Merci Leptro et achess pour vos compliments !

D'ailleur achess, c'est grace à toi que j'ai géré l'ouverture et la fermeture par la lecture de la luminosité via le panneau solaire. J'avait trouvé ton projet sur ton site moncastel. Merci pour ce partage qui m'a aidé !
En tout cas un panneau solaire est très précis pour lire la luminosité.

Pour les fin de courses, ils sont IP65, donc résistants à l'humidité et à la pluie. Pour les fientes... Je vérifie cela quand je vais chercher les œufs, car une fiente mal placée pourrais bloquer le contact du bas !!

En descente, si la trappe coince, tu n'auras pas de surintensité, le moteur continuera a tourner.
La ficelle risque de se dérouler complètement, s'enrouler de nouveau pour remonter la trappe, il me semble.

Tout à fait, il y a une fonction délais max qui est censé stopper le système dans ce cas, pour le moment cela ne bloque pas le programme (et ça devrait). Je te remercie d'avoir mis le doigt la dessus, ca va me remotiver à faire une nouvelle version !

[jeremy701]

Bonjour,

Je suis en pleine réflexion pour créer un porte automatique solaire.

Mais où as tu acheté tes composant pour arriver à seulement 60€ stp!?

Si j'utilise une carte arduino nano faut il encore utiliser le régulateur de tension LD3985M33R ?

Pour le declanchement de l'ouverture ou fermeture de la porte.
C'est le fonctionnement du panneau solaire (présence ou non d'intensité) qui donne les informations pour commander la porte ?
Il n'y a pas de photorésistance ?

Merci

[wopr]

Bonjour,

Cela fait pas mal de temps que je traîne sur les forums, pour faire une porte de poulailler.
Et ton travail correspond en tout point a ce que je recherchais, un projet super bien détaillé, propre avec le PCB, et aussi avec la partie en 3D qui m'intéresse aussi.

Je vais donc réaliser le projet et voir si je modifie uniquement avec les switch Reed. J'ai commencé a voir les composés à commandé sur LSCS, mais il y a une grande partie qui n'est pas disponible.

Je ne connaissais pas ce site qui a l'ai pas mal, mais tu avais commandé les composants chez un autre fournisseur aussi?

Merci.

[Loulou74]

Bravo pour ce projet très abouti

[hbachetti]

nimaj:
Je voudrais remercier particulièrement Henri pour son excellent blog

Merci. La carte est très réussie, câblage très propre sur connecteurs XH. Bravo.

jeremy701:
Si j'utilise une carte arduino nano faut il encore utiliser le régulateur de tension LD3985M33R ?
Il n'y a pas de photorésistance ?

Il suffit de lire le code pour voir qu'il n'y a pas de photorésistance.

ARDUINO NANO : OUI tu peux te passer du régulateur.
Par contre j'espère que tu n'a pas l'intention de faire fonctionner ton montage sur batterie ?

[jeremy701]

Je suis désolé mais je n'y connais rien dans ce domaine.

Si je voudrais faire le montage avec une batterie et un panneau solaire.

Donc sa ne va pas fonctionner ou consommer beaucoup d'énergie avec arduino nano ?

[hbachetti]

Un peu de lecture : consommation-dune-carte-arduino

[wopr]

Je pense que ce projet est suffisamment abouti, ce n'est pas la peine de vouloir modifier les composants majeurs..

[nimaj]

Bonjour à tous et merci pour vos commentaires !

Mais où as tu acheté tes composant pour arriver à seulement 60€ stp!?

Si j'utilise une carte arduino nano faut il encore utiliser le régulateur de tension LD3985M33R ?

Pour le declanchement de l'ouverture ou fermeture de la porte.
C'est le fonctionnement du panneau solaire (présence ou non d'intensité) qui donne les informations pour commander la porte ?
Il n'y a pas de photorésistance ?

J'ai acheté mes composants essentiellement chez TME et aussi parfois sur RS. Le panneau solaire et le TP4056.....il faut se tourner vers les chinois...
Pour les 60€, c'est hors taxe, et c'est un prix pour faire une unité, car parfois les composants tu dois les acheter par 10 ou 1000 donc pour en faire un ca te coûte effectivement plus cher. Perso j'en ai fait 3.
Regarde la nomenclature en PJ du premier poste, il y a le détails.

Pour ce type de projet (avec petite batterie), le nano n'est pas optimisé pour la faible consommation. Il faut partir sur une carte type mini 3.3V 8mhz ou un montage standalone sur ce principe comme je l'ai fait.

Il n'y a pas de photo-résistance, on mesure tout simplement LA TENSION débitée par le panneau solaire.
Par exemple en dessous de 100 mv on considère la nuit, au dessus de 600 mv on considère le jour. C'est très précis comme "capteur" un panneau solaire, je l'ai découvert grace à ce projet (et à Achess !)

Merci. La carte est très réussie, câblage très propre sur connecteurs XH. Bravo.

Merci Henri, venant de toi ça me fait chaud au coeur !

Je ne connaissais pas ce site qui a l'ai pas mal, mais tu avais commandé les composants chez un autre fournisseur aussi?

J'essaye dans une certaine mesure d'éviter de commander hors Europe quitte à payer un peu plus cher. J'ai commander chez TME, c'est un fournisseur Européen qui se débrouille assez bien sur les prix et les quantitatifs mini.

J'ai fait une mise à jour du code par apport à la remarque de Achess, je la publierais ici bientôt.

[hbachetti]

Il faut partir sur une carte type mini 3.3V 8mhz ou un montage standalone sur ce principe comme je l'ai fait.

Une PRO MINI 8MHz 3.3V modifiée (sans LED et régulateur 3.3V) consomme 1.5µA en veille.
La PRO MINI 16MHz 5V consommera 3µA, largement acceptable.

Une NANO consommera 7.5mA en veille, alimentée par sa broche en 5V. Absolument inadapté, à moins de choisir une batterie de voiture.