Caméra série SEN0099

Bonjour à tous,

Avant de vous présenter mon projet, et mon problème voici le matériel que j'utilise :

Le but de mon projet étant de capturer une image avec cette caméra lorsque le capteur de force est activé (pour le moment peu importe le seuil) et d'enregistrer l'image sur la carte microSD de l'ethernet shield.

Le capteur de poids fonctionne très bien, il ne fait donc pas parti de nos soucis :slight_smile:

Cependant pour ce qui en est de la caméra, nous avons testé une multitude de codes d'exemple, mais sans succès. Aucune communication se fait entre l'arduino et la caméra.

Nous venons vers vous afin de vous demander conseil.

Merci,
Cordialement Veknar.

La camera est en RS232, ce qui n'est pas pareil que du serie TTL.

il faut passer par une conversion de niveau de tension a base de MAX232 ou derivé.

http://www.lextronic.fr/P29284-platine-shield-rs232-pour-arduino.html

La RS232, c'est du -12v 12v, le TTL 0 5V, tu as p'tre cramé l'arduino !

Notre but c'est de rester complètement autonome du PC, on souhaite communiquer par les ports RX TX de la carte arduino. Ce qui reste de la liaison série ?

D'après la doc technique on peut communiquer en RS232 TTL etc

"Image sensor
Adopting the advanced version of OmniVision CMOS VGA colour sensor on-board making overall
unit a low powered comsuption, and good quality of image. via RS232, RS458, TTL, etc. serial
interface attached external host system's UART port etc."

