logo
  Logged as: GUEST   
Dataino.it Store data Make Chart Control API Reference Tutorial Download

.:| Arduino RFID shield - Access Table for Doors - Log Table - ID-12 Innovation |:.

.:| Temperature measurement using Dataino and Arduino - dallas DS18b20 sensor |:.

.:| Controlling Arduino via Internet |:.

.:| DATAINO CHROME APP (Controlling arduino via serial.api ) |:.


Component RequiredRFID

1 X Arduino RFID shield  - ID-12

1 X Arduino + 1 X Arduino ethernet shield or 1 X Arduino Ethernet

1 or more RFID Key

1 - Create the Database

We need a databese with two table one for storing RFID Identifyng and enabling or disabling code for the door

In this example we have two arduino that controlling 2 doors FirstDoor, SecondDoor

ID Time Stamp RFID Name FirstDoor SecondDoor
           

and a table for storing LOG.

ID Time Stamp RFID DOOR STATUS
         

** The ID and the Time Stamp are generated automatically

 

a) Login in dataino.it

b) Click [Database]

c) Click [New Database]

d) Give a {Name} and a {Description} 

img01

e) click [Save]

img02

e) Select [My Home] Database

img03

f) click [New DATA TABLE]

img04

g) Choise if {TYPE} is Pubblic or Private (Pubblic = visible and downlodable  for all visitors of dataino.it). Insert a {Data Name} {Data Description} {Data Location}

img01

h) Click [Save]

img02

i) Now Add a table named RFID_TAG and  add the column  RFID  as a text [min 10 - max 10] , Name as a Text, FirstDoor as a Bit,  SecondDoor as a Bit

umg03

f) Add a second table named RFID_LOG with the column RFID  as a text [min 10 - max 10] ,  DOOR as a Text, Status as a Text

umg03

g) Enablig the RFID TAG

 2 - Enable key
//##################################################################################//
//##################################################################################//
#include <SoftwareSerial.h>
#include <Ethernet.h>
#include <SPI.h>
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
//                                        RFID                                      //
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
//Push button PIN 
#define PULSANTE 5

//Data PIN see (jumper board) (7 | 8)
#define DATA_PIN 7

//RELE pin
#define RELE_PIN 9

//Buzzer PIN jumper see (jumper board) (3 | 11)
#define BUZZ_PIN 3

//led green PIN
#define GREEN_LED_PIN 8

//lod red PIN
#define RED_LED_PIN 6

//RELE Action -  '1' Active RELE after a reading '0' do not active RELE
#define RELE 1

//BUZZER Action -  '1' Active BUZZER after a reading '0' do not active BUZZER 
#define BUZZER   1

//LED Action  '1' - Reading a RFID Enabled blink Green led an reading a Reading a RFID 
// not Enabled blink red led '0' do not blink
#define LED 1

// RELE Activation Time
#define DURATA_RELE 1000

//Start Data Pin for ID-12
SoftwareSerial mySerial(DATA_PIN, 1);
char mqttCode[10];
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
//                                        DATAINO                                   //
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
// the mac address for the shield:
byte mac[] = {
  0x90, 0xA2, 0xDA, 0x0E, 0x80, 0xA2};
// the IP address for the shield:
byte ip[] = { 
  192, 168, 0, 200 };
// internet access via router
byte gateway[] = {
  192, 168, 0, 1 };
// subnet mask
byte subnet[] = {
  255, 255, 255, 0 };
