Archives de catégorie : Hardware/Software

***

DM-18

Dotée de 6 modes de fonctionnement différents, la « DM-18A » fait partie des cartes de restitution sonores de la famille « Quick Wave« , lesquelles sont capables de « relire » directement des fichiers « sonores » au format « .WAV ».

Continuer la lecture →

Piloter un arduino à distance depuis un PC

Mise à jour le 31/05/2017 : Dans cet article, nous allons voir comment envoyer des ordres depuis un pc vers un arduino au travers de la communication RF de deux xbee.

Schéma de principe pour le module Xbee

Dans ce schéma, on peut distinguer deux parties :
L’émetteur : il est constitué d’un PC, d’un arduino et d’un shield xbee.
Le récepteur : il est constitué d’un arduino et d’un shield xbee voir description . Il est également relié à une les et un bouton poussoir par le biais d’un shield Grove méga (mais vous pouvez adapter avec votre matériel sans problème).

Dans notre article, nous allons voir comment allumer une LED à distance mais aussi comment recevoir une information provenant du récepteur au travers d’un bouton poussoir.

Partie récepteur

Il faut donc préparer l’arduino pour qu’une led et un bouton poussoir y soient connectés. Il faut également solidariser le tout avec un shield xbee. Dans notre exemple nous avons placé la LED sur le pin D12 et le bouton sur le pin D2. Nous avons également branché le module xbee sur le port série hardware n°1 (par le biais d’un câblage et non en enfichant le shield sur l’arduino, cela permet de libérer le port COM de base qui sert également à la programmation de l’arduino et évite ainsi de devoir bouger les jumpers sans arrêt).

Au niveau programmation, nous allons coder une partie qui va permettre d’effectuer deux actions :

1) On va lire les données provenant du shield xbee pour voir si nous avons reçu un ordre et transmettre cet ordre à la LED (allumer ou éteindre)
2) On va envoyer l’état du bouton, si celui ci a changé, au PC.

//On place le bouton sur le pin D2
const int buttonPin = 2;
//Onb place la LED sur le pin D12
const int ledPin =  12;
//Variable permettant de connaitre le dernier état du bouton
int lastState = LOW;

void setup() {
  //On initialise le port COM xbee
  Serial1.begin(9600);
  //On initialise la LED
  pinMode(ledPin, OUTPUT);
  //On initialise le bouton
  pinMode(buttonPin, INPUT);     
}

void loop() {
  
  // RECEPTION D'UN ORDRE
  String lastOrdre = "";
  while(Serial1.available()) {
    //On récupère le caractère
    char lastchar = Serial1.read();
    //Si celui ci est un # on s'arrete là, l'ordre est complet
    if(lastchar == '#') { break; }
    //Sinon on concatene avec le reste de l'ordre
    lastOrdre += lastchar;
  }
  
  //Si la taille de l'ordre est > à 0
  if(lastOrdre.length() > 0) {
    //Si l'ordre est ALLUMER
    if(lastOrdre == "ALLUMER") {
      //On passe la led à l'état haut (on l'allume)
      digitalWrite(ledPin, HIGH); 
    }
    //Si l'ordre est d'éteindre
    if(lastOrdre == "ETEINDRE") {
      //On passe la led à l'état bas, on l'éteint
      digitalWrite(ledPin, LOW); 
    }
  }
  
  delay(50);
  
  //EMISSION D'UN ORDRE
  
  //On récupère l'état actuel du bouton
  int currentState = digitalRead(buttonPin);
  //Si l'etat actuel du bouton est différent de celui qu'on avait enregistré la derniere fois, 
  //on sait qu'on doit déclencher un nouvel ordre (on a changé d'état)
  if(currentState != lastState) {
    //Tout d'abord, on enregistre le nouvel état
    lastState = currentState;
    //Si l'état est haut
    if(lastState == HIGH) {
      //On demande l'allumage au PC
      Serial1.write("ALLUMER#");
    }
    //Si l'état est bas
    if(lastState == LOW) {
      //On demande l'extinction au PC
      Serial1.write("ETEINDRE#");
    }
  }
}

//On place le bouton sur le pin D2

const int buttonPin = 2;

//Onb place la LED sur le pin D12

const int ledPin = 12;

//Variable permettant de connaitre le dernier état du bouton

int lastState = LOW;

