Show Posts
Pages: [1] 2
1  International / Français / Re: Optimiser un code de commande série (Visca) on: December 18, 2012, 11:08:59 am
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
2  International / Français / [résolu] Re: Optimiser un code de commande série (Visca) on: December 17, 2012, 07:52:40 am
Quote
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é.
3  International / Français / Re: Optimiser un code de commande série (Visca) on: December 16, 2012, 05:23:01 pm
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 :
Code:
  server.addCallback(F("/visca/AddressSet"),&ViscaAddressSet);

L'arduino me retourne une erreur au moment de la compilation :
Quote
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. :
Code:
/************* 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:
[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]
4  International / Français / Re: Optimiser un code de commande série (Visca) on: December 15, 2012, 11:59:38 am
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 :

Code:
#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) );
}
5  International / Français / Re: Optimiser un code de commande série (Visca) on: December 10, 2012, 05:59:52 pm
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
Code:
#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) );
}
6  International / Français / Re: Optimiser un code de commande série (Visca) on: December 10, 2012, 03:44:42 pm
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…
Code:
   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
Code:
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 :
Quote
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) <near match>
/Applications/Arduino.app/Contents/Resources/Java/hardware/arduino/cores/arduino/Print.h:57: note:                 size_t Print::print(int, int) <near match>
/Applications/Arduino.app/Contents/Resources/Java/hardware/arduino/cores/arduino/Print.h:58: note:                 size_t Print::print(unsigned int, int) <near match>
/Applications/Arduino.app/Contents/Resources/Java/hardware/arduino/cores/arduino/Print.h:59: note:                 size_t Print::print(long int, int) <near match>
/Applications/Arduino.app/Contents/Resources/Java/hardware/arduino/cores/arduino/Print.h:60: note:                 size_t Print::print(long unsigned int, int) <near match>

je tourne en rond et ne sais décidement pas par quel bout prendre la chose.
7  International / Français / Re: Optimiser un code de commande série (Visca) on: December 10, 2012, 07:55:12 am
Quote
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.
8  International / Français / Re: Optimiser un code de commande série (Visca) on: December 09, 2012, 06:37:38 pm
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

Code:
#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) );
}
9  International / Français / Optimiser un code de commande série (Visca) on: December 09, 2012, 03:33:41 pm
Bonjour à tous,

Je cherche à controller une camera sony avec le protocole visca. Je suis donc en train d'intégrer toutes les commandes disponibles, mais je ne sais pas comment optimiser mon code afin de ne pas répéter trop de fois les mêmes lignes. Pour l'instant c'est la catastrophe  !!!

Le code est fonctionnel, c'est à dire que les messages OSC commandent bien les fonctions de la caméra… Ce que je souhaite est une optimisation du code.

Chaque commande est une suite de chiffres en hexadecimal. Pour une commande de gain par exemple, il y a 21 valeurs. Pour l'instant j'ai fait un if (value == x)  pour chacune des 8 valeurs, mais cela n'est pas économe car il y a plus de près de 100 fonctions à définir.

Je suis sur de pouvoir réduire ce code, mais je ne sais pas comment. Si quel'un peux me pointer une piste, Merci !!

renaud

Code:
/************* Bright ****************/
void ViscaBright(OSCMessage *_mes) {
  int value = _mes->getArgInt32(0);
  if ( value == 0 ) {
    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) 0);
    Serial.write(0xFF);
  }
  if ( value == 1 ) {
    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(0x01);
    Serial.write(0xFF);
  }
  if ( value == 2 ) {
    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(0x02);
    Serial.write(0xFF);
  }
  if ( value == 3 ) {
    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(0x03);
    Serial.write(0xFF);
  }
  if ( value == 4 ) {
    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(0x04);
    Serial.write(0xFF);
  }
  if ( value == 5 ) {
    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(0x05);
    Serial.write(0xFF);
  }
  if ( value == 6 ) {
    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(0x06);
    Serial.write(0xFF);
  }
  if ( value == 7 ) {
    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(0x07);
    Serial.write(0xFF);
  }
  if ( 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(0x08);
    Serial.write(0xFF);
  }
}
10  International / Français / Re: [Résolu] : ETHERNET - reception osc et envoi tcp (PjLink) on: November 12, 2012, 03:36:10 am
Quote
Comme tu as enlevé les Serial.pribnt(), quand tu arrive au while(), le projecteur n'a pas encore répondu. Trop tôt.
Oui… ben en fait je me suis un peu perdu…
En fait il faut bien fermer la connexion après avoir reçu la réponse comme quoi l'ordre a bien été exécuté, sinon (si on ne ferme pas la connection) celle-ci sera fermée par le projecteur au bout de 30 secondes d'inactivité.
Mais cette réponse arrive "dans les 2 secondes" après que la commande ait été reçue… Or dès que je ferme la connection, je n'ai plus de réponse…