// dataino.it Address
IPAddress server(94,23,64,3); 
//==================================================================================//
//                                     DATAINO                                      //
//==================================================================================//
// API_Key Table RFID_TAG                                                           //
//==================================================================================//
char API_key_Ana[] = "0azX-2z2Y-Injs-78U1-6P26";
//==================================================================================//
// API_Key Table RFID_LOG
//==================================================================================//
char API_key_Log[] = "re82-8c54-674W-s1zo-9BUW";
//==================================================================================//
// API_Key Command Chars
char cmd_find[] = "find_value";
char cmd_add[] = "add_value";
char cmd_read[] = "read_value";
char cmd_delete[] = "delete_value";
char cmd_set[] = "set_value";
//==================================================================================//
// DATA TABLE VAR                                                                   //
//==================================================================================//
char var_RFID_Ana[] = "&RFID=";
char var_Nome_Ana[] = "&Name=";
char var_Door_Ana[] = "&FirstDoor=";
//==================================================================================//
// LOG TABLE VAR                                                                    //
//==================================================================================//
char var_RFID_Log[] = "&RFID=";
char var_Door_Log[] = "&DOOR=FirstDoor";
char var_Status_Log[] = "&STATUS=";
//==================================================================================//
// http command buffer                                                              //
//==================================================================================//
char pageAdd[128];
int totalCount = 0;
int loopCount = 0;
boolean OpenDoor = 0;
EthernetClient client;
//==================================================================================//
// SUTUP
//==================================================================================//
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
    //==============================================================================//
  }
  //================================================================================//
  // Is RELE ACTIVATION TIME < 1 min
  //================================================================================//
  if(DURATA_RELE>60000)
    while(1){
      delay(2000);
      Serial.print("Rele time not valid");
    }
  //================================================================================//
  // set Push Button Pin as Input 
  //================================================================================//
  pinMode(PULSANTE,INPUT);
  //Set to HIGH (pull-up)
  digitalWrite(PULSANTE,HIGH);
  //================================================================================//
  //Activate RELE PIN as Output if RELE is set to 1 
  //================================================================================//
  if(RELE)pinMode(RELE_PIN,OUTPUT);
  //================================================================================//
  //Activate BUZZER PIN  as Output if BUZZER is set to 1 
  //================================================================================//
  if(BUZZER) pinMode(BUZZ_PIN,OUTPUT);
  //================================================================================//
  //Activate GREEN LED PIN AND RED LED PIN  as Output if LED is set to 1 
  //================================================================================//
  if(LED){
    pinMode(GREEN_LED_PIN,OUTPUT);
    pinMode(RED_LED_PIN,OUTPUT);
  }
  //================================================================================//
  // Set Serial Speed 9600 baud
  //================================================================================//
  mySerial.begin(9600);
  //================================================================================//
  // start the Ethernet connection:
  //================================================================================//
  if (Ethernet.begin(mac) == 0) {
    Serial.println("Failed to configure Ethernet using DHCP");
    //==============================================================================//
    // no point in carrying on, so do nothing forevermore:
    // try to congifure using IP address instead of DHCP:
    //==============================================================================//
    Ethernet.begin(mac,ip,gateway,subnet);
  }
  //================================================================================//
  // give the Ethernet shield a second to initialize:
  //================================================================================//
  delay(1000);
}
//==================================================================================//
// LOOP
//==================================================================================//
void loop () {
  if(loopCount < 20)
  {
    //==============================================================================//
    // if loopCount is less than 20, just delay a 50 millisecond
    //==============================================================================//
    delay(50);
  }
  else
  {
    Serial.print(F("Ready\n\r"));
    loopCount = 0;
    //==============================================================================//
    // read tag
    //==============================================================================//
    char *tag;
    tag = read_tag();
    if (strlen(tag) == 10 ){
      // print the readed TAG
      Serial.print("TAG: ");
      Serial.print(tag);
      Serial.print("\n\r");
      //==============================================================================//
      // clear pageadd by strcpy and concatenate the HTTP command
      //==============================================================================//
      strcpy(pageAdd, "GET /~dataino/api/");
      //==============================================================================//
      strcat(pageAdd, cmd_find);
      strcat(pageAdd, ".php?api-KEY=");
      strcat(pageAdd, API_key_Ana);

      strcat(pageAdd, var_RFID_Ana);
      strcat(pageAdd, tag);

      //Is Door enabled for this TAG
      strcat(pageAdd, var_Door_Ana);
      strcat(pageAdd, "1");

      strcat(pageAdd, " HTTP/1.1");

      Serial.println(pageAdd);
      //==============================================================================//
      // connection to Server dataino.it
      //==============================================================================//
      if(!getPage(server,pageAdd)) {
        //============================================================================//
        // Connection failed
        //============================================================================//
        Serial.print(F("Connection Failded\n\r"));
        //=========================================
        // Activate LEDS  and Activate BUZZER
        if(LED){  
          digitalWrite( GREEN_LED_PIN ,HIGH );
          digitalWrite( RED_LED_PIN , HIGH );
        }
        //=========================================
        if(BUZZER){
          analogWrite(BUZZ_PIN,100);                                   
          delay(450);
          digitalWrite(BUZZ_PIN,LOW);
        }
        //=========================================
        if(LED){  
          digitalWrite(GREEN_LED_PIN,LOW);
          digitalWrite(RED_LED_PIN,LOW);
        }
        if(BUZZER){
          analogWrite(BUZZ_PIN,50);                                   
          delay(450);
          digitalWrite(BUZZ_PIN,LOW);
        }
        //=========================================

      }
      else
      {
        //============================================================================//
        // ConnectionTo server dataino.it is OK
        //============================================================================//
        Serial.print(F("Connection OK -> researched RFID\n\r"));
        //============================================================================//
        if (OpenDoor == 1) {
          Serial.print(F("RFID Enabled for This Door\n\r"));
          //=========================================
          if(LED){  
            digitalWrite( GREEN_LED_PIN , HIGH );
            digitalWrite( RED_LED_PIN , LOW );
          }
          //=========================================
          if(BUZZER){
            analogWrite( BUZZ_PIN , 50 );                                   
            delay(50);
            digitalWrite( BUZZ_PIN , LOW );
          }
          //=========================================
          if(RELE){
            if(DURATA_RELE){
              digitalWrite( RELE_PIN , HIGH );
              delay(DURATA_RELE);
              digitalWrite(RELE_PIN,LOW);
            }
            //=========================================
          }
        }
        else {
          Serial.print(F("RFID NOT Enabled for This Door\n\r"));
          if(LED){  
            digitalWrite(RED_LED_PIN,HIGH);
            digitalWrite(GREEN_LED_PIN,LOW);
          }
          if(BUZZER){
            analogWrite(BUZZ_PIN,50);                                   
            delay(100);
            digitalWrite(BUZZ_PIN,LOW);
            delay(50);
            analogWrite(BUZZ_PIN,50);                                   
            delay(150);
            digitalWrite(BUZZ_PIN,LOW);

          }
        }

        totalCount++;
      }
      //================================================================================
      //save in log table Wath appen 
      //================================================================================
      // clear pageadd by strcpy and concatenate command
      strcpy(pageAdd, "GET /~dataino/api/");
      //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      strcat(pageAdd, cmd_add);
      strcat(pageAdd, ".php?api-KEY=");
      strcat(pageAdd, API_key_Log);
      //=========================================
      strcat(pageAdd, var_RFID_Log);
      strcat(pageAdd, tag);
      //=========================================
      //Door enabled for this TAG
      strcat(pageAdd, var_Door_Log);
      strcat(pageAdd, var_Status_Log);
      //=========================================
      if ( OpenDoor == 1 ){
        strcat(pageAdd, "1");
      }
      else
      {
        strcat(pageAdd, "0");
      }
      //=========================================  
      strcat(pageAdd, " HTTP/1.1");
      //=========================================
      Serial.println(pageAdd);
      //=========================================
      if(!getPage(server,pageAdd)) {
        Serial.print(F("Fail Connection\n\r"));
      }
      else {
        Serial.print(F("Connection OK -> Added Log\n\r"));
      }
      //=========================================
      //reset variable to initial value
      //=========================================
      OpenDoor = 0;
      if(LED){  
        digitalWrite(RED_LED_PIN,LOW);
        digitalWrite(GREEN_LED_PIN,LOW);
      }
      //=============================================================================
    }
  }
  loopCount++;
}
//==================================================================================//
// Function READ TAG
//==================================================================================//
char *read_tag()

