Du traceur série inclus dans l'IDE, à côté du moniteur, oui.
J'ai découvert ça ce week-end, mon éditeur était toujours en v1.0.5.

Il se met à jour en temps réel : chaque point des deux courbes correspond à un envoi "humidité, température \n". Je mets le code que j'utilise pour envoyer les données depuis l'Arduino en dessous, c'est directement tiré de la libraire DHT.

#include <Adafruit_Sensor.h>

// Example testing sketch for various DHT humidity/temperature sensors
// Written by ladyada, public domain

#include "DHT.h"

#define DHTPIN 2     // what digital pin we're connected to

// Uncomment whatever type you're using!
#define DHTTYPE DHT22   // DHT 22  (AM2302), AM2321
//#define DHTTYPE DHT11   // DHT 11
//#define DHTTYPE DHT21   // DHT 21 (AM2301)

// Connect pin 1 (on the left) of the sensor to +5V
// NOTE: If using a board with 3.3V logic like an Arduino Due connect pin 1
// to 3.3V instead of 5V!
// Connect pin 2 of the sensor to whatever your DHTPIN is
// Connect pin 4 (on the right) of the sensor to GROUND
// Connect a 10K resistor from pin 2 (data) to pin 1 (power) of the sensor

// Initialize DHT sensor.
// Note that older versions of this library took an optional third parameter to
// tweak the timings for faster processors.  This parameter is no longer needed
// as the current DHT reading algorithm adjusts itself to work on faster procs.
DHT dht(DHTPIN, DHTTYPE);

void setup() {
  Serial.begin(115200);
  //Serial.println("DHTxx test!");

  dht.begin();
}

void loop() {
  // Wait a few seconds between measurements.
  delay(1000);

  // Reading temperature or humidity takes about 250 milliseconds!
  // Sensor readings may also be up to 2 seconds 'old' (its a very slow sensor)
  float h = dht.readHumidity();
  // Read temperature as Celsius (the default)
  float t = dht.readTemperature();
  // Read temperature as Fahrenheit (isFahrenheit = true)
  float f = dht.readTemperature(true);

  // Check if any reads failed and exit early (to try again).
  if (isnan(h) || isnan(t) || isnan(f)) {
    Serial.println("Failed to read from DHT sensor!");
    return;
  }

  // Compute heat index in Fahrenheit (the default)
  float hif = dht.computeHeatIndex(f, h);
  // Compute heat index in Celsius (isFahreheit = false)
  float hic = dht.computeHeatIndex(t, h, false);

  //Serial.print("Humidity: ");
  Serial.print(h);
  Serial.print(",");
  Serial.print(t);
  Serial.println(",");
  //Serial.print(" %\t");
  //Serial.print("Temperature: ");
  //Serial.print(t);
  //Serial.print(" *C ");
  //Serial.print(f);
  //Serial.print(" *F\t");
  //Serial.print("Heat index: ");
  //Serial.print(hic);
  //Serial.print(" *C ");
  //Serial.print(hif);
  //Serial.println(" *F");
}

Bon, après discussion avec Path, si vous mettez votre IDE arduino à jour (pas comme moi), il y a un plotter intégré dans la dernière version.
Il suffit de faire un Serial.print des valeurs voulues séparées par une virgule et de finir par un saut de ligne (Serial.println).

Ci-après un exemple avec le DHT22. Enjoy !
 

Merci ! N'hésitez pas si vous avez des questions, des idées de quoi creuser sur le sujet. Je mettrais sûrement ce topic à jour en allant plus loin.

Aujourd'hui, on plotte.

Quand je teste des trucs avec Arduino, je suis régulièrement frustré par la difficulté à visualiser mes données, particulièrement quand il s'agit de capteurs. Le retour texte par le moniteur série, c'est pas mal, mais rien ne vaut un beau plot temporel (désolé, j'utiliserai l'anglicisme "plot" de to plot, déformation professionnelle ).
Dans cette optique, j'ai regardé ce qui se faisait en termes d'outils pour afficher les données du port série. Mon propre essai d'il y a deux ou trois ans était assez décevant, donc j'ai cette fois repéré trois librairies pour répondre à mon problème :

