IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Arduino Discussion :

[nano] Lecture de temps d'un signal et activation d'une sortie en allongeant la durée de ce signal


Sujet :

Arduino

  1. #21
    Candidat au Club
    Homme Profil pro
    Administrateur systèmes et réseaux
    Inscrit en
    Juin 2022
    Messages
    11
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 39
    Localisation : France, Corrèze (Limousin)

    Informations professionnelles :
    Activité : Administrateur systèmes et réseaux
    Secteur : Service public

    Informations forums :
    Inscription : Juin 2022
    Messages : 11
    Points : 3
    Points
    3
    Par défaut
    Citation Envoyé par Guesset Voir le message
    Attention, il faut vérifier que le nano émetteur coupé n'a pas un état incertain sur la broche simulant le signal calculateur lequel pourrait être détecté comme un état HIGH ou LOW sans logique prévisible. Mettre une résistance, par exemple de 1k, à la masse sur cette sortie du nano émetteur pour s'assurer d'un état LOW en cas d'arrêt.
    Pas de soucis, je testerai à nouveau sur le boitier, j'ai prévu la correction du signal pour l'arduino ainsi que la simulation des injecteurs pour le calculateur (pour éviter les codes défauts)

    voici le montage.

    Nom : Capture d’écran 2022-06-26 à 19.54.46.jpg
