How to control a motorized IP camera with Arduino to take pictures from different locations and post them online as if they came from different webcams? I’ll explain how to do it.

In this article I explain how I made a webcam control system using the famous Arduino microcontroller with ethernet module and Apexis APM-J902-Z-WS PTZ motorized camera.

Ingrediants:

a panoramic position
the Arduino microcontroller personally I recommend Arduino Mega
the Arduino Ethernet Shield ethernet module
a micro SD
a motorized webcam
a pc with the development tool for Arduino Arduino IDE
a usb cable to communicate with the arduino board
an internet connection

The goal: multiple webcams in one

Having a terrace placed in a very wide panoramic position, framing a single point was really a waste. I said to myself, why not take advantage of the motion capability of a motorized webcam to take pictures from different angles, and then post each photo on webcam sites, as if they were webcams physically placed in different places?

To do this, the webcam software was not enough. The idea of using Arduino seemed to me the simplest thing … cheaper and also fun!

Now I’ll explain how I did it.

Factual status analysis: what can the webcam do on its own?

This is the Apexis APM-J902-Z-WS webcam. Let’s start from the state of affairs of what it can do.

First of all, the apexis APM-J902 is a wireless network webcam so it can be remotely controlled via the network (cable or wireless). The first thing to do is therefore to assign them a static IP address and configure it on the home switch or router. Via the network, it can be configured using the appropriate control panel.

Pannello di controllo della webcam apexis APM-J902-Z-WS

So let’s see what the cam can do for our project: the cam can receive and execute commands via http to move the lens right, left, down and up

Receive and execute commands via http to return the image pointed to by the target at that moment
Receive and execute commands via http to memorize up to 8 target positions
Receive and execute commands via http to move the object to one of the 8 stored positions

Taking advantage of the above points it is easy to understand how this can be achieved. Just create a program that for each of the positions to be photographed runs in sequence:

Goal positioning on position 1
Image downloads on location 2
Objective positioning on position 2
Image downloads on location 2
Objective positioning on position 2
Image downloads on location 3
Upload images to FTP server
Wait 10 minutes (or as long as we want) and then repeat the entire cycle

Now just make a program that accomplishes all of this. The problem is that you should leave a pc on all day and all night just to do this !! That’s why I got the idea of using Arduino, which instead of a few dozen Watts, consumes about 4-6 Watts.

Assuming that the IP address of the cam is 10.0.0.100 the commands to be sent to the cam are simple url, and are the following.

Command to receive the “snapshot” image:

http://10.0.0.100:81/snapshot.cgi?user=NOMEUTENTE&pwd=PASSWORD

Command to recall the shift of the lens to a specific position:

http://10.0.0.100:81/decoder_control.cgi?command=31&user=NOMEUTENTE&pwd=PASSWORD

Solution: use Arduino + Ethernet Shield

