Club robotique de Sophia-Antipolis

Accueil > POBOTpedia > Programmation > Apprendre à coder > Les micro-contrôleurs > RTOS sur AVR > DuinOS : Arduino temps réel > Premiers pas avec DuinOS

Premiers pas avec DuinOS

mardi 28 décembre 2010, par Julien H.

DuinOS permet la programmation temps réel d’une Arduino, par la déclaration et la gestion de tâches concurrentes. Cet article vous propose d’installer DuinOS et d’écrire votre premier programme multi-tâches sous cet RTOS.

Matériel nécessaire

Il vous faut un ordinateur (toute version), une Arduino (type Duemilanove ou UNO) et deux leds.

 Récupérer les fichiers

Cette partie est bien documentée dans la partie officielle. Les pages avaient été traduites en français sur le site officiel mais ne sont plus disponibles à ce jour

Il faut donc se référer à notre propre version avant de passer au premier test.

J’ai utilisé les versions de logiciels suivant :

- l’environnement Arduino 0018 (85,8 Mo)
- la version 0.2 alpha de DuinOS (121 ko)

Mise à jour : les fichiers se récupèrent désormais sur le projet GitHub DuinOS

 Installer

Comme j’ai déjà une version 0022 d’Arduino et surtout comme il va falloir modifier l’installation officielle, j’ai décompressé l’environnement Arduino dans un nouveau répertoire, et je l’ai renommé en "ArDuinOS-0018" pour m’en souvenir.