{
  byte i = 0;
  byte val = 0;
  byte code[6];
  byte checksum = 0;
  byte bytesread = 0;
  byte tempbyte = 0;

  if(mySerial.available() > 0) {
    // check for header 
    if((val = mySerial.read()) == 2) {                  
      bytesread = 0; 
      // read 10 digit code + 2 digit checksum
      while (bytesread < 12) {                        
        if( mySerial.available() > 0) { 
          val = mySerial.read();
          { // if header or stop bytes before the 10 digit reading
            if((val == 0x0D)||(val == 0x0A)||(val == 0x03)||(val == 0x02))  
              // stop reading
              break;                                    
          }

          // Do Ascii/Hex conversion:
          if ((val >= '0') && (val <= '9')) {
            val = val - '0';
          } 
          else if ((val >= 'A') && (val <= 'F')) {
            val = 10 + val - 'A';
          }

          // Every two hex-digits, add byte to code:
          if (bytesread & 1 == 1) {
            // make some space for this hex-digit by
            // shifting the previous hex-digit with 4 bits to the left:
            code[bytesread >> 1] = (val | (tempbyte << 4));
            // If we're at the checksum byte,
            if (bytesread >> 1 != 5) {
              // Calculate the checksum... (XOR)            
              checksum ^= code[bytesread >> 1];       
            };
          } 
          else {
            // Store the first hex digit first...
            tempbyte = val;                           
          };
          // ready to read next digit
          bytesread++;                                
        } 
      } 
      //==============================================================
      // RETURN VALUE :
      // if 12 digit read is complete
      //==============================================================
      if (bytesread == 12) {                         
        return converti(code);  
      }
      bytesread = 0;
    }
  }

  return "";
}
//==================================================================================//
// bytes TO String
//==================================================================================//
char* converti(byte * code)
{
  int j = 0;
  //Serial.print("Here are the bytes: ");
  for (int i = 0; i < 5; i++) {
    byte hinibble = (code[i] >> 4) & 0x0f;
    byte lonibble = code[i] & 0x0f;
    //Serial.print(hinibble, HEX);
    //Serial.print(lonibble, HEX);
    //Serial.print(' ');
    mqttCode[j++] = bintohexascii(hinibble);
    mqttCode[j++] = bintohexascii(lonibble);
  }
  mqttCode[j] = '\0';    
  //Serial.print("\nHere is the string: ");
  //Serial.println(mqttCode);
  //Serial.println();
  //delay(1000);
  return mqttCode;
}
//==================================================================================//
// FUNCTION
//==================================================================================//
char bintohexascii(byte x)
{
  char hex[16] = {
    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'        };
  return hex[x & 0x0f];
}
//==================================================================================//
// HTTP Command dataino.it
//==================================================================================//
byte getPage(IPAddress ipBuf,char *page)

{
  int inChar;
  char outBuf[128];
  Serial.print(F("connecting..."));

  //Serial.println(ipBuf);

  if(client.connect(ipBuf,80))
  {
    Serial.println(F("connected"));
    client.println(page);
    client.println("Host: www.dataino.it");
    client.println("User-Agent: Arduino"); 
    client.println("Connection: close\r\n");       
    Serial.println(F("outBuf"));
  } 
  else	
  {
    Serial.println(F("failed"));
    return 0;
  }
  //================================================================================//
  // connectLoop controls the hardware fail timeout
  //================================================================================//
  int connectLoop = 0;
  //================================================================================//
  //Unsigned long variables are extended size variables for number storage, 
  //and store 32 bits (4 bytes). Unlike standard longs unsigned longs 
  //won't store negative numbers, making their range from 0 to 4,294,967,295
  //================================================================================//
  long VAL[16];
  while(client.connected())
  {
    while(client.available())
    {
      //============================================================================//
      inChar = client.read();

      Serial.print(char(inChar));
      //============================================================================//
      // READ The START CHAR (#)
      //============================================================================//
      if (inChar==char('#'))
      {
        inChar = client.read();
        //==========================================================================//
        // READ THE VALUE 
        //==========================================================================//
        while (inChar != '#'){
          //========================================================================//
          // Reset value
          //========================================================================//
          int count_val = 0 ;
          unsigned long i = 1;
          VAL[count_val] = 0; 
          //========================================================================//
          // loop reading and waiting the-end value CHAR (;)
          //========================================================================//
          do {
            VAL[count_val] = VAL[count_val] + ( inChar -48 ) * i;
            i = i * 10;
            inChar = client.read();
          }
          while ( inChar != char(';') );
          //========================================================================//
          //
          //========================================================================//
          inChar = client.read();
          //========================================================================//
          // THE STOP CHAR (*)
          //========================================================================//
          if ( inChar == char( '*' ) ){ 
            Serial.print( F("Query=") );
            Serial.print(VAL[count_val]);
            if ( VAL[count_val] == 1 ){
              OpenDoor = 1; 
            }
            else{
              OpenDoor = 0; 
            }

            break;   
          }
          count_val = count_val + 1;
        }
      }
      //===========================================================================//
      // set connectLoop to zero if a packet arrives
      //===========================================================================//
      connectLoop = 0;
    }
    //============================================================================//
    //
    //============================================================================//
    connectLoop++;
  }
  //==============================================================================//
  // if more than 10000 milliseconds since the last packet
  //==============================================================================//
  if(connectLoop > 10000)
  {
    // then close the connection from this end.
    Serial.println(F("Timeout"));
    client.stop();
  }
  //=============================================================================//
  // this is a delay for the connectLoop timing
  //=============================================================================//
  delay(1);
  Serial.println(F("disconnecting."));
  //=============================================================================//
  // close client end
  //=============================================================================//
  client.stop();
  return 1;
}
//==================================================================================//
//==================================================================================//
.:| UP |:.