TWO WORDS ABOUT ARDUINO:
Arduino (official sitre https://www.arduino.cc) is a programmable microcontroller, an all-Italian Open Source project. In a nutshell it is an electronic board equipped with a microprocessor, a memory to contain programs, various digital and analog inputs and outputs, a C / C ++ programming interface and a myriad of interfaceable components. Arduino is a low-cost platform and is currently used both by students for experimental projects, by hobbyists who are passionate about electronics, and for more professional uses.

There are several versions of Arduino. In my project I used Arduino Mega 2560 R3: Arduino Mega 2560 R3:

Arduino is cspable to connect to the network, and therefore also to the internet through an additional board called Ethernet Shield:

Arduino Ethernet Shield - Arduino Modulo Ethernet

The two boards are used by superimposing the Ethernet Shield module on the Arduino board so that the connecting combs on the Ethernet board fit into the connector holes on the Arduino board.

We will use the integrated Micro SD memory reader of the Ethernet Shield module to store the captured images before sending them to the FTP server.

Using the appropiate development IDE and the appropriate libraries it is possible to program Arduino. In this article I will not explain how to install and configure the development tool on your pc as it is all well explained here.

The final result:

First of all let’s see the final result

These are the three images captured:

The three images are actually clean without the time and logo, which is then put by my PHP code whose operation is not covered here. But the end result is still this, that is, three distinct images as if they came from three different fixed webcams.

The software

Since the code is a bit long, I will not explain everything step by step but only some important details, leaving the explanation of the rest to the comments in the code.

The libraries we will need are the following:

#include <SPI.h>; // per la comunicazine seriale

Let’s move on to the declaration of the main variables. In pLet’s move on to the declaration of the main variables. In particular, the MAC ADDRESS of the Ethernet Shield card must be indicated. You get this number from a label on the card itself. It is essential to get the IP from the DHCP Client.

The setup () function starts when you power up the board and has the task of:

Initialize the SD micro sim
Initialize the serial communication with the PC for printing the logs

void setup()
{
    pinMode(LED_PIN, OUTPUT); // Led che indica se è in ciclo o in attesa 

   // initialize serial communications at 9600 bps:
  Serial.begin(9600);
  Serial.println("(c) Copyright 2013 Alessandro Scola");
  Serial.println("http://www.alessandroscola.it");
  Serial.println("Released under Apache License, version 2.0");
  Serial.println("Software da utilizzare con Arduino Mega 2560 + Ethernet Shield");
  Serial.println("Il software controlla una IP cam Apexis, muovendola in 3 posizioni \"preset\" differenti");
  Serial.println("salvando le 3 immagini su SD card,");
  Serial.println("e successivamente facendo l'upload delle immagini su Server remoto via FTP.");
  Serial.println("Il ciclo si ripete ogni 10 minuti. Ogni 10 minuti vengono acquisite le 3 immagini");
  Serial.println("********************************************");
  Serial.print("Controllo SD Card...");

  //OBBLIGATORIO per l'uso della SD. Dato che arduino comunica alla scheda SD ed alla scheda ethernet con gli stessi pin,
  //solo una delle due può essere utilizzata alla volta. Tramite il pin 53 impostato ad HIGH si disattiva la scheda ethernet
  //in modo da poter usare la scheda SD e viceversa. impostando il pin 53 a OUTPUT si fa in modo che la libreria SD abbia la capacità
  //di gestire in automatico l'attivazione e la disattivazione di questa (in modo da non doverlo fare noi ogni volta) ma questa
  //gestione automatica del pin 53 da parte della libreria SD inizia solo dopo aver inizializzato la libreria con il comando SD.begin(4)

   digitalWrite(53,HIGH);  // il pin 53 è solo per la scheda Arudino Mega. per le altre schede usare il pin 10
   pinMode(53,OUTPUT);     // il pin 53 è solo per la scheda Arudino Mega. per le altre schede usare il pin 10 

   // set up SD
   if(SD.begin(4) == 0)
      Serial.println("errore, non riesco ad accedere a SD");
   else
   {
     Serial.println("SD Card OK !");
   }
}

Fate attenzione al Pin 53 (per la Scheda Arduino Mega, 10 per le altre schede), deve essere impostato subito come uscita e subito a valore HIGH. Questo è spiegato nei commenti e serve a disabilitare la shceda ethernet per poter inizializzare la comunicazione con la microsim SD, dato che l’accesso alla SD è gestita dalla stessa scheda che gestisce la scheda di rete.

Il resto del codice C++ comprende la funzione loop() che rappresenta l’intero ciclco del programma e alcune funzioni per la gestione della connessione FTP.

void loop()
{
  int err =0;
  EthernetClient c;
  HttpClient http(c);
  long bufferCount = 0;

  digitalWrite(LED_PIN,HIGH);

   Serial.println("********************************************");
   Serial.println("Sto ottendendo indirizzo IP dal router ...");
   while (Ethernet.begin(mac) != 1)
   {
    Serial.print("Errore ottendendo indirizzo IP via DHCP, provo ancora ...");
    delay(15000);
   }
   Serial.println("Ok !");

 //******************************************************************************************

 //Da il comando per la rotazione in posizione 1
 // go tp POSIZIONE 1:
 Serial.println("********************************************");
 Serial.println ("Muovo la cam in POSIZIONE 1 e attendo che si posizioni");

 char kPathPOSIZIONE1[] ="/decoder_control.cgi?command=31&pwd=PASSWORD";
 err = http.get(kHostname, 81, kPathPOSIZIONE1);
 if (err != 0)
 {
   Serial.println ("Errore muovendo a POSIZIONE 1.");
 }
 http.stop();
 delay(8000); // attendo 8 secondi che la cam si posizioni

 //******************************************************************************************

  char kPath[] ="/snapshot.cgi?user=NOMEUTENTE&pwd=PASSWORD";
  err = http.get(kHostname, 81, kPath);
  if (err == 0)
  {
    Serial.println("Connessione con la cam OK !");

    err = http.responseStatusCode();
    if (err >= 0)
    {
      Serial.print("Codice risposta http: ");
      Serial.println(err);

      // Usually you'd check that the response code is 200 or a
      // similar "success" code (200-299) before carrying on,
      // but we'll print out whatever response we get

      err = http.skipResponseHeaders();
      if (err >= 0)
      {
        int bodyLen = http.contentLength();
        Serial.print("La risposta e' lunga: ");
        Serial.print(bodyLen);
        Serial.println(" bytes");

        file = SD.open("cam1.jpg", FILE_WRITE);
        file.seek(0);
        if (file) Serial.print("Salvo l'immagine su SD...");
        else Serial.println("Impossibile aprire file!");

        // Now we've got to the body, so we can print it out
        unsigned long timeoutStart = millis();
        byte c;
        // Whilst we haven't timed out haven't reached the end of the body

        bufferCount=0;
        while ( (http.connected() || http.available()) 
               ((millis() - timeoutStart) < kNetworkTimeout) ) { if (http.available()) { //c = http.read(); clientBuf[bufferCount] = http.read(); bufferCount++; // Print out this character //Serial.print(c); //if (file) file.write(c); if(bufferCount > 2047)
                  {
                    file.write(clientBuf,2048);
                    bufferCount = 0;
                  }

                // We read something, reset the timeout counter
                timeoutStart = millis();
            }
            else
            {
                // We haven't got any data, so let's pause to allow some to
                // arrive
                delay(kNetworkDelay);
            }
        }// fine while
        if(bufferCount > 0) file.write(clientBuf,bufferCount);

        file.close();
        Serial.println ("File chiuso.");
      }
      else
      {
        Serial.print("Failed to skip response headers: ");
        Serial.println(err);
      }
    }
    else
    {
      Serial.print("Nessuna risposta: ");
      Serial.println(err);
    }
  }
  else
  {
    Serial.print("Connect failed: ");
    Serial.println(err);
  }
  http.stop();

 //****************************************************************************************

 //Da il comando per la rotazione in posizione 2
 // go tp POSIZIONE 2:  

 Serial.println("********************************************");
 Serial.println ("Muovo la cam in POSIZIONE 2 e attendo che si posizioni");

 char kPathPOSIZIONE2[] ="/decoder_control.cgi?command=33&user=NOMEUTENTE&pwd=PASSWORD";
 err = http.get(kHostname, 81, kPathPOSIZIONE2);
 if (err != 0)
 {
   Serial.println ("Errore muovendo a POSIZIONE 2.");
 }
 http.stop();
 delay(6000);

 //******************************************************************************************

 // SALVA IMG 2

  err = http.get(kHostname, 81, kPath);
  if (err == 0)
  {
    Serial.println("Connessione con la cam OK !");

    err = http.responseStatusCode();
    if (err >= 0)
    {
      Serial.print("Codice risposta http: ");
      Serial.println(err);

      // Usually you'd check that the response code is 200 or a
      // similar "success" code (200-299) before carrying on,
      // but we'll print out whatever response we get

      err = http.skipResponseHeaders();
      if (err >= 0)
      {
        int bodyLen = http.contentLength();
        Serial.print("La risposta e' lunga: ");
        Serial.print(bodyLen);
        Serial.println(" bytes");

        file = SD.open("cam2.jpg", FILE_WRITE);
        file.seek(0);
        if (file) Serial.print("Salvo l'immagine su SD...");
        else Serial.println("Impossibile aprire file!");

        // Now we've got to the body, so we can print it out
        unsigned long timeoutStart = millis();
        byte c;
        // Whilst we haven't timed out haven't reached the end of the body
        bufferCount=0;
        while ( (http.connected() || http.available()) 
               ((millis() - timeoutStart) < kNetworkTimeout) ) { if (http.available()) { //c = http.read(); clientBuf[bufferCount] = http.read(); bufferCount++; // Print out this character //Serial.print(c); //if (file) file.write(c); if(bufferCount > 2047)
                  {
                    file.write(clientBuf,2048);
                    bufferCount = 0;
                  }

                // We read something, reset the timeout counter
                timeoutStart = millis();
            }
            else
            {
                // We haven't got any data, so let's pause to allow some to
                // arrive
                delay(kNetworkDelay);
            }
        }// fine while

        if(bufferCount > 0) file.write(clientBuf,bufferCount);
        file.close();
        Serial.println ("File chiuso.");
      }
      else
      {
        Serial.print("Failed to skip response headers: ");
        Serial.println(err);
      }
    }
    else
    {
      Serial.print("Nessuna risposta: ");
      Serial.println(err);
    }
  }
  else
  {
    Serial.print("Connect failed: ");
    Serial.println(err);
  }
  http.stop();

  //****************************************************************************************

 //Da il comando per la rotazione in posizione 3
 // go tp POSIZIONE 3:  

 Serial.println("********************************************");
 Serial.println ("Muovo la cam in POSIZIONE 3 e attendo che si posizioni");

 char kPathPOSIZIONE3[] ="/decoder_control.cgi?command=35&user=NOMEUTENTE&pwd=PASSWORD";
 err = http.get(kHostname, 81, kPathPOSIZIONE3);
 if (err != 0)
 {
   Serial.println ("Errore muovendo a POSIZIONE 3.");
 }
 http.stop();
 delay(4000);

 //******************************************************************************************

 // SALVA IMG 3

  err = http.get(kHostname, 81, kPath);
  if (err == 0)
  {
    Serial.println("Connessione con la cam OK !");

    err = http.responseStatusCode();
    if (err >= 0)
    {
      Serial.print("Codice risposta http: ");
      Serial.println(err);

      // Usually you'd check that the response code is 200 or a
      // similar "success" code (200-299) before carrying on,
      // but we'll print out whatever response we get

      err = http.skipResponseHeaders();
      if (err >= 0)
      {
        int bodyLen = http.contentLength();
        Serial.print("La risposta e' lunga: ");
        Serial.print(bodyLen);
        Serial.println(" bytes");
        Serial.println("Body returned follows:");

        file = SD.open("cam3.jpg", FILE_WRITE);
        file.seek(0);
        if (file) Serial.print("Salvo l'immagine  su SD...");
        else Serial.println("Impossibile aprire file!");

        // Now we've got to the body, so we can print it out
        unsigned long timeoutStart = millis();
        byte c;
        // Whilst we haven't timed out haven't reached the end of the body
        bufferCount=0;
        while ( (http.connected() || http.available()) 
               ((millis() - timeoutStart) < kNetworkTimeout) ) { if (http.available()) { //c = http.read(); clientBuf[bufferCount] = http.read(); bufferCount++; // Print out this character //Serial.print(c); //if (file) file.write(c); if(bufferCount > 2047)
                  {
                    file.write(clientBuf,2048);
                    bufferCount = 0;
                  }

                // We read something, reset the timeout counter
                timeoutStart = millis();
            }
            else
            {
                // We haven't got any data, so let's pause to allow some to
                // arrive
                delay(kNetworkDelay);
            }
        }// fine while
        if(bufferCount > 0) file.write(clientBuf,bufferCount);
        file.close();
        Serial.println ("File chiuso.");
      }
      else
      {
        Serial.print("Failed to skip response headers: ");
        Serial.println(err);
      }
    }
    else
    {
      Serial.print("Nessuna risposta: ");
      Serial.println(err);
    }
  }
  else
  {
    Serial.print("Connessione fallita: ");
    Serial.println(err);
  }
  http.stop();

  //******************************************************************************************

 //Da il comando per la rotazione in posizione 1
 // go tp POSIZIONE 1:
 Serial.println("********************************************");
 Serial.println ("Riporto la cam in POSIZIONE 1 e attendo che si posizioni");

 char kPathPOSIZIONE4[] ="/decoder_control.cgi?command=31&user=NOMEUTENTE&pwd=PASSWORD";
 err = http.get(kHostname, 81, kPathPOSIZIONE1);
 if (err != 0)
 {
   Serial.println ("Errore muovendo a POSIZIONE 1.");
 }
 http.stop();
 delay(8000); // attendo 8 secondi che la cam si posizioni

 //******************************************************************************************

  //Carico le immagini sul server FTP
  Serial.println("********************************************");
  Serial.println ("");
  Serial.println ("CARICO LE 3 IMMAGINI SU SERVER FTP");
  Serial.println ("");
  uploadFTP();
  Serial.println("********************************************");

  Serial.println("Attendo 10 minuti e poi ricomincero' il ciclo...");
  digitalWrite(LED_PIN, LOW);
  delay(600000);
  //Serial.println("Attendo 15 secondi ...");
  //delay(15000);
} // fine void loop()

// #################### FUNZIONI PER L'FTP: #########################
byte uploadFTP()
{
  char fileName1[13] = "CAM1.JPG";
  char fileName2[13] = "CAM2.JPG";
  char fileName3[13] = "CAM3.JPG";
  byte clientBuf[64];
  long clientCount = 0;

  HttpClient http(client);

  if (client.connect(server,21))
  {
    Serial.println(F("Connesso al server..."));
  }
  else
  {
    Serial.println(F("Connessione al server fallita."));
    return 0;
  }

   if(!eRcv()) return 0;

  client.println(F("NOMEUTENTE FTP"));

  if(!eRcv()) return 0;

  client.println(F("PASSWORD FTP"));

  if(!eRcv()) return 0;

  client.println(F("SYST"));

  if(!eRcv()) return 0;

  client.println(F("PASV"));

  if(!eRcv()) return 0;

  char *tStr = strtok(outBuf,"(,");
  int array_pasv[6];
  for ( int i = 0; i < 6; i++) {
    tStr = strtok(NULL,"(,");
    array_pasv[i] = atoi(tStr);
    if(tStr == NULL)
    {
      Serial.println(F("Bad PASV Answer"));    

    }
  }

  unsigned int hiPort,loPort;

  hiPort = array_pasv[4] < 8; loPort = array_pasv[5]  255; Serial.print(F("Data port: ")); hiPort = hiPort | loPort; Serial.println(hiPort); if (dclient.connect(server,hiPort)) { Serial.println(F("Data connected")); } else { Serial.println(F("Data connection failed")); client.stop(); return 0; } //******************************************************** client.println(F("TYPE I")); // Importante! seleziona modo BINARIO per il trasferimento !! client.println(F("CWD /www.alessandroscola.it/webcam-belluno/CAM1")); client.print(F("STOR ")); client.println(fileName1); if(!eRcv()) { dclient.stop(); return 0; } file = SD.open(fileName1, FILE_READ); if(!file) { Serial.println("Apertura SD fallita !"); return 0; } Serial.println(F("Writing")); clientCount=0; while(file.available()) { clientBuf[clientCount] = file.read(); clientCount++; if(clientCount > 63)
    {
      dclient.write(clientBuf,64);
      clientCount = 0;
    }
  }
  if(clientCount > 0) dclient.write(clientBuf,64);
  dclient.stop();
  Serial.println(F("Data disconnected"));
  file.close();

  //*********************************************************
  if (dclient.connect(server,hiPort))
  {
    Serial.println(F("Data connected"));
  }
  else
  {
    Serial.println(F("Data connection failed"));
    client.stop();
    return 0;
  }

   client.println(F("CWD /www.alessandroscola.it/webcam-belluno/CAM2"));
  client.print(F("STOR "));
  client.println(fileName2);

   if(!eRcv())
  {
    dclient.stop();
    return 0;
  }
  file = SD.open(fileName2, FILE_READ);
  if(!file)
  {
    Serial.println("Apertura SD fallita");
    return 0;
  }
  Serial.println(F("Writing"));
  clientCount=0;
  while(file.available())
  {
    clientBuf[clientCount] = file.read();
    clientCount++;

    if(clientCount > 63)
    {
      dclient.write(clientBuf,64);
      clientCount = 0;
    }
  }
  if(clientCount > 0) dclient.write(clientBuf,clientCount);
  dclient.stop();
  Serial.println(F("Data disconnected"));
  file.close();

  //*********************************************************
  if (dclient.connect(server,hiPort))
  {
    Serial.println(F("Data connected"));
  }
  else
  {
    Serial.println(F("Data connection failed"));
    client.stop();
    return 0;
  }

  client.println(F("CWD /www.alessandroscola.it/webcam-belluno/CAM3"));
  client.print(F("STOR "));
  client.println(fileName3);

   if(!eRcv())
  {
    dclient.stop();
    return 0;
  }

  file = SD.open(fileName3, FILE_READ);
  if(!file)
  {
    Serial.println("Apertura SD fallita");
    return 0;
  }
  Serial.println(F("Writing"));
  clientCount=0;
  while(file.available())
  {
    clientBuf[clientCount] = file.read();
    clientCount++;

    if(clientCount > 63)
    {
      dclient.write(clientBuf,64);
      clientCount = 0;
    }
  }
  if(clientCount > 0) dclient.write(clientBuf,clientCount);
  dclient.stop();
  Serial.println(F("Data disconnected"));
  file.close();
  //******************************************************
  dclient.stop();
  Serial.println(F("Data disconnected"));

  if(!eRcv()) return 0;

  client.println(F("QUIT"));

  if(!eRcv()) return 0;

  client.stop();
  Serial.println(F("Command disconnected"));

  file.close();
  Serial.println(F("SD Chiusa."));
  return 1;

} // fine doFTP()

