http://photocerfvolant.free.fr

Bonjour,

Il y a quelques semaines, Jean-Christophe (alias Deldude) a ouvert un fil sur le projet KAPduino.
Recherchant un système pour commander mon APN qui ne peut être déclenché autrement que par un servo, j'ai fait l'acquisition de la carte Arduino .

Mon premier objectif était de faire un système de déclenchement automatique à intervalles réguliers (intervallomètre) adapté à ma nacelle roitelet et à mon APN.
Voila qui est fait.







Le programme est très simple puisque exclusivement consacré à la manœuvre du servo de déclenchement. Il est là (je n'ai pas réussi à l'insérer dans le message).

Cinq phases :

Attente avant premier déclenchement
Boucle infinie

Manoeuvre du servo pour le déclenchement

Maintien du servo sur le déclencheur

Retour du servo à la position initiale

Temporisation entre deux déclenchements

Le programme s'exécute dès mise sous tension du module (je n'ai pas utilisé d'interrupteur pour des raisons de poids : l'ensemble me paraît déjà lourd : 420 g pour l'ensemble nacelle, arduino, pile et APN; je ne voulais pas en rajouter, aussi minime soit il).
J'alimente le tout par un accu 9 volts (7.2 volts en réalité). Les tests longue durée montrent que l'accu tient 2h15 avec un déclenchement toutes les dix secondes. C'est une bonne surprise ! Je suis arrivé à un peu plus de trois heures avec un intervalle réglé à 20 secondes.

