View  Edit  Attributes  History  Attach  Print  Search

ACCUEIL | ARDUINO > S'INSTALLER > DEBUTER > APPROFONDIR | PROCESSING | MECATRONIQUE | MATERIEL | OUTILS | TESTS | Plus...|
Python > Shell > ATELIERS Python + Qt > PyQt apps > PyQt+Arduino | Mes Robots | RepRap | Mes lib'Arduino | Mes shields Arduino | Mes distros | Les Mini-PC |
ATELIERS ARDUINO| VIDEOS | COMPRENDRE | REFERENCES | CODER | TECHNIQUE | GNU/LINUX | LIENS | Rien à voir |

GLAP-Box : Affichage sur afficheur TFT 320x240 du contenu d'un répertoire reçu sur le port série

Par X. HINAULT - Page créée le : 22/7/2011.

(cliquer sur l'image pour agrandir)

1.  Présentation

Le programme écoute le port série. Lorsqu'une chaine de caractère est disponible, elle est ensuite affichée sur l'afficheur TFT couleur.

Ce programme utilise les fonctionnalités suivantes :

Ressources utiles associées à ce programme :

2.  Matériel Nécessaire

2.1  Un PC fixe + une carte Arduino + une GLAP-Box

  • qui intègre l'espace de développement Arduino / Processing accessible par VNC depuis un PC fixe,
  • ... pour éditer, compiler le programme et programmer la carte Arduino.

2.2  Le matériel suivant pour réaliser le montage associé

  • Watterrott propose également un circuit imprimé de compatibilité pour la carte Arduino à coupler avec cet adaptateur d'écran , le mSD-shield (15 Euros) : http://www.watterott.com/de/Arduino-mSD-Shield L'utilisation est alors très simple puisqu'il suffit d'enficher le module sur la carte Arduino.

3.  Instructions de montage

  • La connexion série vers le PC utilise les broches 0 et 1 (via le câble USB)
  • Connexions à réaliser pour adaptateur écran MI0283QT2 240x320 pixels - 262 K couleurs

Note : ces connexions sont réalisées automatiquement si utilisation du circuit imprimé mSD-shield

  • Broches utilisées pour le contrôle de l'afficheur graphique
    • broche CS de l'adaptateur sur la broche 7
    • broche RST de l'adaptateur sur la broche 8
    • broche LED de l'adaptateur sur la broche 9
  • broches utilisées pour la communication SPI de l'adaptateur MI0283QT2
    • broche SDI de l'adaptateur sur la broche 11
    • broche SDO de l'adaptateur sur la broche 12
    • broche SCL de l'adaptateur sur la broche 13

4.  Le circuit du montage

Le schéma du montage à réaliser (cliquer pour agrandir)

5.  Explication du programme

  • Le programme Arduino écoute le port série et reçoit les chaines se terminant par un saut de ligne. Chaque chaine reçue est affichée sur une ligne.
  • Le programme reconnaît également l'instruction cls() pour effacer l'écran en blanc.

6.  Mise en oeuvre du programme

6.1  Préparation du montage et programmation de la carte Arduino :

  • Commencer par réaliser le montage indiqué sur plaque d'expérimentation
  • Ensuite, programmer la carte Arduino avec ce programme (en bas de page) selon la procédure habituelle

6.2  Préparation du Terminal côté PC dans le logiciel Arduino

  • Côté PC, il faut ouvrir la fenêtre terminal de l'IDE Arduino : pour ce faire, un simple clic sur le bouton « Sérial Monitor ».
  • La fenêtre « Terminal » s'ouvre alors :
  • Il faut alors régler le débit de communication sur la même valeur que celle utilisée par le programme avec lequel nous allons programmer la carte Arduino :

6.3  Fonctionnement

  • Lancer le programme Processing sur le PC (Ubuntu)
  • Le contenu du répertoire voulu s'affiche sur l'écran TFT

7.  Le programme complet en langage Arduino

A copier/coller directement dans l'éditeur Arduino


// --- Programme Arduino ---
// Trame de code générée par le générateur de code Arduino
// du site www.mon-club-elec.fr

// Auteur du Programme : X. HINAULT - Tous droits réservés
// Programme écrit le : 22/7/2011.

// ------- Licence du code de ce programme -----
//  This program is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License,
//  or any later version.
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//  You should have received a copy of the GNU General Public License
//  along with this program.  If not, see <http://www.gnu.org/licenses/>.

// ////////////////////  PRESENTATION DU PROGRAMME ////////////////////

// -------- Que fait ce programme ? ---------
 /* Le programme écoute le port série. Lorsqu'une chaine de caractère est disponible, elle est ensuite affichée sur l'afficheur TFT couleur.  */

// --- Fonctionnalités utilisées ---

// Utilise la connexion série matérielle vers le PC
// Utilise / fonctionne avec une interface Processing coté PC
// Utilise adaptateur pour écran MI0283QT2 240x320 pixels - 262 K couleurs

// -------- Circuit à réaliser ---------

// La connexion série matérielle vers le PC utilise les broches 0 et 1 (via le câble USB)

// Connexions à réaliser pour adaptateur écran MI0283QT2 240x320 pixels - 262 K couleurs
// ces connexions sont réalisées automatiquement si utilisation du circuit imprimé mSD-shield

// ----- broches utilisées pour le contrôle de l'afficheur graphique
// broche CS de l'adaptateur sur la broche 7
// broche RST de l'adaptateur sur la broche 8
// broche LED de l'adaptateur sur la broche 9

// ----- broches utilisées pour la communication SPI de l'adaptateur MI0283QT2
// broche SDI de l'adaptateur sur la broche 11
// broche SDO de l'adaptateur sur la broche 12
// broche SCL de l'adaptateur sur la broche 13


// /////////////////////////////// 1. Entête déclarative ///////////////////////
// A ce niveau sont déclarées les librairies incluses, les constantes, les variables, les objets utiles...

// --- Déclaration des constantes ---

// --- Inclusion des librairies ---

#include <MI0283QT2.h> // librairie de l'afficheur TFT MI0283QT2
// Avant utilisation, il faut installer manuellement cette librairie
// dans le dossier <Libraries> du dossier Arduino

// --- Déclaration des constantes utiles ---

// --- Déclaration des constantes des broches E/S numériques ---


// --- Déclaration des constantes des broches analogiques ---


// --- Déclaration des variables globales ---

int octetReception=0; // variable de stockage des valeurs reçues sur le port Série
long nombreReception=0; // variable de stockage du nombre  reçu sur le port Série
long nombreReception0=0; // variable de stockage du dernier nombre  reçu sur le port Série
String chaineReception=""; // déclare un objet String vide pour reception chaine

//--------- variables taille polices ----
// écran = 320x240
// soit en police 8 x12 un affichage alpha-numérique de 40 colonnes x 20 lignes
// et en police 8x8 un affichage alpha-numérique de 40 colonnes x 30 lignes
// la taille de la police est définie dans le fichier fonts.h
int font_larg=8; // variable de largeur de la police en pixels
int font_haut=8; // variable de hauteur de la police en pixels

int ligne=1, colonne=1; // variables ligne/colonne

// --- Déclaration des objets utiles pour les fonctionnalités utilisées ---

MI0283QT2 lcd; // création d'un objet de type MI0283QT2 appelé lcd


// ////////////////////////// 2. FONCTION SETUP = Code d'initialisation //////////////////////////
// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme

void setup()   { // debut de la fonction setup()

// --- ici instructions à exécuter 1 seule fois au démarrage du programme ---

// ------- Initialisation fonctionnalités utilisées -------  

Serial.begin(115200); // initialise connexion série matérielle à 115200 bauds
// IMPORTANT : régler le terminal côté PC avec la même valeur de transmission

//initialisation écran MI0283QT2  240x320 pixels
lcd.init(4); //spi-clk = Fcpu/4
lcd.clear(RGB(255,255,255)); // efface ecran en blanc

//configuration écran MI0283QT2  240x320 pixels - après calibrage touchpad
lcd.setOrientation(0); // configure orientation afficheur en degrés : 0,90,180,270
// Par défaut 0 = point 0,0 en regard connecteur USB

lcd.clear(RGB(255,255,255)); // efface ecran en blanc
lcd.led(50); // fixe luminosité


// ------- Broches en sorties numériques -------  

// ------- Broches en entrées numériques -------  

// ------- Activation si besoin du rappel au + (pullup) des broches en entrées numériques -------  

// ------- Initialisation des variables utilisées -------  

// ------- Codes d'initialisation utile -------  

} // fin de la fonction setup()
// ********************************************************************************

////////////////////////////////// 3. FONCTION LOOP = Boucle sans fin = coeur du programme //////////////////
// la fonction loop() s'exécute sans fin en boucle aussi longtemps que l'Arduino est sous tension

void loop(){ // debut de la fonction loop()


// --- ici instructions à exécuter par le programme principal ---


//---- code type réception chaine sur le port série ---
while (Serial.available()>0) { // tant qu'un octet en réception
        octetReception=Serial.read(); // Lit le 1er octet reçu et le met dans la variable

        if (octetReception==10) { // si Octet reçu est le saut de ligne
                Serial.println ("Chaine recue="+chaineReception); // affiche la chaine recue

                chaineReception.trim(); // enlève espaces
                analyseChaine(chaineReception); // appelle la fonction d'analyse de la chaine en réception

                //chaineReception=""; //RAZ le String de réception
                break; // sort de la boucle while
        }
        else { // si le caractère reçu n'est pas un saut de ligne
                chaineReception=chaineReception+char(octetReception); // ajoute le caratère au String
        }

} // fin tant que  octet réception

//----- une fois que le saut de ligne est reçu, on sort du While et on se positionne ici

if (chaineReception=="cls()") { // si chaine cls()

  lcd.clear(white);// on efface l'écran
  ligne=1; // RAZ ligne

}
else if ((chaineReception.length()>0)&&(ligne<31)) { // si une chaine a été reçue et que l'on n'a pas utilisé les 30 lignes

  //--- transformation du String en tableau de caractères ---

  char texte[chaineReception.length()+1]; // tableau char de taille du String +1 (caractère vide de fin de chaine)

  chaineReception.toCharArray(texte, sizeof(texte)); // met le contenu du String dans le tableau de caractères
  // attention : la syntaxe de la référence est fausse : la bonne est maChaine.toCharArray(texte, sizeof(texte));

  lcd.drawText(colonne-1,(ligne-1)*font_haut,texte,1,blue,white);

  ligne=ligne+1; // incrémente ligne pour effet saut de ligne

} // fin si chaine reçue


chaineReception=""; //RAZ le String de réception

//while(1); // stop loop

} // fin de la fonction loop() - le programme recommence au début de la fonction loop sans fin
// ********************************************************************************


// ////////////////////////// FONCTIONS DE GESTION DES INTERRUPTIONS ////////////////////


// ////////////////////////// AUTRES FONCTIONS DU PROGRAMME ////////////////////



//------------- fonction d'analyse de la chaine reçue sur le port série ----

void analyseChaine(String chaineRecue) { // fonction d'analyse de la chaine recue

        //--- variables locales
        int valeur=0; // variable utile
        String chaineTest; // objet STring pour analyse chaine recue

  //analyse des premiers caractères
  //if (chaineRecue.startsWith("chaine")) { // si la chaine débute par "chaine"

        //}

    //analyse d'un nombre
    // valeur=chaineRecue.charAt(4); // extrait le caractère ASCII à la position voulue - index 0 est le 1er caractère
        //valeur=valeur-48; // obtient la valeur décimale à partir de la valeur ASCII
        //if (valeur>=0 && valeur<=9) { // si valeur est entre 0 et 9

       //Serial.print("valeur="), Serial.println(valeur);

        //}

        // analyse d'une sous-chaine
        //chaineTest=chaineRecue.substring(5,6); // extraction du 6ème caractère - le 1er est à index=0
        //if ( chaineTest=="H" || chaineTest=="L") { // si la sous-chaine est H ou L
        //}


} // fin fonction analyse chaine

// ---------- fonction de conversion d'un String numérique en long

long stringToLong(String chaineLong) { // fonction conversion valeur numérique String en int

    long nombreLong=0; // variable locale
    int valeurInt=0; // variable locale

    for (int i=0; i<chaineLong.length(); i++) { // défile caractères de la chaine numérique

      valeurInt=chaineLong.charAt(i); // extrait le caractère ASCII à la position voulue - index 0 est le 1er caractère
      valeurInt=valeurInt-48; // obtient la valeur décimale à partir de la valeur ASCII  

     if (valeurInt>=0 && valeurInt<=9) { // si caractère est entre 0 et 9
       nombreLong=(nombreLong*10)+valeurInt;
     } // fin si caractère est entre 0 et 9


    } // fin for défile caractères

 return (nombreLong); // renvoie valeur numérique

} // fin stringToLong


// ////////////////////////// Fin du programme ////////////////////

 

8.  Le programme Processing

8.1  Description

  • Ce programme exécute une ligne de commande ls chemin | cat pour obtenir le contenu d'un répertoire ligne à ligne.
  • Chaque ligne est envoyée sur le port série, suivie d'un saut de ligne.

8.2  Ressources utiles

  • man ls
  • man cat

8.3  Le programme complet en langage Processing

A copier/coller directement dans l'éditeur Processing

// Programme processing
// généré avec le générateur de code Processing
// www.mon-club-elec.fr
// par X. HINAULT - Juillet 2011 - tous droits réservés

/////////////// Description du programme ////////////
// Ce programme fait exécuter la commande système ls | cat d'un répertoire
// et récupère la sortie qui est envoyée sur le port série ligne à ligne


// XXXXXXXXXXXXXXXXXXXXXX ENTETE DECLARATIVE XXXXXXXXXXXXXXXXXXXXXX

// inclusion des librairies utilisées

import processing.serial.*; // importe la librairie série processing

// déclaration objets

// --- port Série ---
Serial  myPort; // Création objet désignant le port série

String[] command ;

String inputString;
String adresseIP;

String cheminRepertoire="/home/hinault/Bureau/musiques_videos/tubes/";



// déclaration variables globales

// XXXXXXXXXXXXXXXXXXXXXX  Fonction SETUP XXXXXXXXXXXXXXXXXXXXXX

void setup(){ // fonction d'initialisation exécutée 1 fois au démarrage

// --- initialisation des objets et fonctionnalités utilisées ---

        //------------- initialisation port série ----
        println(Serial.list()); // affiche dans la console la liste des ports séries
        // Vérifier que le numéro du port série utilisé est le meme que celui utilisé avec  Serial.list()[index]
        myPort = new Serial(this, Serial.list()[0], 115200); // Initialise une nouvelle instance du port Série
        //myPort = new Serial(this, "/dev/ttyUSB0", 115200); // Initialise une nouvelle instance du port Série
        myPort.bufferUntil('\n'); // attendre arrivée d'un saut de ligne pour générer évènement série


  myPort.write("cls()\n"); // envoie la chaine suivi saut ligne sur le port Série

} // fin fonction Setup

// XXXXXXXXXXXXXXXXXXXXXX Fonction Draw XXXXXXXXXXXXXXXXXXXX

void  draw() { // fonction exécutée en boucle

  delay(2000); // laisse le temps à l'Arduino de s'initialiser

contenuRep(cheminRepertoire);

while(true); // stoppe boucle draw

} // fin de la fonction draw()



// XXXXXXXXXXXXXXXXXXXXXX Autres Fonctions XXXXXXXXXXXXXXXXXXXXXX

void contenuRep(String cheminRep) {

// commande : ls chemin |cat
// cat pour afficher ligne à ligne

command = new String[3];
command[0] = "ls";
command[1] = cheminRepertoire;
command[2]="|cat";
//command[3]="";  
//command[4]="";
//command[5]="";  
//command[6]="";
//command[7]="";

//--- exécution de la ligne de commande
try {
    Process p = exec(command); // exécute la commande

    //--- récupère la sortie de la commande dans la console de Processing
    BufferedReader in = new BufferedReader(new InputStreamReader(p.getInputStream()));
    String ligne = null;

    while ((ligne = in.readLine()) != null) { // lit la sortie console ligne à ligne

        System.out.println(ligne); // affiche la ligne courante issue de la console

        myPort.write(ligne+"\n"); // envoie la chaine suivi saut ligne sur le port Série
        delay(150); // pause entre les envois pour laisser temps réception par Arduino

        inputString=ligne; // on mémorise la ligne

        //---- traitement de la chaine de la deuxième ligne = extraction de l'IP
        inputString=trim(inputString);

        //String[] subString = split(inputString, ':'); // coupe entre les :

      }




  }
  catch (IOException e) {
    e.printStackTrace();
  }  

}

//---------- fin programme ------------
 

9.  Utilisation concrète

  • Ce programme peut être utile pour visualiser le contenu d'un répertoire de la GLAP-Box sans disposer d'écran VGA par ailleurs.