byte eRcv()
{
  byte respCode;
  byte thisByte;

  while(!client.available()) delay(1);

  respCode = client.peek();

  outCount = 0;

  while(client.available())
  {
    thisByte = client.read();
    Serial.write(thisByte);

    if(outCount < 127) { outBuf[outCount] = thisByte; outCount++; outBuf[outCount] = 0; } } if(respCode >= '4')
  {
    efail();
    return 0;
  }

  return 1;
}

void efail()
{
  byte thisByte = 0;

  client.println(F("QUIT"));

  while(!client.available()) delay(1);

  while(client.available())
  {
    thisByte = client.read();
    Serial.write(thisByte);
  }

  client.stop();
  Serial.println(F("Command disconnected"));
  file.close();
  Serial.println(F("SD Chiusa."));
}

Help me support this blog

If you want you can help me concretely to support this blog. You can do it with a free donation, by credit card or paypal. I will be grateful to you.

Blog Post

Control an IP camera with Arduino

How to control a motorized IP camera with Arduino to take pictures from different locations and post them online as if they came from different webcams? I’ll explain how to do it.

Ingrediants:

The goal: multiple webcams in one

Factual status analysis: what can the webcam do on its own?

Solution: use Arduino + Ethernet Shield

The final result:

The software

Help me support this blog

Categories

Blog Post

Control an IP camera with Arduino

How to control a motorized IP camera with Arduino to take pictures from different locations and post them online as if they came from different webcams? I’ll explain how to do it.

Ingrediants:

The goal: multiple webcams in one

Factual status analysis: what can the webcam do on its own?

Solution: use Arduino + Ethernet Shield

The final result:

The software

Help me support this blog

Related Posts

View PDF documents with HTML5

Snowman, I program a game for the Commodore 64

Recursion in Basic on Commodore 64 – The Tower of Hanoi

Categories