Pour moi, ce premier essai est plutôt encourageant sur les projets à venir : diminuer la consommation de la carte (en jouant sur la vitesse d'horloge), mise en place d'un deuxième servo (pan), réglage des différentes tempo avec des DIP switchs, puis par dialogue avec un Palm.
Pour la suite, il existe des modules de communications sans fil spécialement adaptés à Arduino qui m'ont l'air intéressants (Shield XBee pour Arduino).
A noter aussi la présence d'exemples de programmes sur internet pour la commande par infrarouge.

Voili, voilou.

Philippe.

alpaph a écrit:Le programme est très simple puisque exclusivement consacré à la manœuvre du servo de déclenchement. Il est là (je n'ai pas réussi à l'insérer dans le message).

Oups le lien : http://alpaph.free.fr/?article36/programme-pour-autokapduino

Bravo pour ce premier Arduino volant. Tiens nous au courant des futures fonctionnalités !

Un gentil collègue qui a lu le programme m'a indiqué que je pouvais simplifier le programme. C'est ce que j'ai fait illico.

Liste des modification apportées :
- Au lieu d'utiliser des variables (lignes commençant par int) pour des constantes, il faut carrément déclarer des constantes pour l'instruction #define. En plus, on y économise quelques octets.

- Utiliser des majuscules pour les constantes (plus de facilités pour lire le programme).

- Changer de place la temporisation avant premier déclenchement pour la positionner dans void setup(). Ca permet de supprimer la fonction While (1) dans void loop.

Bref, ça simplifie. Voici le nouveau code d'autoKAPduino v1.1

Code: Tout sélectionner

// autoKAPduino déclenchement v1.1
// par ALPAPH
// programme autoKAP consacré exclusivement au déclenchement

// Passage v1=>v1.1
//   Déclaration des constantes par fonction #define
//   Changement casse des constantes (majuscules)
//   La temporisation de délai avant premier déclenchement est passée dans void setup()

#include <Servo.h>

Servo srv_dec;  // création de l'objet srv_dec (servo de déclenchement)

// déclarations pour le servo de déclenchement
int serv_dec_pos = 0;       // variable to store the servo serv_dec_position

// les angles sont à définir selon la position du servo sur la nacelle
#define SERV_DEC_ANGL_DEB 40 // Constante angle de départ du servo
#define SERV_DEC_ANGL_FIN 19 // Constante angle d'arrivée du servo

// la variable 'pas' permet le calcul du sens de rotation du servo (cf. setup)
int pas;

// Temporisations
#define TEMPO_AVANT_PREM_DECL 5000  // Constante Temporisation avant premier déclenchement
int serv_dec_vit_rot_aller = 200;   // Vitesse de rotation du servo à l'aller
#define SERV_DEC_MAINTIEN_DEC 100   // Constante temps de maintien du servo sur déclencheur
#define DELAI_INTERVALLOMETRE 10000 // Constante intervalle entre deux déclenchements

// variable de calcul de la dernière temporisation de la boucle
// ATTENTION : 'DELAI_INTERVALLOMETRE' est nécessairement supérieur
// à la somme de la temporisation de maintien de déclenchement et de la vitesse de rotation du servo
// = fct (angle et vitesse de rotation) => cf. void setup()
int serv_dec_intervallometre;


void setup()
{
  srv_dec.attach(9);  // la commande du servo est rattachée à la broche 9 de la carte arduino
  srv_dec.write(90);  // écriture de la position 90
 
  if (SERV_DEC_ANGL_DEB > SERV_DEC_ANGL_FIN) {
      pas = -1;
      }
      else {
      pas = 1;
      }

  // calcul d'ajustement de la temporisation de fin de boucle pour garantir l'intervalle défini dans les déclarations
  int delai = SERV_DEC_MAINTIEN_DEC + (pas * (SERV_DEC_ANGL_FIN - SERV_DEC_ANGL_DEB)) * serv_dec_vit_rot_aller;
     
  if (delai < DELAI_INTERVALLOMETRE)   {
      serv_dec_intervallometre = DELAI_INTERVALLOMETRE - delai;
      }
      else {
      serv_dec_intervallometre = DELAI_INTERVALLOMETRE; // cas d'erreur dans les déclarations : pas d'ajustement : tant pis !
      }

// action 1
delay(TEMPO_AVANT_PREM_DECL); // temporisation avant premier déclenchement
}

// algoritme du programme
// 1 - temporisation avant premier déclenchement
// 2 - actionner le servo de déclenchement
// 3 - maintenir appuyé le déclencheur
// 4 - replacer le servo à sa position initiale
// 5 - temporisation avant prochain déclenchement

void loop()
{
// action 2
  // Déplacement du servo pour déclencher
  for(serv_dec_pos = SERV_DEC_ANGL_DEB; serv_dec_pos > SERV_DEC_ANGL_FIN; serv_dec_pos += pas)
    {
    srv_dec.write(serv_dec_pos);     // écriture de la position
    delay(serv_dec_vit_rot_aller);   // attente serv_dec_vit_rot_aller ms avant prochaine rotation
    }
 
// action 3
    delay(SERV_DEC_MAINTIEN_DEC);    // maintien du bras du servo pendant SERV_DEC_MAINTIEN_DEC ms
 
// action 4
// Déplacement du servo pour retour au point initial                       
    srv_dec.write(SERV_DEC_ANGL_DEB);     // écriture de la position

// action 5
    delay(serv_dec_intervallometre);   
}

Le servomoteur ressemble à celui qui est fourni dans un kit démarrage arduino.
A quoi le petit shield que tu as mis sur l'arduino? aux contacts?

icare a écrit:Le servomoteur ressemble à celui qui est fourni dans un kit démarrage arduino.

En fait, le servomoteur vient d'ici : http://www.hobbycity.com/hobbycity/store/uh_listCategoriesAndProducts.asp?idCategory=287&curPage=3&v=&sortlist=

icare a écrit:A quoi le petit shield que tu as mis sur l'arduino? aux contacts?

Des pin soudées sur la carte sont enfichées dans les connecteurs de la carte arduino. Avec, j'achemine jusqu'au connecteur servomoteur, les polarités et la commande. Ca fait un ensemble qui tient bien les mouvements de la nacelle qui sont parfois un peu violent. Elle ne s'est jamais "désenfichée".

A +