Published July 3, 2016 © GPL3+

Grove Serial Camera with Linkit ONE

Using the Grove Serial Camera with Mediatek Labs Linkit ONE.

BeginnerProtip30 minutes2,026

Things used in this project

Hardware components

Seeed Studio Grove Serial Camera

SparkFun Pushbutton switch 12mm

Software apps and online services

Arduino IDE

Microsoft Visual Studio 2015

Story

This is my first project on Hackster.io and it is designed for those who are in need to connect the Grove Serial Camera to a Mediatek Labs Linkit ONE. Although the official SeeedStudio wiki says it's not compatible, it does work properly. I didn't had the time to play with it longer, but I'll show here what I have achieved in my first experiment with it.

Open SerialCam.ino in your preferred Arduino editor (Arduino IDE or Visual Studio/Visual Micro) and flash it to the board. This code is based on the Arduino example available here, with a few modifications to make it work on Linkit ONE. Here they are:

The original code uses the SoftwareSerial implementation, which is not available on the Linkit ONE, but this board does have a second serial (called Serial1), that is what we are using instead.

Linkit ONE access to storage (SD or internal) is made with its own specific libraries;

Storage CS pin (to SD or internal) is 10, instead of 4.

Here we will be using the internal storage, but you can use a SD card by commenting this line:

#define SD LFlash // use Internal 10M Flash

And uncommenting this one:

//#define SD LSD // use SD card

Note that you'll need a Class10 SD Card to use with Linkit ONE (I tried several non-Class10 and it doesn't recognize them).