Je vais donc essayer avec tes conseils le code suivant (la semaine prochaine) :

J'ai mis le "c" dans serial.print qui est le contenu de ce qui est recu provenant du vp ("vpClient[vp].available()" C'est bien ca?


Code:
        if ( value == 1 ) {
        vpClient[vp].print("%1AVMT 31\r");
        Serial.print(c);
        while ( vpClient[vp].available() )
           {         
                char c = (vpClient[vp].read());
                Serial.print(c);
            }
          vpClient[vp].stop();
      }
      else {
        vpClient[vp].print("%1AVMT 30\r");
        Serial.print(c);
        while ( vpClient[vp].available() )
           {         
                char c = (vpClient[vp].read());
                Serial.print(c);
            }
            vpClient[vp].stop();
      }

Voici le topo en image :
 :


Spécifications PJLink : http://pjlink.jbmia.or.jp/english/data/PJLink%20Specifications100.pdf
11  International / Français / Re: [Résolu] : ETHERNET - reception osc et envoi tcp (PjLink) on: November 08, 2012, 01:27:34 pm
J'ai essayé ce que tu m'as dit mais je n'ai pas réussi à bien faire la chose.

J'ai modifié la fonction shutter comme ceci mais je n'ai toujours pas de réponse du vp. J'ai la réponse du projecteur si j'enleve le client.stop, mais dans ce cas la cela n'est pas conforme au protocole pjlink qui demande à fermer la connection s'il y a 30 secondes d'inactivité, car dans ce cas la le projecteur fermera la communication.
Code:
        if ( value == 1 ) {
        vpClient[vp].print("%1AVMT 31\r");
        while ( vpClient[vp].available() )
           {         
                char c = (vpClient[vp].read());
                Serial.print(c);
            }
          vpClient[vp].stop();
      }
      else {
        vpClient[vp].print("%1AVMT 30\r");
        while ( vpClient[vp].available() )
           {         
                char c = (vpClient[vp].read());
                Serial.print(c);
            }
            vpClient[vp].stop();
      }


Cette solution est viable pour moi en l'état, c'est à dire en retirant les client.print car ils prennent du temps, mais cela me donne envie de coder tout le protocole PJlink dans une arduino avec un petit LCD, mais je pense que c'est une autre affaire qui necessitera du temps… je reviendrais surement sur le forum à ce moment la !!

J'ai encore accès aux projecteurs demain, si quelqu'un à une idée… ensuite je ne les retrouverais que dans quelques semaines…

merci encore pour cette précieuse aide…

renaud
12  International / Français / Re: [Résolu] : ETHERNET - reception osc et envoi tcp (PjLink) on: November 08, 2012, 03:07:43 am
Quote
S'il faut fermer la connexion après la réponse, alors autant le faire dans la fonction shutter
Mais au lieu de faire un delay(), reprend la boucle de lecture.
Et fait le dans cet ordre :
Merci du conseil, je vais essayer dès que j'arrive près de la machine tout à l'heure.
13  International / Français / Re: [Résolu] : ETHERNET - reception osc et envoi tcp (PjLink) on: November 07, 2012, 12:05:07 pm
En (re)-lisant la doc PJLINK dans les détails, il apparait qu'il faut fermer la connection après avoir reçu la réponse comme quoi l'ordre a bien été executé.

J'ai donc ajouté une fermeture de la connection à l'aide de la commande "vpClient[vp].client.stop()" placée après un délai de 2 secondes aprèsl'envoi de la commande au VP.
Cela donne donc le code suivant, qui permet d'envoyer des commandes même après 30 secondes puisqu'on ferme et re-ouvre la connection à chaque fois… En revanche, j'ai perdu le retour d'info avec cet ajout, car il semble que l'arduino reste en pause et la "loop" ne s'effectue plus pendant ce temps…