Je pense que cette doc est plus générale, le fournisseur a peut-être des modules avec plusieurs interfaces.
Mais chez DFRobot (d'où vient la caméra achetée chez Gotronic), il est bien écrit "NOTE: The interface of this module is using RS232 protocol." (0.3M Pixel Serial JPEG Camera Module For Arduino - DFRobot).

Donc il n'est pas possible de communiquer simplement entre l'arduino uno et cette camera?
Ne peut on pas, passer les ports de l'arduino RX/TX en communication RS232?

Non, il faut faire une conversion de niveau de tension comme indiqué plus haut.

Alors, on nous a vendu cette caméra comme étant adaptable arduino uno, mais s'il faut passer par un ordinateur il n'y a plus rien d'autonome et de portatif.

Si je comprends bien nous devons investir dans une autre camera adapté arduino uno?

Veknar:
Alors, on nous a vendu cette caméra comme étant adaptable arduino uno, mais s'il faut passer par un ordinateur il n'y a plus rien d'autonome et de portatif.

Qui ça ?

Veknar:
Si je comprends bien nous devons investir dans une autre camera adapté arduino uno?

Oui, ou bien faire une conversion de niveau de tension.

La camera que nous utilisons est une camera qu'il y avait en réserve, c'est certainement pour ça qu'ils nous l'ont donné pour le projet.

Nous avons regardé le module proposé par Nommam.
http://www.lextronic.fr/P29284-platine-shield-rs232-pour-arduino.html

Cependant nous avons des contraintes ergonomique qui nous empêche de cumuler des modules sur l'arduino.

Maintenant est-ce que vous auriez une idée de choix de camera, qui serait le plus approprié pour notre projet ?
C'est à dire prendre une image avec la camera, envoyé via les ports RX TX de l'arduino et stocker dans la carte microSD du module ethernet shield.

Il y a ça par exemple, avec un tutoriel en prime:

Nous avions également trouvé cette caméra.
Nous la commandons et reviendrons vers vous pour vous donner des nouvelles :wink:

A bientôt et merci pour vos conseils.

Bonsoir,
Alors, nous avons bien reçu la caméra (TTL Serial JPEG Camera with NTSC Video : ID 397 : $39.95 : Adafruit Industries, Unique & fun DIY electronics and kits) cela fonctionne plutôt bien.

Deux petit soucis :

  • Le premier : la rapidité, nous ne voyons pas comment faire fonctionner plus rapidement le processus, sans diminuer les résolutions. (La photo s'enregistre en 15s :()
  • Le second : les photos s'incrémentent automatiquement et nous souhaiterions que les photos s'écrasent au fur et à mesure. (On veut qu'il n'y ait qu'une seule photo à chaque fois dans la SDcard, toujours le même nom.)

J'aimerai savoir si vous auriez une idée la dessus ?
Cordialement.

PS : voici notre code en pièce jointe (on retrouve un capteur "fsrAnalogPin" et une photoresistance "photocellPin")

#include <Adafruit_VC0706.h>
#include <SD.h>
#include <SoftwareSerial.h>         
#define chipSelect 4
#if ARDUINO >= 100
SoftwareSerial cameraconnection = SoftwareSerial(2, 3);
#else
NewSoftSerial cameraconnection = NewSoftSerial(2, 3);
#endif
Adafruit_VC0706 cam = Adafruit_VC0706(&cameraconnection);

///////////capteur de présence d'entrée/////////////////////
  int fsrAnalogPin = A0; // FSR branché sur pin Analog 0
  
///////////capteur lumineu + LED flash//////////
int photocellPin = A2; // the cell and 10K pulldown are connected to a0
const int diode_flash=5;



void setup(void) {
    Serial.begin(9600); // Envoi de message de déboggage sur connexion série            
    pinMode(diode_flash, OUTPUT);
 }
 
 
void prise_de_photo ()
{
          
     Serial.println("VC0706 Camera snapshot test");
  
  // see if the card is present and can be initialized:
  if (!SD.begin(chipSelect)) {
    Serial.println("Card failed, or not present");
    // don't do anything more:
    return;
  }  
  
  // Try to locate the camera
  if (cam.begin()) {
    Serial.println("Camera Found:");
  } else {
    Serial.println("No camera found?");
    return;
  }
  // Print out the camera version information (optional)
  char *reply = cam.getVersion();
  if (reply == 0) {
    Serial.print("Failed to get version");
  } else {
    Serial.println("-----------------");
    Serial.print(reply);
    Serial.println("-----------------");
  }

  // Set the picture size - you can choose one of 640x480, 320x240 or 160x120 
  // Remember that bigger pictures take longer to transmit!
  
  cam.setImageSize(VC0706_640x480);        // biggest
  //cam.setImageSize(VC0706_320x240);        // medium
  //cam.setImageSize(VC0706_160x120);          // small

  // You can read the size back from the camera (optional, but maybe useful?)
  uint8_t imgsize = cam.getImageSize();
  Serial.print("Image size: ");
  if (imgsize == VC0706_640x480) Serial.println("640x480");
  
  


  if (! cam.takePicture()) 
    Serial.println("Failed to snap!");
  else 
    Serial.println("Picture taken!");
  
  // Create an image with the name IMAGExx.JPG
  char filename[13];
  strcpy(filename, "IMAGE00.JPG");
  for (int i = 0; i < 100; i++) {
    filename[5] = '0' + i/10;
    filename[6] = '0' + i%10;
    // create if does not exist, do not open existing, write, sync after write
    if (! SD.exists(filename)) {
     break;
    }
 }
  
  // Open the file for writing
  File imgFile = SD.open(filename, FILE_WRITE);

  // Get the size of the image (frame) taken  
  uint16_t jpglen = cam.frameLength();
  Serial.print("Storing ");
  Serial.print(jpglen, DEC);
  Serial.print(" byte image.");

  int32_t time = millis();
  pinMode(8, OUTPUT);
  // Read all the data up to # bytes!
  byte wCount = 0; // For counting # of writes
  while (jpglen > 0) {
    // read 32 bytes at a time;
    uint8_t *buffer;
    uint8_t bytesToRead = min(32, jpglen); // change 32 to 64 for a speedup but may not work with all setups!
    buffer = cam.readPicture(bytesToRead);
    imgFile.write(buffer, bytesToRead);
    if(++wCount >= 64) { // Every 2K, give a little feedback so it doesn't appear locked up
      Serial.print('.');
      wCount = 0;
    }
    //Serial.print("Read ");  Serial.print(bytesToRead, DEC); Serial.println(" bytes");
    jpglen -= bytesToRead;
  }
  imgFile.close();

  time = millis() - time;
  Serial.println("done!");
  Serial.print(time); 
  Serial.println(" ms elapsed");
  delay (500);
  asm volatile ("  jmp 0"); 
  
}










void loop(void) {
    digitalWrite(diode_flash,LOW);
  if(analogRead(fsrAnalogPin) >= 400 && analogRead(photocellPin) <= 200)
    {
    digitalWrite(diode_flash,HIGH);  
    prise_de_photo();
    digitalWrite(diode_flash,LOW);
    } 
  else if(analogRead(fsrAnalogPin) >= 400 && analogRead(photocellPin) >= 200)
    {
    digitalWrite(diode_flash,LOW);    
    prise_de_photo();
    }

}

Bizzare que cela prenne autant de temps en effet dans l'exemple Adafruit ça prend un peut plus que 2s:

Bon maitenant c'est vrai qu'ils précisent que:

This is a pretty slow UART camera, it can take up to 30 seconds to transfer an image! It is meant for snapshots or time-lapse type photography, not for any kind of real-time analysis

Pour l'écrasement des photos il faut supprimer la partie création de l'image par incrémentation et laisser un nom identique à chaque fois, dans cette partie:

// Create an image with the name IMAGExx.JPG
  char filename[13];
  strcpy(filename, "IMAGE00.JPG");
  for (int i = 0; i < 100; i++) {
    filename[5] = '0' + i/10;
    filename[6] = '0' + i%10;
    // create if does not exist, do not open existing, write, sync after write
    if (! SD.exists(filename)) {
     break;
    }

Peut être parce que la photo doit s'enregistrer dans la SD du module shield.
Qu'en penses tu ?

Je sais pas trop moi non plus, sans baisser la résolution je vois pas trop.

En tout cas NE changez PAS le baudrate apparemment c'est pas une bonne idée.

Nous avons donc testé ça :

// Create an image with the name IMAGExx.JPG
  char filename[13];
  strcpy(filename, "IMAGE00.JPG");
  */for (int i = 0; i < 100; i++) {
    filename[5] = '0' + i/10;
    filename[6] = '0' + i%10;
    // create if does not exist, do not open existing, write, sync after write
    if (! SD.exists(filename)) {
     break;
    }*/

Cependant la photo de s'écrase pas. On a bien une seule photo, mais ça reste la première. :frowning:

Il doit falloir dire de supprimer si existe et après recréer une nouvelle.

ça marche pas comme un copier/coller sous windows.

On écrit les valeurs brutes du fichier image sur un fichier qui s'apelle IMAGE00.JPG comme si s'était un fichier texte.

Donc de toute façon à un moment il faut effacer l'ancien pour créer un nouveau, sinon ça va écrire 2 images à la suite dans le même fichier et l'image s'ouvrira pas correctement:

 if (SD.exists(picName))
    {
        SD.remove(picName);
    }

Il faut donc prévoir un test:
Si le fichier n'existe pas on crée IMAGE.JPG
Si le fichier IMAGE.JPG existe et qu'il n'est pas vide, on l'efface et on en crée un nouveau pour l'image d'après

DAns le code sur cette ligne c'est indiqué:

uint8_t bytesToRead = min(32, jpglen); // change 32 to 64 for a speedup but may not work with all setups!

Vous avez changé à 64 pour voir si c'était mieux?

Bonjour,
J'ai donc réalisé la premiére partie grâce à ton code.
Cela fonctionne très bien je n'ai plus d'incrementation de fichiers

Pour la deuxieme partie j'ai essayé avec "64" et cela ne fonctionne pas, tant pis pour la vitesse.

Maintenant je rencontre un problème en voulant fusionner deux programmes: celui de la camera, et un programme de serveur ethernet ( celui-ci crée une page HTML et grace a un bouton on active ou non un servo moteur).
Separement les deux codes fonctionnent, et lors de la fusion, rien ne se passe comme on le souhaite.

je vous met le code ethernet :smiley:

#include <SPI.h>
#include <Ethernet.h>
#include <Servo.h> 
Servo microservo; 
int pos = 0; 
int fsrAnalogPin2 = A1;

byte mac[] = { 0x90, 0xA2, 0xDA, 0x0E, 0xA6, 0x0D };   //physical mac address
byte ip[] = { 169, 254, 73, 50 };                      // ip in lan (that's what you need to use in your browser. ("192.168.1.178")
byte gateway[] = { 192, 168, 1, 1 };                   // internet access via router
byte subnet[] = { 255, 255, 255, 0 };                  //subnet mask
EthernetServer server(80);                             //server port     
String readString;

void setup() {
 // Open serial communications and wait for port to open:
  Serial.begin(9600);
   while (!Serial) {
    ; // wait for serial port to connect. Needed for Leonardo only
  }
  microservo.attach(9);
  // start the Ethernet connection and the server:
  Ethernet.begin(mac, ip, gateway, subnet);
  server.begin();
  Serial.print("server is at ");
  Serial.println(Ethernet.localIP());
}


void loop() {
  // Create a client connection
  EthernetClient client = server.available();
  if (client) {
    while (client.connected()) {   
      if (client.available()) {
        char c = client.read();
     
        //read char by char HTTP request
        if (readString.length() < 100) {
          //store characters to string
          readString += c;
          //Serial.print(c);
         }

         //if HTTP request has ended
         if (c == '\n') {          
           Serial.println(readString); //print to serial monitor for debuging
     
           client.println("HTTP/1.1 200 OK"); //send new page
           client.println("Content-Type: text/html");
           client.println();     
           client.println("<HTML>");
           client.println("<HEAD>");
           client.println("<meta name='apple-mobile-web-app-capable' content='yes' />");
           client.println("<meta name='apple-mobile-web-app-status-bar-style' content='black-translucent' />");
           client.println("<link rel='stylesheet' type='text/css' href='http://randomnerdtutorials.com/ethernetcss.css' />");
           client.println("<TITLE>AUTOBARRIGO</TITLE>");
           client.println("</HEAD>");
           client.println("<BODY>");
           client.println("<H1>Autobarrigo : simulation de passage</H1>");
           client.println("<hr />");
           client.println("
");  
           client.println("
");     
           client.println("
"); 
           client.println("<a href=\"/03312203011191tmm\"\">Ouverture</a>");
           client.println("
"); 
           client.println("</BODY>");
           client.println("</HTML>");
     
          delay(1000);
           //stopping client
          client.stop();
           //controls the Arduino if you press the buttons
 
           if (readString.indexOf("03312203011191tmm") >0){
                for(pos = 53; pos < 143; pos += 5)  // goes from 0 degrees to 180 degrees 
                {                                  // in steps of 1 degree 
                  microservo.write(pos);              // tell servo to go to position in variable 'pos' 
                  delay(100);                       // waits 15ms for the servo to reach the position 
                } 
           }
            //clearing string for next read
            readString="";  
           
         }
       }
    }
}
             
              if (analogRead(fsrAnalogPin2) > 400)
           {
                for(pos = 143; pos>=53; pos-=5)     // goes from 180 degrees to 0 degrees 
                {                                
                  microservo.write(pos);              // tell servo to go to position in variable 'pos' 
                  delay(100);                       // waits 15ms for the servo to reach the position 
                } 
           }
           
}

Nous, nous demandons si arduino rentre en conflit lorsque l'on utilise les ports RX TX pour faire fonctionner la caméra et la communication ethernet

Si on réalise le montage et qu'on branche l'arduino dessus.
Et qu'on met le programme de la prise de photo, le servomoteur branché en pin digital 9 ne s'active pas (donc normal).
Pareil si on remplace le programme prise de photo par celui de la liaison ethernet et qu'on ne demande pas d'activer le servomoteur, il ne s'active pas (donc normal).

Maintenant lorsqu'on réunit les deux programmes, pour n'en faire plus qu'un, le servomoteur s'active et réalise des micro mouvements incohérent.

Auriez vous une idée du problème ?

Merci.

Oui tu ne pourras normalement pas faire marcher 2 choses en même temps sur le port série.
Utilises le SoftSerial pour te mettre sur d'autres pins

:wink: