Arduino En Série.print() optimisation

unsigned long current_millis_value = 0;
unsigned long previous_millis_value = 0;
unsigned long m = 0;
unsigned int seconds = 0;
unsigned int minutes = 0;
unsigned int hours = 0;

unsigned long clockTimeStart = 1800000; //30 Minutes
unsigned long currentClockTime;

void loop() {
    current_millis_value = millis();
    currentClockTime -= current_millis_value - previous_millis_value;
    previous_millis_value = current_millis_value;

    minutes = (currentClockTime / 1000 / 60);
    seconds = (currentClockTime / 1000) % 60;
    m = (currentClockTime % 100);

    Serial.print(minutes);
    Serial.print(":");
    Serial.print(seconds);
    Serial.print(":");
    Serial.println(m);
}

Je suis un écart dans le temps entre la série écrit de n'importe où à partir de 9 à 11 ms par ligne série écrite. Est-il un moyen d'optimiser la Serial.print() méthode pour autoriser l'écriture de plusieurs valeurs dans tous les types de temps et les valeurs de Chaîne?

Exemple (ce n'est pas valide, mais le long de la ligne de ce que je pense):

Serial.print(minutes + ":" + seconds + ":" + m);

Je sais que ce n'est pas le JavaScript, je travaille dans - juste à la recherche de possibilités d'optimisation dans le processus d'écriture. Je sais que le MOD peut être coûteux, mais juste en faisant la simple soustraction et de la rédaction de la valeur de currentClockTime me laisse avec un écart de temps de 6 à 7 ms.

Avez-vous chercher à la sortie sur un oscilloscope pour voir quand le fossé se produit? Qui pourrait aider à réduire le problème.

OriginalL'auteur Jeff | 2011-04-04

arduino c serial-port

4

L'arduino est un semi-java comme la concaténation de chaîne. Je n'ai aucune idée si cela va vous toute vitesse, mais il va concaténer le tout dans une chaîne de caractères avant de l'envoyer.
```
String package = "" + minutes;
package += ":"+seconds;
package += ":"+m;
Serial.print(package);
```
Si vous êtes en mesure de reconstituer la chaîne de l'autre côté, peut-être un meilleur plan d'action est d'utiliser Serial.Write et envoyer les données brutes, alors reconstituer la Chaîne sur le côté de réception. Cela permettrait de réduire la quantité de données que vous envoyez à chaque boucle de 5 à 10 octets à 3 ou 4 octets.

Je suis d'accord avec votre commentaire que la mémoire tampon est une solution de nettoyage. Mais le temps qu'il faut allouer de la mémoire tampon et le remplir avec de l'information qui prend plus de temps (1-2ms) de votre solution. Tandis que la votre n'est pas la solution parfaite pour mes besoins c'est un début. Merci pour l'aide.
Les avantages d'un tampon, c'est que vous ne devez allouer une fois, ainsi que pas besoin d'allouer au moment où vous l'utilisez. Je n'ai pas testé spécifiquement, mais c'est quelque chose que vous pourriez essayer.

OriginalL'auteur helloworld922
3

La Streaming bibliothèque doit faire ce que vous voulez:
```
Serial << minutes << ":" << seconds << ":" << m;
```
OriginalL'auteur John Y
2

Tout moyen de pré-tout convertir une chaîne de valeur, de sorte que vous pouvez écrire la totalité de la chaîne à la fois? Par exemple, utiliser quelque chose comme un snprintf() fonction d'écriture dans un pré-alloués char[], puis l'imprimer dans un appel à Serial.print()?

Ainsi, par exemple:
```
char buffer[32];
snprintf(buffer, 32, "%u : %u : %lu", minutes, seconds, m);
Serial.print(buffer);
```
--Jason

+1 pour une solution plus élégante 😛
L'inconvénient de l'utilisation de n'importe quelle variante de printf (), c'est que votre code taille augmentera ~1-2KB.

OriginalL'auteur Jason
0

J'ai trouvé la manière la plus simple de Série de l'impression d'une seule chaîne composée d'entiers et de vos mots (message):

dans scketch :
```
int w = 12;

Serial.Print ("my number is: ");

Serial.Print (w);

Serial.Println (" - which is to be used in calculation!"
```
RÉSULTAT:

Sur le moniteur de série, vous verrez (sur une seule LIGNE!!!!!!!!!!):

mon numéro est le: 12 - qui est utilisé dans le calcul!

OriginalL'auteur Vettel
0

La manière la plus rapide et la meilleure façon de faire la concaténation de chaîne en vertu de l'Arduino est,
- Utilisation de la classe String.
- Si vous avez vraiment besoin de la vitesse et/ou que vous souhaitez simplement pour éviter de créer de nouveaux en mémoire des chaînes de caractères avec chaque opération de concaténation, réserve de la mémoire nécessaire à l'avance avec la réserve (les).
- Tout d'abord, définir l'objet à une chaîne vide "".
- Ensuite, ajouter le besoin de caractères ou chaînes de caractères en invoquant la méthode concat() ou l'opérateur +=, en utilisant exactement une méthode concat() ou += opération par ligne de code. C'est pour éviter la création de Chaînes temporaires des objets.
- Par l'exécution de la réserve (les) à l'avance, la Chaîne de l'objet sera agissent comme un tampon de ligne.
En appliquant les lignes directrices ci-dessus, la concaténation des opérations sera effectué en place.

Noter que les réserves() doit être appelée avec la valeur la plus appropriée pour la ligne de capacité de la mémoire tampon, c'est à dire: nombre maximum de caractères que vous avez besoin avant que la Chaîne ne un realloc(), non compris le nul de terminaison de caractère '\0'.

Trois alternatives à suivre:

1) Voici un exemple de code,
```
//Declaration, outside setup() and loop()
String line;

//Inside setup()
//Use the appropriate value for reserve(), depending on on your actual usage.
line.reserve(10);

//Inside loop()
line = "";
line += minutes;
line += ":";
line += seconds;
line += ":";
line += m;
Serial.println(line);
```
2) Comme une alternative à l'appel de la réserve() lors de l'installation(), vous pouvez déclarer et initialiser la Chaîne avec un "modèle" ou factices de la chaîne qui a le choix (maximum) de longueur.