• ArduinoPlot de gregpinero (github ArduinoPlot) : ce qui m'a plu dans ce projet, c'est que le code est en python et utilise wxWidgets, dont je me sers également en ce moment pour des projets de logiciel avec GUI. L'utilisation est simple, l'interface propre, et visiblement configurable.
• arduino-plotter de devinaconley (github arduino-plotter) : plot en temps ou en XY, configuration de l'affichage du plot à partir de l'Arduino, possibilité de changer le layout facilement.
• RealTimePlotter de sebnil (github RealtimePlotter) : il expose exactement la problématique qui me préoccupe dans sa description (Yay!), le format de message série est explicitement simple, l'interface a l'air simple et on peut la modifier en live.

Principe
Avant de rentrer dans mon retour d'expérience, un petit mot sur le principe très général des plotters et de leur mise en oeuvre ici.
Il faut distinguer deux programmes : celui qui tourne sur l'Arduino (et qui est chargé de collecter les données et de les envoyer sur le port série), et celui qui tourne sur le PC (et qui lit le port et affiche le graphe). On définit un port pour la communication (COMx ou /dev/ttyX), puis le programme côté Arduino envoie des données à une certaine fréquence, tandis que le programme côté PC met à jour son affichage périodiquement ou à réception des données. Les trois librairies sont je parle respectent ce principe, vous devrez donc d'une part, uploader un code sur l'Arduino, d'autre part lancer le programme de visualisation sur votre PC.
Pour tester tout ça, j'ai utilisé un montage basique avec un capteur DHT 22 branché sur le port 2 de mon Arduino Uno et alimenté en 3.3V.

Résultats
Le principal critère dans cette évaluation est d'abord la facilité de mise en oeuvre : je n'ai pas envie de passer des heures à adapter le système à mon problème pour visualiser mes données ou à chercher quel script lancer. Si ça ne marche pas, out. Ensuite viennent les aspects simplicité du code (et donc "hackabilité" pour mes propres systèmes) et configuration de l'interface (pour différences échelles de temps, amplitudes des données, etc.). Je n'ai pas vraiment regardé ces derniers points ici, mais je poursuivrai sûrement ça bientôt.

ArduinoPlot
Première déception, le code qui va lire le port série utilise une méthode (read_all) qui n'existe pas dans ma version de la librairie. J'ai également galéré à installer wxWidgets sur la machine où je teste (je l'utilse sur un autre ordi sans problème), même avec un virtualenv. Bon, trop d'efforts, pas de réconfort, on laisse tomber.

arduino-plotter
Lors de mon premier test, j'ai laissé tomber assez rapidement, parce que je trouvais le code peut clair à mettre en oeuvre. Je viens de retester ce soir, et en fait, cette librairie est plutôt bien ! Déjà, le fait de configurer l'affichage à partir de l'Arduino est vraiment sympa, pour faire évoluer l'affichage dynamiquement (hop, je presse un bouton connecté à un pin et j'affiche tel ou tel signal). Le code côté Arduino est super simple (voir plus bas).
Quelques petits défauts quand même : l'affichage n'est pas continu (pas de ligne mais des points), ce qui fait qu'entre deux données qui ont un grand écart (par exemple, mon taux d'humidité qui passe de 15 à 10%), on a du vide. L'affichage en abscisse est aussi assez bizarre, mais je ne me suis pas trop penché sur le code côté plotter. Autre défaut, le graph se reset parfois, je pense quand l'Arduino reboot, ce qui n'est pas forcément génial, mais ne pose pas de problème si on ne touche pas au montage.

/*
  ===========================================================================================
  Example used in Quick-Start + DHT sensor (R1D1)
  -------------------------------------------------------------------------------------------
  Plotter
  v2.3.0
  https://github.com/devinaconley/arduino-plotter
  by Devin Conley
  ===========================================================================================
*/

// Includes and definitions for sensor :
#include <Adafruit_Sensor.h>
#include "DHT.h"

#define DHTPIN 2
#define DHTTYPE DHT22
DHT dht(DHTPIN, DHTTYPE);

// Plotting lib
#include "Plotter.h"

// Containing variables
double x,t,h;

Plotter p;

void setup()
{
    h= 0.0;
    t= 0.0;
    p.Begin();
    dht.begin();

    p.AddTimeGraph( "R1D1 - test DHT 22", 500, "t (temp)", t , "h (hum)", h ); // for adding x : "x (sin)", x ,
}

void loop()
{
  // Reading temperature or humidity takes about 250 milliseconds!
  h = dht.readHumidity();
  // Read temperature as Celsius (the default)
  t = dht.readTemperature();

    // Check if any reads failed and exit early (to try again).
  if (isnan(h) || isnan(t)){ return; }
  
  // The following value will not be sent actually (R1D1)
  x = 10*sin( 2.0*PI*( millis() / 5000.0 ) );

  delay(500);
  p.Plot(); // usually called within loop()

}

RealTimePlotter
Le premier que j'ai réussi à faire fonctionner. J'ai passé un certain temps pour obtenir un affichage correct, et surtout à comprendre quel type de message envoyer à partir de l'Arduino (je suis pas sûr d'avoir tout compris). L'affichage est robuste aux erreurs dans la communication. Le code côté Arduino n'est pas forcément super clair, il est probable que pas mal de parties pourraient être intégrées dans une classe et séparées du code principal.
 

