uCam-III with Arduino Uno(SYNC issue)

[haomiy]

I am trying to communicate with the uCam-III using an Arduino Uno.

My main issue is that the initial SYNC process(upon power-on) is failing.

---

The pins are connected as follows:

• Power is connected to the 5V port on the Uno
• Ground is connected to the GND port on the Uno
• TX is connected to the RX on the Uno
• RX is connected to the TX on the Uno
• Reset is connected to a digital port on the Uno and toggled through software(active low)

---

In the code attached below, what I am trying to do is:

1. Reset it using the digital pin from Uno
2. Send it SYNC command until I receive an ACK back(or 60 tries have passed)
3. Finalize the process by receiving a SYNC and sending a ACK back to the camera

I am currently failing to even receive anything meaningful back from the camera.
I have no good way/equipment of testing whether the Uno is sending what I think it is sending.

---

I know that:

• The data width is correct, because I used "Serial.begin(9600, SERIAL_8N1)". The 8N1 means 8 bit data, with no parity bit, and one stop bit, which is exactly what the camera expects.
• The camera is being powered successfully, since we can feel the camera is a bit warm
• The baud rate is OK, because the specification says the camera will auto detect the rate, and 9600 is one of the acceptable ones.

---

I feel like I am doing exactly what the uCam-III specification says, but something is not right.
I have searched around and found no answer that could help me.
If anyone have a theory as to why this is not working, please feel free to say something.
Thanks.

For your reference, the uCam-III specification is also attached below, as a file.

// Compiler Linkage
extern "C" {
  #include <stdbool.h>
  #include "commandSet.h"
}
// Pin Declaration
static const int Reset = 7;

/*
 * Simple Test to assess the communication
 * capability of the uCAM-III device
 * (Designed for Arduino Uno or similar hardware)
 * NOTE: It is highly recommended that the Reset pin
 *       is connected, although it is optional
 *
 * Author: Haomin Yu
 */
void setup() {
  Serial.begin(9600, SERIAL_8N1);
  pinMode(Reset, OUTPUT);
  digitalWrite(Reset, LOW);
  delay(5);
  digitalWrite(Reset, HIGH);
  if(initializeCamera()) {
    delay(5);
    bool receivedSync = receiveSyncCommand();
    sendAckSyncCommand();
    if(receivedSync) {
      Serial.println("Initialization Successful!");
    }
    else {
      Serial.println("Received ACK but not SYNC");
    }
  }
  else {
    Serial.println("Initialization Failed!");
  }
}

void loop() {}

// Compiler Linkage
extern "C" {
  #include <stdbool.h>
  #include "commandSet.h"
}

/*
 * Holds auxiliary commands necessary for testing
 * the uCAM-III device
 * (Designed for Arduino Uno or similar hardware)
 *
 * Author: Haomin Yu
 */

/*
 * Initializes the uCAM-III
 * (Necessary upon power-on)
 */
static const int MAX_SYNC_ATTEMPTS = 60;
bool initializeCamera() {
  int syncAttempts = 0;
  bool ackReceived = false;
  do {
    sendSyncCommand();
    ackReceived = receiveAckCommand();
    delay(5 + syncAttempts++);
  } while((syncAttempts < MAX_SYNC_ATTEMPTS) && !ackReceived);
  return syncAttempts < MAX_SYNC_ATTEMPTS;
}

/*
 * Sends a SYNC command through serial
 * (With a small built-in delay)
 */
void sendSyncCommand() {
  Serial.write(syncCommand, sizeof(syncCommand));
  delay(1);
}

/*
 * Attempts to receive a SYNC command through serial
 * (Returns false if fails)
 */
bool receiveSyncCommand() {
  bool isSyncCommand = true;
  char incoming = 0;
  // Checking if first byte is 0xAA
  incoming = Serial.read();
  isSyncCommand = isSyncCommand && (incoming == 0xAA);
  // Checking if second byte is 0x0D
  incoming = Serial.read();
  isSyncCommand = isSyncCommand && (incoming == 0x0D);
  // Checking if third byte is 0x00
  incoming = Serial.read();
  isSyncCommand = isSyncCommand && (incoming == 0x00);
  // Checking if fourth byte is 0x00
  incoming = Serial.read();
  isSyncCommand = isSyncCommand && (incoming == 0x00);
  // Checking if fifth byte is 0x00
  incoming = Serial.read();
  isSyncCommand = isSyncCommand && (incoming == 0x00);
  // Checking if sixth byte is 0x00
  incoming = Serial.read();
  isSyncCommand = isSyncCommand && (incoming == 0x00);
  return isSyncCommand;
}

/*
 * Sends a ACK command through serial, indicating
 * that the SYNC command has been registered
 * (With a small built-in delay)
 */
void sendAckSyncCommand() {
  Serial.write(ackSyncCommand, sizeof(ackSyncCommand));
  delay(1);
}

/*
 * Attempts to receive a ACK command through serial
 * (Returns false if fails)
 */
bool receiveAckCommand() {
  bool isAckCommand = true;
  char incoming = 0;
  // Checking if first byte is 0xAA
  incoming = Serial.read();
  isAckCommand = isAckCommand && (incoming == 0xAA);
  // Checking if second byte is 0x0E
  incoming = Serial.read();
  isAckCommand = isAckCommand && (incoming == 0x0E);
  // Checking if third byte is 0x0D
  incoming = Serial.read();
  isAckCommand = isAckCommand && (incoming == 0x0D);
  // Throwing away fourth byte (Debugging byte)
  incoming = Serial.read();
  // Checking if fifth byte is 0x00
  incoming = Serial.read();
  isAckCommand = isAckCommand && (incoming == 0x00);
  // Checking if sixth byte is 0x00
  incoming = Serial.read();
  isAckCommand = isAckCommand && (incoming == 0x00);
  return isAckCommand;
}

/*
 * This file holds the byde code which represents
 * the command set for the camera (uCAM-III)
 *
 * Author: Haomin Yu
 */
#pragma once

#ifndef _COMMANDSET_H_
#define _COMMANDSET_H_

// SYNC command
static const char syncCommand[] = {0xAA, 0x0D, 0x00, 0x00, 0x00, 0x00};
// ACK command for SYNC without debugging
static const char ackSyncCommand[] = {0xAA, 0x0E, 0x0D, 0x00, 0x00, 0x00};

#endif /* _COMMANDSET_H_ */

[John Kevin]

Hello,

I have noticed that you are using Hardware Serial (Serial.begin) to communicate with both the Serial Monitor and the uCAM.
You can use Software Serial to communicate with the uCAM, and the Hardware Serial for debugging purposes.

#include <SoftwareSerial.h>
SoftwareSerial SoftSer(2,3); // (pin 2 of Arduino -> TX of uCAM, pin 3 of Arduino-> RX of uCAM)

Serial.begin(9600);
SoftSer.begin(115200);

You may want to change your read/write operations

SoftSer.write(syncCommand, sizeof(syncCommand));
SoftSer.write(ackSyncCommand, sizeof(ackSyncCommand));
incoming =SoftSer.read();

Also, please change the data type of the incoming data from char to byte

 byte incoming = 0;

I have modified the code posted above, please see attached files.

If you still have any concerns, please don't hesitate to ask.

Best Regards,
Kevin