Voici un exemple de code pour cette alternative,
```
//Declaration, outside setup() and loop()
String line = "XXXX:YY:ZZ";

//No need to use reserve() inside setup()

//Inside loop()
line = "";
line += minutes;
line += ":";
line += seconds;
line += ":";
line += m;
Serial.println(line);
```
La première approche permet d'utiliser les réserves() avec un calculées dynamiquement longueur maximale de la valeur, tandis que la seconde approche un peu de nettoyant à lire le code lorsque vous avez un "modèle" ou fixes connus de la longueur de la chaîne que vous serez plus tard de la composition.

3) Si vous avez seulement besoin d'enregistrer les données dans le flux de sortie (généralement de Série), c'est le plus rapide et le plus compact de code, pas besoin de Corde ou de bibliothèques externes,
```
//No need to declare a String outside setup() and loop()
//No need to use reserve() inside setup()

//Inside loop()
Serial.print(minutes);
Serial.print(":");
Serial.print(seconds);
Serial.print(":");
Serial.println(m);
```
Remarque: la réponse par Jean Y fait exactement la même chose que mon dernier morceau de code, à l'exception de ses "plus simple" à lire le code (en supposant que vous vous sentez à l'aise avec l'opérateur <<, utilisé comme C++ streaming sucre syntaxique). Dans certains cas, cependant, en utilisant le Streaming bibliothèque de générer un peu plus lent, code.

L'inconvénient de l'utilisation de la Chaîne de la bibliothèque de l'Arduino, c'est que votre code taille augmentera ~1-2KB. En appliquant directement print()/println() de Série, vous pouvez éviter cette augmentation de la taille du code.

OriginalL'auteur jose.angel.jimenez

Vous devez vous connecter pour publier un commentaire.