#include <Adafruit_Sensor.h>
#include "DHT.h"

#define DHTPIN 2     // what digital pin we're connected to

// Uncomment whatever type you're using!
//#define DHTTYPE DHT11   // DHT 11
#define DHTTYPE DHT22   // DHT 22  (AM2302), AM2321
DHT dht(DHTPIN, DHTTYPE);

uint8_t buffer[20]; //Buffer needed to store data packet for transmission
int16_t data1 = 1;
int16_t data2 = 2;
int16_t data3 = 3;
int16_t data4 = 4;
bool debug = false;

uint8_t buffer2[20];

void setup() {
  // put your setup code here, to run once:
  Serial.begin(115200);
  dht.begin();
}

int16_t value = 0;
int8_t direction = 5;
void loop()
{
   // Reading temperature or humidity takes about 250 milliseconds!
  int16_t h = (int16_t)dht.readHumidity();
  // Read temperature as Celsius (the default)
  int16_t t = (int16_t)dht.readTemperature();

   // Check if any reads failed and exit early (to try again).
  if (isnan(h) || isnan(t))
  { return; }
  // put your main code here, to run repeatedly: 
  //Serial.write(value);
  value = (value + direction);
  if (value > 100)
    direction = -10;
  else if (value < -50)
    direction = 10;
  //data3 = value;
  //plot(value, value/2, value/4, value/8);
  for (uint8_t i = 0; i<7; i++) {
    switch (i)
    {
      case 0:
      Serial.print(t);
      break;
      /*case 1:
      Serial.print(h);
      break;
      case 2:
      Serial.print(0);
      break;
      case 3:
      Serial.print(0);
      break;
      case 4:
      Serial.print(0);
      break;
      case 5:
      Serial.print(0);
      break;*/
    }
    if (i < 7)
      Serial.print(" ");
  }
  Serial.println("");
  delay(500);
}

uint8_t variableA = {0x00};

void plot(int16_t data1, int16_t data2, int16_t data3, int16_t data4)
{
  int16_t pktSize;
  
  buffer[0] = 0xCDAB;             //SimPlot packet header. Indicates start of data packet
  //buffer[1] = 4*sizeof(int16_t);      //Size of data in bytes. Does not include the header and size fields
  buffer[1] = 1;
  buffer[2] = 5;
  buffer[3] = 6;
  buffer[4] = 7;
  buffer[5] = 8;
    
  pktSize = 2 + 2 + (4*sizeof(int16_t)); //Header bytes + size field bytes + data
  
  if (!debug) {
    Serial.print(data1);
    Serial.print(" ");
    Serial.print(data2);
    Serial.print(" ");
    Serial.print(data3);
    Serial.print(" ");
    Serial.print(data4);
    Serial.print('\r');
  }
  else {
    Serial.print("Size: ");
    Serial.println(pktSize, HEX);
    for (int i = 0; i<pktSize; i++) {
      Serial.print(buffer[i], HEX);
      Serial.print(" ");
    }
    Serial.println();
  }
}