Peux-être que le "delay(2000)" n'est pas la fonction la plus adapté, car d'après la doc de référence, cela met le prgramme général en pause, et la loop ne s'effectue plus, et le retour d'info et dans la loop…

D'en arriver la, du coup j'aurais envie d'implémenter tout le protocole PJLINK, avec les retours d'info et tout et tout, les autres fonctions etc… mais je sens que ca va prendre du temps !!!

merci des précédents conseils en tout cas, et je reste preneur d'une piste pour me lancer pour la suite (retrouver les retours d'info)

Code:
      if ( value == 1 ) {
      Serial.println();
      vpClient[vp].print("%1AVMT 31\r");
      delay(2000);
      vpClient[vp].stop();
      }
      else {
      Serial.println();
      vpClient[vp].print("%1AVMT 30\r");
      delay(2000);
      vpClient[vp].stop();
   }

14  International / Français / Re: [Résolu] : ETHERNET - reception osc et envoi tcp (PjLink) on: November 07, 2012, 11:14:32 am
Waou…… Super explication et très belle optimisation… je ne pouvais réver mieux…

J'ai donc importé les morceaux de code proposés, et cela fonctionne bien… Merci !!!!!

Bon, mais cela ne fonctionne que durant 30 secondes, ensuite c'est déconnecté et cela ne veux plus se reconnecter… Mais cela est du au protocole PJLink qui demande à fermer la connection lors du retour d'information… c'est à implémenter maintenant…

Voici le code fonctionnel (durant 30 secondes)

La déclaration de variable et les imports de librairie

Code:
#include <Ethernet.h>
#include <SPI.h>
#include <ArdOSC.h>
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
byte ip[] = { 10, 0, 0, 10 };
byte vpIp[3][4] = { { 10, 0, 0, 11 },  { 10, 0, 0, 12 },  { 10, 0, 0, 13 } } ;
EthernetClient vpClient[3];
int serverPort = 10000;
OSCServer server;

Le setup

Code:
void setup() {
  Ethernet.begin(mac, ip);
  Serial.begin(19200);
  server.begin(serverPort);
  server.addCallback("/pjlink.1/shutter",&shutter1);
  server.addCallback("/pjlink.2/shutter",&shutter2);
  server.addCallback("/pjlink.3/shutter",&shutter3);
  delay(1000);
  }

La loop

Code:
void loop() {
  // reception de messages OSC
  if(server.aviableCheck()>0) {
  }
  for ( byte vp = 0 ; vp < 3 ; vp++ )
  while ( vpClient[vp].available() )
      {
      char c = vpClient[vp].read();
      Serial.print(c);
      }
}

La fonction shutter

Code:
void shutter1(OSCMessage *_mes) {
  shutter( 1, _mes );
}

void shutter2(OSCMessage *_mes) {
  shutter( 2, _mes );
}

void shutter3(OSCMessage *_mes) {
  shutter( 3, _mes );
}

void shutter(byte vp, OSCMessage *_mes) {

  --vp; // 1, 2, 3 => 0, 1, 2 pour index de tableau

    int value = _mes->getArgInt32(0);

    if ( ! vpClient[vp].connected() )
    {
       // connexion au vp
       Serial.println("connecting...");
       int ret = vpClient[vp].connect(vpIp[vp], 4352);
       if ( (ret == 0) || !vpClient[vp].connected() )
       {
          Serial.println("connection failed");
          return;
       }
       else {
      Serial.println("connected");
       }
    }
      if ( value == 1 ) {
      Serial.println();
      Serial.println(vpClient[vp]);
      vpClient[vp].print("%1AVMT 31\r");
      }
      else {
      Serial.println();
      Serial.println(vpClient[vp]);
      vpClient[vp].print("%1AVMT 30\r");
   }
}

15  International / Français / Re: [Résolu] : ETHERNET - reception osc et envoi tcp (PjLink) on: November 06, 2012, 11:28:42 am
Pour ceux que cela intéresse, le code va évoluer sur un repo Git
https://github.com/reno-/osc-pjlink/
Pages: [1] 2