J’ai supprimé le répertoire "java" de l’installation officielle d’Arduino 0018 (je fais ça pour toutes mes versions sinon ça plante, ce n’est pas spécifique à DuinOS et ne le faites pas si Arduino se lance bien.

Pour continuer, il ne faut pas que le logiciel soit ouvert. C’est logique mais la doc d’origine le précise et on n’y pense pas toujours.

J’ai copié le répertoire situé dans l’archive :

[Zip DuinOS_v0.2_Alpha]\arduino.DuinOS

dans le répertoire d’Arduino (avec le nom que je lui ai donné) :
[arDuinOS-0018]\hardware\arduino\cores

où il se trouve donc en parallèle avec "arduino".

J’ai supprimé les fichiers :

- [arDuinOS-0018]\hardware\arduino\boards.txt
- [arDuinOS-0018]\lib\keywords.txt

Et je les ai remplacés par ceux contenus dans l’archive :

- [Zip DuinOS_v0.2_Alpha]\ide\boards.txt
- [Zip DuinOS_v0.2_Alpha]\ide\keywords.txt

En fait, le changement pour boards.txt est de référencer la version DuinOS que nous avons copié dans "cores", soit la ligne suivante :

atmega328.build.core=arduino

qui devient :

atmega328_DuinOS.build.core=arduino.DuinOS

Quant au fichier "keywords.txt", cela ajoute la coloration syntaxique (ainsi que SERIAL et DISPLAY, je ne sais pas pourquoi ils n’étaient pas présents dans l’Arduino officiel) :

#######################################
# Datatypes (KEYWORD1)
#######################################

taskLoop       KEYWORD1

#######################################
# Methods and Functions (KEYWORD2)
#######################################
declareTaskLoop        KEYWORD2
createTaskLoop KEYWORD2
suspend        KEYWORD2
suspendTask    KEYWORD2

etc...

Comme le fichier inclus dans l’archive ne fonctionnait pas (il contient des espaces au-lieu de tabulations, je vous propose le mien :

Texte - 4.2 ko
Fichier keywords.txt

C’est toujours utile de savoir ce qu’on fait, et cela nous donne déjà un aperçu du "langage" spécifique qu’on pourra utiliser dans notre code.

Vous pouvez aller plus loin et essayer d’adapter le fichier "boards.txt" pour être compatible avec une Arduino UNO (à l’heure où j’écris, DuinOS n’explique pas comment faire). Ce n’est pas compliqué, et il suffit de copier le répertoire du bootloader "optiboot" depuis une archive Arduino plus récente (j’ai pris ma 0021 pour exemple).

Enfin, copiez les deux répertoires d’exemple de l’archive vers le répertoire exemples de votre version modifiée d’Arduino.

 Lancement

Une fois lancé l’environnement Arduino (avec le fichier arduino.exe situé à la racine), vous n’observerez pas de changement majeur : mais allez dans le menu "tools" puis le sous-menu "boards" et vous verrez les cartes en version DuinOS :

JPEG - 23.1 ko

J’ai fait un peu de ménage dans le fichier boards.txt donc la liste dans l’image ci-dessus est plus réduite que celle que vous devez observer sur votre propre installation.

 Premier exemple

Par analogie avec le premier test développé par tout débutant dans un nouveau langage de programmation, vous savez qu’on appelle "Hello World de l’électronique" le fait de faire clignoter une lumière.

C’est ce qu’on va faire. Les deux exemples fournis étant un peu complexe, et comme je veux juste vérifier que le code DuinOS fonctionne bien, j’ai adapté le code pour faire simplement clignoter les deux leds en parallèle :


/***
* Exemple simple d’utilisation de DuinOS
* basé sur l’exemple fourni dans la v0.2 "MoreComplexBlinking"
* Il s’agit tout simplement de faire clignoter deux leds en parallèle à des rythmes différents.
*
* Based on the original Blink code by David Cuartielles
*
*/

// on place les leds entre le 3,3 volts et les pattes analog 0 et 1 soit digital 14 et 15
int ledPinRed = 14 ;
int ledPinGreen = 15 ;

// Déclaration des deux tâches parallèles

taskLoop(redLED)

digitalWrite(ledPinRed,HIGH) ;
delay(200) ;
digitalWrite(ledPinRed,LOW) ;
delay(200) ;

taskLoop(greenLED)

digitalWrite(ledPinGreen, HIGH) ;
delay(500) ;
digitalWrite(ledPinGreen, LOW) ; // set the LED off
delay(500) ;

// Fonctions habituelles

void setup()

// Initialisation des deux sorties pour les leds
pinMode(ledPinRed, OUTPUT) ;
pinMode(ledPinGreen, OUTPUT) ;

// Création des deux tâches
createTaskLoop(redLED, NORMAL_PRIORITY) ;
createTaskLoop(greenLED, NORMAL_PRIORITY) ;

void loop()

// Deux tâches en parallèle pendant 2 secondes
resumeTask(greenLED) ;
resumeTask(redLED) ;
delay(2000) ;
// Puis seulement la verte pendant 2 secondes
suspendTask(redLED) ;
delay(2000) ;
// Puis seulement la rouge
resumeTask(redLED) ;
suspendTask(greenLED) ;
delay(2000) ;
// et on recommence (loop)

Le schéma de connexion est très simple, il suffit de prendre deux leds et de les connecter directement sur l’Arduino entre le 3,3 volts (la tension la plus basse à disposition, et c’est déjà trop) et une patte contrôlable par une sortie numérique.

J’ai choisi les pattes "analog 0" et "analog 1" qui portent mal leur nom puisqu’elles peuvent aussi être utilisées simplement en tout ou rien, sous le nom de "digital 14" et "digital 15".

Voici le schéma (si vous avez une platine d’essai, ajoutez les résistances qui vont bien pour obtenir la tension supportée par la led) :

JPEG - 30.8 ko

Puis compilez ce code et envoyez le après avoir sélectionné le bon port COM et la bonne carte portant la mention "+ DuinOS" dans le menu des outils.

Si vous compilez en ayant sélectionné une carte qui n’a pas la mention "DuinOS", vous constaterez une erreur dès l’instruction "taskLoop" puisque le compilateur s’attend à voir une déclaration de fonction, or il n’y a pas de type devant.


error : expected constructor, destructor, or type conversion before ’(’ ...

Et voilà, pas la peine de rentrer plus en détail dans ce code, ce sera l’objet d’un autre article. Vous savez au moins que vous avez un environnement qui fonctionne avec DuinOS, et vous pouvez sereinement commencer à découvrir la programmation multi-tâche temps réel.

JPEG - 440.1 ko

Vos commentaires

  • Le 11 juin 2012 à 14:21, par ? En réponse à : Premiers pas avec DuinOS

    Bonjour,

    je viens de tester duinos avec une board arduino mega 2560 (rev 1 ou 2 je sais pas) et arduino IDE 1.0.

    Pour ceux que ça interresse, j’ai fait l’installation en suivant les instruction
    et en utilisant le patch port.c(le 2eme).

    TOut marche, sauf que mes LEDs clignote environ 20 fois trop vite. En fait l’instrction delay et environ 20x trop rapide.
    D’où celà peut il venir ?
    (si je met delay(10000) au lieu de delay(500), ça me fait un clignotement d’environ 1/2 second)

     ?????

    Merci

    • Le 12 juin 2012 à 12:04, par Julien H. En réponse à : Premiers pas avec DuinOS

      Sans doute la fréquence de l’horloge dans le firmware Arduino n’est pas bonne.

    • Le 16 juin 2012 à 12:33, par ? En réponse à : Premiers pas avec DuinOS

      le truc c’est que le code de clignotement de led sans duinos fonctionne correctement (bonne fréquence) mais pas celui avec duinos ????

    • Le 16 juin 2012 à 15:40, par Julien H. En réponse à : Premiers pas avec DuinOS

      Plus de précision sur ma réponse : pour utiliser DuinOS, vous avez modifié le fichier "boards.txt" pour ajouter la référence à DuinOS pour que le code puisse compiler.

      A mon avis vous avez une mauvaise fréquence sur la ligne comme ça : "atmega328.build.f_cpu=16000000L"

      Vérifiez la valeur.

    • Le 18 juin 2012 à 17:53, par ? En réponse à : Premiers pas avec DuinOS

      OK, on m’a trouvé la solution...

      le patch pour utilisation d’un arduino mega n’était plus d’actualité !

      Maintenant pour l’utilisation de l’arduino mega avec DuinOS, il faut installer DuinOS, puis suivre les instruction donnée là :

      Merci !

    • Le 9 septembre 2013 à 22:08, par Loic En réponse à : Premiers pas avec DuinOS

      J’ai le même problème, le delay n’est pas en milliseconde sur ma carte 2560 ...
      Pourtant j’ai tout relu et j’ai les bonnes valeurs dans le /usr/share/arduino/hardware/arduino/boards.txt :


      mega2560_DuinOS.name=Arduino Mega 2560 + DuinOS
      mega2560_DuinOS.upload.protocol=stk500v2
      mega2560_DuinOS.upload.maximum_size=258048
      mega2560_DuinOS.upload.speed=115200
      mega2560_DuinOS.bootloader.low_fuses=0xFF
      mega2560_DuinOS.bootloader.high_fuses=0xD8
      mega2560_DuinOS.bootloader.extended_fuses=0xFD
      mega2560_DuinOS.bootloader.path=stk500v2
      mega2560_DuinOS.bootloader.file=stk500boot_v2_mega2560.hex
      mega2560_DuinOS.bootloader.unlock_bits=0x3F
      mega2560_DuinOS.bootloader.lock_bits=0x0F
      mega2560_DuinOS.build.mcu=atmega2560
      mega2560_DuinOS.build.f_cpu=16000000L
      mega2560_DuinOS.build.core=arduino.DuinOS

      Quelqu’un aurait une idée ?
      Merci par avance,
      Loïc

    Répondre à ce message

  • Le 10 juillet 2013 à 11:45, par ThierryG En réponse à : Premiers pas avec DuinOS

    Bonjour,
    Le lien de téléchargement en début de tuto ne fonctionne plus
    Installation officielle de DuinOS
    Ou peut-on downloader la dernière version SVP ?
    Merci

    Répondre à ce message

  • Le 9 janvier 2011 à 00:33, par laurentito En réponse à : Premiers pas avec DuinOS

    Bonjour !
    Tout d’abord je tiens à vous remercier pour votre travail. C’est super de voir des gens collaborer comme vous le faites.
    Je m’intéresse depuis peu au temps réel et j’avais cru comprendre que seulement une tâche peu avoir accès à la CPU et pour qu’une autre tâche puisse à son tour accéder à la CPU il faut qu’il y ait suspension de la tâche (causée par un évènement) ou bien une interruption. Or dans votre exemple les tâches fonctionnent en parallèle, et le fait que les leds soient allumées veut-il dire que les 2 tâches ont accès à la CPU en même temps ? Alors bêtement je me dis que les deux accèdent périodiquement à la CPU très rapidement, donnant l’impression que les 2 leds sont allumées en même temps... Je dis surement des bêtises, en fait je suis perdu et j’apprécierais que quelqu’un m’éclaire à ce sujet ! je n’ai pas encore d’Arduino pour tester...
    C’est une question surement très basique mais bon, faut bien commencer par quelque chose. Je remercie d’avance ceux qui pourront m’apporter des réponses ! Bon début d’année à tout le monde, tcho !

    • Le 9 janvier 2011 à 18:55, par Julien H. En réponse à : Premiers pas avec DuinOS

      Bonjour !

      Tu as presque raison : le CPU ne peut traiter qu’un ordre à la fois, donc le temps réel est obtenu en mettant un algorithme qui distribue le temps CPU tour par tour (de manière intelligente).

      Par contre pour les leds, il n’est pas nécessaire de "maintenir" le signal qui allume la led : il suffit d’une consigne pour allumer et une consigne pour éteindre.

      Donc le temps nécessaire pour ordonner l’allumage ou l’extinction d’une led est très très court (125 nanosecondes), bien plus que le temps d’affichage qu’on a choisi pour pouvoir visualiser correctement le changement d’une led à l’autre (plus d’1 million de fois plus, soit 125 millisecondes).

      Le temps réel n’est pas nécessaire pour allumer simultanément deux ou même dix leds : on a choisi cet exemple pour montrer comment on écrit du code pour un RTOS, mais généralement on s’en sert pour contrôler des moteurs ou des capteurs qui ont besoin d’une réaction de l’ordre de la microseconde.

    • Le 9 janvier 2011 à 19:06, par laurentito En réponse à : Premiers pas avec DuinOS

      Merci pour cette réponse !

      Robotiquement,

      Laurent

    • Le 8 juillet 2011 à 18:06, par ? En réponse à : Premiers pas avec DuinOS

      Bonjour,

      Très intéressant, donc je m’y suis lancé et j’ai bidouillé pour faire apparaître un Uno + DuinOS.
      J’ai lancé l’exemple fournit et ça marche.
      Par contre en Uno + DuinOS il ne veut pas des entrées analogiques A.. et je ne sais pas pourquoi :
      Un simple sketch contenant une A0, passe en Uno et me déclare une erreur de déclaration en Uno + DuinOS.

      Auriez-vous une solution ?
      En plus, je suis débutant !
      Merci

    • Le 8 juillet 2011 à 22:51, par Julien H. En réponse à : Premiers pas avec DuinOS

      Intrigant ! Envoi ton code et on testera. Je ne suis pas sur de comprendre ce A0.

    • Le 9 juillet 2011 à 05:31, par ? En réponse à : Premiers pas avec DuinOS

      Tout d’abord, merci de ta réponse rapide.
      Voici un exemple de code (qui ne nécessite pas DuinOS) qui fonctionne et se compile avec toutes les boards sans DuinOS :
      PS : Je ne sais pas comment t’envoyer mon code donc je l’ai coller ici.
      /*
      LECTURE DE TROIS CAPTEURS LM35DZ ET AFFICHAGE
      */

      void setup()
      Serial.begin(9600) ;

      void loop()
      /* int sensorValue = analogRead(A0) ;
      Serial.println(sensorValue, DEC) ;
      */
      int areading = analogRead(A0) ;
      float avoltage = areading * 5.0 / 1024 ;
      int atemp = avoltage * 100 ;

      int breading = analogRead(A1) ;
      float bvoltage = breading * 5.0 / 1024 ;
      int btemp = bvoltage * 100 ;

      int creading = analogRead(A2) ;
      float cvoltage = creading * 5.0 / 1024 ;
      int ctemp = cvoltage * 100 ;

      Serial.print("A = ") ;
      Serial.print(atemp, DEC) ;
      Serial.print("C - B = ") ;
      Serial.print(btemp, DEC) ;
      Serial.print("C - C = ") ;
      Serial.print(ctemp, DEC) ;
      Serial.println("C") ;

      delay (1000) ;

      Mais qui butte dès que l’on utilise une board + DuinOS :

      fracois1.cpp : In function ’void loop()’ :
      fracois1:13 : error : ’A0’ was not declared in this scope
      fracois1:17 : error : ’A1’ was not declared in this scope
      fracois1:21 : error : ’A2’ was not declared in this scope

      Merci
      Michel

    • Le 9 juillet 2011 à 12:33, par Julien H. En réponse à : Premiers pas avec DuinOS

      Je ne connaissais pas cette syntaxe, je fais directement analogRead(0), analogRead(1), etc...

      Essaies et dis-moi ce que ça donne.

    • Le 16 juillet 2011 à 12:47, par ? En réponse à : Premiers pas avec DuinOS

      Je poste ici la copie de ma réponse que j’avais envoyé directement sur le mail du site :

      Bonjour,

      J’ai essayé et ça marche avec DuinOS et dans tous les autres programmes.
      L’erreur vient de ce que j’ai vu dans l’exemple "AnalogInput" fournit dans l’IDE Arduino.
      Désormais, je ne mettrai plus de A pour coder les entrées analogiques.

      Merci pour ton aide, votre site est superbe, je vais m’y plonger à fond.

      Une autre question, j’ai lu que DuinOS n’était pas copain avec l’instruction Delay, est-ce toujours le cas ? et quelle solution permettrait de la remplacer ?

      Encore merci
      Cordialement
      Michel

    • Le 16 juillet 2011 à 14:09, par Julien H. En réponse à : Premiers pas avec DuinOS

      Bonjour.

      Je ne sais pas ce que veut dire "être copain avec une instruction". Si c’est sur notre site que vous l’avez lu je vais le corriger. Il est tout à fait possible que puisque "delay" et "DuinOS" utilisent des interruptions, on ne puisse entremêler du code faisant appel en même temps à deux interruptions. C’est une limite du micro-contrôleur AVR qui est mono-interruption : il faut finir la première avant de pouvoir traiter la seconde. Il est possible de modifier la logique de son code pour faire le moins possible de traitement long dans une interruption.

      Merci pour vos compliments sur le site.

    • Le 9 août 2011 à 16:53, par Telson En réponse à : Premiers pas avec DuinOS

      Bonjour,

      Comme il faut en faut toujours un pour poser la question stupide j’me lance.

      C’est compatible avec la mega2560 ???

      Merci.

    • Le 10 août 2011 à 10:29, par Telson En réponse à : Premiers pas avec DuinOS

      Selon la source : http://code.google.com/p/duinos/

      DuinOS is a small multithreading real time operating system (RTOS), based on the FreeRTOS kernel, for Arduino compatible boards.

      It’s installed as an Arduino core, and currently supports the following AVR processors :

      * ATmega168
      * ATMega328
      * ATMega644
      * ATMega1280
      * ATMega1284

      Donc pas de compatibilité avec la Méga2560 !! ARG !! j’suis vert !!!

    • Le 11 août 2011 à 23:37, par Telson En réponse à : Premiers pas avec DuinOS

      Une première solution très fraîche :

      http://arduino.cc/forum/index.php/topic,69003.0.html

      Ou ici (Mega2560 Patch) :

      http://code.google.com/p/duinos/updates/list

      Des testeurs en vue ??

    • Le 2 septembre 2011 à 03:25, par Telson En réponse à : Premiers pas avec DuinOS

      serait t’il possible d’utiliser Duinos avec des capteurs Ultrason SR HC04, pour ma part après 8-10 mesures tout se fige.....puis obligé de re uploader le programme pour pouvoir réaliser de nouveau 6-8 mesures....etc

    • Le 4 septembre 2011 à 15:16, par Julien H. En réponse à : Premiers pas avec DuinOS

      Bonjour,

      Il doit y avoir un problème de fréquence d’acquisition (trop rapide ?) créant une exclusion (on attend une ressource).

      Je ne vois pas ce qui pourrait bloquer sinon.

      As-tu essayé sans DuinOS pour valider l’acquisition continue ?

    • Le 5 septembre 2011 à 00:45, par Telson En réponse à : Premiers pas avec DuinOS

      Le problème vient de Serial.println(duration), cela fait planter le programme

      Cette variable est une unsigned long avec bien sur duration = duration/58.

      Lorsque j’utilise Serial.println(D) pour marquer le début de la fonction loop et lorsque je place Serial.println(F) pour marquer la fin de la boucle loop il n’y à aucun problème.

      Par contre si je met, Serial.println(345) le programme fige et avec Serial.println(32) le programme fonctionne.

      Les valeurs D, F, 32 et 345 sont des valeurs d’essais choisies un peu,beaucoup, au hasard.....

      Est ce que cela vous inspire quelque chose ??

    • Le 5 septembre 2011 à 20:59, par Julien H. En réponse à : Premiers pas avec DuinOS

      Oui, conflit dans les interruptions matérielles nécessaires à gérer la liaison série et à gérer l’ordonnanceur (DuinOS).

      C’est très sensible, il faut mieux mettre l’affichage hors du programme temps réel, dans une tâche dédiée à l’affichage, qui n’est pas sensible au temps (mais du coup fonctionnera quand les ressources sont disponibles).

    Répondre à ce message

  • Le 6 mars 2012 à 01:29, par gegeP En réponse à : Premiers pas avec DuinOS

    Félicitation à l’auteur de cet article pour son travail.
    Je suis passionné par le temps réel et j’aimerais connaître l’ ensemble des instructions du DuinOs avec en particulier : les sémaphores et la commande de prémption du processeur. J’ai essayé les instructions du freeRTOS mais un paquet d’erreurs du genre :

    xSemaphoreHandle’ does not name a type

    ’xSemaphore’ was not declared in this scope

    ’xSemaphoreGive’ was not declared in this scope

    m’a dissuadé de poursuivre. Il manque sans doute l’inclusion de fichiers d’entête et de librairies ou bien ces instructions n’ont pas étés portées sur DuinOS ??

    Un petit coup de mains serait le bienvenue.

    merçi
    ggP

    Nota :
    J’ai eu l’expérience en temps réel avec les OS :

    OS9 de microware et

    Solaris de Sun.

    Répondre à ce message

  • Le 8 août 2012 à 23:03, par ? En réponse à : Premiers pas avec DuinOS

    Bonsoir,
    Merci pour cet excellent tuto.

    Testé avec :

    - Arduino : UNO & MEGA ADK

    - Arduino ide : 1.0.1

    - DuinOS : V4 —> liens

    Fonctionne parfaitement.

    • Le 16 octobre 2012 à 18:53, par stéphane En réponse à : Premiers pas avec DuinOS

      Bonjour à tous,
      Quelqu’un aurait ’il un bout de programme qui fait bouger 2 servo en utilisant les sorties pwm ou la bibliothèque servo.h si elle marche avec duinos.
      Merci d’avance...
      Stéphane

    • Le 16 octobre 2012 à 22:50, par Julien H. En réponse à : Premiers pas avec DuinOS

      Bonjour,

      Le code des servomoteurs pour Arduino (voir article "bien débuter avec Arduino") fonctionne pareil avec DuinOS, non ?

      A+
      Julien.

    • Le 17 octobre 2012 à 11:07, par Stéphane En réponse à : Premiers pas avec DuinOS

      Bonjour julien,
      Merci pour ta réponse, oui le code des servo du tutorial fonctionne, ce qui me bloque c’est la facon de programmer avec duinos pour bouger les deux servos en même temps, je suis têtu, c’est mon défaut.
      Je te met mon code, si tu peux me donner un coup de main.

      #include <Servo.h>

      #define INCR  1  
       
      // on déclare le servomoteur comme une variable typée  
      Servo servo1;  
      Servo servo2;  
      // l'angle actuel du servomoteur  
      int angle = 0;  
      // le sens actuel du servomoteur  
      int sens = 0;  

      // Déclaration des deux tâches parallèles  
       
      taskLoop(Servo1)  
      {  
        servo1.write(angle);
      }  
       
      taskLoop(Servo2)  
      {  
        servo2.write(angle);
      }  
       
      /**
      * Initialisation du programme
      */  
      void setup()  
      {  
       servo1.attach(9); // le servomoteur est sur une patte PWM  
        servo2.attach(11); // le servomoteur est sur une patte PWM  
      createTaskLoop(Servo1, NORMAL_PRIORITY);  
      createTaskLoop(Servo2, NORMAL_PRIORITY);

      }  
       
      /**
      * Boucle infinie qui va gérer la rotation et faire alterner le sens de rotation  
      */  
      void loop()  
      {  
         // faire tourner le servomoteur  
         if (sens == 0)  
         {  
           angle += INCR;  
         }  
         else {  
           angle -= INCR;  
         }  
         // si on est arrivé à une extremité  
         if (angle == 0)  
         {  
           sens = 0;  
         }  
         if (angle == 180) {  
           sens = 1;  
         }  
         delay(10);  
          resumeTask(Servo1);  
          resumeTask(Servo2);  
      }  

      Stéphane

    • Le 17 octobre 2012 à 14:30, par Julien H. En réponse à : Premiers pas avec DuinOS

      Je n’ai pas mes cartes sous les yeux, mais est-ce qu’un "volatile int angle = 0 ;" ne serait pas nécessaire ? Le mot-clé "volatile" permet de rendre la variable accessible depuis tous contextes, y compris dans des interruptions, ce qui peut être le cas selon l’implémentation de DuinOS.

      Sinon, qu’est-ce qui ne marche pas dans le code ci-dessus ?

      A+
      Julien.

    • Le 17 octobre 2012 à 15:04, par Stéphane En réponse à : Premiers pas avec DuinOS

      Je n’ai pas de pb de compilation ni de chargement, ce qui serait intéressant pour debugger.
      Mes servos reste dans la même position(position 0 de démarrage).
      J’ai mis mes int en volatile (angle et sens) comme tu me l’a indiqué mais pas d’amélioration.
      C’est étonnant de ne pas voir un exemple sur des servo pour justement voir le fonctionnement. J’arrive par contre à commander les 2 servos en mode normal :

       servo1.write(angle);
       servo2.write(angle);
       //resumeTask(Servo1);  
       //resumeTask(Servo2);

      Mais ce qui m’intéresse c’est de pouvoir les commander indépendamment en vitesse et en position. Je sais le faire un par un, c’est pour celà que j’ai pensé à duinos. As tu un exemple ou un lien qui explique le fonctionnement avec au moins deux servo.
      A+ Stéphane

    • Le 17 octobre 2012 à 23:09, par stéphane En réponse à : Premiers pas avec DuinOS

      Est ce que ce ne serait pas servo.h qui utliserait le même timer que duinos ?
      Je vais essayé demain matin sans servo.h, seulement avec les sorties pwm.
      A+ Stéphane

    Répondre à ce message

Un message, un commentaire ?

modération a priori

Attention, votre message n’apparaîtra qu’après avoir été relu et approuvé.

Qui êtes-vous ?

Pour afficher votre trombine avec votre message, enregistrez-la d’abord sur gravatar.com (gratuit et indolore) et n’oubliez pas d’indiquer votre adresse e-mail ici.

Ajoutez votre commentaire ici
  • Ce formulaire accepte les raccourcis SPIP [->url] {{gras}} {italique} <quote> <code> et le code HTML <q> <del> <ins>. Pour créer des paragraphes, laissez simplement des lignes vides.

Ajouter un document