Bonus stage : Graph (https://www.arduino..../tutorial/graph)
A posteriori, j'ai découvert Graph, qui fonctionne aussi avec Processing. L'affichage n'est pas top, mais le code est ultra simple, donc ouvert à évolutions.

Conclusion :
À première vue, j'ai commencé à écrire ce post dans l'idée de recommender RealTimePlotter. Après mes quelques essais supplémentaires, je pense que arduino-plotter est plus prometteur, et je vais sûrement creuser plus en détail ce que l'on peut faire avec. J'aime bien l'idée que l'Arduino envoie la config du plotter, changer le nombre de variables envoyé est enfantin, bref, c'est facile d'utilisation.
Pour ArduinoPlot, je vous invite à la tester si vous pouvez facilement installer les librairies requises dans leur bonne version. Vu que j'avais deux autres librairies à tester, je n'y ai consacré que le minimum de temps.

Salut !

Bonjour à tous, je viens vous présenter... Refrobot.org!

Tout d'abord, l'équipe est composée de:
Johnest ou Refrobot (moi): administrateur du blog et auteur.
Mattéo: responsable de la catégorie Prof. David (pour plus d'informations regardez les catégories ce-dessous).

Johnest ... Ah oui, c'était toi l'auteur de ce sujet : http://www.robot-maker.com/forum/topic/7043-tutoriel-dinformatique/ !
Espérons que les choses aient évolué.

Comme vous le pourrez remarquer, l'interface de Refrobot est simple car l'objectif est d'aller droit au but, c'est-à-dire, aller le plus directement possible au contenu que l'on est intéressé sans etre éblouit par des designs trop lumineux, sans sedévier son attention aux graphiques au lieu qu'au contenu et sans se perdre à cause des pages interconnectées. C'est pour cela que j'ai préféré garder un aspect simple et rapide.

Le design est effectivement simple, par contre, je trouve l'écart entre les blocs blancs un peu trop large (sur Firefox en tout cas).

Les critiques : Pourquoi critiquer le tutoriel du Cocotix ? Ça n'est pas un produit qui s'achète, c'est le résultat d'un tutoriel qui permet de faire un système simple. Du coup, à côté de produits vendus (Boe-Bot, Pro-Bot), ça n'a pas de sens (c'est comme mettre en parallèle la BD d'un auteur et le dessin que tu aurais fait en suivant un guide qui t'apprend les bases). Dans les critiques du Boe-bot, tu dis :

Il n’est pas cher du tout (comptez environ 159$ sur le site officiel).

ce qui n'est pas très logique avec les échelles de prix que tu évoques dans les tutoriels. Le reste des points forts/faibles mis en avant pour les autres critiques, j'ai du mal à saisir pourquoi ils sont pertinents. Typiquement :

Il peut être programmé en BASIC (même logiciel que le Boe-Bot) et en C-Compact ce qui lui donne des "pouvoirs" universels.

Des pouvoirs ? Comment ça ? Ca n'est pas clair.

Le programme n’a pas été ajourné depuis longtemps, un peu de nouveau ça fait du bien…

De quel programme tu parles ? Si c'est de celui que fait l'utilisateur, je ne comprends pas la remarque.

L’aide proposée par le programme est assez… inutile selon moi. Si vous vous trompez à écrire quelque chose, il vous montre où est l’erreur mais pas ce qu’il faudrait corriger et si vous ne savez pas utiliser une fonction, vous êtes un peu mal barré…

??? C'est comme ça que fonctionne la plupart les compilateurs : ils indiquent la ligne de l'erreur, ce qui est incorrect (problème de syntaxe, de type, de mauvaise utilisation de la fonction, etc ...), mais ils ne disent pas ce qu'il faut mettre à la place (même si pour les erreurs de syntaxe et les fautes de frappes, les compilos font des suggestions de la fonction correcte). C'est à l'utilisateur de savoir ce qu'il veut faire dans son bout de code et de consulter la documentation correspondante. Si tu ne sais pas utiliser une fonction, il ne faut pas essayer jusqu'à ce que ça marche, il faut chercher pourquoi ...

Les tutos : j'ai regardé "Introduction à la vision par informatique" et "tutoriel robots (apprentis)" 1 et 2. Sincèrement, la qualité n'est pas au rendez-vous.
Sur les tutos robots : beaucoup de faits sont balancés sans explication : pourquoi faire un robot permet de s'intéresser à "la compréhension d’un animal et la psychologie humaine" ? Je connais la réponse, mais quelqu'un qui lit ton tutoriel va se demander ce que tu veux dire.
"Il est mieux de commencer ce tutoriel en se posant des questions comme quel est notre but de créer un robot." : là encore, guider le lecteur dans son processus de réflexion est le but d'un tutoriel, pas d'affirmer "il faut faire ça" et de laisser les gens se débrouiller sans comprendre ce qu'ils font.
Par contre, mettre en avant le "Keep it simple" est une bonne chose.
L'argument de l'argent n'est pas pertinent à mon avis : l'argent est une contrainte (pour les plus jeunes) mais pas un besoin. L'argent nécesaire dépendra de la taille du projet (faire un petit robot à roues ou un drone quadri-rotor n'est pas la même chose).
Plutôt que de dire "improvisez" pour dimensionner les moteurs, pourquoi ne pas expliquer clairement comment on fait ? Le but d'un tuto est d'apprendre quelque chose au gens, pas de leur faire faire de la magie ... Ta recommandation manque du contexte qui justifierait un moteur alimenté sous 5-8V, et je ne parle pas de la remarque sur le couple.
Vision par ordinateur : Le paragraphe sur le corps humain et les signaux est faux. Il n'y a pas qu'un chemin Capter->Traiter, il y a une boucle et une interaction forte entre le capteur (l'oeil) et le traitement qui est fait sur l'information. La perception va orienter l'action pour concentrer la perception sur un point spécifique. Il est par ailleurs faux de dire que la vision par ordinateur est une reproduction de ce que fait le corps humain, notamment parce que les capteurs sont différents, et les méthodes de traitement aussi (même s'il existe des travaux de vision bio-inspirée).

