J'ai besoin d'aide pour accélérer l'écriture en série. J'ai trouvé quelques questions similaires à cela, mais rien qui traite du langage de traitement ou Java, donc j'espère que quelqu'un peut m'aider avec ce problème que j'ai.L'écriture rapide du port série sur Arduino à partir du traitement
modifier
Comme John indique ci-dessous, il apparaît de série est tout simplement pas assez rapide pour envoyer cette quantité de données à la vitesse que je veux. Est-ce que quelqu'un sait d'autres interfaces arduino qui sont disponibles?
modifier fin
J'utilise un arduino pour contrôler une grille de 400 LED RGB j'accroché vers le haut. Pour envoyer des commandes à l'Arduino, j'ai écrit un petit programme en traitement qui manipule un grand tableau qui représente les voyants. Je tente alors de mettre à jour la grille en envoyant 800 octets de données à l'arduino toutes les 20ms à 115200 bauds en série. Le code de traitement qui est appelé à chaque 20ms est:
noStroke();
int dataPos = 0; // position in LED data array
byte[] dataLedGrid = new byte[400*2]; // array for bytes to send
for(int j=0; j<LEDS_TALL; j++) {
for(int i=0; i<LEDS_WIDE; i++) {
int pos = j*20+i;
int r = ledGrid[LEDS_WIDE-i-1][LEDS_TALL-j-1][0], g = ledGrid[LEDS_WIDE-i-1][LEDS_TALL-j-1][1] ,b = ledGrid[LEDS_WIDE-i-1][LEDS_TALL-j-1][2];
int colorData = ((g & 0x1F) << 10) | ((b & 0x1F) << 5) | (r & 0x1F);
dataLedGrid[dataPos] = byte(colorData & 0x00FF);
dataLedGrid[dataPos+1] = byte(colorData & 0xFF00);
dataPos+=2;
// draw LED squares on gui
fill(ledGrid[i][j][0], ledGrid[i][j][1], ledGrid[i][j][2]);
rect(SIDE_PANEL_WIDTH+(LED_SQUARE_SIDE+LED_SQUARE_SPACING)*i+HORIZONTAL_MARGIN,
(LED_SQUARE_SIDE+LED_SQUARE_SPACING)*j+VERTICAL_MARGIN,
LED_SQUARE_SIDE, LED_SQUARE_SIDE);
}
}
myPort.write(dataLedGrid); // write to serial
Sur le arduino je un tableau 1D (affichage) qui représente la grille du côté arduino. Le code de boucle est:
void loop() {
unsigned int pos, c1, c2;
if (Serial.available() > 0) {
for(byte j=0; j<20; ++j) {
for(byte i=0; i<20; ++i) {
c1 = Serial.read();
c2 = Serial.read();
pos = i+20*j;
if(j % 2 != 0) // it's a square of leds created by a zigzaging line
pos = 20*(j+1)-i-1; // so I have to reverse every other line
Display[pos] = (unsigned int)(c1<<8 | c2);
}
}
show();
}
}
Maintenant le code lui-même fonctionne bien mais lorsque l'écriture série ralentit tout. Lorsque je cours le code de traitement sans l'écriture en série tout va bien et fonctionne à la vitesse prévue. Cependant, quand j'ajoute l'écriture en série, tout devient légèrement saccadé. Le processeur ne dépasse pas le maximum, donc je suppose que c'est la méthode serial.write que j'appelle. Que puis-je faire pour accélérer ce code ou supprimer le décalage de l'écriture en série?
Merci pour votre aide!
Wow, je dois de calculé que mal. Des idées de ce que je peux faire pour obtenir 800 octets à l'arduino toutes les 20 ms? – Anon
Juste à noter, les ports série RS-232 doivent passer environ 10 bits pour envoyer un seul octet en raison de la surcharge du protocole. Cet overhead est réellement inclus dans les maths de John ici. – caveman
@William, pas familier avec les interfaces disponibles, mais vous pouvez utiliser USB ou SPI. Vous avez besoin d'environ 320 kBaud de ce que je vois ici. – caveman