Affichages : 179
Taille : 255,4 Ko

    quand au clignotement oui c'est visible, j'ai pris l'habitude à force de tester. Par exemple, sur mon programme qui "bloque", sur breadboard on voit bien la luminosité augmenter, puis a une certain régime elle s'éteint presque pour ré-augmenter à nouveau si on continue à tourner le potentiomètre, chose qui sur la voiture se traduit par une coupure au moment ou elle devrait faiblir comme sur planche, et je pense que le calculateur sentant un manque il doit couper le signal. Le problème c'est que la conception du calculateur est plutot vieille (1986) et nous n'avons aucune info sur la gestion précise des pannes ou du fonctionnement, juste les codes d'erreur des capteurs.

    Merci à vous en attendant

  2. #22
    Expert confirmé

    Homme Profil pro
    mad scientist :)
    Inscrit en
    Septembre 2019
    Messages
    2 685
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : Septembre 2019
    Messages : 2 685
    Points : 5 328
    Points
    5 328
    Par défaut
    Citation Envoyé par Guesset Voir le message
    Sauf erreur de ma part, ça ne semble pas correspondre au comportement précisé par Pierre : redémarrage systématique d'un nouveau cycle sur ordre du calculateur.
    effectivement, j'avais raté cela alors!

    (sinon of course pour le changement d'état - je parlais bien des digitalWrite qui vont prendre un peu de temps et qui ne sont pas utiles)

  3. #23
    Candidat au Club
    Homme Profil pro
    Administrateur systèmes et réseaux
    Inscrit en
    Juin 2022
    Messages
    11
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 39
    Localisation : France, Corrèze (Limousin)

    Informations professionnelles :
    Activité : Administrateur systèmes et réseaux
    Secteur : Service public

    Informations forums :
    Inscription : Juin 2022
    Messages : 11
    Points : 3
    Points
    3
    Par défaut
    Bonjour,

    J'ai testé le dernier de Guesset, il ne fonctionne pas, le led reste allumé sur n'importe quel état de la broche de signal.

    Du coup, j'ai fouillé un peu.

    J'ai fait vite fait un montage de simulateur d'injection, avec le code Mr LOUTREL (cf http://www.loutrel.org/Injectionbancessai.php)

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    //Injection_banc_BT120919
    //Details sur http://a110a.free.fr/SPIP172/article.php3?id_article=192
    //Pilotage d'un injecteur en fonction de:
    //Nt/mn (4 cylindres), Dinj durée d'injection en microsecondes
    //et du
    //Nombre total d'injections à effectuer( option smartphone )
     
    //La Led de l' Arduino s'allume pendant l'injection
     
    //Ces valeurs  sont entrées au choix
    //--par deux potards pour N et Dinj, mode par defaut
    //--par Sphone via Bluetooth ou PC pour N, Dinj et total injections
    //Si on affiche N=1000 et Dinj = 5 ms aux potards, on doit voir la led clignoter
     
    //Pour le mode smartphone, tourner N au maxi AVANT la mise sous tension
    //Pour le Sphone l'appli conseillée est Bluetooth Terminal HC-05(OK aussi pour HC06)
    //Pour un moniteur de PC, 3 commentaires  sont à modifier dans LireVal()
     
    #include"TimerOne.h"
    #include <SoftwareSerial.h>  //Pour Bluetooth BT
    SoftwareSerial BT(10, 11); //  RX,TX respectivement vers le HC05/06 à 9600bps
    #define Nmax  6000   //en t/mn
    #define Dinjmax 20000 // en microseconds
    #define potN  A0  //Potard affichage Nt/mn sur A0
    #define potDinj A1  //Potard durée injection sur A1
    #define Inj1  3//Injecteur 1 sur D3( gate de l'IGBT)
    #define Led 13  //Celle de l'Arduino
     
    int N_aff = 0;  //Valeur 0/1023 lue du potard
    int Dinj_aff = 0; //Valeur 0/1023 lue du potard
    int long  unsigned  TotInj = 1;//Nb total d'injections
    int long  unsigned  Val = 0; // Nombre entré au clavier
    float N = 0;  //En t/mn pour calcul du cycle soit D720
    float Dinj = 0; //En µs durée d'injection
    float D720 = 0; //En ms, durée d'un cycle: 720°, 2 tours moteur
    int Mode = 0; //1pour Sphone, 0 pour potards
    //**************************************
    void  GameOver()
    { Serial.println("Fin de test, ou erreur de saisie, redemarrer avec le bouton de Reset sur l'Arduino");
      BT.println("Fin de test, ou erreur de saisie, redemarrer avec le bouton de Reset sur l'Arduino");
      while (1); //Attente infinie
    }
    //*****************************************
    void  Init()  //Résupère 3 nombres entrés au clavier
    { Mode = 1; // On est en mode Sphone
      Serial.println("****Essais injection****"); BT.println("****Essais injection****");
      Serial.println(); BT.println();
     
      Serial.println("Duree d'injection en microsecondes ( 1 -- 20 000)");
      BT.println("Duree d'injection en microsecondes "); BT.println("      1 -- 20 000");
      LireVal();// Lecture du clavier
      Serial.println(Val); BT.println(Val);
      if ((Val < 1) || (Val > 20000))GameOver(); //Erreur redemarrer
      Dinj = Val;
     
      Serial.println("Regime moteur 4 cylindres  N t/mn  ( 1000 -- 8 000)");
      BT.println("Regime moteur 4 cylindres  N t/mn "); BT.println("       1000 -- 8 000");
      LireVal();// Lecture du clavier
      Serial.println(Val); BT.println(Val);
      if ((Val < 1000) || (Val > 8000))GameOver(); //Erreur redemarrer
      D720 = 60000 / Val; //Durée du  cycle en ms
     
      Serial.println("Nombre total d'injections( 1 -- 10 000) ");
      BT.println("Nombre total d'injections "); BT.println("       1 -- 10 000");
      LireVal();// Lecture du clavier
      Serial.println(Val); BT.println(Val);
      if ((Val < 1) || (Val > 10000))GameOver(); //Erreur redemarrer
      TotInj = Val;
    }
    //*****************************************************
    void  isr_Fin_injection()
    { Timer1.stop();
      digitalWrite(Inj1, 1); //Couper l'injecteur
      digitalWrite(Led, 0);
    }
    //****************************************************
    void LireVal()
    //Attend une ligne de car terminée par CR ou LF et la convertit en entiers
    { char carLu; // Stock le car lu
      String  Ligne = ""; //Accumule les car reçus du clavier
     
      while (1)
      { //On en sortira par CR ou LF
        //   while (Serial.available() == 0); //Attendre un car  pour le moniteur
        while (BT.available() == 0); //Attendre un car
        //    carLu = Serial.read(); //Lit ce car pour le moniteur
        carLu = BT.read(); //Lit ce car
        delay(100);   //Indispensable
        if ((carLu == 13 ) || (carLu == 10)) break;//Sortir
        Ligne = Ligne + carLu; //cumuler
      }
      Val = Ligne.toInt(); // convertir en entier, en general c'est utile
      //  while (Serial.available() != 0)carLu = Serial.read(); //Purge pour le moniteur
      while (BT.available() != 0)carLu = BT.read(); //Purge
    }
    //***************************************************
    void setup()
    {
      Serial.begin(9600);  //Pour moniteur PC
      BT.begin(9600);  //Pour Sphone, Bluetooth
      Timer1.attachInterrupt(isr_Fin_injection); //Tmr1 deconnecte l'injecteur
      pinMode(Inj1, OUTPUT); //Gate de l'IGBT qui commande l'injecteur
      pinMode(Led, OUTPUT);
      if (analogRead(potN) > 900)Init(); //Mode Sphone, PotN était au maxi au demarrage
    }
    //****************************************************
    void loop()
    {
      digitalWrite(Inj1, 1); //par precaution
      if (Mode == 0) //Mode Potards, lire les valeurs dynamiques
      { N_aff = analogRead(potN);
        Dinj_aff = analogRead(potDinj);
        N = map(N_aff, 0, 1023, 0, Nmax);  // N de 0 à 8000t/mn
        Dinj = map(Dinj_aff, 0, 1023, 0, Dinjmax);  // Dinj de 0 à 20ms
        D720 = 60000 / N; //Un cycle en ms
      }
      else TotInj--; //Mode Sphone, decompter cette injection
      Timer1.initialize(Dinj);//Lancer TMR1 qui coupera l'injection
      digitalWrite(Inj1, 0); //Alimenter l'injecteur
      digitalWrite(Led, 1);
      delay(D720);// Attendre fin du cycle
      if (TotInj == 0)GameOver(); //Fin du test, jamais executé en mode Potard
    }
    Je l'ai modifié pour obtenir les même régimes que je peux avoir, et modifié l'état de sortie qui simule les impulsion car son code d'origine envoi des impulsions en positif (HIGH) pour commander un igbt, moi c'est l'inverse pour simuler le calculateur il me faut un LOW, et c'est là que je m'aperçois d'une chose...

    J'étais partie de mon programme qui "fonctionnait", la première version, sans obtenir de bon résultats comme énoncé plus haut, avec le code que vous avez lu.

    J'ai alors décidé d'inversé l'état de la broche de signal dans le programme de Jay M....et là miracle !

    Ça marche ! Sans coupure, je n'obtient pas encore la richesse désirée à pleine ouverture mais il se peut qu'il y ait un problème de débit de pompe ou autre, mais c'est clairement mieux qu'avant ! De toute façon sur route ouverte mon permis ne tient pas à tester la pleine ouverture...


    Donc déjà pour ça MILLES MERCI à vous deux qui avez pris de votre temps pour me sortir de ce casse tête.

    Je ne m'explique toujours pas le pourquoi du comment, mon programme me permet de rouler, je ne suis jamais tombé en panne, mais pourquoi sur le mien je suis sur HIGH en entrée pour capter le signal et sur LOW sur le votre ?

    ça veut dire (et j'ai honte sincèrement) que depuis le départ j'ouvrait les injecteurs quand le calculateur les fermés ? Mais mécaniquement ce n'est pas possible....j'ai inversé mes valeurs d'entrée sur mon programme de débutant et ça ne marche pas, j'ai beau chercher ce qui peu induire cette inversement d'état pour que ça fonctionne je ne me l'explique pas, j'aurais pas pu faire des milliers de km avec l'injection inversée....bref....


    Donc, puisque cela fonctionne, j'avais au départ prévu un lcd 1604 pour savoir 4 valeurs, le temps d'injection, le temps sup., le temps total corrigé et le % d'enrichissement.

    Voici mon code à l'époque, avant que je ne m'aperçoive que l'utilisation d'un lcd i2c prenne énormément de ressources, j'avais donc essayer de limiter le rafraîchissement de celui ci, en fouillant un peu j'avais lu que l'utilisation de comptage de temps dans le code "bouffé" les ressource pour le lcd. Et donc à chaque rafraichissement j'avais une belle coupure bien propre...


    Maintenant que les timers et les delays ont disparus avec votre super code, puis-je remettre le lcd en intégrant ce que j'ai mis dans ce code ou y a t'il un moyen plus propre et simple avec une librairie qui ne gênerait pas l'exécution du code ?

    Si ce n'est pas possible, comme vous le voyez j'ai prévu les sorties i2c sur mon circuit imprimé pour l'écran, peut on faire communiquer cette arduino avec un autre qui s'occuperait uniquement du lcd par ces broches ?

    Sinon je laisse tomber le lcd mais j'aime bien avoir pleins d'infos visuelles autre que les manomètres.

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
     
    //Coefficient d'enrichissement maxi
    #define Coeff_max 30 //% d'enrichissement
     
     
    ////////////////////////////////////////////////////////
     
    #include"TimerOne.h" //librairie timerone pour le décompte du temps
    #include <Wire.h> //librairie wire.h pour lcd
    #include <LiquidCrystal_I2C.h> //librairie pour ecran lcd
    #include <TimedAction.h> //librairie pour l'actualisation du lcd pendant un temps donné et non pendant la boucle de programme
    #include "Arduino.h" //librairie pour faire fonctionner la précédente
     
    LiquidCrystal_I2C lcd(0x27, 16, 2); //modèle d'écran lcd utilisé
     
    //Attribution des broches
    #define Signal_injecteurs 2 //La masse des injecteurs côté calculateur est branché sur la broche D2
    #define Commande_injecteurs 3 //Le transistor de commande des injecteurs est branché sur la broche D3
    #define led_int 13 //led intégré pour visualiser les impulsion du programme
    #define Broche_potentiometre A0 //Le potentiomètre est branché sur la broche A0
     
    /////////////////////////////////////////////////////////
    //Variables
    unsigned long debut_ouverture = 0; //Heure de début d'ouverture des injecteurs
    unsigned long T_inj = 0; //Temps d'injection brut
    float T_sup = 0; //Temps d'ouverture supplémentaire pour application coefficient d'enrichissement
    float Cor_inj; //variable de coefficient d'enrichissement
    int Pot;
    int Potentiometre = 0;
    unsigned long Fermeture_injecteurs = 0;
    unsigned long Fermeture_inj = 0;
     
    void Actualisation_lcd(); //routine d'actualisation de l'écran lcd
    TimedAction Act_lcd = TimedAction(500, Actualisation_lcd); //cacul du raffraichissement toutes les secondes
     
    /////////////////////////////////////////////////////////
     
     
    void setup() {
      pinMode(Signal_injecteurs, INPUT_PULLUP); //borne signal injecteur en entrée mode pullup
      pinMode(Commande_injecteurs, OUTPUT); //borne sortie injecteurs assigné en borne de sortie
      pinMode(led_int, OUTPUT); //borne led interne en sortie
      digitalWrite(led_int, LOW); //par défaut la led interne est éteinte
      digitalWrite(Commande_injecteurs, LOW); //par défaut la commande de sortie injecteur est éteinte
      Timer1.attachInterrupt(ISR_fermeture_injecteurs); //temps d'interruption pour la commande de fermeture des injecteurs
      lcd.init();  //blabla lcd
      lcd.backlight(); //blabla lcd
      lcd.clear();
      init();
    }
     
    /////////////////////////////////////////////////////////
     
    void loop() {
      { Potentiometre = analogRead(A0); //la broche du potentiometre est en mode analogique sur A0
        Pot = map(Potentiometre, 0, 1023, 0, Coeff_max); //on fait la map de la valeur Pot pour le calcul de COR_inj
        Cor_inj = float (Pot) / 100; //on caclcul la valeur de correction
      }
      {
        while (digitalRead(Signal_injecteurs) == HIGH); //on capte le signal du calculateur pour l'ouverture des injecteurs
        debut_ouverture = micros(); //on note l'heure d'ouverture
        digitalWrite(Commande_injecteurs, HIGH);  //on ouvre les injecteur
        digitalWrite(led_int, HIGH); //et en même temps on allume la led interne pour avoir un siganl visuel
        while (digitalRead(Signal_injecteurs) == LOW); //le calculateur ferme les injecteurs, on les garde ouvert
        Fermeture_inj = micros();
        T_inj = Fermeture_inj - debut_ouverture; //On calcule le temps d'injection ordonné par le calculateur
        T_sup = float(T_inj * Cor_inj); //On calcule le temps supplémentaire d'ouverture pour application de l'enrichissement
        if (Fermeture_injecteurs > debut_ouverture)
        { T_inj = (Fermeture_injecteurs - Fermeture_inj);
          T_sup = float(T_inj * Cor_inj);
        }
        }
        Act_lcd.check(); //on check si on doit actualiser le lcd
        Timer1.initialize(T_sup); //on lance le timer pour le temps supplémentaire d'injection caluculé plus haut
      }
     
     
     
    void ISR_fermeture_injecteurs() { //on appelle l'interruption des injecteur
      Timer1.stop();           // Fin du compte à rebours, le temps supplémentaire d'ouverture est appliqué
      Fermeture_injecteurs = micros();
      digitalWrite(Commande_injecteurs, LOW); //Fermeture des injecteurs
      digitalWrite(led_int, LOW); //et on éteint la led interne
     
    }
    void Actualisation_lcd() {
      //si on doit actualiser le lcd, on y écrit les valeurs suivantes
      lcd.setCursor(0, 0);
      lcd.print("Tinj=");
      lcd.print(float(T_inj) / 1000);
      lcd.setCursor(11, 0);
      lcd.print("T+");
      lcd.setCursor(12, 0);
      lcd.print((float(Fermeture_injecteurs - debut_ouverture)) / 1000);
      lcd.setCursor(0, 1);
      lcd.print("Tcor=");
      lcd.print((T_inj + T_sup) / 1000, 2);
      lcd.setCursor(10, 1);
      lcd.print("Cor%");
      lcd.setCursor(14, 1);
      lcd.print(Cor_inj * 100, 0);
    }
    ce code qui doit vous paraitre "sale" m'a pris des jours pour l'écrire afin d'avoir ce que je voulais sur le lcd.... même en me faisant un peu aidé au travail par mon collègue (pour les connections de l'i2c et la bibliothèque à prendre)


    Merci encore à vous, vous m'avez déjà sortis une belle épine du pied !!!!

    Pierre.

  4. #24
    Expert confirmé

    Homme Profil pro
    Directeur de projet
    Inscrit en
    Mai 2013
    Messages
    1 317
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Directeur de projet
    Secteur : Service public

    Informations forums :
    Inscription : Mai 2013
    Messages : 1 317
    Points : 4 124
    Points
    4 124
    Par défaut The End
    Bonjour,

    Si les impulsions sont inversées, il n'y a qu'en mode prolongement à 0 que cela pouvait fonctionner tout en ne servant à rien

    Le circuit montre une certaine désaffection pour tout condensateur de découplage. Pourtant un véhicule n'est pas un modèle de calme électrique...

    Pour ce qui est du LCD, il va falloir du doigté pour ne pas perturber le timing des injecteurs. J'aurais tendance à penser que c'est au début d'un ordre d'ouverture que c'est le moins risqué mais il va certainement être nécessaire de fractionner les actualisations. Et ce n'est pas gagné. Le problème ne serait pas du tout le même avec un multicœur comme un ESP32 où on porrait confier à un autre cœur l'affichage. Mais ceci est une autre histoire comme disait Kipling.

    P.S. Le transistor de sortie vers les injecteurs qui fait l'adaptation 12 V inverse la sortie !

    Bonne continuation.
    Ever tried. Ever failed. No matter. Try Again. Fail again. Fail better. (Samuel Beckett)

  5. #25
    Expert confirmé

    Homme Profil pro
    mad scientist :)
    Inscrit en
    Septembre 2019
    Messages
    2 685
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : mad scientist :)

    Informations forums :
    Inscription : Septembre 2019
    Messages : 2 685
    Points : 5 328
    Points
    5 328
    Par défaut
    d'accord avec @Guesset - un LCD peut créer des risques sur le timing, ça se tente cela dit

    Qu'est-ce que vous voudriez afficher?

  6. #26
    Candidat au Club
    Homme Profil pro
    Administrateur systèmes et réseaux
    Inscrit en
    Juin 2022
    Messages
    11
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 39
    Localisation : France, Corrèze (Limousin)

    Informations professionnelles :
    Activité : Administrateur systèmes et réseaux
    Secteur : Service public

    Informations forums :
    Inscription : Juin 2022
    Messages : 11
    Points : 3
    Points
    3
    Par défaut
    Oui j'avais vite compris en faisant mes tests que le lcd mettait un peu le bazar partout...

    J'aurai voulu au départ de mon projet, afficher le temps d'injection, le temps sup, le temps total d'inj et le % d'enrichissement.

    Il me faudrait au moins le pourcentage, le temps nominal et le temps total.

    Cela afin de savoir dans quelle map du calculateur je suis par rapport au temps d'injection, et le pourcentage et le temps total pour voir que le programme ajoute bien ce qu'on lui demande et savoir ou j'en suis de l'enrichissement.
    Il m'est impossible, avec le diag constructeur du véhicule d'avoir les temps d'injection en temps réels (avec un rafraichissement d'une seconde par exemple ou 1/2 seconde), l'interface datant des années 80 n'est pas assez rapide, donc je me disais que c'était l'occasion d'avoir une lecture fiable avec l'arduino.

    En roulage depuis une semaine sans soucis notable sur le véhicule, vraiment en pleine charge je manque un poil de richesse mais je ne pense pas que ça vienne du code, je pense plutôt à la pompe a essence que je reçois demain pour la remplacer et être sûr de son fonctionnement.


  7. #27
    Expert confirmé

    Homme Profil pro
    Directeur de projet
    Inscrit en
    Mai 2013
    Messages
    1 317
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Directeur de projet
    Secteur : Service public

    Informations forums :
    Inscription : Mai 2013
    Messages : 1 317
    Points : 4 124
    Points
    4 124
    Par défaut Ne le dites à personne
    Bonjour,

    Il y a une solution simple et peu élégante qui consiste à mettre un second MCU qui capte entrée et sortie et s'occupe de l'affichage. Un biprocesseur en fait .

    Un affichage réduit pourrait certainement être greffé (en espérant que la greffe prenne) sur le montage actuel en faisant bien attention

    Je ne suis pas très fier de cette proposition "biprocesseur" mais elle ne pose aucun problème.

    Salutations
    Ever tried. Ever failed. No matter. Try Again. Fail again. Fail better. (Samuel Beckett)

  8. #28
    Candidat au Club
    Homme Profil pro
    Administrateur systèmes et réseaux
    Inscrit en
    Juin 2022
    Messages
    11
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 39
    Localisation : France, Corrèze (Limousin)

    Informations professionnelles :
    Activité : Administrateur systèmes et réseaux
    Secteur : Service public

    Informations forums :
    Inscription : Juin 2022
    Messages : 11
    Points : 3
    Points
    3
    Par défaut
    Merci pour votre réponse, je vais partir là dessus, mon programme est déjà fait pour ce que je souhaite je n'ai plus qu'a faire le montage en parallèle d'un autre nano.

    Merci à tous pour votre gentillesse et vos programmes qui m'ont permis de faire ce que je voulais.

    Pierre.

+ Répondre à la discussion
Cette discussion est résolue.
Page 2 sur 2 PremièrePremière 12

Discussions similaires

  1. Lecture du temps de prise de vue photo
    Par labottine dans le forum C++
    Réponses: 2
    Dernier message: 18/05/2010, 18h04
  2. Création/lecture fichier TEMP, XP vs Vista/7
    Par Razor82 dans le forum Entrée/Sortie
    Réponses: 3
    Dernier message: 17/02/2010, 00h06
  3. lecture en temp réel sur spectre
    Par diaso dans le forum C++
    Réponses: 0
    Dernier message: 02/09/2009, 18h54
  4. Décalage dans le temps d'un signal
    Par matvig dans le forum Signal
    Réponses: 1
    Dernier message: 29/03/2009, 12h24
  5. Réponses: 1
    Dernier message: 08/12/2008, 14h10

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo