Arduino cesse d'envoyer des données sur le port série après une longue période de temps

Peut-être faire une réinitialisation logicielle de votre problème serait résolu.
J'ai couru le code suivant pour savoir si un logiciel de réinitialisation de se réinitialiser l'horloge et donc la millis() fonction:

void setup()
{
  Serial.begin(9600);
  Serial.println("Will start sending millis values in 5 seconds...");
  delay(5000);
}

void loop()
{
  Serial.println(String(millis()));

  if (Serial.available() > 0)
  {
    if (Serial.read() == '@')
    {
      Serial.println("Rebooting. . .");
      delay(100); //Give the computer time to receive the "Rebooting. . ." message, or it won't show up
      void (*reboot)(void) = 0; //Creating a function pointer to address 0 then calling it reboots the board.
      reboot();
    }
  }
}

Comme expliqué dans le code, de faire un logiciel de redémarrer il suffit de créer un pointeur de fonction à l'adresse 0 et de l'appeler.
J'ai, en effet, eu des résultats satisfaisants:

Will start sending clock values in 5 seconds...
5000
5000
5000
5001
5001
5001
5002
5002
5002
. . .
6804
Rebooting...
Will start sending millis value in 5 seconds...
5000
5000
5000
5001
5001
5001
5002
5002
5002
5003
5003
. . .

J'espère que cela résout votre problème 🙂

OriginalL'auteur Matheus Rocha

Il est possible que les plis autour de l'horloge.

previousclock = millis() peut se retrouver dans une haute valeur, juste avant de plier autour de. Vous pouvez étendre le test d'inclure le cas que (currentmilis < previousmillis) plus/moins certains facteur.

BTW Il utilisé ignasi du code source (à l'OP code source n'était pas readble sans inscription, et je ne veux pas de la régistration)

EDIT: j'ai copié le fragment ci-dessous à partir de wakkerbot, et modifié un peu. C'est juste pour
démontrer comment enveloppante pouvez obtenir votre last_action horodateurs coincé en haut d'un int interval (si la majoration de la valeur n'est pas un diviseur de int_max)
Vous pourriez probablement simplifier la ci-dessus/en-dessous de la logique un peu, puisque vous vous intéressez seulement à l'intérieur/à l'extérieur de l'intervalle de tests. La définition de type de Timbre doit bien sûr être adapté au type de millis() (unsigned long ?) et fakemillis() supprimés et les références à son remplacement par millis().

#include <stdio.h>

#define STAMP_INSIDE 0
#define STAMP_BELOW -1
#define STAMP_ABOVE 1
#define STAMP_BEYONDO -1

    /* Intentionally very small, for fast wraparound
    ** Intentionally signed to stress test the logig.
    */
typedef signed char Stamp;

    /* fake clock, returns incrementing value, but folds around
    */
Stamp fakemillis(void)
{
static Stamp ticker =0;
return ticker++;
}

/* Check if "test" is inside or above/below the interval {low,high}
** low and high may have been wrapped around zero (--> low > high)
** return
**      0 := "test" inside interval
**      1 := "test" below interval
**      -1 := "test" above interval (but wrapped)
** The two impossible cases return -2.
*/
static int check_interval(Stamp low, Stamp high, Stamp test)
{
switch (4 *(high >= low)
        +2 *(test >= low)
        +1 *(test > high)
        ) {
        case 0: return STAMP_INSIDE;    /* inside (wrapped) */
        case 1:                 /* outside (wrapped) */
                return ((Stamp)(low - test) < (Stamp)(test - high)) ? STAMP_BELOW : STAMP_ABOVE;
        case 2: break;      /* impossible */
        case 3: return STAMP_INSIDE;    /* inside (wrapped) */
        case 4:                 /* all below */
                return ((Stamp)(low - test) < (Stamp)(test - high)) ? STAMP_BELOW : STAMP_ABOVE;
        case 5: break;      /* impossible */
        case 6: return STAMP_INSIDE;    /* inside normal case */
        case 7:                 /* all above) */
                return ((Stamp)(low - test) < (Stamp)(test - high)) ? STAMP_BELOW : STAMP_ABOVE;
        }   
return STAMP_BEYONDO;
}   

    /* Get new clock value, test if it is inside interval {*old, *old+width)
    ** iff inside: return STAMP_INSIDE;
    ** iff above (or below) return STAMP_ABOVE or STAMP_BELOW
    ** and UPDATE *old
   */
