Pour permettre à mon quadricoptère de voler il faut un châssis, pour ce faire j’ai fait un châssis en aluminium de 280g (merci à mon petit frère). Voici l’image ,

Ok il me manque encore 1 moteurs qui est en cours d’approvisionnement et mes divers capteurs qui devraient arriver samedi.

Sur ce châssis j’ai rajouté des goulotte en aluminium pour y fixer les détecteur infrarouge pour éviter à mon quadricoptère de se cogner sur des obstacles.

Pour les pieds j’ai utilisé des bouchons de bouteille de vin

Prochaine étape la programmation de la manette de jeu type Freebox ou PS2.

Cela fait bien longtemps que je n’ai pas fait un petit poste, pourquoi ? pour plein de raisons …

Mon nouveau projet c’est un quadricoptère à base d’une FEZ Domino. simple et compliqué à la fois. Je vous détaillerai tout au long du projet les pièces, le code.

Dans ce premier poste voyons ce que nous devons avoir pour les moteurs. Je suis parti sur des moteurs “Moteurs brushless”, pour la carte vous l’aurez compris je reste avec ma FEZ Domino qui réagit très bien.

J’ai rencontrés des souci car je n’avais pas commencé avec le bon matériel, donc mon poste ne concerne que le matériel que j’utilise.

Pour les moteurs il faut une alimentation pour ce faire j’ai opté pour ceci :

Pour contrôler les moteurs il vous faut un contrôleur (variateur) c’est pièce est indispensable sans elle, il ne vous sera pas possible de piloter votre moteur. J’ai opté pour celui-ci:

Maintenant le moteur, je dit le moteur car dans un premier temps je teste juste la réaction d’un moteur, dans le prochain poste j’ajouterai les 3 autres moteurs.

Voici ce que ressemble le tout avec le contrôleur brancher en PWM sur la FEZ Domino.

Il faut retenir une chose, le Micro-Framework simplifie beaucoup le travail, mais le matériel peut rapidement compliquer la vie

Au niveau programmation merci au site  http://forum.pobot.org

Donc voici le principe de base :

Petite méthode pour mettre la puissance :

private setServo(PWM s, uint valeur)
{
    s.SetPulse(20 * 1000 * 1000, valeur * 1000);
}

et dans la méthode, par exemple, vous pouvez faire ceci :

while (true)
 {
       setServo(servo,1125); 
       Thread.Sleep(3*60*1000); // Attente de 3 min
       setServo(servo,1200);       // 
       Thread.Sleep(2*60*1000); // Attente de 2 min
 }

Le moteur que j’utilise commence à 1101 jusqu’à 2000 cela laisse une marge pour gérer la vitesse

Pour mes premiers tests j’utilise la manette FreeBox pour gérer mon moteur.

Bonne lecture

Matériels utilisés :

• FEZ Domino
• FEZ Connect Shield
• XBee Expansion de GHI (http://www.ghielectronics.com/catalog/product/158)
• Tahoe II

Pour communiquer, on va utiliser la Fez pour la réception et la Tahoe pour l’envoie d’informations.

Pour tous les codes suivants, il faut importer Microsoft.SPOT.Hardware et Microsoft.SPOT.Hardware.SerialPort

Pour la réception :

• Il faut ouvrir un port série. J’ai choisi de brancher le module Xbee sur le “COM1” donc les broche 0(IN) et 1(OUT). La vitesse de transfert sera de 9600 Baud(Nombre de bits transférés par seconde). Lors de mes recherches c’est la valeur que j’ai croisé le plus souvent.

 SerialPort Xbee =new SerialPort("COM1", 9600);

Ensuite il faut ouvrir le port pour qu’il écoute :

      Xbee.Open();

Après il faut créer un événement qui se déclenchera à chaque fois que le module Xbee recevra des informations

Xbee.DataReceived += new SerialDataReceivedEventHandler(Xbee_DataReceived);

Et pour finir mettre un timeout.infini pour que le programme reste sur l’écoute du réseau Xbee.

Exemple d’utilisation :

using System;
using System.Threading;

using Microsoft.SPOT;
using Microsoft.SPOT.Hardware;
using System.IO.Ports;
using GHIElectronics.NETMF.FEZ;
using System.Text;

namespace FEZ_Domino_Application1
{      public class Program
       {
          public static int long = 0;
          public static SerialPort Xbee = null;
          public static void Main()
          {
              Xbee = new SerialPort("COM1", 9600);
              Xbee.Open();
              Xbee.DataReceived += new SerialDataReceivedEventHandler(Xbee_DataReceived);
              Thread.Sleep(Timeout.Infinite);
          }
          private static void Xbee_DataReceived(object sender, SerialDataReceivedEventArgs e)
          {
              byte[] buffin = new byte[50];
              read_count = Xbee.Read(buffin, 0, Xbee.BytesToRead);
              String message = new String(Encoding.UTF8.GetChars(buffin));
              Debug.Print(message);
          }
      }
}

Pour l’émission, il faut aussi créer un port série et l’ouvrir. Ensuite il faut créer un tableau de byte qui contiendra le message à envoyer.

Exemple :

byte[] tx_data = Encoding.UTF8.GetBytes("Message");
Xbee.Write(tx_data, 0, tx_data.Length);
Xbee.Flush();

Maintenant pour l’émission avec la Tahoe II

Il faut aussi créer et ouvrir un port série

SerialPort xbee = new SerialPort(port, baudrate);
xbee.Open();

Ensuite on peut créer une fonction envoyer()

 public static void envoyer(string message)
 {
    byte[] tx_data = Encoding.UTF8.GetBytes(message);
    xbee.Write(tx_data, 0, tx_data.Length);
    String bh = new String(Encoding.UTF8.GetChars(tx_data));
    xbee.Flush();
 }

Comme les réseaux Xbee ne sont pas sécurisés, il suffit d’envoyer le message en radio et tous les modules Xbee en écoute recevront le message.