Go Down

Topic: Problema al conectar Wifi Shield + Cámara (Read 434 times) previous topic - next topic

joaquinlara

Mar 09, 2018, 05:30 pm Last Edit: Mar 09, 2018, 05:41 pm by joaquinlara
Hola a todos, soy nuevo en el foro y escribo debido a que tengo un problema en un proyecto muy importante que estoy haciendo y necesito ayuda urgente.

El tema es el siguiente: estoy utilizando un módulo wifi cc3000 junto con una cámara (arducam ov264), (ambas conectadas a un Arduino Mega 2560), la idea es conseguir transmitir la captura que realice la cámara a través de la red hasta mi servidor.

El problema que me surge es el siguiente: inicializo la placa wifi sin problema, inicializo la cámara también de forma correcta, pero a la hora de hacer la captura no consigue hacerla y se queda bloqueada. Si pruebo la cámara por si sola funciona perfectamente y realiza la captura, pero cuando uso ambas a la vez no se realiza la captura.

Otra cosa que ocurre cuando inicializo la cámara es que utilizo un print para debug por serial, y lo que ocurre es que este print se repite muchas veces (como si ejecutase esa sentencia varias veces).

Tanto la cámara como el módulo wifi utilizan comunicación SPI.

Soy muy nuevo en Arduino y necesito ayuda, no sé si es problema de que no tienen suficiente potencia (cosa que no creo ya que se consiguen inicializar los dos módulos) o es cuestión de la comunicación SPI.

Si pudierais ayudarme lo agradecería enormemente.

Muchísimas gracias.

surbyte

Lo que debes controlar es que no compartan el mismo CS o Chip Select. Verifica eso en ambas.
Como?
Hojas de datos de ambos dispositivos.

joaquinlara

Hola,

no lo comparten, el módulo wifi tiene como CS el pin 10 y la cámara el 7.

surbyte

Porque no pones el código.
Yo creo que hay que ver las librerías y observar con detalle quien es cayendo en un timeout o en un loop del que no puede salir.

joaquinlara

Haciendo pruebas (para ver si era por falta de energía) he conectado otro Arduino Uno de modo que la cámara la alimento a través de este y el módulo Wifi a través del Arduino Mega original. La idea entonces sería utilizar I2C para pedir la captura y que la devuelva y ya enviarla a través del módulo Wifi.

Sin embargo me vuelve a ocurrir el problema de que se repite código (no es por ningún loop o bucle iterador), ya que cuando no enciendo el Arduino Uno (el que tiene la cámara), dicho código no se repite mientras que si está encendido sí ocurre.

¿Alguna idea de por qué puede ser?, el código del Arduino Uno con la cámara es el siguiente:

Code: [Select]
#include <Wire.h>
#include <ArduCAM.h>
#include <SPI.h>
#include "memorysaver.h"

// set pin 7 as the slave select for the digital pot:
const int Camera_CS = 7;
int mode = 0;
uint8_t start_capture = 0;

ArduCAM myCAM( OV2640, Camera_CS );
boolean isShowFlag = true;

//Fin includes para la camara

void setup() {

  Serial.begin(115200);
 
  uint8_t vid, pid;
  uint8_t temp;

  Wire.begin();

  Serial.println(F("\nArduCAM Start!"));
    // set the CS as an output:
    pinMode(Camera_CS, OUTPUT);
    // initialize SPI:
    SPI.begin();
    while(1){
      //Check if the ArduCAM SPI bus is OK
      myCAM.write_reg(ARDUCHIP_TEST1, 0x55);
      temp = myCAM.read_reg(ARDUCHIP_TEST1);
      if (temp != 0x55){
        Serial.println(F("ACK CMD SPI interface Error!"));
        delay(1000);continue;
      }else{
        Serial.println(F("ACK CMD SPI interface OK."));break;
      }
    }
   
      while(1){
        //Check if the camera module type is OV2640
        myCAM.wrSensorReg8_8(0xff, 0x01);
        myCAM.rdSensorReg8_8(OV2640_CHIPID_HIGH, &vid);
        myCAM.rdSensorReg8_8(OV2640_CHIPID_LOW, &pid);
        if ((vid != 0x26 ) && (( pid != 0x41 ) || ( pid != 0x42 ))){
          Serial.println(F("ACK CMD Can't find OV2640 module!"));
          delay(1000);continue;
        }
        else{
          Serial.println(F("ACK CMD OV2640 detected."));break;
        }
      }

    //Change to JPEG capture mode and initialize the OV5642 module
    myCAM.set_format(JPEG);
    myCAM.InitCAM();
    #if defined (OV2640_MINI_2MP)
      myCAM.OV2640_set_JPEG_size(OV2640_320x240);
    #else
      myCAM.write_reg(ARDUCHIP_TIM, VSYNC_LEVEL_MASK);   //VSYNC is active HIGH
      myCAM.OV5642_set_JPEG_size(OV5642_320x240);
    #endif
   
    delay(1000);
    myCAM.clear_fifo_flag();
    #if !(defined (OV2640_MINI_2MP))
    myCAM.write_reg(ARDUCHIP_FRAMES,0x00);
    #endif
   
    //FIN CODIGO SETUP CAMARA

    Serial.println(F("SETUP DE LA CAMARA COMPLETADO"));
   
    // Pines en modo salida
    pinMode(2, OUTPUT);
    // Unimos este dispositivo al bus I2C con dirección 2
    Wire.begin(2);
    // Registramos el evento al recibir datos
    Wire.onReceive(receiveEvent);
   
    //Para realizar la captura
    start_capture = 1;
    mode = 1;
    //Fin para realizar la captura
 
}