Bref, il y a du travail à faire sur le fond et la forme.

Hello !

Je suis en train de préparer la réalisation d'un à plusieurs Metabots (https://github.com/R...ter/docs/bom.md), petit quadrupède qui fonctionne avec des servo Dynamixel XL 320 ( http://www.robotshop.com/en/dynamixel-xl-320-ollo-smart-serial-servo.html ), qui m'ont l'air un bon produit d'entrée de gamme en servo numérique.
Est-ce que vous pensez en inclure dans la boutique à moyen terme (dans l'année) ? Quitte à ce que je paie des frais de ports vers le Tyrol, autant que ça bénéficie à RM

Je ne ferais qu'une seule vidéo, toutes les photos permettant de reproduire le char seront visibles vers la fin, comme d'habitude.

Pour l'instant, je bloque sur la première photo. Je pense que c'est celle là qui accrochera le plus le regard quand on voit défiler des dizaines de vidéos LEGO.
Ces derniers temps, je ne sais pas ce qui se passe, mais j'ai au moins 2 nouveaux abonnés par jour sur YouTube. J'en suis à 202 et à 28462 vues au total !
Il doit y avoir un forum qui parle de mes réalisations, mais lequel, impossible de le savoir.

Merci, les garçons.

Sur Youtube, tu as un outil analytics sous les vidéos ; tu n'as pas la page à partir de laquelle les gens arrivent sur ta vidéo ?

1 et 3 pour les mêmes raisons que Jan

 

Je ne sais pas ce que tu as prévu comme vidéo, mais la 1 peut faire image d'intro et l'angle 3 servir à une vidéo où le robot tourne pour montrer les détails du mécanisme.

Salut,

Vire tes conditions et appelle la fonction d'envoi avec une valeur en dur. Si ça marche, le problème ne vient pas de là.

Utiliser une String pour faire du réseau et de la transmission de packet, ça me semble bizarre ... Et le résultat de "inputString +=" assez aléatoire ... Regarde les méthodes associées à la classe pour ça, ça sera plus propre.
D'ailleurs, pourquoi passer par un "RSblabla" ? Quelle est l'information récupérée envoyée par la télécommande ? N'y a-t-il pas une valeur en hexa (sous forme d'octet) dans la trame plutôt qu'une chaîne de caractères ?

