Go Down

Topic: Envoyer des données à l'Arduino (Read 5228 times) previous topic - next topic

Lokaz

Bonjour,
J'ai reçu récemment une carte Arduino Uno et j'ai réalisé un programme qui permet d'allumer/éteindre des leds en inscrivant leur numéro en utilisant le Serial Monitor. Je me suis dis que ce serait plus pratiquement si je pouvais les contrôler via un autre programme sur mon PC, en cliquant sur des boutons ou quelque chose du genre. J'ai essayé de me renseigner mais je n'ai rien trouvé qui permette d'envoyer un octet à l'Arduino comme le fait le Serial Monitor.

J'aimerais donc savoir si cela est possible. Je souhaiterais pouvoir l'utiliser via un programme externe que je ferais avec Code::Blocks ou en tout cas un autre IDE qu'Arduino.


skywodd

Salut,

Pour communiquer avec une carte arduino il faut utiliser le port série usb.

Tu as quelques pistes avec différent langage de programmation ici :
http://www.arduino.cc/playground/Main/Interfacing
Des news, des tutos et plein de bonnes choses sur http://skyduino.wordpress.com !

Lokaz

Merci, je vais regarder de ce côté  :)

barbudor

@Lokaz

Es-tu sous Windows ?
Si oui, tu peux utiliser les version gratuites de VisualStudio : Visual C++ ou Visual C#

Sinon, tu peux aussi utiliser "Processing" l'environnement PC d'où Wiring/Arduino est issu.
Dans la section Learning - Exemples du site Arduino, la section "4 - Communicatons" comporte plusieurs exemples d'interaction entre PC et Arduino utilisant l'environnement Processing.

cyberfred91

#4
Apr 01, 2012, 09:42 am Last Edit: Apr 01, 2012, 06:33 pm by cyberfred91 Reason: 1
Tu peux aussi simplement eznvoyer avec des println() et lire avec des readln()

Je te donne un petit exemple que j'ai fait hier, mais la c'etait l'arduino qui envois les données et processing qui les recoit.

J'ai trouvé ca sur le net :

Coté Arduino :

Code: [Select]
/*  Graph

A simple example of communication from the Arduino board to the computer:
the value of analog input 0 is sent out the serial port.  We call this "serial"
communication because the connection appears to both the Arduino and the
computer as a serial port, even though it may actually use
a USB cable. Bytes are sent one after another (serially) from the Arduino
to the computer.

You can use the Arduino serial monitor to view the sent data, or it can
be read by Processing, PD, Max/MSP, or any other program capable of reading
data from a serial port.  The Processing code below graphs the data received
so you can see the value of the analog input changing over time.

The circuit:
Any analog input sensor is attached to analog in pin 0.

created 2006
by David A. Mellis
modified 30 Aug 2011
by Tom Igoe and Scott Fitzgerald

This example code is in the public domain.

http://www.arduino.cc/en/Tutorial/Graph
*/

void setup() {
 // initialize the serial communication:
 Serial.begin(9600);
}

void loop() {
 // send the value of analog input 0:
 Serial.println(analogRead(A0));
 // wait a bit for the analog-to-digital converter
 // to stabilize after the last reading:
 delay(10);
}


Coté Processing :
Code: [Select]

import processing.serial.*;

Serial myPort;        // The serial port
int xPos = 1;         // horizontal position of the graph

void setup () {
// set the window size:
size(400, 300);        

// List all the available serial ports
println(Serial.list());
// I know that the first port in the serial list on my mac
// is always my  Arduino, so I open Serial.list()[0].
// Open whatever port is the one you're using.
myPort = new Serial(this, Serial.list()[0], 9600);
// don't generate a serialEvent() unless you get a newline character:
myPort.bufferUntil('\n');
// set inital background:
background(0);
}
void draw () {
// everything happens in the serialEvent()
}