void setup() {

//On initialise le port COM xbee

Serial1.begin(9600);

//On initialise la LED

pinMode(ledPin, OUTPUT);

//On initialise le bouton

pinMode(buttonPin, INPUT);

}

void loop() {

// RECEPTION D'UN ORDRE

String lastOrdre = "";

while(Serial1.available()) {

//On récupère le caractère

char lastchar = Serial1.read();

//Si celui ci est un # on s'arrete là, l'ordre est complet

if(lastchar == '#') { break; }

//Sinon on concatene avec le reste de l'ordre

lastOrdre += lastchar;

}

//Si la taille de l'ordre est > à 0

if(lastOrdre.length() > 0) {

//Si l'ordre est ALLUMER

if(lastOrdre == "ALLUMER") {

//On passe la led à l'état haut (on l'allume)

digitalWrite(ledPin, HIGH);

}

//Si l'ordre est d'éteindre

if(lastOrdre == "ETEINDRE") {

//On passe la led à l'état bas, on l'éteint

digitalWrite(ledPin, LOW);

}

delay(50);

//EMISSION D'UN ORDRE

//On récupère l'état actuel du bouton

int currentState = digitalRead(buttonPin);

//Si l'etat actuel du bouton est différent de celui qu'on avait enregistré la derniere fois,

//on sait qu'on doit déclencher un nouvel ordre (on a changé d'état)

if(currentState != lastState) {

//Tout d'abord, on enregistre le nouvel état

lastState = currentState;

//Si l'état est haut

if(lastState == HIGH) {

//On demande l'allumage au PC

Serial1.write("ALLUMER#");

}

//Si l'état est bas

if(lastState == LOW) {

//On demande l'extinction au PC

Serial1.write("ETEINDRE#");

}

Partie émetteur – Arduino

La partie émetteur est la plus basique au niveau branchements : Nous avons juste branché un shield xbee par le biais de câbles (comme pour le récepteur) sur le port Série hardware n°1 et nous avons relié l’arduino au port USB.

Le programme de la partie émetteur est très simple, c’est une sorte de routeur. Il va recevoir les ordres du pc qu’il transmet au récepteur et il reçoit des ordres du récepteur qu’il transmet au pc. On utilise donc deux canaux série : le canal série Arduino/PC et le canal série Arduino/xbee.

void setup() {
  //On initialise le port Serie Arduino / PC
  Serial.begin(9600);
  //On initialise le port Serie Arduino / Xbee
  Serial1.begin(9600);
}

void loop() {
  // RECEPTION D'UN ORDRE PROVENANT DE L'ARDUINO
  String lastOrdre = "";
  while(Serial1.available()) {
    //On récupère chaque caractere provenant du module xbee
    char lastchar = Serial1.read();
    //On concatene le caractère au reste de l'ordre
    lastOrdre += lastchar;
    //Si le caractère reçu est un #, on s'arrete là, fin de l'ordre.
    if(lastchar == '#') { break; }
  }
  
  //Si la taille de l'ordre est supérieur à 0 
  if(lastOrdre.length() > 0) {
    //On le renvoie directement vers le PC
    Serial.println(lastOrdre);
  }
  
  delay(50);
  
  // RECEPTION D'UN ORDRE PROVENANT DU PC
  lastOrdre = "";
  while(Serial.available()) {
    //On récupère chaque caractère provenant du PC
    char lastchar = Serial.read();
    //On concatene le caractère au reste de l'ordre
    lastOrdre += lastchar;
    //Si le dernier caractère était un #, on s'arrete là
    if(lastchar == '#') { break; }
  }
  
  if(lastOrdre.length() > 0) {
    //On transmet l'ordre à l'autre arduino via le shield Xbee
    Serial1.print(lastOrdre);
  }
  
}

void setup() {

//On initialise le port Serie Arduino / PC

Serial.begin(9600);

//On initialise le port Serie Arduino / Xbee

Serial1.begin(9600);

}

void loop() {

// RECEPTION D'UN ORDRE PROVENANT DE L'ARDUINO

String lastOrdre = "";

while(Serial1.available()) {

//On récupère chaque caractere provenant du module xbee

char lastchar = Serial1.read();

//On concatene le caractère au reste de l'ordre

lastOrdre += lastchar;

//Si le caractère reçu est un #, on s'arrete là, fin de l'ordre.

if(lastchar == '#') { break; }

}

//Si la taille de l'ordre est supérieur à 0

if(lastOrdre.length() > 0) {

//On le renvoie directement vers le PC

Serial.println(lastOrdre);

}

delay(50);

// RECEPTION D'UN ORDRE PROVENANT DU PC

lastOrdre = "";

while(Serial.available()) {

//On récupère chaque caractère provenant du PC

char lastchar = Serial.read();

//On concatene le caractère au reste de l'ordre

lastOrdre += lastchar;

//Si le dernier caractère était un #, on s'arrete là

if(lastchar == '#') { break; }

}

if(lastOrdre.length() > 0) {

//On transmet l'ordre à l'autre arduino via le shield Xbee

Serial1.print(lastOrdre);

}

Partie émetteur – PC

La partie émetteur PC est assez similaire à la partie récepteur : il va lire les ordres reçus (état du bouton poussoir) et envoyer des ordres (allumer ou éteindre la led).

Dans notre exemple, nous utilisons un bouton nommé « LED » pour allumer ou éteindre la LED. Si on reste appuyé sur le bouton, la LED reste allumée. Si on relâche, elle s’éteint.
En revanche, tant qu’on reste appuyé sur le bouton poussoir, la case à cocher reste cochée, si on relâche le bouton poussoir, la case à cocher se décoche.

Public Class Form1

    Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
        'Au chargement du programme, on ouvre le port COM 3
        SerialPort1.PortName = "COM3"
        SerialPort1.Open()
    End Sub

    Private Sub Form1_FormClosing(sender As Object, e As FormClosingEventArgs) Handles MyBase.FormClosing
        'A la fermeture de fenetre, on ferme le port COM et on détruit le composant SerialPort1
        SerialPort1.Close()
        SerialPort1.Dispose()
    End Sub

    'Evenement reçu lorsqu'on presse le clic souris sur le bouton "LED"
    Private Sub btnLed_MouseDown(sender As Object, e As MouseEventArgs) Handles btnLed.MouseDown
        'On envoie l'ordre d'allumer la LED
        SerialPort1.Write("ALLUMER#")
    End Sub

    'Evenement reçu lorsqu'on relache le clic souris du bouton "LED"
    Private Sub btnLed_MouseUp(sender As Object, e As MouseEventArgs) Handles btnLed.MouseUp
        'On envoie l'ordre d'éteindre la led
        SerialPort1.Write("ETEINDRE#")
    End Sub

    'Evenement reçu lorsqu'on reçoit des données sur le port COM provenant de l'arduino
    Private Sub SerialPort1_DataReceived(sender As Object, e As IO.Ports.SerialDataReceivedEventArgs) Handles SerialPort1.DataReceived
        'On lit la ligne de données provenant de l'arduino
        Dim valeurDepuisArduino As String = SerialPort1.ReadLine().ToString()
        'On traite l'information
        SetValeur(valeurDepuisArduino.Substring(0, valeurDepuisArduino.Length - 2))
    End Sub

    'Méthode déléguée. Cela permet de réaliser la mise à jour de l'interface graphique alors que l'on provient d'un autre 
    'thread que celui de l'interface (opération interdite en direct)
    Delegate Sub SetTextCallback(valeur As String)

    'Fonction permettant de gérer l'appel par délégué
    Private Sub SetValeur(valeur As String)
        'On regarde si on a besoin de passer par un délégué ou non
        If Me.InvokeRequired Then
            'Si oui, on invoque le délégué en transmettant la valeur
            Dim d As New SetTextCallback(AddressOf SetValeur)
            Me.BeginInvoke(d, New Object() {valeur})
        Else
            'Si non, on demande à mettre à jour l'affichage directement
            MettreAJourAffichage(valeur)
        End If
    End Sub

    'Fonction permettant de gérer l'affichage. On lui passe en paramètre la valeur reçue depuis l'arduino
    Private Sub MettreAJourAffichage(valeur As String)
        If valeur = "ETEINDRE" Then
            'Si la valeur reçue est "ETEINDRE" on décoche la case à cocher
            chkBouton.Checked = False
        ElseIf valeur = "ALLUMER" Then
            'Si la valeur reçue est "ALLUMER" on coche la case à cocher
            chkBouton.Checked = True
        End If
    End Sub

End Class

Public Class Form1

Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load

'Au chargement du programme, on ouvre le port COM 3

SerialPort1.PortName = "COM3"

SerialPort1.Open()

End Sub

Private Sub Form1_FormClosing(sender As Object, e As FormClosingEventArgs) Handles MyBase.FormClosing

'A la fermeture de fenetre, on ferme le port COM et on détruit le composant SerialPort1

SerialPort1.Close()

SerialPort1.Dispose()

End Sub

'Evenement reçu lorsqu'on presse le clic souris sur le bouton "LED"

Private Sub btnLed_MouseDown(sender As Object, e As MouseEventArgs) Handles btnLed.MouseDown

'On envoie l'ordre d'allumer la LED

SerialPort1.Write("ALLUMER#")

End Sub

'Evenement reçu lorsqu'on relache le clic souris du bouton "LED"

Private Sub btnLed_MouseUp(sender As Object, e As MouseEventArgs) Handles btnLed.MouseUp

'On envoie l'ordre d'éteindre la led

SerialPort1.Write("ETEINDRE#")

End Sub

'Evenement reçu lorsqu'on reçoit des données sur le port COM provenant de l'arduino

Private Sub SerialPort1_DataReceived(sender As Object, e As IO.Ports.SerialDataReceivedEventArgs) Handles SerialPort1.DataReceived

'On lit la ligne de données provenant de l'arduino

Dim valeurDepuisArduino As String = SerialPort1.ReadLine().ToString()

'On traite l'information

SetValeur(valeurDepuisArduino.Substring(0, valeurDepuisArduino.Length - 2))

End Sub

'Méthode déléguée. Cela permet de réaliser la mise à jour de l'interface graphique alors que l'on provient d'un autre

'thread que celui de l'interface (opération interdite en direct)

Delegate Sub SetTextCallback(valeur As String)

'Fonction permettant de gérer l'appel par délégué

Private Sub SetValeur(valeur As String)

'On regarde si on a besoin de passer par un délégué ou non

If Me.InvokeRequired Then

'Si oui, on invoque le délégué en transmettant la valeur

Dim d As New SetTextCallback(AddressOf SetValeur)

Me.BeginInvoke(d, New Object() {valeur})

Else

'Si non, on demande à mettre à jour l'affichage directement

MettreAJourAffichage(valeur)

End If

End Sub

'Fonction permettant de gérer l'affichage. On lui passe en paramètre la valeur reçue depuis l'arduino

Private Sub MettreAJourAffichage(valeur As String)

If valeur = "ETEINDRE" Then

'Si la valeur reçue est "ETEINDRE" on décoche la case à cocher

chkBouton.Checked = False

ElseIf valeur = "ALLUMER" Then

'Si la valeur reçue est "ALLUMER" on coche la case à cocher

chkBouton.Checked = True

End If

End Sub

End Class

Téléchargements

Télécharger => Émetteur PC

Télécharger => Émetteur – Arduino

Télécharger => Récepteur Arduino

Grove : Potentiomètre à glissière COM05231P

.

Mise à jour le 25/09/2019 : Ce module potentiomètre compatible Grove délivre un signal analogique et est équipé d’une résistance de 10 kΩ

Continuer la lecture →

Librairie Arduino SofwareSerial()

***

Mise à jour le 20/03/2015

Les cartes Arduino disposent d’une communication série matérielle sur les broches 0 et 1 (qui va aussi à l’ordinateur via la connexion USB).Cette communication série matérielle est réalisée par un module matériel (intégré dans la puce) appelé UART . Ce matériel permet a la puce Atmega de recevoir des communications série même en travaillant sur d’autres tâches, tant qu’il y a de la place dans les 64 octets de buffer de l’UART (le buffer est reçoit les données entrantes et les stocke en attendant qu’elles soit lues).

Pour inclure la librairie SerialSoftware dans un programme, on ajoutera au début du programme la ligne suivante :

#include <SoftwareSerial.h>

Fonction

Définition de la fonction

SoftwareSerial()

Un appel de l’instruction SoftwareSerial(rxBroche, txBroche) crée un nouvel objet SoftwareSerial, que vous pourrez nommer selon votre choix

Exemple de Syntaxe : SoftwareSerial mySerial = SoftwareSerial(rxPin, txPin);

mySerial : le nom donné au nouvel objet SoftwareSerial créé.
rxBroche : la broche utilisée pour recevoir les données série.
txBroche : la broche utilisée pour émettre les données série.

Exemple dans un programme:

//
//
#define rxPin 2
#define txPin 3

// mettre en place un nouveau port série
SoftwareSerial mySerial =  SoftwareSerial(rxPin, txPin);
//
//

#define rxPin 2

#define txPin 3

// mettre en place un nouveau port série

SoftwareSerial mySerial = SoftwareSerial(rxPin, txPin);

begin()

Définit la vitesse pour la communication série . L’utilisation d’une vitesse supérieures à 9600 bauds donnera des erreurs de communications
Exemple de Syntaxe : mySerial.begin(9600);

Exemple dans un programme:

//
//
//inclure la bibliothèque SoftwareSerial de sorte que vous 
//pouvez utiliser ses fonctions

#include <SoftwareSerial.h>

#define rxPin 2
#define txPin 3

// mets en place un nouveau port série
SoftwareSerial mySerial =  SoftwareSerial(rxPin, txPin);

void setup()  {
   // définition du modes des broches pour tx, rx:
   pinMode(rxPin, INPUT);
   pinMode(txPin, OUTPUT);
   // régler le débit de données pour le port SoftwareSerial
   mySerial.begin(9600);
}

void loop() {
   // suite du programme
}

//inclure la bibliothèque SoftwareSerial de sorte que vous

//pouvez utiliser ses fonctions

#include <SoftwareSerial.h>

#define rxPin 2

#define txPin 3

// mets en place un nouveau port série

SoftwareSerial mySerial = SoftwareSerial(rxPin, txPin);

void setup() {

// définition du modes des broches pour tx, rx:

pinMode(rxPin, INPUT);

pinMode(txPin, OUTPUT);

// régler le débit de données pour le port SoftwareSerial

mySerial.begin(9600);

}

void loop() {

// suite du programme

}

read()

Lit un caractère sur la broche en réception sur le port série logiciel . Il le lit et renvoie la valeur reçue

Exemple de Syntaxe : char a = serial.read();
A savoir – > a : une variable de type char
Valeur renvoyée -> le caractère lu sur le port série (type int)

print()

Affiche dans une fenêtre Terminal les données émises par la broche d’émission du port série logiciel

Exemple de Syntaxe : mySerial.print(valeur) ou mySerial.print(valeur, format)

Cette instruction peut prendre plusieurs formes :

mySerial.print(55); affiche « 55 »
mySerial.print(1.23456); affiche « 1.23 »
mySerial.print(byte(79)); affiche « O » (dont la valeur ASCII est 79)
mySerial.print(‘N’); affiche « N »
mySerial.print(« bonjour »); affiche « bonjour »

println()

Affiche dans une fenêtre Terminal les données émises par la broche d’émission du port série logiciel, suivi d’un saut de ligne.

Exemple de Syntaxe : mySerial.println(valeur) ou mySerial.println(valeur, format)

Cette instruction peut prendre plusieurs formes :

mySerial.println(55); affiche « 55 »
mySerial.println(1.23456); affiche « 1.23 »
mySerial.println(byte(79)); affiche « O » (dont la valeur ASCII est 79)
mySerial.println(‘N’); affiche « N »
mySerial.println(« bonjour »); affiche « bonjour »

Librairie Arduino stepper ( pour moteur pas à pas )

***

Mise à jour le 21/02/2015

Cette librairie vous permet de contrôler des moteurs pas à pas unipolaires et bipolaires. Ce type de moteur est très courant dans tous les dispositifs où l’on souhaite faire du contrôle de vitesse ou de position en boucle ouverte ( sans retour d’une information pour vérifier la réponse du système ) . Un moteur pas à pas est capable d’exécuter des rotations « angle par angle » d’une grande précision. Pour utiliser cette librairie avec votre carte Arduino, vous aurez besoin d’un moteur pas à pas et d’une interface de puissance adaptée pour contrôler le moteur.

Pour inclure la librairie Stepper dans un programme, on ajoutera au début du programme la ligne suivante :

#include <Stepper.h>

Fonction	Définition de la fonction
setSpeed()	Cela permet de définir la vitesse de rotation du moteur c’est a dire la fréquence des signaux rectangulaire Exemple: // définît la vitesse du moteur à 30 tours par minute stepper.setSpeed(30);
steps()	C’est le fonction la plus utile puisque c’est celle qui permet de faire tourner le moteur du nombre de pas spécifié Exemple: stepper.steps(nombre_de_pas); nombre_de_pas est une variable int [Une variable de type int (pour integer, entier en anglais], spécifiant le nombre de pas à générer. Cette variable variable peut être positive ou négative selon le sens dans le lequel on veut faire tourner le moteur.

Librairie Arduino gestion des cartes SD

***

Mise à jour le 25/03/2015

Cette librairie gère aussi bien les cartes SD que les cartes SD HC et support aussi bien les cartes formatées en FAT16 qu’en FAT32. Elle utilise les noms de fichier courts comportant au maximum 8 caractères . La notion de répertoire et de sous répertoire est également supportée.

Fonction	Définition de la fonction
SD.begin()	Initialise la librairie SD et la carte SD. Cela lance l’utilisation du bus SPI (broches numériques 11,12 et 13 sur la plupart des cartes Arduino; 50, 51 et 52 sur la Mega)
SD.exists(nom du fichier )	Cette fonction teste la présence d’un fichier ou d’un répertoire sur la carte préalablement initialisée. Elle retourne un résultat: true : si le fichier ou répertoire existe —–> true = vrai false : si le fichier ou le répertoire n’existe pas ——-> false = faux
SD.mkdir(« nom du répertoire »)	Cette fonction crée un répertoire sur la carte mémoire SD. Elle retourne un résultat vrai si la création s’est bien passée et faux dans le cas contraire .
SD.rmdir(« nom du répertoire »)	Cette fonction est le contraire de la précédente pour détruire le répertoire spécifié. Elle retourne un résultat vrai si la destruction s’est bien passée et faux dans le cas contraire . ( a savoir : si le répertoire n’excite pas , la valeur de retour est indéterminée )
SD.remove(nom du fichier )	Cette fonction efface un fichier de la carte mémoire SD. Elle retourne un résultat vrai si la suppression s’est bien passée et faux dans le cas contraire . ( a savoir : si le répertoire n’excite pas , la valeur de retour est indéterminée )
SD.open(nom du fichier) ou SD.open(nom du fichier, mode)	Cette fonction ouvre un fichier sur la carte mémoire SD. Elle retourne un objet de type fichier correspondant au fichier qui vient d’être ouvert, si cette ouverture n’est pas possible , cet objet peut être testé comme une variable booléenne . mode (optionnel), le mode d’ouverture du fichier, par défaut FILE_READ – byte. Les paramètres possibles sont : FILE_READ: ouvre le fichier pour lecture, en démarrant au début du fichier. FILE_WRITE: ouvre le fichier pour lecture et écriture, en démarrant au début du fichier.
file.available()	Cette fonction vérifie si des octets sont disponibles en lecture dans le fichier.
file.close()	Cette fonction ferme le fichier en s’assurant que les données qui y ont éventuellement été écrits sont bien sauvegardées sur la carte SD .Cette fonction ne retourne aucun résultat .
file.flush()	Cette fonction s’assure que les données écrites dans un fichier ont été physiquement enregistrées sur la carte mémoire SD.
file.peek()	Cette fonction lit un octet dans un fichier sans avancer au suivant. Ainsi, des appels successifs de la fonction peek() renverront la même valeur, jusqu’au prochain appel de la fonction read().
file.position()	Cette fonction indique la position ou se trouve le pointeur au sein du fichier
file.print(data) ou file.print(data, BASE)	Cette fonction écrit des données dans un fichier, lequel doit être ouvert pour écriture. Cette fonction affiche les nombres comme une séquence de chiffres, chacun comme un caractère ASCII
file.println() ou file.println(data) ou file.println(data, BASE)	Cette fonction écrit des données suivies d’un saut de ligne ( retour chariot + nouvelle ligne) dans un fichier , lequel doit être ouvert pour écriture. Cette fonction affiche les nombres comme une séquence de chiffres, chacun comme un caractère ASCII (par exemple le nombre 123 est écrit sous la forme de 3 caractères ‘1’, ‘2’, ‘3’). file : une instance de l’objet File (renvoyée par la fonction SD.open()) data: les données à écrire dans le fichier – types possibles : char, byte, int, long, ou string BASE : (optionnel): la base dans laquelle écrire les nombres : BIN pour binaire (base 2), DEC pour décimal (base 10), OCT pour octal (base 8), HEX pour hexadécimal (base 16). La base par défaut est la base décimale.
file.seek(pos)	Cette fonction positionne le pointeur dans le fichier sur la valeur indiquée par position qui doit etre comprise entre 0 et la taille maximun du fichier
file.size()	Cette fonction permet de connaître la taille d’un fichier (en nombre d’octets).
file.read()	Cette fonction lit un octet dans un fichier et avance le pointeur au suivant .Elle retourne le caractère lu ou -1 si aucun caractère n’est disponible
file.write(données) ou file.write(tampon, longueur)	1 er forme : Cette fonction écrit des données dans un fichier . 2 éme forme : elle écrit le contenu du tampon dont la taille est spécifiée par le paramètre longueur

Communication PC (Visual Studio) vers Arduino

.

Mise à jour le 08/09/2019 : Dans cet article, nous allons envoyer des données depuis le pc vers l’Arduino. Le principe est tout simple : lorsqu’on va déplacer la glissière (trackbar) sur l’application PC, on va modifier l’éclairage de la LED connectée à l’Arduino.

Continuer la lecture →

Communication Arduino vers PC (Visual Studio)

.

Mise à jour le 03/02/2016 : Dans cet article, nous allons voir comment créer un petit programme PC permettant de récupérer très simplement la valeur d’un potentiomètre connecté à l’Arduino.

Continuer la lecture →

Librairie Arduino Grove [ OLE42178P ]

***

Mise à jour le 21/03/2015

La bibliothèque Gris OLED fournit des interfaces logicielles complètes pour utiliser les fonctions du pilote SSD1327Z avec un afficheur Grove OLED 96×96 gris

A savoir :

Pour démarrer le programme chargé d’abord la bibliothèque Wire.h .Cette bibliothèque vous permet de communiquer avec des périphériques I2C. (Pour la procédure d’installation cliquez ici )

Fonction	Définition de la fonction
SeeedGrayOled.init ();	Initialise l’affichage
SeeedGrayOled.clearDisplay ();	Efface tout l’écran. Devrait être utilisé avant de commencer un nouveau départ ou après la désactivation du défilement. Cette fonction positionne le curseur sur le coin supérieur gauche.
SeeedGrayOled.setNormalDisplay ();	Définir affichage en mode normal (en mode non inverse)
SeeedGrayOled.setContrastLevel (127);	Définir l’affichage et le rapport de contraste à demi-niveau(c.-à 256/2 -1).
SeeedGrayOled.setInverseDisplay ();	Placer l’affichage en mode inverse
SeeedGrayOled.setHorizontalMode ();	Définir le mode d’affichage en mode horizontal
SeeedGrayOled.setVerticalMode ();	Définir le mode d’affichage en mode vertical
SeeedGrayOled.setTextXY (0,0);	Placez le curseur à 0e ligne de texte, la colonne de texte 0e
SeeedGrayOled.putChar (‘S’);	Affiche le caractère S .Afficher un caractère à l’écran à partir de l’adresse pointeur réglé par setTextXY (X, Y). Cette fonction est utilisée en interne par PutString ().
SeeedGrayOled.putString (“Bonjour tout le monde!”);	Affiche la chaîne de caractères .
SeeedGrayOled.putNumber (-56,123);	Affiche le numéro de -56123 .Le nombre peut être char, int ou long en type de données. Il prend également en charge le signe
SeeedGrayOled.drawBitmap (SeeedLogo, 96 * 96/8);	Dessine une image binaire (96 pixels * 96 pixels / 8) octets
SeeedGrayOled.setHorizontalScrollProperties (Scroll_Left, 72,95,0,47, Scroll_5Frames);	Définit les propriétés du défilement horizontal
SeeedGrayOled.activateScroll ();	Activer défilement.
SeeedGrayOled.deactivateScroll ()	Désactiver le défilement.

Télécharger la Bibliothèque LCD_Display

Utilisation du module GPS Grove SEN10752P

***

Mise à jour le 27/03/2017 : Le module Grove SEN10752P est un module pour Arduino permettant de recevoir des trames GPS aux normes NMEA. Seeedstudio propose quelques exemples d’utilisation sur leur site.

Continuer la lecture →