En général, le switch case ne fonctionne pas sur autre chose que des char ou des int, mais je n'ai rien vu de précisé pour Arduino. S'il fonctionne, change tes if if if if if ...

Si tu nous mets une sortie console, ça peut être bien aussi.

Salut,

Processing et Arduino ont une logique comparable : des fonctions et libraires assez haut niveau qui permettent de prendre vite en main les fonctions. Si tu es habitué sur Arduino, faire du Processing ne devrait pas te poser trop de problèmes (surtout que la doc est plus conséquente dans mon souvenir, sur leur site).

Il existe de la même manière que pour Arduino une libraire Serial qui permet de communiquer avec une carte connectée sur en Serial-over-USB (ce qui est le cas de l'Arduino sur le port USB). Tu peux ainsi envoyer et recevoir les données dont tu as besoin.
Une libraire Keyboard permet de traiter les appuis détectés sur le clavier, ce qui facilitera ta gestion des contrôles. Ce sont a priori les deux libraires principales pour faire une interface de contrôle basique, avec les variables qui vont bien (et éventuellement let affichage graphique).

Du côté Arduino, il faut traiter les messages reçus pour extraire les informations. Jusqu'à présent, j'ai toujours fait ça à base de string et autres char, il y a peut-être une solution plus intelligente (i.e une librairie qui fait ça bien), en tout cas, ça marchait.

Waou.

Si c'est le projet que vous vous êtes donnés avec ton amie pour apprendre la robotique, c'est bien trop ambitieux si vous ne maîtrisez pas les bases. Pour moi, ça sonne comme un sujet de stage/projet de recherche de master.
S'il s'agit juste d'apprendre, un robot simple avec Arduino, c'est une première base. La couche additionnelle de ROS est utile pour des projets plus ambitieux, mais pas pour découvrir l'électronique, la mécanique et l'informatique en robotique.
Suivre les conseils d'arobasseb est le meilleur moyen de commencer sans trop de douleurs (ROS est ingrat parfois ).

de plus, je ne comprends pas à quoi sert le "-p /dev/tty03" dans ma ligne :

avrdude -p /dev/ttyS3 -c usbasp -p t85 -v -U flash:w:ledblink_tiny85.hex

ne devrais-je pas ajouter un "-P usb:03" ? (j'ai tenté mais ça ne le trouve pas mieux)
merci d'avance.

D'après la doc, l'argument -P permet de préciser le port. Le chemin est ensuite le point d'accès au port sur lequel ton Programmer est branché. La majuscule est importante (tu as mis deux fois -p) parce que -p et -P sont deux options différentes.
Je ne sais pas si c'est la source de ton erreur, mais ça n'arrange sûrement pas les choses. ^^

avrdude -p /dev/ttyS3 -c usbasp -p t85 -v -U flash:w:ledblink_tiny85.hex

Je viens de regarder rapidement, d'après la doc¹, l'option -c permet de spécifier l'ID du programmeur USB, en l'occurrence un USBASP. Est-ce que c'est bien celui que tu utilises ? Est-ce que tu as essayé sans l'option (qui n'est pas obligatoire, il semblerait) ?

[1] Doc AVR Dude

Ah, j'avais pas vu tes nouveaux posts !

si une âme charitable pouvait m'expliquer ce qu'est F_CPU et comment le définir afin de ne plus avoir ce message je lui en serait très reconnaissant. Merci d'avance.

Après un peu de recherche, j'ai trouvé les fichiers delay.h dans les sous-dossiers associés à avr-dude, du logiciel Arduino. L'erreur est déclenchée par le bout de code :

#ifndef F_CPU
/* prevent compiler error by supplying a default */
# warning "F_CPU not defined for <util/delay.h>"
# define F_CPU 1000000UL
#endif

Et les commentaires au dessus disent ça :

/** \file */
/** \defgroup util_delay <util/delay.h>: Convenience functions for busy-wait delay loops
    \code
    #define F_CPU 1000000UL  // 1 MHz
    //#define F_CPU 14.7456E6
    #include <util/delay.h>
    \endcode

    \note As an alternative method, it is possible to pass the
    F_CPU macro down to the compiler from the Makefile.
    Obviously, in that case, no \c \#define statement should be
    used.

    The functions in this header file are wrappers around the basic
    busy-wait functions from <util/delay_basic.h>.  They are meant as
    convenience functions where actual time values can be specified
    rather than a number of cycles to wait for.  The idea behind is
    that compile-time constant expressions will be eliminated by
    compiler optimization so floating-point expressions can be used
    to calculate the number of delay cycles needed based on[b] the CPU
    frequency passed by the macro F_CPU.[/b]

    \note In order for these functions to work as intended, compiler
    optimizations <em>must</em> be enabled, and the delay time
    <em>must</em> be an expression that is a known constant at
    compile-time.  If these requirements are not met, the resulting
    delay will be much longer (and basically unpredictable), and
    applications that otherwise do not use floating-point calculations
    will experience severe code bloat by the floating-point library
    routines linked into the application.

    The functions available allow the specification of microsecond, and
    millisecond delays directly, using the application-supplied macro
    [b]F_CPU as the CPU clock frequency (in Hertz).[/b]

*/

Donc clairement, cette constante mémorise le fréquence de ton µP, et l'utilise pour effectuer des calculs en temps plutôt qu'en nombre d'opérations (quelqu'un confirme ?). Visiblement, cette constante peut être définie dans le Makefile qui permet la compilation du programme Arduino que tu as écrit.

Salut, />
Je me permet de poster ici car ma nouvelle question reste sur les transferts de programmes entre PC et ATTiny.
Cette fois je me demande si il est possible de demander au logiciel Arduino de compiler un programme en ".hex", mais sans le transférer sur l'arduino : je veux juste qu'il me le compile et qu'il sauvegarde le ".hex" à côté de mon ".ino".
merci d'avance.

A priori, c'est ce qui est fait quand tu cliques sur "Vérifier" mais pas sur "Téléversement". Par contre, je ne sais pas où atterrit le fichier compilé. Peut-être dans un répertoire temporaire. Je ne connais pas assez le fonctionnement bas-niveau d'Arduino pour t'affirme quelque chose de sûr ...

Et tu ne peux pas faire un clone de ton circuit qui balance une tension plus élevée ? Sachant que visiblement, tu peux changer le moteur sur ton montage actuel, il suffirait donc de déplacer ce moteur gourmand sur la nouvelle électronique. Évidemment, c'est plus facile à dire qu'à faire.

si tu rajoutais les condo de decouplage?

Quel intérêt ?
http://fr.wikipedia.org/wiki/Condensateur_de_d%C3%A9couplage

Ok , merci. Je vien de voir qu'il y a 2 erreur : " digitalWrite(led, HIGH)," une virgule au lieu d'un point virgule et ça marche quand meme !

Oui mais uniquement parce qu'il y a un delay(); derrière. Essaie de l'enlever, ça devrait planter. Le point-virgule marque la fin d'une instruction, tandis que la virgule sépare deux instructions (en C/C++ en tout cas).
Par exemple, tu peux écrire :

int i = 0, y = 5;
...
y += (i+1);
...
i++, y=i;

La première ligne déclare et initialise les variables y et i en une ligne.
La deuxième ligne ajoute 1 à i puis ajoute le résultat à y.
La dernière ligne augmente i de 1 et donne à y la nouvelle valeur de i (attention à l'ordre des instructions).

Mais :

int i = 2,
i++,

renverra une erreur (il n'y a pas de fin d'instruction marquée).

Salut !

Cette fois c'est bon

if ((sensorValue -  sensorValue1)<=50 &&  (sensorValue -  sensorValue1) >= -50 )

Ce que tu cherches à faire, c'est effectivement vérifier que tu es dans une certaine région autour d'une consigne. La manière classique de faire, c'est de calculer une erreur (valeur à atteindre - valeur mesurée), et de vérifier que cette erreur est inférieure à un seuil, le résultat auquel tu es arrivé.
Pour optimiser encore de code, tu peux calculer la valeur absolue de l'erreur (abs(val à atteindre - val mesurée) avec arduino) et la comparer à une tolérance sur la valeur à atteindre. Du coup, pas besoin de vérifier par rapport à chaque borne, simplement que l'erreur est inférieure à la tolérance.

Regarde du côté des simulateurs, genre MORSE, tu dois pouvoir récupérer les modèles 3D au prix d'un effort de conversion dans un format utilisable pour l'impression.

Random guess : la partie setup est lancée dès que l'arduino est mise sous tension ; donc si ton arduino est branchée, et à moins de ré-uploader son code, au moment où tu tentes de communiquer avec, elle est déjà dans la loop.

À l'inverse, si setup n'a pas encore été appelé, il est possible que le port série ne soit pas encore initialisé (réponse sans vérifier tous les détails de ton architecture, si tu utilises un shield le comportement est peut-être différent). Je ne sais pas comment se comporterait un Serial.begin() en dehors de ces fonctions (théoriquement, il serait juste appelé dans le main du programme, mais peut-être que le placer dans le setup garantit une bonne initialisation de la carte?).

 

Au passage, bravo pour ton projet, je fais habituellement partie de la masse silencieuse des lecteurs mais c'est l'occasion de le dire

Tu me fais envie ...

Tu veux en faire un ?

Les sources, design, etc. sont dispos sur github : https://github.com/r1d1/KarotzLikeBot. Et hasard du calendrier, j'en suis à exactement 42 commits.

OOuuaaiiisss vive tonton K

Oui, merci à lui, ça entretient ma motivation

Nouveau projet en cours




Plus de détails: https://www.robot-maker.com/forum/topic/12548-project-marcel/?p=103473

Fini le teaser, place aux infos !

 

Projet M.A.R.C.E.L

 

Comme l'a repéré Mike, MARCEL correspond à Minimalist Autonomous Robot Constantly Experiencing Life (encore que l'acronyme ne soit pas final). Détaillons un peu:

• Minimalist : faisons simple, fonctionnel, autant que possible avec les composants disponibles, pour éviter l'échec du projet par perte de motivation.
• Autonomous : le robot doit fonctionner selon une boucle sensorimotrice qui n'est pas contrôlée par l'humain (donc sans boutons, télécommande, ...). Au début, une simple boucle de contrôle. Ensuite, une machine à états basique. Pour les évolutions, on verra plus tard.
• Robot : j'ai vraiment besoin d'expliquer ça ?
• Constantly Experiencing Life : le robot doit fonctionner pendant une longue période de temps, idéalement une journée, avec des phases d'activité différentes. Les humains autour doivent pouvoir vaquer à leurs propres activités indépendamment de ce que fait le robot (et des fois, le robot ne fait rien), pouvoir interagir avec le robot et recevoir une forme d'engagement.

 

Genèse du projet (on dit "origin story" pour les djeunz) : quand on est gamin, on a pas la même notion des choses qu'un adulte. Ça fait longtemps que je sais que je veux faire de la robotique, et un de mes oncles, appelons-le tonton K, m'a fait promettre, quand j'étais petit, que mon premier robot serait pour lui. Des robots, j'en manipule régulièrement, mais je n'en ai jamais vraiment construit un de A à Z. La v3 de mon plus vieux projet, Froggy, démarré en 2012, traîne démontée dans une boite depuis deux ans. J'ai revu tonton K à Noël dernier et il m'a rappelé sur le ton de la blague ma promesse.

 

Challenge accepted ! MARCEL is coming.

 

Bon j'ai des vacances la semaine prochaine, j'espère avancer sur Marcel !