void serialEvent (Serial myPort) {
// get the ASCII string:
String inString = myPort.readStringUntil('\n');

if (inString != null) {
// trim off any whitespace:
inString = trim(inString);
// convert to an int and map to the screen height:
float inByte = float(inString);
inByte = map(inByte, 0, 1023, 0, height);

// draw the line:
stroke(127,34,255);
line(xPos, height, xPos, height - inByte);

// at the edge of the screen, go back to the beginning:
if (xPos >= width) {
xPos = 0;
background(0);
}
else {
// increment the horizontal position:
xPos++;
}
}
}


Le code je l'ai recupéré d'internet. Par contre, je trouve qu'autant processing est super pratique pour faire des gfx, qu'il est lourd pour faire des interfaces, et je vais voir pour coder en Delphi ou C++ Builder pour faire les interface, autant Delphi ou C++ Builder sont enfantin a faire des interfaces.

Donc j'ai encore du boulot a faire pour apprendre tout ca.

Dans ton cas, l'arduino va envoyer des datas, et Processing les afficheras. Si tu modifies un peut les sources, Processing peut envoyer des infos, et ton arduino les recevoirs. Par contre, ca risque d'etre plus dur a visualiser, car Processing et Arduino n'aime pas trop utiliser le meme port en meme temps.

Je ferais d'autres essais cette apres midi. Le code n'est pas de moi, donc j'ai laissé les commentaires ;)

Lokaz

Merci à tous ! Pour l'instant j'ai essayé Processing et j'ai réussi à faire un programme pour allumer/éteindre 6 leds différentes en cliquant sur l'image de la led correspondante dans le programme. Je vais continuer là-dessus pour le moment, je verrai pour le C++ plus tard.

cyberfred91

Envois ton code source :p

Sympa ce que tu as reussi a faire :)

Lokaz

Ce n'est pas très compliqué. J'ai simplement branché 6 leds aux broches 2 à 7.

Le code pour l'Arduino :

Code: [Select]
int ledPin[6] = {2,3,4,5,6,7};

void setup()
{
  for(int i = 0 ; i < 6 ; i++)
    pinMode(ledPin[i], OUTPUT);

  Serial.begin(9600);
}

void loop()
{
  char allumer[6] = {0};

  while(true)
  {
    for(int i = 0 ; i < 6 ; i++)
    {
      if(allumer[i])
        digitalWrite(ledPin[i], HIGH);
      else
        digitalWrite(ledPin[i], LOW);
    }

    while(Serial.available())
    {
      int c = Serial.read();

      if(c >= '0' && c <= '5')
      {
        if(allumer[c - '0'] == 0)
          allumer[c - '0'] = 1;
        else
          allumer[c - '0'] = 0;
      }
      else if(c == 'F')
      {
        for(int i = 0 ; i < 6 ; i++)
        {
          allumer[i] = 0;
        }
      }
    }
  }
}


Le code pour Processing :

Code: [Select]
import processing.serial.*;

Serial port;

boolean mouseReleased = false;
boolean allume[] = new boolean[6];
PImage imageLed1, imageLed2;


void setup()
{
  size(400, 300);
  rectMode(RADIUS);

  println(Serial.list());
  port = new Serial(this, Serial.list()[0], 9600);

  imageLed1 = loadImage("led1.png");
  imageLed2 = loadImage("led2.png");

  port.write('F'); // On éteint tout
}


void draw()
{
  //Événements

  if (mouseReleased == true)
  {
    if (mouseX >= 100 && mouseX <= 297 && mouseY >= 80 && mouseY <= 126)
    {
      int ledClic = ((mouseX-100) - (mouseX-100)%33)/33;

      if (allume[ledClic] == false)
        allume[ledClic] = true;
      else
        allume[ledClic] = false;

      port.write(ledClic + '0');
    }

    mouseReleased = false;
  }
 
  background(0, 0, 0);

  for (int i = 0 ; i < 6 ; i++) // Leds
  {
    if (allume[i] == true)
      image(imageLed2, 100 + i*(100/3), 80);
    else
      image(imageLed1, 100 + i*(100/3), 80);
  }
}

void mouseReleased()
{
  mouseReleased = true;
}


J'ai aussi créé deux petites images de led, une allumée et une éteinte.


cyberfred91

J'ai modifié mon post pour mettre des balises Code.

Merci pour ton code source, je vais le tester pour voir :p

Go Up