void loop() {

  delay(100);

}

// Función que se ejecuta siempre que se reciben datos del master
// siempre que en el master se ejecute la sentencia endTransmission
// recibirá toda la información que hayamos pasado a través de la sentencia Wire.write
void receiveEvent(int howMany) {
 
  int pinOut = 2; //LED PARA DEBUG, ES IRRELEVANTE
 
 
  // Activamos/desactivamos salida
  digitalWrite(pinOut,HIGH);

  //Se realiza la captura
  char str[8];
  byte buf[256];
  static int i = 0;
  static int k = 0;
  static int n = 0;
  uint8_t temp, temp_last;
  int total_time = 0;

  delay(1000);

  //Flush the FIFO
  myCAM.flush_fifo();
  //Clear the capture done flag
  myCAM.clear_fifo_flag();
  //Start capture
  myCAM.start_capture();
  Serial.println("Start Capture");

  while (!myCAM.get_bit(ARDUCHIP_TRIG , CAP_DONE_MASK));

  digitalWrite(pinOut, LOW); //Se apaga el led cuando se ha realizado la captura

  Serial.println("Capture Done!");
 
  i = 0;
  myCAM.CS_LOW();
  myCAM.set_fifo_burst();
  temp = SPI.transfer(0x00);

  //Read JPEG data from FIFO
  while ( (temp != 0xD9) | (temp_last != 0xFF) )
  {
    temp_last = temp;
    temp = SPI.transfer(0x00);;
    //Write image data to buffer if not full
    if (i < 256)
      buf[i++] = temp;
    else
    {
      //Write 256 bytes image data to file
      myCAM.CS_HIGH();
      i = 0;
      buf[i++] = temp;
      myCAM.CS_LOW();
      myCAM.set_fifo_burst();
    }
  }
  //Write the remain bytes in the buffer
  if (i > 0)
  {
    myCAM.CS_HIGH();
  }

  //Clear the capture done flag
  myCAM.clear_fifo_flag();
  //Clear the start capture flag
 
}



En el maestro la idea es utilizar el siguiente código:

Code: [Select]
Wire.beginTransmission(2);

    Wire.write(2);

    Wire.endTransmission();



Como señal para que haga la captura (luego el esclavo le devolvería la imagen capturada).

Veo que para inicializar la cámara aparece un Wire.begin(), lo que creo que indica es que ya inicializa el arduino como esclavo porque me imagino que la cámara también utiliza I2C para comunicarse con el Arduino. ¿Puede ser que esté generando conflicto que luego utilice Wire.begin(2) para comunicarme con el otro Arduino?¿Explicaría esto que se repitiese código?

Muchas gracias de antemano.

surbyte

O sea que tienes un arduino con la Arducam que captura la imagen y debe enviarla via I2C a otro arduino con WIFI CC3000. Es asi?

joaquinlara

Sí, esa es la idea ahora mismo. Aunque lo que me gustaría sería integrarlo todo en una misma placa y así no tener que transmitir la imagen de un arduino a otro. El tema de ponerlos en placas separadas era por falta de potencia, pero ese no parece ser el error por lo que me gustaría volver a todo integrado en una misma placa.

Go Up