Optimiser un code de commande série (Visca)

Si c'est à chaque fois la même chose : seul le 8eme octet change, alors ceci devrait simplifier :

uint8_t ViscaMsg[9] = { 0x81, 0x01, 0x04, 0x4D, 0x00, 0x00, 0x00, 0x00, 0xFF };

void ViscaBright(OSCMessage *_mes) {
  ViscaMsg[7] =  _mes->getArgInt32(0);
  Serial.write( ViscaMsg, sizeof(ViscaMsg) );
}

Super, merci beaucoup !!

J'essaierais demain la caméra en vrai, mais j'ai déjà optimiser mon code suivant ton conseil.

Voici le code arduino, si jamais vous voyez d'autres optimisations possibles je suis preneur !!

J'ai enlevé un grand nombre de fonctions car sinon le message n'était pas accepté par le forum (9500 caracteres max)

par avance, merci

renaud

#include <Ethernet.h>
#include <SPI.h>
#include <ArdOSC.h>
/************* Variables ****************/
byte mac[] = { 
  0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
byte ip[] = { 
  10, 0, 0, 10 };
int serverPort = 10000;
OSCServer server;
EthernetClient client;
uint8_t ViscaMsg[6] = {  
  0x81, 0x01, 0x04, 0x00, 0x00, 0xFF      };
uint8_t ViscaLongMsg[9] = {  
  0x81, 0x01, 0x04, 0x47, 0x00, 0x00, 0x00, 0x00, 0xFF            };
void setup()
{
  /************* Launch ethernet server  ****************/
  Ethernet.begin(mac, ip);
  server.begin(serverPort);  
  /************* Launch Serial Communication for visca commands ****************/
  Serial.begin(9600);
  /************* Add some osc messages ****************/
  server.addCallback("/visca.1/sw",&ViscaSw);
  server.addCallback("/visca/zoom/stop",&ViscaZoomStop);
  server.addCallback("/visca/zoom/standart",&ViscaZoomStandard);
  server.addCallback("/visca/zoom/variable",&ViscaZoomVariable);
  server.addCallback("/visca/zoom",&ViscaZoom);
  server.addCallback("/visca/zoom/digital/sw",&ViscaZoomDigitalSw);
  server.addCallback("/visca/zoom/digital/mode",&ViscaZoomDigitalMode);
  server.addCallback("/visca/zoom/digital/stop",&ViscaZoomDigitalStop);
  server.addCallback("/visca/zoom/digital/variable",&ViscaZoomDigitalVariable);
  server.addCallback("/visca/zoom/digital/variable",&ViscaZoomDigitalDirect);
  server.addCallback("/visca/focus/stop",&ViscaFocusStop);
  server.addCallback("/visca/focus/standart",&ViscaFocusStandard);
  server.addCallback("/visca/focus/variable",&ViscaFocusVariable);
}
void loop()
{ 
  /************* // Check OSC messages ****************/
  if(server.aviableCheck()>0)
  {
  }
}
/************* Power ****************/
void ViscaSw(OSCMessage *_mes) {
  int value = _mes->getArgInt32(0);
  if ( value == 1 ) {
    ViscaMsg[5] =  0x02;
  } 
  else {
    ViscaMsg[5] =  0x03;
  } 
  Serial.write( ViscaMsg, sizeof(ViscaMsg) );
}
/************* Zoom Stop ****************/
void ViscaZoomStop(OSCMessage *_mes) {
  ViscaMsg[4] =  0x07;
  Serial.write( ViscaMsg, sizeof(ViscaMsg) );

}
/************* Zoom Standard ****************/
void ViscaZoomStandard(OSCMessage *_mes) {
  ViscaMsg[4] =  0x07;
  int strSize=_mes->getArgStringSize(0);
  char value[strSize]; //string memory allocation
  _mes->getArgString(0,value);  
  if ( value == "tele" ) {
    ViscaMsg[5] =  0x02;
  }
  if ( value == "wide" ) {
    ViscaMsg[5] =  0x03;
  }
  Serial.write( ViscaMsg, sizeof(ViscaMsg) );
}
/************* Zoom Variable ****************/
void ViscaZoomVariable(OSCMessage *_mes) {
  ViscaMsg[4] =  0x07;
  int strSize=_mes->getArgStringSize(0);
  char value[strSize]; //string memory allocation
  int value2 = _mes->getArgInt32(1);
  _mes->getArgString(0,value);
  if (value == "tele") {
    if (value2 == 0) {
      ViscaMsg[5] =  0x20;
    }
    if (value2 == 1) {
      ViscaMsg[5] =  0x21;
    }
    if (value2 == 2) {
      ViscaMsg[5] =  0x22;
    }
    if (value2 == 3) {
      ViscaMsg[5] =  0x23;
    }
    if (value2 == 4) {
      ViscaMsg[5] =  0x24;
    }
    if (value2 == 5) {
      ViscaMsg[5] =  0x25;
    }
    if (value2 == 6) {
      ViscaMsg[5] =  0x25;
    }
    if (value2 == 7) {
      ViscaMsg[5] =  0x27;
    }
  }
  if (value == "wide") {
    if (value2 == 0) {
      ViscaMsg[5] =  0x30;
    }
    if (value2 == 1) {
      ViscaMsg[5] =  0x31;
    }
    if (value2 == 2) {
      ViscaMsg[5] =  0x32;
    }
    if (value2 == 3) {
      ViscaMsg[5] =  0x33;
    }
    if (value2 == 4) {
      ViscaMsg[5] =  0x34;
    }
    if (value2 == 5) {
      ViscaMsg[5] =  0x35;
    }
    if (value2 == 6) {
      ViscaMsg[5] =  0x35;
    }
    if (value2 == 7) {
      ViscaMsg[5] =  0x37;
    }
  }
  Serial.write( ViscaMsg, sizeof(ViscaMsg) );
}
/************* Zoom Direct ****************/
void ViscaZoom(OSCMessage *_mes) {
  int value = _mes->getArgInt32(0);
  int valuea = value % 16 ; 
  int valueb = value >> 4 % 16  ; 
  int valuec = value >> 8 % 16 ; 
  int valued = value >> 12 % 16 ; 
  ViscaLongMsg[4] =  0x47;
  ViscaLongMsg[5] =  valued;
  ViscaLongMsg[6] =  valuec;
  ViscaLongMsg[7] =  valueb;
  ViscaLongMsg[8] =  valuea;
  Serial.write( ViscaLongMsg, sizeof(ViscaLongMsg) );
}
/************* Digital Zoom Switch ****************/
void ViscaZoomDigitalSw(OSCMessage *_mes) {
  ViscaMsg[4] =  0x06;
  int value = _mes->getArgInt32(0);
  if ( value == 1 ) {
    ViscaMsg[5] =  0x02;
  } 
  else {
    ViscaMsg[5] =  0x03;
  } 
  Serial.write( ViscaMsg, sizeof(ViscaMsg) );
}
/************* Digital Zoom Mode ****************/
void ViscaZoomDigitalMode(OSCMessage *_mes) {
  ViscaMsg[4] =  0x36;
  int strSize=_mes->getArgStringSize(0);
  char value[strSize]; //string memory allocation
  _mes->getArgString(0,value);  
  if ( value == "combine" ) {
    ViscaMsg[5] =  0x00;
  }
  if ( value == "separate" ) {
    ViscaMsg[5] =  0x01;
  }
  Serial.write( ViscaMsg, sizeof(ViscaMsg) );
}
/************* Digital Zoom Stop ****************/
void ViscaZoomDigitalStop(OSCMessage *_mes) {
  ViscaMsg[4] =  0x06;
  ViscaMsg[5] =  0x00;
  Serial.write( ViscaMsg, sizeof(ViscaMsg) );
}
/************* Digital Zoom Variable ****************/
void ViscaZoomDigitalVariable(OSCMessage *_mes) {
  ViscaMsg[4] =  0x07;
  int strSize=_mes->getArgStringSize(0);
  char value[strSize]; //string memory allocation
  int value2 = _mes->getArgInt32(1);
  _mes->getArgString(0,value);
  if (value == "tele") {
    if (value2 == 0) {
      ViscaMsg[5] =  0x20;
    }
    if (value2 == 1) {
      ViscaMsg[5] =  0x21;
    }
    if (value2 == 2) {
      ViscaMsg[5] =  0x22;
    }
    if (value2 == 3) {
      ViscaMsg[5] =  0x23;
    }
    if (value2 == 4) {
      ViscaMsg[5] =  0x24;
    }
    if (value2 == 5) {
      ViscaMsg[5] =  0x25;
    }
    if (value2 == 6) {
      ViscaMsg[5] =  0x25;
    }
    if (value2 == 7) {
      ViscaMsg[5] =  0x27;
    }
  }
  if (value == "wide") {
    if (value2 == 0) {
      ViscaMsg[5] =  0x30;
    }
    if (value2 == 1) {
      ViscaMsg[5] =  0x31;
    }
    if (value2 == 2) {
      ViscaMsg[5] =  0x32;
    }
    if (value2 == 3) {
      ViscaMsg[5] =  0x33;
    }
    if (value2 == 4) {
      ViscaMsg[5] =  0x34;
    }
    if (value2 == 5) {
      ViscaMsg[5] =  0x35;
    }
    if (value2 == 6) {
      ViscaMsg[5] =  0x35;
    }
    if (value2 == 7) {
      ViscaMsg[5] =  0x37;
    }
  }
  Serial.write( ViscaMsg, sizeof(ViscaMsg) );
} 
/************* Digital Zoom Direct ****************/
void ViscaZoomDigitalDirect(OSCMessage *_mes) {
  int value = _mes->getArgInt32(0);
  int valuea = value % 16 ; 
  int valueb = value >> 4 % 16  ; 
  int valuec = value >> 8 % 16 ; 
  int valued = value >> 12 % 16 ; 
  ViscaLongMsg[4] =  0x47;
  ViscaLongMsg[5] =  valued;
  ViscaLongMsg[6] =  valuec;
  ViscaLongMsg[7] =  valueb;
  ViscaLongMsg[8] =  valuea;
  Serial.write( ViscaLongMsg, sizeof(ViscaLongMsg) );
}
/************* Focus Stop ****************/
void ViscaFocusStop(OSCMessage *_mes) {
  ViscaMsg[4] =  0x08;
  ViscaMsg[5] =  0x00;
  Serial.write( ViscaMsg, sizeof(ViscaMsg) );
}
/************* Focus Standard ****************/
void ViscaFocusStandard(OSCMessage *_mes) {
  ViscaMsg[4] =  0x08;
  int strSize=_mes->getArgStringSize(0);
  char value[strSize]; //string memory allocation
  _mes->getArgString(0,value);
  if (value == "far") {
    ViscaMsg[5] =  0x02;

  }
  if (value == "near") {
    ViscaMsg[5] =  0x03;
  }
  Serial.write( ViscaMsg, sizeof(ViscaMsg) );
}
/************* Focus Variable ****************/
void ViscaFocusVariable(OSCMessage *_mes) {
  ViscaMsg[4] =  0x08;
  int strSize=_mes->getArgStringSize(0);
  char value[strSize]; //string memory allocation
  int value2 = _mes->getArgInt32(1);
  _mes->getArgString(0,value);
  if (value == "far") {
    if (value2 == 0) {
      ViscaMsg[5] =  0x20;
    }
    if (value2 == 1) {
      ViscaMsg[5] =  0x21;
    }
    if (value2 == 2) {
      ViscaMsg[5] =  0x22;
    }
    if (value2 == 3) {
      ViscaMsg[5] =  0x23;
    }
    if (value2 == 4) {
      ViscaMsg[5] =  0x24;
    }
    if (value2 == 5) {
      ViscaMsg[5] =  0x25;
    }
    if (value2 == 6) {
      ViscaMsg[5] =  0x25;
    }
    if (value2 == 7) {
      ViscaMsg[5] =  0x27;
    }
  }
  if (value == "near") {
    if (value2 == 0) {
      ViscaMsg[5] =  0x30;
    }
    if (value2 == 1) {
      ViscaMsg[5] =  0x31;
    }
    if (value2 == 2) {
      ViscaMsg[5] =  0x32;
    }
    if (value2 == 3) {
      ViscaMsg[5] =  0x33;
    }
    if (value2 == 4) {
      ViscaMsg[5] =  0x34;
    }
    if (value2 == 5) {
      ViscaMsg[5] =  0x35;
    }
    if (value2 == 6) {
      ViscaMsg[5] =  0x35;
    }
    if (value2 == 7) {
      ViscaMsg[5] =  0x37;
    }
  }
  Serial.write( ViscaMsg, sizeof(ViscaMsg) );
}

reno-:
J'essaierais demain la caméra en vrai, mais j'ai déjà optimiser mon code suivant ton conseil.

bonjour
Juste par curiosité , c'est pour gerer une camera/APN par ethernet ?

Juste par curiosité , c'est pour gerer une camera/APN par ethernet ?

Cela permet de contrôler ma camera sony à l'aide du protocole visca via ethernet.
L'arduino recoit des messages OSC, et à chaque message OSC est associé une commande série. Puis les messages série sont acheminés via zigbee.

Cela permet d'avoir l'arduino à portée de zigbee de la caméra, puis de se connecter via ordinateur, ipad ou iphone ou n'importe quel logiciel gérant l'osc et de piloter la caméra.

Bonjour,

Dans l'exemple de code que tu donnes je vois toujours les mêmes lignes à une modification prés qui dépend de "value".

Voila ce que je ferai personnellement :

/************* Bright ****************/
void ViscaBright(OSCMessage *_mes) {
  int value = _mes->getArgInt32(0);
  if(value >= 0 && value <= 8) {
    Serial.write(0x81);
    Serial.write(0x01);
    Serial.write(0x04);
    Serial.write(0x4D);
    Serial.write((uint8_t) 0);
    Serial.write((uint8_t) 0);
    Serial.write((uint8_t) 0);
    Serial.write((uint8_t) value);
    Serial.write(0xFF); 
  }
}

Reni-

Attention je vois un problème.
Dans la fonction ViscaSw() tu met à jour la valeur ViscaMsg[5];
Puis dans ViscaZoomStop() tu change la ViscaMsg[4];

La variable ViscaMsg est un tableau en variable globale qui n'est initialisé aux valeurs { 0x81, 0x01, 0x04, 0x00, 0x00, 0xFF } QU'UNE SEULE FOIS

Donc les changements fait par une ou l'autre fonction sont conservés !

Il faut que tu identifies les parties variables du message et systématiquement les mettre aux bonnes valeurs car sinon tu va avoir des problèmes.

Merci pour l'avertissement Barbudor, j'ai voulu être économe, mais il est vrai qu'il faut que je redonne la bonne valeur pour chaque variable qui est changée.
Je vais faire ca …

Merci pour le conseil d'optimisation skywodd, je vais également le suivre.

Mais j'ai en fait un problème, le message ViscaMsg n'arrive pas à destination. C'est à dire qu'il n'est pas envoyé sur le port série. J'ai donc déconnecté ma caméra et mis le serial monitor, et rien ne sort. Alors que quand j'envoie par exemple le code suivant, j'ai une sorte de [y] avec des accents, mais je vois que quelque chose se passe…

   Serial.write(0x81);
    Serial.write(0x01);
    Serial.write(0x04);
    Serial.write(0x4D);

Du coup, je me suis dit tiens… je vais changer de carte pour voir. Je change ma uno pour une leonardo et la carrément le ViscaMsg me donne des erreurs de compilation

osc_visca.cpp: In function 'void ViscaZoomStop(OSCMessage*)':
osc_visca:128: error: no matching function for call to 'Serial_::write(uint8_t [6], unsigned int)'
/Applications/Arduino.app/Contents/Resources/Java/hardware/arduino/cores/arduino/USBAPI.h:41: note: candidates are: virtual size_t Serial_::write(uint8_t)

Trois questions du coup :
#1 : Est-ce que le ViscaMsg est mal formaté?
#2 : Est-ce que le serial.write n'est pris en compte que par certaines cartes? Une autre solution?
#3 : comment monitorer la sortie, afin de débugger la chose. J'ai essayé de remplacer serial.write par serial.print mais ca veux pas… erreur suivante :

osc_visca.cpp: In function 'void ViscaZoomStop(OSCMessage*)':
osc_visca:129: error: call of overloaded 'print(uint8_t [6], unsigned int)' is ambiguous
/Applications/Arduino.app/Contents/Resources/Java/hardware/arduino/cores/arduino/Print.h:56: note: candidates are: size_t Print::print(unsigned char, int)
/Applications/Arduino.app/Contents/Resources/Java/hardware/arduino/cores/arduino/Print.h:57: note: size_t Print::print(int, int)
/Applications/Arduino.app/Contents/Resources/Java/hardware/arduino/cores/arduino/Print.h:58: note: size_t Print::print(unsigned int, int)
/Applications/Arduino.app/Contents/Resources/Java/hardware/arduino/cores/arduino/Print.h:59: note: size_t Print::print(long int, int)
/Applications/Arduino.app/Contents/Resources/Java/hardware/arduino/cores/arduino/Print.h:60: note: size_t Print::print(long unsigned int, int)

je tourne en rond et ne sais décidement pas par quel bout prendre la chose.

Quelle version de l'IDE ?

Attention pour léonardo, la v1.0.2 est indispensable a moins d'avoir patcher la v1.0.1 (erreurs dans pins_arduino.h)

Je viens d'essayer, et ca passe très bien que ce soit en UNO ou en Leonardo (je n'ai repris que mes 5 lignes du 1er post).