static int test_or_set(Stamp *old, Stamp width)
{
Stamp tick;
int diff;
tick = fakemillis();

diff = check_interval( *old, *old+width, tick);
if (!diff) return 0;
*old = tick;
return diff;
}


int main(void) {
Stamp goodlast=0;
Stamp tick=0;
Stamp badlast=0;
int goodtest;
int badtest;
unsigned uu;

for (uu = 0; uu < 260; uu++) {
    tick= fakemillis();
    if (tick > badlast+10) { badlast=tick; badtest=1; } else {badtest =0;}
    goodtest = test_or_set ( &goodlast, 10);
    printf("%x:Tick=%x bad=%x, badtest=%d good=%x goodtest=%d\n"
    , uu, (unsigned) tick
    , (unsigned) badlast, badtest
    , (unsigned) goodlast, goodtest
    );
    }
return 0;
}

Si vous compilez et exécutez le programme ci-dessus sur un "normal" de l'ordinateur, vous pouvez voir l'badlast et badtest coincé. Qu'est ce qui se passe sur votre arduino, trop, à mon humble avis.

Mise à jour: définitivement débordement de tonneaux. (GIYF)
http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1200662708

Update2: non, mais les mauvaises pratiques de codage:

#define CMD_SET_SPEED "S"
...
/* Internal configuration */
if(buffer.substring(0,1)==CMD_SET_SPEED) {
  updateSpeed(buffer.substring(1));
  }

De la comparaison de deux chaînes de caractères ici. (ce peut être gérée comme prévu par le c++, mais en C, il est tout simplement faux. Je voudrais aussi suggérer le remplacement de la répétition if(...) {...} par un géant de l'instruction switch, qui permettrait au moins d'éviter d'appeler la fonction substr() à plusieurs reprises. (ou est-elle insérée?)

Mise à JOUR 20111211: ici est une synthèse inconscient comparer&ensemble de la fonction il a besoin d'un pointeur de la valeur à comparer et à régler, et la largeur de l'intervalle:

int test_and_set_if_beyond( unsigned long *pprev, unsigned long width )
{
unsigned long tick, low,high;
low = *pprev;
high = low+width;
tick = millis();

if (low < high) {
    if (tick >= low && tick < high ) return 0; /* normal case */
    }
else { /* interval is wrapped , clock could have wrapped */
    if (tick >= low || tick < high) return 0;
    }
*pprev = tick;
return 1;
}

Cette fonction est utilisée dans la boucle() l'article comme suit:

if (test_and_set_if_beyond ( &lightTimer, lightnessCheckPeriod)) {
    int newLightness = analogRead(brightnessPin);
    if(newLightness-lightness > LIGHT_TRESHOLD) {
      say(RESPONSE_FLASH);
    }
    lightness = newLightness;
  }
  if (test_and_set_if_beyond ( &pingTimer, pingTimerPeriod)) {
    say(RESPONSE_PING);
  }
  if (test_and_set_if_beyond ( &pingLEDTimer, pingTimerPeriod*2)) {
    digitalWrite(failPin, HIGH);
  }
  feed();

Enfin: à mon humble avis, la raison pour laquelle RESET ne fonctionne pas, c'est que pas toutes les variables globales sont initialisées dans le setup() de la fonction. Aussi: je pense que vous devriez vous débarrasser de la Chaîne des bidules (il n'y a GC dans le runtime ?) et l'utilisation de caractères ordinaires tampons à la place.

OriginalL'auteur wildplasser