After flashing the code, open the Serial Monitor and press the pushbutton (or ground PIN4) to take a picture. Note that it can take several seconds to take the picture (you'll see the red light on your camera), I haven't had the time to improve the transfer speed (if anyone can figure it out, leave in the comments, please!). After taking the shot, turn off Linkit ONE and change the switch from UART to MS (mass storage) and plug it again. You'll be seeing the internal storage just like a USB thumbdrive and in there should be your taken shots. Have fun!

Please, leave a comment if you have any issues or suggestions!

Setup

Connect the grove cable to the camera and to the grove connector on the board. Note that there are two connectors on the board, one is for serial communication (labeled with RX and TX) and the other one is for i2C (labeled SDA and SCL). You must use the serial one, as this is a serial device. The pins on this connector are the same as D0 and D1, which is the second serial port available on the Linkit ONE, but using the connector makes it more pretty. If you have a pushbutton, connect one pin to D4 and the other one to GND, or you can use a simple dupont wire to make this connection.

Code

SerialCam.ino

//  File SerialCamera_DemoCode_CJ-OV528.ino
//  8/8/2013 Jack Shao
//  Demo code for using seeeduino or Arduino board to cature jpg format
//  picture from seeed serial camera and save it into sd card. Push the
//  button to take the a picture .

//  For more details about the product please check http://www.seeedstudio.com/depot/

// PRETO   -> GND
// VERM    -> 5V
// BRANCO  -> D3
// AMARELO -> D2

#include <arduino.h>
#include <LFlash.h>
#include <LSD.h>
#include <LStorage.h>

#define PIC_PKT_LEN    128        //data length of each read, dont set this too big because ram is limited
#define PIC_FMT_VGA    7
#define PIC_FMT_CIF    5
#define PIC_FMT_OCIF   3
#define CAM_ADDR       0
#define CAM_SERIAL     Serial1

#define PIC_FMT        PIC_FMT_VGA

#define SD LFlash          // use Internal 10M Flash
//#define SD LSD           // use SD card

LFile myFile;

const byte cameraAddr = (CAM_ADDR << 5);  // addr
const int buttonPin = 4;                 // the number of the pushbutton pin
unsigned long picTotalLen = 0;            // picture length
int picNameNum = 0;

/*********************************************************************/
void setup()
{
  Serial.begin(9600);
  //CAM_SERIAL.begin(9600);       //cant be faster than 9600, maybe difference with diff board.
  CAM_SERIAL.begin(9600);       //cant be faster than 9600, maybe difference with diff board.
  pinMode(buttonPin, INPUT);    // initialize the pushbutton pin as an input
  Serial.println("Initializing SD card....");
  pinMode(10, OUTPUT);         // CS pin of SD Card Shield

  if (!SD.begin()) {
    Serial.print("sd init failed");
    return;
  }
  Serial.println("sd init done.");
  initialize();
}
/*********************************************************************/
void loop()
{
  int n = 0;
  while (1) {
    Serial.println("\r\nPress the button to take a picture");
    while (digitalRead(buttonPin) == LOW);      //wait for buttonPin status to HIGH
    Serial.println("taking");
    if (digitalRead(buttonPin) == HIGH) {
      delay(20);                               //Debounce
      if (digitalRead(buttonPin) == HIGH)
      {
        delay(200);
        if (n == 0) preCapture();
        Capture();
        Serial.print("Saving picture...");
        GetData();
      }
      Serial.print("\r\nDone ,number : ");
      Serial.println(n);
      n++ ;
    }
  }
}
/*********************************************************************/
void clearRxBuf()
{
  while (CAM_SERIAL.available())
  {
    CAM_SERIAL.read();
  }
}
/*********************************************************************/
void sendCmd(char cmd[], int cmd_len)
{
  for (char i = 0; i < cmd_len; i++) CAM_SERIAL.write(cmd[i]);
}
/*********************************************************************/
int readBytes(char *dest, int len, unsigned int timeout)
{
  int read_len = 0;
  unsigned long t = millis();
  while (read_len < len)
  {
    while (CAM_SERIAL.available() < 1)
    {
      if ((millis() - t) > timeout)
      {
        return read_len;
      }
    }
    *(dest + read_len) = CAM_SERIAL.read();
    //Serial.write(*(dest+read_len));
    read_len++;
  }
  return read_len;
}
/*********************************************************************/
void initialize()
{
  char cmd[] = {0xaa, 0x0d | cameraAddr, 0x00, 0x00, 0x00, 0x00} ;
  unsigned char resp[6];

  Serial.print("initializing camera...");

  while (1)
  {
    sendCmd(cmd, 6);
    if (readBytes((char *)resp, 6, 1000) != 6)
    {
      Serial.print(".");
      continue;
    }
    if (resp[0] == 0xaa && resp[1] == (0x0e | cameraAddr) && resp[2] == 0x0d && resp[4] == 0 && resp[5] == 0)
    {
      if (readBytes((char *)resp, 6, 500) != 6) continue;
      if (resp[0] == 0xaa && resp[1] == (0x0d | cameraAddr) && resp[2] == 0 && resp[3] == 0 && resp[4] == 0 && resp[5] == 0) break;
    }
  }
  cmd[1] = 0x0e | cameraAddr;
  cmd[2] = 0x0d;
  sendCmd(cmd, 6);
  Serial.println("\nCamera initialization done.");
}
/*********************************************************************/
void preCapture()
{
  char cmd[] = { 0xaa, 0x01 | cameraAddr, 0x00, 0x07, 0x00, PIC_FMT };
  unsigned char resp[6];

  while (1)
  {
    clearRxBuf();
    sendCmd(cmd, 6);
    if (readBytes((char *)resp, 6, 100) != 6) continue;
    if (resp[0] == 0xaa && resp[1] == (0x0e | cameraAddr) && resp[2] == 0x01 && resp[4] == 0 && resp[5] == 0) break;
  }
}
void Capture()
{
  char cmd[] = { 0xaa, 0x06 | cameraAddr, 0x08, PIC_PKT_LEN & 0xff, (PIC_PKT_LEN >> 8) & 0xff , 0};
  unsigned char resp[6];

  while (1)
  {
    clearRxBuf();
    sendCmd(cmd, 6);
    if (readBytes((char *)resp, 6, 100) != 6) continue;
    if (resp[0] == 0xaa && resp[1] == (0x0e | cameraAddr) && resp[2] == 0x06 && resp[4] == 0 && resp[5] == 0) break;
  }
  cmd[1] = 0x05 | cameraAddr;
  cmd[2] = 0;
  cmd[3] = 0;
  cmd[4] = 0;
  cmd[5] = 0;
  while (1)
  {
    clearRxBuf();
    sendCmd(cmd, 6);
    if (readBytes((char *)resp, 6, 100) != 6) continue;
    if (resp[0] == 0xaa && resp[1] == (0x0e | cameraAddr) && resp[2] == 0x05 && resp[4] == 0 && resp[5] == 0) break;
  }
  cmd[1] = 0x04 | cameraAddr;
  cmd[2] = 0x1;
  while (1)
  {
    clearRxBuf();
    sendCmd(cmd, 6);
    if (readBytes((char *)resp, 6, 100) != 6) continue;
    if (resp[0] == 0xaa && resp[1] == (0x0e | cameraAddr) && resp[2] == 0x04 && resp[4] == 0 && resp[5] == 0)
    {
      if (readBytes((char *)resp, 6, 1000) != 6)
      {
        continue;
      }
      if (resp[0] == 0xaa && resp[1] == (0x0a | cameraAddr) && resp[2] == 0x01)
      {
        picTotalLen = (resp[3]) | (resp[4] << 8) | (resp[5] << 16);
        //Serial.print("picTotalLen:");
        //Serial.println(picTotalLen);
        break;
      }
    }
  }

}
/*********************************************************************/
void GetData()
{
  unsigned int pktCnt = (picTotalLen) / (PIC_PKT_LEN - 6);
  if ((picTotalLen % (PIC_PKT_LEN - 6)) != 0) pktCnt += 1;

  char cmd[] = { 0xaa, 0x0e | cameraAddr, 0x00, 0x00, 0x00, 0x00 };
  unsigned char pkt[PIC_PKT_LEN];

  char picName[] = "pix00.jpg";
  picName[3] = picNameNum / 10 + '0';
  picName[4] = picNameNum % 10 + '0';

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

  myFile = SD.open(picName, FILE_WRITE);
  if (!myFile) {
    Serial.println("myFile open fail...");
  }
  else {
    for (unsigned int i = 0; i < pktCnt; i++)
    {
      cmd[4] = i & 0xff;
      cmd[5] = (i >> 8) & 0xff;

      int retry_cnt = 0;
retry:
      delay(10);
      clearRxBuf();
      sendCmd(cmd, 6);
      uint16_t cnt = readBytes((char *)pkt, PIC_PKT_LEN, 200);

      unsigned char sum = 0;
      for (int y = 0; y < cnt - 2; y++)
      {
        sum += pkt[y];
      }
      if (sum != pkt[cnt - 2])
      {
        if (++retry_cnt < 100) goto retry;
        else break;
      }

      myFile.write((const uint8_t *)&pkt[4], cnt - 6);
      //if (cnt != PIC_PKT_LEN) break;
    }
    cmd[4] = 0xf0;
    cmd[5] = 0xf0;
    sendCmd(cmd, 6);
  }
  myFile.close();
  picNameNum ++;
}