Mais je vois quelque chose d'incohérent dans les messages d'erreurs que tu donne :

Une fois une erreur sur un appel de Serial.write( uint8_t * , int )

osc_visca:128: error: no matching function for call to 'Serial_::write(uint8_t [6], unsigned int)'
/Applications/Arduino.app/Contents/Resources/Java/hardware/arduino/cores/arduino/USBAPI.h:41: note: candidates are: virtual size_t Serial_::write(uint8_t)

Et une autre à propos de Serial.print

osc_visca:129: error: call of overloaded 'print(uint8_t [6], unsigned int)' is ambiguous

Le 2eme cas est clairement faux car il faut utiliser write() et non pas print.
Et dans le 1er, pourquoi Serial_ au lieu de Serial ?

La fonction exacte à utiliser est (telle que décrite dans Print.h) :

size_t write(const uint8_t *buffer, size_t size);

Bon, c'est sur qu'avec la version 1.03, plus d'erreur avec la leonardo… donc écartons ce faux problème.

Je n'arrive pas à comprendre pourquoi, mais la camera ne recoit rien lorsque je lui parle avec le ViscaMsg…

OK… J'ai compris comment monitorer simplement la sortie. Avec Max et l'objet serial ca roule…

DOnc tout ca pour m'apercevoir que lorsque tout le code est chargé, cela ne fonctionne pas, mais avec une plus petite partie cela fonctionne… Donc cela est peut-être du à la librairie Ardosc que j'utilise.

