Affichage des articles dont le libellé est programmation. Afficher tous les articles
Affichage des articles dont le libellé est programmation. Afficher tous les articles

14/09/2019

La Barrière LEGO avec telecommande - Arduino

Cet article fait suite à l'article La Barrière LEGO

Car c'est bien beau d'avoir une barrière LEGO qui se lève à l'approche d'un véhicule, seulement le problème, c'est une fois que l'on est passé, comment on fait pour revenir, car il n'y a pas de capteur de l'autre côté de la barrière...

La solution est d'utiliser une télécommande, sur laquelle nous utiliserons deux boutons... un pour lever la barrière et l'autre pour la baisser !

<video>

Prenez maintenant la télécommande et son capteur fournis dans le kit (voir  l'article La Barrière LEGO pour vous procurer le kit )


Sur la plaque du capteur infrarouge, repérez les broches S et -

PINDescriptionCouleur du câbleConnexion vers la carte ARDUINO
SSortie des donnéesmarronD11
3.3 - 5Vrouge VCC  / 5V
-0Vnoir GND

--> Utilisez les câbles fournis avec la télécommande et reliez
la pin S du capteur à la pin D11 de la carte Arduino
la pin du milieu du capteur à la pin 5V / VCC de la carte Arduino
la pin - du capteur

<troisphotos branchements>



Installez la librairie IRremote et ouvrez l'exemple IRrecvDemo
<trois photos install>

Nous n'allons pas nous servir du code hexadécimal de la touche, mais son code décimal. Pour ce faire, ajoutez la ligne
 Serial.println(results.value);

comme indiqué dans le code ci-dessous :

#include <IRremote.h>
int RECV_PIN = 11;
IRrecv irrecv(RECV_PIN);
decode_results results;
void setup()
{
  Serial.begin(9600);
  // In case the interrupt driver crashes on setup, give a clue
  // to the user what's going on.
  Serial.println("Enabling IRin");
  irrecv.enableIRIn(); // Start the receiver
  Serial.println("Enabled IRin");
}
void loop() {
  if (irrecv.decode(&results)) {
    Serial.println(results.value, HEX);
Serial.println(results.value);
    irrecv.resume(); // Receive the next value
  }
  delay(100);
}

Enregistrez ce code sous le nom de "Test_Telecommande" et téléverser-le sur la carte.


Ouvrez le moniteur série (dans le menu Outils) et appuyez alternativement sur les touches "Fleche Haut" et "Fleche Bas" de la télécommande.
Attention, si vous appuyez trop longtemps sur une touche, il peut arriver que les codes parasites "FFFFFFFF" et "4294967295", mais nous allons les gérer


<photo codes>

A chaque appui de touche, vous devriez voir apparaître un code correspondant à la touche appuyée . Moi j'ai pour :

Flèche HAUTFlèche BAS
code hexadécimalFF18E7FF4AB5
code décimal1671805516730805

Notez les codes que vous affiche le moniteur, ils peuvent être différents des miens !


Modifiez maintenant le code de la manière suivante pour détecter l'appui sur les deux flèches "HAUT" et "BAS".





#include <IRremote.h>
int RECV_PIN = 11;
IRrecv irrecv(RECV_PIN);
decode_results results;
void setup()
{
  Serial.begin(9600);
  // In case the interrupt driver crashes on setup, give a clue
  // to the user what's going on.
  Serial.println("Enabling IRin");
  irrecv.enableIRIn(); // Start the receiver
  Serial.println("Enabled IRin");
}
void loop() {
  if (irrecv.decode(&results)) {
    // Serial.println(results.value, HEX);
    // Serial.println(results.value);
    if (results.value == 16718055) {
      Serial.println("HAUT");
    } else if  (results.value == 16730805) {
      Serial.println("BAS");
    } else {
      Serial.println(results.value);
    }
    irrecv.resume(); // Receive the next value
  }
  delay(100);
}

Enregistrez votre programme (que l'on appelle également Sketch chez Arduino), et téléversez-le sur la carte. Ouvrez-le moniteur série et appuyez successivement sur les touches "HAUT" et "BAS". Ces deux mots devraient maintenant s'afficher dans le moniteur :

<photo moniteur haut bas>

On va maintenant utiliser deux fonctions leve_barriere() et baisse_barriere() dans lesquelles ont ajoutera le code contrôlant le servomoteur...

Modifiez maintenant le code comme suit :

00);


#include <IRremote.h>

int RECV_PIN = 11;

IRrecv irrecv(RECV_PIN);

decode_results results;

void setup()
{
  Serial.begin(9600);
  // In case the interrupt driver crashes on setup, give a clue
  // to the user what's going on.
  Serial.println("Enabling IRin");
  irrecv.enableIRIn(); // Start the receiver
  Serial.println("Enabled IRin");
}

void loop() {
  if (irrecv.decode(&results)) {
    // Serial.println(results.value, HEX);
    // Serial.println(results.value);
    if (results.value == 16718055) {
      leve_barriere();
    } else if  (results.value == 16730805) {
      baisse_barriere();
    } else {
      Serial.println(results.value);
    }
    irrecv.resume(); // Receive the next value
  }
  delay(100);
}

void leve_barriere(){
  Serial.println("HAUT dans la fonction");
}

void baisse_barriere(){
  Serial.println("BAS dans la fonction");
}


<photo leve barriere fonction>


Bien bien bien, pas mal jusque là... Il ne nous reste plus qu'à brancher le servomoteur comme dans l'article précédent  sur la PIN D9 et à ajouter le code qui gère ce moteur :

Comme on n'a pas utilisé les lignes "bleus et rouges" pour le 5V et le GRND, on va juxtaposer les câbles d'alimentation du moteur à ceux du capteur infra rouge .

<photos branchement moteur>

Un petit peu de copier/coller  depuis le code produit dans l'article précédent, et votre code pourrait ressembler à ceci :




#include <IRremote.h>
#include <Servo.h>

int RECV_PIN = 11;

IRrecv irrecv(RECV_PIN);

decode_results results;

/* Creation d'un objet Servo pour contrôler le servomoteur */
Servo mon_servo;

void setup()
{
  Serial.begin(9600);
  // In case the interrupt driver crashes on setup, give a clue
  // to the user what's going on.
  Serial.println("Enabling IRin");
  irrecv.enableIRIn(); // Start the receiver
  Serial.println("Enabled IRin");
  mon_servo.attach(9);
  mon_servo.write(180);
}

void loop() {
  if (irrecv.decode(&results)) {
    // Serial.println(results.value, HEX);
    // Serial.println(results.value);
    if (results.value == 16718055) {
      leve_barriere();
    } else if  (results.value == 16730805) {
      baisse_barriere();
    } else {
      Serial.println(results.value);
    }
    irrecv.resume(); // Receive the next value
  }
  delay(100);
}

void leve_barriere() {
  Serial.println("HAUT dans la fonction");
  mon_servo.write(90);
}

void baisse_barriere() {
  Serial.println("BAS dans la fonction");
  mon_servo.write(180);
}





ET voilà, notre Barrière LEGO télécommandée  !!!!!

<video >

Ajouter des leds pour indiquer si l'on peut avancer ou pas ???

Inspirez-vous de ce code  : un mix des exemples  Blink  et Fade  présents dans Fichier / Exmples / 01.Basic ou sur le site Arduino  --> vous aurez aussi des indications sur la manière de brancher vos leds si vous avez des doutes


Connectez vos led sur les pin 5 et 7 de l'Arduino
Sans oublier de les protéger par des resistances de 220 ohms ! 


int led_rouge = 5;
int led_verte = 7; 
void setup() {
  // initialize digital pin as an output.
  pinMode(led_rouge, OUTPUT);
  pinMode(led_vertee, OUTPUT);
}

// the loop function runs over and over again forever
void loop() {
  digitalWrite(led_rouge, HIGH);   
  digitalWrite(led_verte, LOW);  
  delay(1000);                      
  digitalWrite(led_rouge, LOW);   
  digitalWrite(led_verte, HIGH); 
  delay(1000);                      
}












10/06/2018

La Barrière LEGO - Arduino

Objets connectés, iot, Arduino, par où commencer ?


"La barrière LEGO, un bon projet pour débuter avec Arduino".


" ça serait bien, une barrière pour ma maison LEGO !
- Une barrière pour ta maison de LEGO, ok, qu'est-ce qu'il nous faut ? Un moteur pour actionner la barrière, et un moyen de la déclencher. Pour le moteur, on va utiliser un SG90, fourni avec la plupart des kits Arduino, et pour activer ce moteur ?? J'ai une Funduino Mega2560 qui traîne, on va voir ce qu'on peut faire avec, mais note que n'importe quelle carte Arduino, ou compatible doit faire l'affaire..."



ES-TU PRÊT A RELEVER LE DEFI DE CREER UNE BARRIERE LEGO EN SEULEMENT 20 LIGNES DE CODE ???

- niveau débutant,
- matériel : KIT "Barrière LEGO Arduino" comprenant :

  • une carte arduino
  • une breadboard
  • un capteur ultrason
  • un servomoteur
  • une télécommande infrarouge et son capteur
  • quelques leds de couleur et les resistances qui les protègent
  • des câbles pour effectuer les connexions...
C'est tout ce qu'il faut pour construire les deux versions de la "Barrière LEGO Arduino"
! le kit "Barrière LEGO Arduino" ne comprend pas les pièces LEGO pour fixer le servomoteur (voir au bas de cette page pour plus de précisions)



Pour 20€ chez LEGO, tu as ça , mais tu peux aussi choisir d'aller voir un peu plus loin et d'apprendre à coder avec le kit "Barrière LEGO Arduino"
 --> commander un kit "Barriere LEGO - Arduino"  
ou envoyez un mail à scenaristeur@gmail.com

La barrière LEGO peut être déclinée sous plusieurs versions, et celles-ci peuvent être combinées :
- 1 la barrière LEGO à partir d'un capteur ultrason.
- 2 la barrière LEGO utilisant la télécommande infrarouge
... a vous de voir ensuite comment vous pouvez améliorer votre barrière LEGO... 😉

Le graphe de la barriere LEGO

Nous allons voir dans un premier temps la version avec le capteur ultrason :

- 1 la barrière LEGO à partir d'un capteur ultrason.

Quand un véhicule passe devant le capteur Ultrason, la barrière se lève pendant trois secondes puis reprend sa position initiale : 




 










Matériel nécessaire :  'KIT Arduino Barrière LEGO'
 --> commander un kit "Barriere LEGO - Arduino"  
ou envoyez un mail à scenaristeur@gmail.com

1 breadboard (ou planche à pain en français ), c'est la plaque où l'on va positionner nos composants et qui nous permettra d'établir les connexions entre ceux-ci.

A l'interieur de la breadbord, des connexions sont déjà établies (traits noirs sur la photo ci-dessous), par exemple, vous pour connecter une broche qui serait connectée en 'A1', vous pouvez utilisez tous les trous de 'B1' à 'E1'. Les trous 'F1' à 'J1' sont également connectés entre eux.

une carte Arduino Uno ou
une carte Arduino Nano avec son cable USB,
ou compatible
un capteur ultrasons HC-SR04 pour capter le passage d'un véhicule
Un servomoteur SG90 pour actionner la barrière
Une dizaine de câbles pour relier tout ça 
Une barre LEGO Technic qui servira de barrière
+ Quelques briques LEGO pour fixer le servomoteur


Repérez les deux lignes à l'extérieur de la breadboard: une rouge et une bleue. Ne les utilisez pas pour l'instant, elles serviront à transmettre le courant pour alimenter les composants.




Effectuer les branchements


1. Commencez par positionner et enficher la carte Arduino et le capteur ultrasons HC-SR04 sur la breadboard :
- la carte Arduino au centre de la breadbord et le capteur sur le bord.

2. Pour alimenter le capteur ultrason HC-SR04, nous allons créer un circuit :
- repérez sur la carte Arduino la broche notée '5V' (c'est le + ) et branchez un fil pour la relier jusqu'à la ligne rouge.
- repérez sur le capteur HC-SR04 la broche notée 'VCC' et reliez la également à la ligne rouge



Dans un deuxième temps :
- repérez sur la carte Arduino une des broches notée 'GND' (c'est le -) et branchez un fil pour la relier jusqu'à la ligne bleue.
- repérez sur le capteur la broche notée 'GND' et reliez-la avec la ligne bleue.

Vous devriez maintenant avoir une carte Arduino, un capteur ultrason HC-SR04 et 4 fils comme sur la photo suivante :




Le capteur HC-SR04 est un capteur ultrason et fonctionne suivant le principe du sonar de la chauve-souris : un ultrason est émis, puis l’écho est réceptionné, la délai entre l’émission et la réception permet de calculer la distance de l'obstacle.
Sur le capteur il reste deux broches : 'Trig' et 'Echo' . Avec deux autres fils, reliez 'Trig' à la broche 'D3' de la carte Arduino et 'Echo' à la broche 'D4' . 'Trig' enverra un ultrason et 'Echo' réceptionnera l'écho...






Passons maintenant à la programmation de la carte Arduino :

Une petite video pour l'installation du logiciel,
Pensez bien à vérifier la configuration de la carte dans le menu 'Outils/ type de carte' et 'Outils/port' (choix de la carte et de son port). Pour plus de précisions ces sujets ont étés maintes fois traités comme ici.



Voici le code de test du capteur HCSR-04 présenté dans la vidéo :
#include <HCSR04.h>

UltraSonicDistanceSensor distanceSensor(3,4);  // Initialize sensor that uses digital pins 13 and 12.

void setup () {
    Serial.begin(9600);  // We initialize serial connection so that we could print values from sensor.
}

void loop () {
    // Every 500 miliseconds, do a measurement using the sensor and print the distance in centimeters.
    Serial.println(distanceSensor.measureDistanceCm());
    delay(500);
}

En allant ensuite consulter le traceur série, vous devriez voir une courbe apparaître :




Maintenant que le capteur est opérationnel, on va pouvoir brancher le servomoteur :
sur un servomoteur, nous avons 3 fils :
- le + (rouge)
- le - (noir ou marron)
- la mesure (jaune ou blanc)

Utilisez trois nouveaux fils pour prolonger ceux issus du moteurs


et connectez ceux-ci de la manière suivante :
le + vers la ligne rouge de la breadboard,
le - vers la ligne bleue de la breadboard
le 3ème vers la broche 'D9' de la carte Arduino




Reprenons maintenant notre code et modifions le pour prend en compte le moteur. On peut s'inspiré de l'exemple 'Knob' comme évoqué dans la vidéo d'installation du logiciel Arduino :

Attention les deux vidéos suivantes se superposent  pour montrer à la fois la partie code et la partie exécution du code :

Confection du code :



Voici le code qui permet de faire fonctionner notre barrière LEGO avec déclenchement par capteur Ultrason :


////////////////////////////////////////////////////////////////////////////////////////
// Le code suivant correspond au tutoriel présenté à cette adresse :                  //
// http://smag0.blogspot.com/2017/06/arduino-barriere-lego.html                       //
// L'objectif est de créér une barrière qui se lève lorsqu'un véhicule passe devant   //
// le capteur ultrason                                                                //
// Pensez à bien vérifier le type de carte et le port COM dans le menu 'Outils'       //
////////////////////////////////////////////////////////////////////////////////////////


/* Import de la librairie pour le capteur ultrason HCSR04
  et pour le servomoteur */
#include <HCSR04.h>
#include <Servo.h>

/* On créé un objet capteur ultrason (UltraSonicDistanceSensor)
  que l'on initialise sur les pins D3 pour TRIG et D4 pour ECHO*/
UltraSonicDistanceSensor capteur_distance(3, 4);

/* Creation d'un objet Servo pour contrôler le servomoteur */
Servo mon_servo;


/*  la fonction setup() permet de mettre en place l'environnement */
void setup () {
  /* - On initialise une connection série pour pouvoir afficher les
 valeurs dans le moniteur ou le traceur (menu Outils).
       - On indique que notre servomoteur est relié à la Pin 9
       - On positionne notre servomoteur à l'horizontale (180°)   */
  Serial.begin(9600);
  mon_servo.attach(9);
  mon_servo.write(180);
}


/* la fonction loop() boucle à l'infini,
 lit la valeur du capteur et actionne le moteur */
void loop () {
  /* on lit la distance en cm mesurée par le capteur grâce
 à la fonction measureDistanceCm de l'objet capteur_distance précédemment créé */
  int distance = capteur_distance.measureDistanceCm(); 
   /* on teste si la valeur est comprise entre 1 cm et 15 cm */   
  if ( distance > 1 && distance < 15 ) {  
    /* Si elle est comprise entre 1 cm et 15 cm
 on l'envoi à la connexion série pour l'afficher dans le moniteur ou le traceur */               
    Serial.println(distance);                            
/* On demande envoi un angle de 90° au servo moteur ce qui doit lever la barrière */ 
    mon_servo.write(90);                                 
    /* et on attend 3000 millisecondes = 3 secondes avant de continuer */
    delay(3000);
  } else {
    /* Sinon, la distance n'est pas comprise entre 1cm et 15 cm,
 on baisse la barrière en positionnant le servomoteur à 180° */
    mon_servo.write(180);                                 
  }
  /* On attend 500 millisecondes avant d'effectuer une nouvelle boucle (loop)
 et de lire la valeur suivante */
  delay(500);                                             
}


Exécution du code :





Qu'est-ce qu'il vous reste à faire ?
Trouver le moyen de fixer le servo-moteur à l'aide de briques et de plaques LEGO, ci dessous un exemple de ce que l'on peut faire :










11/12/2017

Code slither.io pour P5js

Un petit bout de code pour p5.js,  inspiré de slither.io, pour les CM1 /CM2 de l'école la Rédemption qui apprennent à coder.
Allez voir le tutoriel, pour comprendre la logique de ce code et pouvoir l'adapter selon vos envies .

code à copier dans l'interface p5js editor :

  1. sélectionnez tout le code ci-dessous
  2. Ctrl+C pour copier
  3. rendez-vous ensuite sur l'éditeur  p5js editor : 
  4. Ctrl+V pour coller
  5. puis lancez en cliquant sur le triangle.
  6. vous pouvez ensuite modifier ce code pour adapter le jeu selon vos envies, n'oubliez pas le site p5.js pour quelques explications sur les fonctions utilisées : P5JS / Référence
       
var serpent;
var positions = [];
var nourriture;
//var mechantSerpent; //pour créer un adversaire ?

function setup() {
  fullscreen();
  createCanvas(800, 600);
  serpent = new Serpent();
//  mechantSerpent = new Serpent();
  nourriture = new Nourriture();
  positions[positions.length] = {mouseX,mouseY};
  textSize(32);
}

function draw() {
  background(0);
  tick();
  serpent.move();
  serpent.display();
  nourriture.display();
  nourriture.croque();
  fill(0, 102, 153);
  text( serpent.corps.boules.length-1, width-100, 30);
}

// serpent
function Serpent() {
  this.x = random(width);
  this.y = random(height);
  //  positions[0].x = this.x;
  //  positions[0].y = this.y;
  this.diameter = random(10, 30);
  this.speed = 1;
 this.corps = new Corps();
 var tete = new Boule(mouseX, mouseY,  color(random(0,255),random(0,255),random(0,255)));
 this.corps.boules[0] = tete;
 console.log(this.corps);

  this.move = function() {
    var boules = this.corps.boules;
  for (var i = 0; i < boules.length; i++) {
    var b = boules[i];
     if (i == 0){
          b.x = positions[0].x;
        b.y = positions[0].y;
          if (positions.length > 1 ){
            positions.shift();
          }
   }else{
        var precedente = boules[i-1];
        var d = int(dist(b.x, b.y, precedente.x, precedente.y));
        if(d > 10){
          if(b.x - precedente.x > 0){
            b.x = (3*b.x+ precedente.x)/4 ; // b.x-1-(d/20);
          }else if (b.x - precedente.x < -0) {
            b.x = (3*b.x+precedente.x)/4; //b.x+1+(d/20);
          }
          if (b.y - precedente.y > 0){
            b.y = (3*b.y + precedente.y)/4; //b.y-1-(d/20);
          }else if(b.y - precedente.y < -0){
            b.y = (3*b.y+precedente.y)/4; //b.y+1+(d/20);
          }
        }
   }
  }
  };

  this.display = function() {
    var boules = this.corps.boules;
  for (var i = 0; i < boules.length; i++) {
      var b = boules[i];
        fill(b.color);
        ellipse(b.x, b.y, this.diameter, this.diameter);
      }
      fill(boules[0].color);
      strokeWeight(1);
      stroke(color(0));
      ellipse(boules[0].x, boules[0].y, this.diameter*1.2, this.diameter*1.2);
      ellipse(boules[0].x, boules[0].y+this.diameter/4, this.diameter/3, this.diameter/4);
   }
}


function Corps(){
 this.boules = [];
}

function Boule(_x,_y, _color){
 this.x = _x;
 this.y = _y;
  this.color = _color;
}

function tick(){
  var longueurPos = 40;
  if (positions.length > longueurPos ){
    positions.shift();
  }
  if ((positions[positions.length-1].x != mouseX)&& (positions[positions.length-1].y != mouseY)){
    var pos = {};
    pos.x = mouseX;
    pos.y = mouseY;
    positions[positions.length] = pos;
  }else{
    if (positions.length > 1 ){
      positions.shift();
    }
  }
}

function Nourriture(){
  this.x = random (10, width-10);
  this.y = random (10, height-10);
  this.color =  color(random(0,255),random(0,255),random(0,255));

  this.display = function(){
    stroke(color(random(0,255),random(0,255),random(0,255)));
    strokeWeight(1);
    fill(this.color);
    rect(this.x, this.y, 5,5);
    noStroke();
  }

   this.croque = function(){
    var serpentTete = serpent.corps.boules[0];
    var d = int(dist(this.x, this.y, serpentTete.x, serpentTete.y));
    if (d < 10 ){
      var nouveau = new Boule(mouseX, mouseY, this.color);
      var longueur = serpent.corps.boules.length;
      serpent.corps.boules[longueur] = nouveau;
      nourriture = new Nourriture();
    }
  }
}

11/03/2014

Rover pcDuino partie logicielle

Édit (25/11/2015) :

I DID IT, JE L'AI FAIT !!!

Yahoo, Eureka, ça fonctionne...

Ça roule, ça tourne, ça envoie les images... !!!

Bon ok j'ai mis le temps, mais j'y suis arrivé. J'ai mon robot explorateur, une première étape du projet "Smag0" beaucoup plus vaste, de "robot qui range ma chambre".

Contrôlable par une interface web, une application mobile, ou adaptable à toute autre interface, le robot se déplace dans la maison et vous envoie les images, que vous soyez chez vous, au bureau ou à l'autre bout du monde !!!

Je m'apprête à préparer un "kit" pour ce robot explorateur avec tout le matériel nécessaire et les instructions, pas à pas pour en monter un vous même, ou encore à le proposer déjà tout monté, alors faites-moi signe si ce projet de robot vous intéresse par mailscenaristeur@gmail.com ou par twitter  @DFaveris . 

 Voir aussi http://smag0.blogspot.fr/2014/03/rover-pcduino-introduction.html pour l'introduction et la partie matérielle.
et un guide pour l'installation des composants utiles  http://smag0.blogspot.fr/2015/12/reinstallation-pcduino.html

 
Introduction
1. Matériel
1.1 Outils nécessaires
1.2 Découverte du matériel
1.3 Montage de la caméra PTZ
1.4 Assemblage de la plate-forme
1.5 Instruction de câblage
2. Partie Logicielle
2.1 Configurer pcDuino en point d'accès WiFi
2.2 Installer Video Stream Server sur pcDuino
2.3 Installer le logiciel de contrôle
2.4 Contrôler le rover avec un PC
2.5 Contrôler le Rover avec un appareil Android
2.5.1Introduction
2.5.2 GUI
2.5.3 Introduction au code source
2.5.3.1Module de contrôle d'interface
2.5.3.2 Module de conversion du format d'images
2.5.3.3 Module de communication
2.5.4 Guide de l'utilisateur
2.6 Liens de téléchargement

 Cette partie est la deuxième partie, la partie logicielle, pour consulter l'introduction et la partie matérielle cliquez ici

infos pour éviter des galères : 
régler l'heure sur pcduino :  sudo ntpdate ntp.ubuntu.com 
régler le clavier en français : sudo setxkbmap fr


2. Partie Logicielle

Le pcDuino sert de point d'accès Wi-Fi, et un serveur de flux vidéo. Il peut transmettre
vidéo en temps réel, et accepter le commandement de commande de client par WiFi. il
contrôle le mouvement de Rover et la rotation de la caméra.



################################################################################
EDIT pour le PCDUINO V2 avec carte Wifi Noir : 
source : http://learn.linksprite.com/wifi/enable-the-wireless-ap-function-on-pcduino-v2/
################################################################################
This tutorial is use to pcDuino V2 with black wifi module (rt1818cus driver) and pcDuino Lite WiFi with black wifi module (rt1818cus driver)

The pcDuino 2 / 3, Lite Wifi with Green WiFi Module (rt1818eus driver) is different .
The built-in hostapd can’t support system service mode. However, there are one package available online.

1.Download  software tools:
$sudo apt-get update
$sudo apt-get install git vim
$sudo apt-get install isc-dhcp-server
2. Download source code for drivers from official website:
$wget ftp://WebUser:Lc9FuH5r@58.211.24.153/cn/wlan/RTL8188C_8192C_USB_linux_v4.0.2_9000.20130911.zip
#http://www.realtek.com.tw/downloads/downloadsView.aspx?Langid=1&PNid=21&PFid=48&Level=5&Conn=4&DownTypeID=3&GetDown=false&Downloads=true#2742
3.Download header file for compiling the driver:
$sudo apt-get install pcduino-linux-headers-3.4.29+

$cd  /usr/src/ linux-headers-3.4.29+/arch
$cp  arm  armv7l  -rf
Note:  You will need to reboot pcDuino after this step if you are using pcDuino Lite wifi, wait for  3 seconds at  u-boot stage, enter the command, otherwise it can not be started properly.
$setenv loglevel 8 ramfs
$boot
$mount  /deV/nandd /mnt
$cd  /mn lib/modules/3.4.29+/kernel/drivers
$rm gpu –rf
$reboot
4. Delete original “8188cu.ko”:
$rm  /lib/modules/3.4.29+/kernel/drivers/net/wireless/rtl8192cu/8192cu.ko
$rm  /lib/modules/3.4.29+/kernel/drivers/net/wireless/8192cu.ko
5. Compile installing driver:
$unzip  RTL8188C_8192C_USB_linux_v4.0.2_9000.20130911.zip
$cd   RTL8188C_8192C_USB_linux_v4.0.2_9000.20130911
$chmod +x install.sh
$sudo ./install.sh
6. Finish Installation:
ubuntu@ubuntu:~/RTL8188C_8192C_USB_linux_v4.0.2_9000.20130911$ lsmod
Module                  Size  Used by
8192cu                624916  0
sw_interrupt            2424  0
gpio                    4509  0
pwm                     5050  0
adc                     1671  0
hardwarelib             1551  4 sw_interrupt,gpio,pwm,adc
rt5370sta             616973  0

INSTALLATION HOSTAPD : 

$git clone https://github.com/jenssegers/RTL8188-hostapd

$cd RTL8188-hostapd/hostapd
$sudo make install
Install 8188’s hostapd:
$cd  RTL8188C_8192C_USB_linux_v4.0.2_9000.20130911/wpa_supplicant_hostapd
$tar xvf wpa_supplicant_hostapd-0.8_rtw_r7475.20130812.tar.gz
$cd  hostapd
$sudo make install
Configure hostapd:
$vim  /etc/hostapd/hostapd.conf
# Basic configuration
interface=wlan3  #it depends on your own connection
ssid=wifi
channel=1
#bridge=br0
# WPA and WPA2 configuration
macaddr_acl=0
auth_algs=1
ignore_broadcast_ssid=0
wpa=3
wpa_passphrase=12345678
wpa_key_mgmt=WPA-PSK
wpa_pairwise=TKIP
rsn_pairwise=CCMP
# Hardware configuration
driver=rtl871xdrv
ieee80211n=1
hw_mode=g
device_name=RTL8192CU
manufacturer=Realtek
service hostapd restart
Name this wifi AP as wifi, password as 12345678
Now you need to reset your wifi password, and you can find this wifi available, but if it’s not working, you need to configure your internet.
vim /etc/network/interfaces
auto wlan3
iface wlan3 inet static
        address 192.168.100.1
        netmask 255.255.255.0              
service networking restart
Configure dhcp:
vim /etc/dhcp/dhcpd.conf #add it in the end
subnet 192.168.100.0 netmask 255.255.255.0 {
  range 192.168.100.10 192.168.100.100;
  option routers 192.168.100.1;
  option domain-name-servers 8.8.8.8;
}
service isc-dhcp-server restart

################################################################################

2.1 Configurer pcDuino en point d'accès WiFi

  Le noyau (20130531) publié sur le site pcDuino habituellement seulement fournit pilote en mode WiFi STA. Il n'a pas les iptables pour le routage IP soit. Donc, la première étape consiste à remplacer le limage du noyau de pcDuino.
 
Vous pouvez télécharger tous les fichiers nécessaires à l'adresse :  https://s3.amazonaws.com/linksprite/pcduino/wifiAP.rar

Copier wifiAP le répertoire ubuntu:
 ubuntu@ubuntu:~$ ls
Desktop Downloads Pictures Templates c_enviroment wifiAP
Documents Music Public Videos sample
$ sudo mount /dev/nanda /boot
$ sudo cp uImage /boot -f
$ sudo cp evb.bin /boot -f
$ sudo cp 3.4.292B.tar.bz2 /lib/modules/
$ cd /lib/modules/
ubuntu@ubuntu:/lib/modules$sudo tar -xvf 3.4.292B.tar.bz2

Redémarrer pcDuino :

$sudo reboot
Consulter les modules logiciels en utilisant la commande '$ lsmod ':
root@ubuntu:/home/ubuntu# lsmod
Module Size Used by
rt5370sta 617141 0
8192cu 537048 0
rt2800usb 11321 0
rt2800lib 40721 1 rt2800usb
crc_ccitt 1094 1 rt2800lib
rt2x00usb 7245 1 rt2800usb
rt2x00lib 31040 3 rt2800usb,rt2800lib,rt2x00usb
mali_drm 2087 1
drm 157060 2 mali_drm
mac80211 257514 3 rt2800lib,rt2x00usb,rt2x00lib
cfg80211 150671 2 rt2x00lib,mac80211
mali 91258 0
disp_ump 823 0
ump 44002 4 mali,disp_ump
Redémarrez et modifier / etc / modules, retirez rt5370sta:

$sudo modprobe rt2800usb
$echo 148F 5370 > /sys/bus/usb/drivers/rt2800usb/new_id
Vous pouvez également modifier la commande ci-dessus dans un port série de débogage.
Si nous activons WLAN, "$ ifconfig wlan3 up", nous allons voir le message d'erreur suivant:

root@ubuntu:~# ifconfig wlan3 up
[ 1043.640000] phy0 -> rt2x00lib_request_firmware: Error –
Failed to request Firmware.
SIOCSIFFLAGS: No such file or directory
Il montre qu'il n'ya pas de firmware pour le dongle USB WiFi. Nous avons besoin de le mettre dans le bon endroit.  (A Modifier si pcDuino V2 ?)
Utilisez la commande "$ modinfo rt2800usb" et trouver le nom de firmware est rt2870.bin.


 root@ubuntu:~# modinfo rt2800usb
filename:
/lib/modules/3.4.29+/kernel/drivers/net/wireless/rt2x00/rt28
00usb.ko
license: GPL
firmware: rt2870.bin
description: Ralink RT2800 USB Wireless LAN driver.
version: 2.3.0
author: http://rt2x00.serialmonkey.com
 Copiez le firmware dans le répertoire correct:

 $sudo cp rt2870.bin /lib/firmware/
 Maintenant, nous redémarrons WLAN, alors nous pouvons trouver une connexion Wi-Fi:

 ”$sudo ifconfig wlan3 up”
Installez iptables:

 $sudo apt-get install iptables vim iw
Après l'installation est terminée, vérifiez si iptables a été installé avec succès:
$sudo iptables -L
root@ubuntu:~# iptables -L
Chain INPUT (policy ACCEPT)
target prot opt source destination
Chain FORWARD (policy ACCEPT)
target prot opt source destination
Chain OUTPUT (policy ACCEPT)
target prot opt source destination
Télécharger et éditer hostapd:
En compilant nous aurons besoin "libnl-dev" et "libssl-dev". Alors  installons-les en premier.


 $sudo apt-get install libnl-dev libssl-dev
Hostpad 1.0 can be downloaded from http://hostap.epitest.fi/releases/.
A complete list of commands are:

ubuntu@ubuntu:~$ wget
http://hostap.epitest.fi/releases/hostapd-1.0.tar.gz
ubuntu@ubuntu:~$ tar xvf hostapd-1.0.tar.gz
ubuntu@ubuntu:~$ cd hostapd-1.0
ubuntu@ubuntu:~/hostapd-1.0$ cd hostapd/
ubuntu@ubuntu:~/hostapd-1.0/hostapd$ vim defconfig
 Trouvez la ligne contenant “#CONFIG_IEEE80211N=y”, enlevez le dièse ‘#’
Sauvegarder et quittez


ubuntu@ubuntu:~/hostapd-1.0/hostapd$ cp defconfig .config
ubuntu@ubuntu:~/hostapd-1.0/hostapd$ make
CC main.c
CC config_file.c
CC ../src/ap/hostapd.c
CC ../src/ap/wpa_auth_glue.c
CC ../src/ap/drv_callbacks.c
CC ../src/ap/ap_drv_ops.c
CC ../src/ap/utils.c
CC ../src/ap/authsrv.c
ubuntu@ubuntu:~/hostapd-1.0/hostapd$ sudo make install
mkdir -p /usr/local/bin
for i in hostapd hostapd_cli; do cp -f $i /usr/local/bin/$i; done
Vérifiez si hostpad a été installé avec succès:

ubuntu@ubuntu:~/hostapd-1.0/hostapd$ hostapd -v
hostapd v1.0
User space daemon for IEEE 802.11 AP management,
IEEE 802.1X/WPA/WPA2/EAP/RADIUS Authenticator
Copyright (c) 2002-2012, Jouni Malinen <j@w1.fi> and
contributors
Maintenant, nous commençons à configurer hostpad.
Nous espérons que notre hotspot est configuré comme suit,


SSID: ssid=pcduino
Password: wpa_pass
phrase=1234567890
Encryption: wpa_key_mgmt=WPA-PSK
 Configurez comme suit:

 root@ubuntu:~# nano /etc/hostapd.conf
interface=wlan3
driver=nl80211
ssid=pcduino
hw_mode=g
channel=11
dtim_period=1
rts_threshold=2347
fragm_threshold=2346
macaddr_acl=0
auth_algs=1
ieee80211n=0
wpa=2
wpa_passphrase=1234567890
wpa_key_mgmt=WPA-PSK
wpa_pairwise=TKIP
rsn_pairwise=CCMP

 Note: si wlan3 peuvent changer, nous devons utiliser "ipconfig" pour vérifier.
Une fois la configuration terminée, nous utilisons les commandes suivantes pour vérifier la configuration.


 root@ubuntu:~# hostapd -dd /etc/hostapd.conf
random: Trying to read entropy from /dev/random
Configuration file: /etc/hostapd.conf
nl80211: interface wlan4 in phy phy0
rfkill: initial event: idx=0 type=2 op=0 soft=0 hard=0
rfkill: initial event: idx=1 type=1 op=0 soft=0 hard=0
nl80211: Using driver-based off-channel TX
nl80211: Register frame command failed (type=208): ret=-114 (Operation already in progress)
nl80211: Register frame match – hexdump(len=1): 06
nl80211: Failed to register Action frame processing – ignore for now
nl80211: Add own interface ifindex 5
nl80211: Set mode ifindex 5 iftype 3 (AP)
nl80211: Create interface iftype 6 (MONITOR)
nl80211: New interface mon.wlan4 created: ifindex=7
nl80211: Add own interface ifindex 7
BSS count 1, BSSID mask 00:00:00:00:00:00 (0 bits)
nl80211: Regulatory information – country=00
nl80211: 2402-2472 @ 40 MHz
nl80211: 2457-2482 @ 40 MHz
nl80211: 2474-2494 @ 20 MHz
nl80211: 5170-5250 @ 40 MHz
nl80211: 5735-5835 @ 40 MHz
nl80211: Added 802.11b mode based on 802.11g information
Allowed channel: mode=1 chan=1 freq=2412 MHz max_tx_power=20 dBm
Allowed channel: mode=1 chan=2 freq=2417 MHz max_tx_power=20 dBm
Allowed channel: mode=1 chan=3 freq=2422 MHz max_tx_power=20 dBm
Allowed channel: mode=1 chan=4 freq=2427 MHz max_tx_power=20 dBm
Allowed channel: mode=1 chan=5 freq=2432 MHz max_tx_power=20 dBm
Allowed channel: mode=1 chan=6 freq=2437 MHz max_tx_power=20 dBm
Allowed channel: mode=1 chan=7 freq=2442 MHz max_tx_power=20 dBm
Allowed channel: mode=1 chan=8 freq=2447 MHz max_tx_power=20 dBm
Allowed channel: mode=1 chan=9 freq=2452 MHz max_tx_power=20 dBm
Allowed channel: mode=1 chan=10 freq=2457 MHz max_tx_power=20 dBm
Allowed channel: mode=1 chan=11 freq=2462 MHz max_tx_power=20 dBm
Allowed channel: mode=0 chan=1 freq=2412 MHz max_tx_power=20 dBm
Allowed channel: mode=0 chan=2 freq=2417 MHz max_tx_power=20 dBm
Allowed channel: mode=0 chan=3 freq=2422 MHz max_tx_power=20 dBm
Allowed channel: mode=0 chan=4 freq=2427 MHz max_tx_power=20 dBm
Allowed channel: mode=0 chan=5 freq=2432 MHz max_tx_power=20 dBm
Allowed channel: mode=0 chan=6 freq=2437 MHz max_tx_power=20 dBm
Allowed channel: mode=0 chan=7 freq=2442 MHz max_tx_power=20 dBm
Allowed channel: mode=0 chan=8 freq=2447 MHz max_tx_power=20 dBm
Allowed channel: mode=0 chan=9 freq=2452 MHz max_tx_power=20 dBm
Allowed channel: mode=0 chan=10 freq=2457 MHz max_tx_power=20 dBm
Allowed channel: mode=0 chan=11 freq=2462 MHz max_tx_power=20 dBm
Completing interface initialization
Mode: IEEE 802.11g Channel: 11 Frequency: 2462 MHz
nl80211: Set freq 2462 (ht_enabled=0 sec_channel_offset=0)
RATE[0] rate=10 flags=0×1
RATE[1] rate=20 flags=0×1
RATE[2] rate=55 flags=0×1
RATE[3] rate=110 flags=0×1
RATE[4] rate=60 flags=0×0
RATE[5] rate=90 flags=0×0
RATE[6] rate=120 flags=0×0
RATE[7] rate=180 flags=0×0
RATE[8] rate=240 flags=0×0
RATE[9] rate=360 flags=0×0
RATE[10] rate=480 flags=0×0
RATE[11] rate=540 flags=0×0
Flushing old station entries

Ensuite, installez le serveur DHCP.
$sudo apt-get install dhcp3-server
Une fois que c'est fait, configurez le serveur DHCP:
$sudo nano /etc/dhcp/dhcpd.conf
Ajoutez les lignes suivantes à la fin du fichier:
subnet 192.168.0.0 netmask 255.255.255.0
{
range 192.168.0.2 192.168.0.10;
option routers 192.168.0.1; #router address
option domain-name-servers 8.8.8.8;
}
Redémarrez hostapd:
root@ubuntu:~# killall hostapd
hostapd: no process found
root@ubuntu:~# hostapd -B /etc/hostapd.conf
Configuration file: /etc/hostapd.conf
Using interface wlan4 with hwaddr 00:c3:16:a0:03:00 and ssid ‘pcduino’
Définissez l'adresse IP de WiFi de pcDuino:
root@ubuntu:~# ifconfig wlan4 192.168.0.1
Activez DHCP :
root@ubuntu:~# dhcpd wlan4 -pf /var/run/dhcp-server/dhcpd.pid
Internet Systems Consortium DHCP Server 4.1-ESV-R4
Copyright 2004-2011 Internet Systems Consortium.
All rights reserved.
For info, please visit https://www.isc.org/software/dhcp/
Wrote 0 leases to leases file.
Listening on LPF/wlan4/00:c3:16:a0:03:00/192.168.0.0/24
Sending on LPF/wlan4/00:c3:16:a0:03:00/192.168.0.0/24
Sending on Socket/fallback/fallback-net
Activez l'IP forwarding:
root@ubuntu:~# echo 1 >/proc/sys/net/ipv4/ip_forward
 Réglez NAT:
root@ubuntu:~# iptables -t nat -A POSTROUTING -o eth0 -j
MASQUERADE
Après la configuration ci-dessus est fait, nous devrions voir un point d'accès nommé "pcduino".
Remarque: Dans le débogage, vérifiez votre WiFi en utilisant "ipconfig" et le changement wlan en conséquence.

Installer Video Stream Server sur pcDuino

 

Nous utilisons le package opensource mjpg-streamer de mettre en œuvre le serveur de transmission vidéo. Le client peut être un navigateur ou une application spéciale.

D'abord installer quelques logiciels.

$sudo apt-get install libv4l-dev
$sudo apt-get install libjpeg8-dev
$sudo apt-get install subversion
$sudo apt-get install imagemagick
Le libv4l-dev et ibjpeg8-dev sont des bibliothèques. La Subversion et ImageMagick sont nécessaires pour compiler le code source mjpg-streamer.


Ensuite téléchargez, compiler et installer le logiciel serveur vidéo mjpg-streamer.


$svn co https://mjpg-streamer.svn.sourceforge.net/svnroot/mjpg-streamer mjpg-streamer
! remplacé par : svn co svn co https://svn.code.sf.net/p/mjpg-streamer/code/ mjpg-streamer

$cd mjpg-streamer
$make USE_LIBV4L2=true clean all
$sudo make DESTDIR=/usr install
Après l'installation est terminée, nous devons ouvrir le serveur de vidéo-streamer jpg. La commande pour activer le service est:

$mjpg_streamer -i "/usr/lib/input_uvc.so -d /dev/video0 -y -r 320x240 -f 10" -o "/usr/lib/output_http.so -p 8090 -w /var/www/mjpg_streamer"
Les paramètres sont les suivants:

-d: device
-r: resolution
-f: frequency
Si votre webcam ne prend pas en charge le format MJPEG, nous pouvons utiliser '-y' pour spécifier d'utiliser le format YUYV au lieu du format MJPEG.

-p: port
-w: web directory

Sur un terminal pcDuino nous utilisons la commande "ipconfig" pour obtenir l'adresse IP de l'pcDuino. Puis dans un navigateur en un client, visitez http://192.168.1.3:8090/?action=stream pour accéder à la vidéo en temps réel. L'adresse 192.168.1.3 est l'adresse IP de l'pcDuino.
(erreur sur le document originel ? action = steam au lieu de stream ? voir copie ecran)

 

Installer le logiciel de contrôle

traduction à reprendre page 60

Contrôler le rover avec un PC

Contrôler le Rover avec un appareil Android

Introduction

GUI

Introduction au code source

- Module de contrôle d'interface
- Module de conversion du format d'images
- Module de communication

Guide de l'utilisateur

Liens de téléchargement