Donc en épurant un peu afin de comprendre ce qui se passe, j'ai extrait juste le début du code.

Et la miracle ca marche !!

enfin presque, car les messages /zoom/stop et /zoom/standart ne répondent pas… rien, que chi......

Une idée?

En tout cas je continue…

un grand merci

#include <Ethernet.h>
#include <SPI.h>
#include <ArdOSC.h>
/************* Variables ****************/
byte mac[] = { 
  0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
byte ip[] = { 
  192, 168, 0, 10 };
int serverPort = 10000;
OSCServer server;
EthernetClient client;
uint8_t ViscaMsg[6] = {  
  0x81, 0x01, 0x04, 0x00, 0x00, 0xFF      };
uint8_t ViscaLongMsg[9] = {  
  0x81, 0x01, 0x04, 0x47, 0x00, 0x00, 0x00, 0x00, 0xFF            };
void setup()
{ 
  /************* Launch Serial Communication for visca commands ****************/
  Serial.begin(9600);
  /************* Launch ethernet server  ****************/
  Ethernet.begin(mac, ip);
  server.begin(serverPort);  
  /************* Add some osc messages ****************/
  server.addCallback("/visca/AddressSet",&ViscaAddressSet);
  server.addCallback("/visca/ifclear",&ViscaIfClear);
  server.addCallback("/visca/cancel",&ViscaCancel);
  server.addCallback("/visca.1/sw",&ViscaSw);
  server.addCallback("/visca.1/zoom/stop",&ViscaZoomStop);
  server.addCallback("/visca.1/zoom/standart",&ViscaZoomStandard);
}
void loop()
{ 
  /************* // Check OSC messages ****************/
  int result = server.aviableCheck();
  
  if(result>0){
  }
}
/************* ViscaAddressSet ****************/
void ViscaAddressSet(OSCMessage *_mes) {
  Serial.write(0x88);
  Serial.write(0x30);
  Serial.write(0x01);
  Serial.write(0xFF); 
}
/************* IfClear ****************/
void ViscaIfClear(OSCMessage *_mes) {
  Serial.write(0x88);
  Serial.write(0x01);
  Serial.write((uint8_t) 0);
  Serial.write(0x01);
  Serial.write(0xFF); 
}
/************* Cancel ****************/
void ViscaCancel(OSCMessage *_mes) {
  /* Buffer 1 */
  Serial.write(0x81);
  Serial.write(0x21);
  Serial.write(0xFF); 
  /* Buffer 2 */
  delay(200);
  Serial.write(0x81);
  Serial.write(0x22);
  Serial.write(0xFF); 
}
/************* Power ****************/
void ViscaSw(OSCMessage *_mes) {
  int value = _mes->getArgInt32(0);
  if ( value == 1 ) {
    ViscaMsg[3] =  0x00;
    ViscaMsg[4] =  0x02;
  } 
  else {
    ViscaMsg[4] =  0x03;
  } 
  Serial.write( ViscaMsg, sizeof(ViscaMsg) );
}
/************* Zoom Stop ****************/
void ViscaZoomStop(OSCMessage *_mes) {
  ViscaMsg[3] =  0x07;
  Serial.write( ViscaMsg, sizeof(ViscaMsg) );
}
/************* Zoom Standard ****************/
void ViscaZoomStandard(OSCMessage *_mes) {
  ViscaMsg[3] =  0x07;
  int strSize=_mes->getArgStringSize(0);
  char value[strSize]; //string memory allocation
  _mes->getArgString(0,value);  
  if ( value == "tele" ) {
    ViscaMsg[4] =  0x02;
  }
  if ( value == "wide" ) {
    ViscaMsg[4] =  0x03;
  }
  Serial.write( ViscaMsg, sizeof(ViscaMsg) );
}

Me revoilà, avec mon projet corrigé. Il y avait plein de faute d'inattention…
Le nombre de callback osc dans le setup est également problématique, j'ai donc supprimé un certain nombre de fonctions qui ne m'étaient pas primordiales et tout passe dans une Uno. Sinon j'étais obligé de passer par une Mega, mais je souhaite ce projet portable sur une Uno.
Donc pour mémoire, avec la librairie OSC ArdOSC, attention au nombre de callback dans le setup… la Uno a ses limites…
Sinon j'avais également un problème avec les comparaisons de char, j'ai donc utilisé la librarie string qui me permet d'utiliser la fonction [memcmp].
Voila donc mon code, qui reste à optimiser vu les redondances, et il reste également du travail sur le retour d'information…
mais je ne lache pas le morceau et reviendrait ici poster les mises à jour.

Voici le code Fonctionnel actuel :

#include <Ethernet.h>
#include <SPI.h>
#include <ArdOSC.h>
#include <string.h>
/************* Variables ****************/
byte mac[] = { 
  0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
byte ip[] = { 
  10, 0, 0, 10 };
int serverPort = 10000;
int incomingByte = 0;   // for incoming serial data
OSCMessage global_mes;
int destPort = 12000;
OSCServer server;
OSCClient client;
byte destIp[]  = { 
  10, 0, 0, 4 };
uint8_t ViscaMsg[6] = {  
  0x81, 0x01, 0x04, 0x00, 0x00, 0xFF      };
uint8_t ViscaLongMsg[9] = {  
  0x81, 0x01, 0x04, 0x47, 0x00, 0x00, 0x00, 0x00, 0xFF            };
uint8_t ViscaMemMsg[7] = {  
  0x81, 0x01, 0x04, 0x47, 0x00, 0x00, 0xFF            };
void setup()
{
  Ethernet.begin(mac, ip);
  server.begin(serverPort);  
  Serial.begin(9600);
  server.addCallback("/visca/AddressSet",&ViscaAddressSet);
  server.addCallback("/visca/ifclear",&ViscaIfClear);
  server.addCallback("/visca/cancel",&ViscaCancel);
  server.addCallback("/visca.1/sw",&ViscaSw);
  server.addCallback("/visca.1/zoom/stop",&ViscaZoomStop);
  server.addCallback("/visca.1/zoom/standart",&ViscaZoomStandard);
  server.addCallback("/visca.1/zoom/variable/wide",&ViscaZoomVariableWide);
  server.addCallback("/visca.1/zoom/variable/tele",&ViscaZoomVariableTele);
  server.addCallback("/visca.1/zoom",&ViscaZoom);
  server.addCallback("/visca.1/focus/stop",&ViscaFocusStop);
  server.addCallback("/visca.1/focus/standart",&ViscaFocusStandard);
  server.addCallback("/visca.1/focus/variable/far",&ViscaFocusVariableFar);
  server.addCallback("/visca.1/focus/variable/near",&ViscaFocusVariableNear);
  server.addCallback("/visca.1/focus",&ViscaFocus);
  server.addCallback("/visca.1/focus/mode",&ViscaFocusMode);
  server.addCallback("/visca.1/focus/auto/trigger",&ViscaFocusTrigger);
  server.addCallback("/visca.1/focus/infinity",&ViscaFocusInfinity);
  server.addCallback("/visca.1/focus/nearlimit",&ViscaFocusNearLimit);
  server.addCallback("/visca.1/focus/auto/sensitivity",&ViscaFocusAFSens);
  server.addCallback("/visca.1/focus/auto/mode",&ViscaFocusAFMode);
  server.addCallback("/visca.1/ir/correction",&ViscaIRCorrection);
  server.addCallback("/visca.1/init/internal",&ViscaInit);
  server.addCallback("/visca.1/whitebalance",&ViscaWB);
  server.addCallback("/visca.1/mode",&ViscaExposure);
  server.addCallback("/visca.1/auto/response",&ViscaAutoResponse);
  server.addCallback("/visca.1/compensation/sw",&ViscaExpComp);
  server.addCallback("/visca.1/compensation/level",&ViscaExpCompDirect);
  server.addCallback("/visca.1/slowshutter",&ViscaSlowShutter);
  server.addCallback("/visca.1/shutter",&ViscaShutter);
  server.addCallback("/visca.1/iris",&ViscaIris);
  server.addCallback("/visca.1/gain",&ViscaGain);
  server.addCallback("/visca.1/ir",&ViscaIR);
  server.addCallback("/visca.1/backlight",&ViscaBackLight);
  server.addCallback("/visca.1/reverse",&ViscaReverse);
  server.addCallback("/visca.1/flip",&ViscaFlip);
  server.addCallback("/visca.1/fx",&ViscaFX);
  server.addCallback("/visca.1/freeze",&ViscaFreeze);
  server.addCallback("/visca.1/stabilizer",&ViscaStab);
  server.addCallback("/visca.1/hs",&ViscaHS);
  server.addCallback("/visca.1/hr",&ViscaHR);
  server.addCallback("/visca.1/nr",&ViscaNR);
  server.addCallback("/visca.1/wd",&ViscaWD);
  server.addCallback("/visca.1/gamma",&ViscaGamma);
  server.addCallback("/visca.1/aperture",&ViscaAperture);
  server.addCallback("/visca.1/widedynamic",&ViscaWD);
  server.addCallback("/visca.1/memory/reset",&ViscaMemReset);
  server.addCallback("/visca.1/memory/set",&ViscaMemSet);
  server.addCallback("/visca.1/memory/recall",&ViscaMemRecall);
  server.addCallback("/visca.1/chromasupress",&ViscaChromaSuppress);
}
void loop()
{ 
  int result = server.aviableCheck();
  if(result>0) {
  }
  /************* // Check Serial messages for loopback ****************/
  if (Serial.available() > 0) {
    // read the incoming byte:
    incomingByte = Serial.read();
    global_mes.setAddress(destIp,destPort);
    global_mes.beginMessage("/visca/from");
    global_mes.addArgInt32(incomingByte);
    client.send(&global_mes);
    global_mes.flush(); //object data clear
  }
}
/************* ViscaAddressSet ****************/
void ViscaAddressSet(OSCMessage *_mes) {
  Serial.write(0x88);
  Serial.write(0x30);
  Serial.write(0x01);
  Serial.write(0xFF); 
}
/************* IfClear ****************/
void ViscaIfClear(OSCMessage *_mes) {
  Serial.write(0x88);
  Serial.write(0x01);
  Serial.write((uint8_t) 0);
  Serial.write(0x01);
  Serial.write(0xFF); 
}
/************* Cancel ****************/
void ViscaCancel(OSCMessage *_mes) {
  /* Buffer 1 */
  Serial.write(0x81);
  Serial.write(0x21);
  Serial.write(0xFF); 
  /* Buffer 2 */
  delay(200);
  Serial.write(0x81);
  Serial.write(0x22);
  Serial.write(0xFF); 
}
/************* Power ****************/
void ViscaSw(OSCMessage *_mes) {
  int value = _mes->getArgInt32(0);
  if ( value == 1 ) {
    ViscaMsg[4] =  0x02;
  } 
  else {
    ViscaMsg[4] =  0x03;
  } 
  Serial.write( ViscaMsg, sizeof(ViscaMsg) );
}
/************* Zoom Stop ****************/
void ViscaZoomStop(OSCMessage *_mes) {
  ViscaMsg[3] =  0x07;
  ViscaMsg[4] = ((uint8_t) 0);
  Serial.write( ViscaMsg, sizeof(ViscaMsg) );

}
/************* Zoom Standard ****************/
void ViscaZoomStandard(OSCMessage *_mes) {
  ViscaMsg[3] =  0x07;
  int strSize=_mes->getArgStringSize(0);
  char value[strSize]; //string memory allocation
  _mes->getArgString(0,value);  
  if ( memcmp(value,"tele",4) == 0) {
    ViscaMsg[4] =  0x02;
  }
  if ( memcmp(value,"wide",4) == 0) {
    ViscaMsg[4] =  0x03;
  }
  Serial.write( ViscaMsg, sizeof(ViscaMsg) );
}
/************* Zoom Variable Tele ****************/
void ViscaZoomVariableTele(OSCMessage *_mes) {
  ViscaMsg[3] =  0x07;
  int value2 = _mes->getArgInt32(0);
    if (value2 == 0) {
      ViscaMsg[4] =  0x20;
    }
    if (value2 == 1) {
      ViscaMsg[4] =  0x21;
    }
    if (value2 == 2) {
      ViscaMsg[4] =  0x22;
    }
    if (value2 == 3) {
      ViscaMsg[4] =  0x23;
    }
    if (value2 == 4) {
      ViscaMsg[4] =  0x24;
    }
    if (value2 == 5) {
      ViscaMsg[4] =  0x25;
    }
    if (value2 == 6) {
      ViscaMsg[4] =  0x26;
    }
    if (value2 == 7) {
      ViscaMsg[4] =  0x27;
    }
  Serial.write( ViscaMsg, sizeof(ViscaMsg) );
  }
/************* Zoom Direct ****************/
void ViscaZoom(OSCMessage *_mes) {
  int value = _mes->getArgInt32(0);
  int valuea = value % 16; 
  int valuebZ = value >> 4; 
  int valuecZ = value >> 8; 
  int valuedZ = value >> 12; 
  int valueb = valuebZ % 16  ; 
  int valuec = valuecZ % 16 ; 
  int valued = valuedZ % 16 ; 
  ViscaLongMsg[3] =  0x47;
  ViscaLongMsg[4] =  valued;
  ViscaLongMsg[5] =  valuec;
  ViscaLongMsg[6] =  valueb;
  ViscaLongMsg[7] =  valuea;
  Serial.write( ViscaLongMsg, sizeof(ViscaLongMsg) );
}
/************* Focus Standard ****************/
void ViscaFocusStandard(OSCMessage *_mes) {
  ViscaMsg[3] =  0x08;
  int strSize=_mes->getArgStringSize(0);
  char value[strSize]; //string memory allocation
  _mes->getArgString(0,value);
  if ( memcmp(value,"far",3) == 0) {
    ViscaMsg[4] =  0x02;

  }
  if ( memcmp(value,"near",4) == 0) {
    ViscaMsg[4] =  0x03;
  }
  Serial.write( ViscaMsg, sizeof(ViscaMsg) );
}
/************* Focus Variable Near ****************/
void ViscaFocusVariableNear(OSCMessage *_mes) {
  ViscaMsg[3] =  0x08;
  int value2 = _mes->getArgInt32(0);
    if (value2 == 0) {
      ViscaMsg[4] =  0x20;
    }
    if (value2 == 1) {
      ViscaMsg[4] =  0x21;
    }
    if (value2 == 2) {
      ViscaMsg[4] =  0x22;
    }
    if (value2 == 3) {
      ViscaMsg[4] =  0x23;
    }
    if (value2 == 4) {
      ViscaMsg[4] =  0x24;
    }
    if (value2 == 5) {
      ViscaMsg[4] =  0x25;
    }
    if (value2 == 6) {
      ViscaMsg[4] =  0x26;
    }
    if (value2 == 7) {
      ViscaMsg[4] =  0x27;
    }
  Serial.write( ViscaMsg, sizeof(ViscaMsg) );
}

Je sait pas si la librairie OSC supporte les strings en flash mais ça ferait un sacré bonus !
Toute tes chaines de caractères sont actuellement en ram, essaye de voir si la lib OSC supporte les chaines en flash: "toto" -> F("toto").
Avec ça tu pourrais gagner un sacré paquet de mémoire RAM.

Pour les parties du genre:

if (value2 == 0) {
      ViscaMsg[4] =  0x20;
    }
    if (value2 == 1) {
      ViscaMsg[4] =  0x21;
    }
    if (value2 == 2) {
      ViscaMsg[4] =  0x22;
    }
    if (value2 == 3) {
      ViscaMsg[4] =  0x23;
    }
    if (value2 == 4) {
      ViscaMsg[4] =  0x24;
    }
    if (value2 == 5) {
      ViscaMsg[4] =  0x25;
    }
    if (value2 == 6) {
      ViscaMsg[4] =  0x26;
    }
    if (value2 == 7) {
      ViscaMsg[4] =  0x27;
    }

Un switch / case serait plus lisible.

Ou mieux tu peut tout réduire en une seule ligne :

if (value >= 0 && value <= 7)
    ViscaMsg[4] =  0x20 | value2;

Merci pour le conseil, cela m'a permit d'alleger 4 fonctions qui utilisaient des if {value == 0} etc… Super !!

J'ai essayé de déclarer les variable OSC en Flash, mais apparemment la librairie Ard0SC ne le gere pas… Dans le setup si je fait ca :

  server.addCallback(F("/visca/AddressSet"),&ViscaAddressSet);

L'arduino me retourne une erreur au moment de la compilation :

osc_visca.ino: In function 'void setup()':
osc_visca:32: error: no matching function for call to 'OSCServer::addCallback(const __FlashStringHelper*, void ()(OSCMessage))'
/Users/renaudrubiano/Documents/Arduino/libraries/ArdOSC/OSCCommon/OSCServer.h:53: note: candidates are: void OSCServer::addCallback(char*, void ()(OSCMessage))

J'ai encore 7 ou 8 fois ce genre de cas dans le code que je pourrais certainement optimiser, mais je ne sais pas comment mettre plusieurs opérateurs mathématique. :

/************* Zoom Direct ****************/
void ViscaZoom(OSCMessage *_mes) {
  int value = _mes->getArgInt32(0);
  int valuea = value % 16; 
  int valuebZ = value >> 4; 
  int valuecZ = value >> 8; 
  int valuedZ = value >> 12; 
  int valueb = valuebZ % 16  ; 
  int valuec = valuecZ % 16 ; 
  int valued = valuedZ % 16 ; 
  ViscaLongMsg[3] =  0x47;
  ViscaLongMsg[4] =  valued;
  ViscaLongMsg[5] =  valuec;
  ViscaLongMsg[6] =  valueb;
  ViscaLongMsg[7] =  valuea;
  Serial.write( ViscaLongMsg, sizeof(ViscaLongMsg) );
}

J'avais essayé cela, mais cela ne fonctionnait pas, les %16 n'étaient pas pris en compte pour lesvariables valueb valuec et valued :

[code]/************* Zoom Direct ****************/
void ViscaZoom(OSCMessage *_mes) {
  int value = _mes->getArgInt32(0);
  int valuea = value % 16; 
  int valueb = value >> 4 %16; 
  int valuec = value >> 8 %16; 
  int valued = value >> 12 %16; 
  ViscaLongMsg[3] =  0x47;
  ViscaLongMsg[4] =  valued;
  ViscaLongMsg[5] =  valuec;
  ViscaLongMsg[6] =  valueb;
  ViscaLongMsg[7] =  valuea;
  Serial.write( ViscaLongMsg, sizeof(ViscaLongMsg) );
}

[/code]

reno-:
J'ai essayé de déclarer les variable OSC en Flash, mais apparemment la librairie Ard0SC ne le gere pas… Dans le setup si je fait ca :

  server.addCallback(F("/visca/AddressSet"),&ViscaAddressSet);

L'arduino me retourne une erreur au moment de la compilation :

osc_visca.ino: In function 'void setup()':
osc_visca:32: error: no matching function for call to 'OSCServer::addCallback(const __FlashStringHelper*, void ()(OSCMessage))'
/Users/renaudrubiano/Documents/Arduino/libraries/ArdOSC/OSCCommon/OSCServer.h:53: note: candidates are: void OSCServer::addCallback(char*, void ()(OSCMessage))

Dommage .. ça aurait permis une sacrée économie de mémoire RAM ...

reno-:
J'ai encore 7 ou 8 fois ce genre de cas dans le code que je pourrais certainement optimiser, mais je ne sais pas comment mettre plusieurs opérateurs mathématique. :

Tu peut te passer des variables temporaires :wink:

/************* Zoom Direct ****************/
void ViscaZoom(OSCMessage *_mes) {
  int value = _mes->getArgInt32(0);
  ViscaLongMsg[3] = 0x47;
  ViscaLongMsg[4] = (value >> 12) % 16;
  ViscaLongMsg[5] = (value >> 8) % 16;
  ViscaLongMsg[6] = (value >> 4) % 16;
  ViscaLongMsg[7] = value % 16;
  Serial.write( ViscaLongMsg, sizeof(ViscaLongMsg) );
}

Tu peut te passer des variables temporaires

Et oui les parenthèeses, logique !!

merci !!

prochaine étape, le tri des messages revenant de la caméra en forwardant les messages serial reçus de la camera via OSC
je reviendrais surement par la… mais pour lors je peux je pense clore ce topic car le code est maintenant optimisé.

et surtout

& 15

au lieu de

% 16

Au cas ou le compil soit un peu benet...

J'ai remplacé les % 16 par des & 15, et cela fonctionne toujours, bien que cela fonctionnait déjà avec les % 16.
C'est plus sur si je comprends bien.

merci,

renaud

J'avais zappé le modulo 16 tient ... effectivement un modulo d'une puissance de 2 équivaut à un ET logique de la valeur du modulo - 1.

Le modulo est une opération arithmétique qui implique une division partielle afin de calculer le reste de la division.
En gros A % B calcule A - ENT(A/B)*B
Le & 15 est une opération logique effectuée en 1 seule instruction par le processeur.

Le cas général de calcul du modulo est très consommateur de CPU surtout sur un micro qui n'a pas d'unité de calcul avancée (le calcul d'une division est par principe itératif et ne peut pas être cablé en 1 seul cycle dans un processeur)

A moins que le compilo sache reconnaitre le modulo d'une puissance de 2, utiliser "& (2^n -1)" au lieu de "% 2^n" est bien plus efficace en vitesse et nombre d'instructions

Je suis en train de contrôler une caméra VISCA, mais j'ai du mal à établir la communication.

Pourriez-vous publier votre programme dans son ensemble?

S'il vous plaît pardonnez-moi si c'est une mauvaise traduction - Google Translate ....