As I mentioned in one my of previous posts about RDM6300, I have built an RFID based access control system for the makerspace where I work. To build this project, I chose NodeMCU as micro controller and as a server since we want to monitor our system remotely. For wireless connectivity, I can interface ESP8266 with Arduino. But in the sense of price and easiness it's NodeMCU is better suited for WiFi or Cloud connectivity projects.

What is NodeMCU ?

NodeMCU is a open-source firmware based on ESP8266 WiFi-soc, that helps you to prototype your IOT products. There is a wide variety of development kits available based on NodeMCU firmware. For more information on ESP8266 and interfacing with Arduino, checkout this article ESP8266 INTERFACING WITH ARDUINO UNO.

When we look at features of NodeMCU, it has small form factor and comes with GPIO pins to which you can connect sensors, and input/output devices required for your project. Open-source, Interactive, Programmable, Low cost, Simple, Smart, WI-FI enabled - this is what they described in NodeMCU official website.

It's easy program NodeMCU if you are familiar with Arduino already, but prior experience with Arduino is not mandatory. There are many other ways you can program NodeMCU using Lua, python, JavaScript etc. Here I am going with Arduino IDE for that purpose.

Steps

1. Install Arduino IDE
2. Configure board manager to recognize NodeMCU
3. Write sample program
4. Upload program to NodeMCU

So, let me explain each steps in detail.

Install Arduino IDE

Go to Arduino website adn download and install Arduino software that suits your operating system.

Configure board manager to recognize NodeMCU

Open Aarduino IDE. By defualt, Arduino IDE don't comes with a support for NodeMCU. We have to configure Arduino IDE for third party development tools or boards to program using Arduino IDE. In order to do that,

1. Select File >> Preferences from the menu. Where you can see a label named Additional board manager URLs: next to a text box. Put http://arduino.esp8266.com/stable/package_esp8266com_index.json in that text text box and click OK button.

1. Select Tools >> Board >> Board Manager from the menu. It will take a little to load the board details. When it's done, search esp8266 or NodeMCU on the search box. Then something shown below will appear. Click on install, this will install necessary files to work with NodeMCU in Arduino IDE. Once the download is complete, close the Board manager window.

1. To verify ESP8266 or NodeMCU board is configured correctly, go to Tools >> Board >> NodeMCU 1.0 (ESP 12E Module). If necessary files are not downloaded completely, you can't see NodeMCU 1.0 entry in Boards list.

2. Now connect NodeMCU to your computer using USB cable.

3. Go to Tools >> Port. Select port of connected NodeMCU.

Write sample program

To make sure your NodeMCU is working prefectly with Arduino IDE, let's try a sample blink program which is already in the Arduino IDE.

1. Go to File >> Examples >> ESP8266 >> Blink.

It will look like below screen shot.

Upload program to NodeMCU

Now it's time to upload the blink program to NodeMCU hardware. Make sure NodeMCU is connected, correct Board and Port is elected. Then click on upload button. It will take few seconds to finish the uploading. If it get uploaded without any errors, then LED in the NodeMCU will start blinking.

Congratulations! You have completed your first NodeMCU programming. Now explore more exciting possibilities you can try this little amazing hardware.

What about if we can operate scissor using a motor and battery? Cool, Isn't it. Here I will share a simple way to build motorized scissors. But why this motorized scissors? That's a good question. For me, this was an essential requirement to Automate Ribbon Cutting process of Inauguration of our maker-space. One of my acquaintance come with this idea to automate ribbon cutting, and then I agreed to give a try. Watch the working video given below and you will get a better idea about motorized scissors.

Working Video

Components

1. BO Motor with Wheel (http://amzn.in/fm9uD1i)
2. Scissors
3. Strong bond glue - Araldite, Super Glue etc
4. Strong thing iron road
5. 9v battery

How to Build - Steps

Arrange the components listed above.

1. Make a small hole in the plastic handle of scissors and in the wheel body as shown in the images using Drilling machine. Here I used 2mm drill bit. Choose a drill bit that suits the diameter of your iron road.
2. Fix one handle of scissors on top of BO motor as shown in pictures using a strong adhesive like Super Glue or Araldite.
3. Take the iron road and bend both sides 90 degrees and connect the Schorrs handle and wheel. Then try to rotate the wheel gently. If the scissor handle is moving with it, you are done. Sometimes the length of the iron road is little longer so that the teeth of scissor will not come close. In that situation, what you have to do is bend the iron road a little to adjust its effective length (See the 2nd and 3rd pictures).
4. Now you are all set to fly. Connect a 9v battery to the motor and you will have a motorized scissor with you. You can use this to cut papers, cloths or other materials which is suitable for the used scissors. As part of the user experience, you can connect a switch between the positive side of battery and motor, so that you can operate the scissors easily.

A BO Motor is a DC motor with gear setup and operated by battery. The gear setup is to increase the torque of the motor. These type of motors are mainly used in DIY robot vehicles. BO motors are available in different specifications.

Learnings

1. How to use Araldite Adhesive. Previously I have used Araldite for bonding, but I misunderstood it as a weak adhesive. Becuase Araldite takes time to make a strong between materials. But I expected a strong bond using this in a shorter time. After watching a video on how to use Araldite, I understood that it requires some time to settle the bond.

TBC...

Recently I was working on an RFID access control system for Makerspace where I am working. I have used Arduino Uno and RDM6300 for prototyping. You may wonder why I used RDM6300 instead of popular RC522 reader module. Students who study in the campus were already issued ID cards with RFID tags of 125KHz frequency. So, RC522 is not an option as a reader, because RC522 is 13.56 MHz Reader.

For 125KHz tags, we can either use RDM630 or RDM6300 as reader module. Both have the same pin layouts. But RDM630 is superior in functionality and little costlier. I ordered RDM6300 from Amazon without aware of its multi-read behaviour. That is RDM6300 will read the same tag continuously if it's put near the reader for a long time. While RDM630 will read the same tag only once. So, when I use the output of this reader to trigger a hardware like an opening door if the tag is authorised, it will trigger multiple times if the card placed near the reader for a while.

To tackle this issue, I have tried several ways like clearing input buffer, set up a delay etc. But none of them gave me the perfect solution. The problem with Serial input buffer is that we don't have control over it and Arduino doesn't provide a way to clear input serial buffer.

So, I finally come up with a solution for this. I managed the triggering process completely in software part rather than depending on hardware Serial communication. What I did is that I have stored the previous tag information in a variable called previous_tag and compared it with currently read tag. If they are not matching, then we can trigger the hardware or door. And when there is no serial communication happening, I will reset this previous_tag to zero. This solution is working perfectly for me to control the door using RDM6300 RFID reader module.

Connection

RDM6300 5V - Arduino 5V
RDM6300 GND - Arduino GND
RDM6300 TX - Arduino PIN 2
Connect antenna in the antenna pins of reader
Arduino PIN8 - LED Positive leg
Arduino GND - LED negative leg

Code

This is my tweaked version of code originally posted in this website

#include <SoftwareSerial.h>
const int BUFFER_SIZE = 14; // RFID DATA FRAME FORMAT: 1byte head (value: 2), 10byte data (2byte version + 8byte tag), 2byte checksum, 1byte tail (value: 3)
const int DATA_SIZE = 10; // 10byte data (2byte version + 8byte tag)
const int DATA_VERSION_SIZE = 2; // 2byte version (actual meaning of these two bytes may vary)
const int DATA_TAG_SIZE = 8; // 8byte tag
const int CHECKSUM_SIZE = 2; // 2byte checksum
SoftwareSerial ssrfid = SoftwareSerial(2,3); 
uint8_t buffer[BUFFER_SIZE]; // used to store an incoming data frame 
int buffer_index = 0;
unsigned long previous_tag = 0L;
void setup() {
  pinMode(8,OUTPUT); //led pin
 Serial.begin(9600); 

 ssrfid.begin(9600);
 ssrfid.listen(); 

 Serial.println("INIT DONE");
}
void loop() {
  if (ssrfid.available() > 0){
    bool call_extract_tag = false;

    int ssvalue = ssrfid.read(); // read 
    if (ssvalue == -1) { // no data was read
      return;
    }
    if (ssvalue == 2) { // RDM630/RDM6300 found a tag => tag incoming 
      buffer_index = 0;
    } else if (ssvalue == 3) { // tag has been fully transmitted       
      call_extract_tag = true; // extract tag at the end of the function call
    }
    if (buffer_index >= BUFFER_SIZE) { // checking for a buffer overflow (It's very unlikely that an buffer overflow comes up!)
      Serial.println("Error: Buffer overflow detected!");
      return;
    }

    buffer[buffer_index++] = ssvalue; // everything is alright => copy current value to buffer
    if (call_extract_tag == true) {
      if (buffer_index == BUFFER_SIZE) {
        unsigned tag = extract_tag();
        Serial.println(tag);
        if(previous_tag == tag){
//          Serial.println("Same tag ===================");  
    }
    else{

//put the triggering code here digitalWrite(8,1); delay(1000); digitalWrite(8,0); //Serial.println(previoustag); //Serial.println(tag); previoustag = tag; }

  } else { // something is wrong... start again looking for preamble (value: 2)
    buffer_index = 0;
    return;
  }
}    
}    
 else{
//    Serial.println("NO Cards detected ++++++++++++++++++++++++++++++++++");
previous_tag = 0L; // reset previous tag 
  }
}
unsigned extract_tag() {
uint8_t msg_head = buffer[0];
uint8_t *msg_data = buffer + 1; // 10 byte => data contains 2byte version + 8byte tag
uint8_t *msg_data_version = msg_data;
uint8_t *msg_data_tag = msg_data + 2;
uint8_t *msg_checksum = buffer + 11; // 2 byte
uint8_t msg_tail = buffer[13];
// print message that was sent from RDM630/RDM6300
Serial.println("--------");
Serial.print("Message-Head: ");
Serial.println(msg_head);
Serial.println("Message-Data (HEX): ");
for (int i = 0; i < DATA_VERSION_SIZE; ++i) {
  Serial.print(char(msg_data_version[i]));
}
Serial.println(" (version)");
for (int i = 0; i < DATA_TAG_SIZE; ++i) {
  Serial.print(char(msg_data_tag[i]));
}
Serial.println(" (tag)");
Serial.print("Message-Checksum (HEX): ");
for (int i = 0; i < CHECKSUM_SIZE; ++i) {
  Serial.print(char(msg_checksum[i]));
}
Serial.println("");
Serial.print("Message-Tail: ");
Serial.println(msg_tail);
Serial.println("--");
long tag = hexstr_to_value(msg_data_tag, DATA_TAG_SIZE);
Serial.print("Extracted Tag: ");
Serial.println(tag);
long checksum = 0;
for (int i = 0; i < DATA_SIZE; i+= CHECKSUM_SIZE) {
  long val = hexstr_to_value(msg_data + i, CHECKSUM_SIZE);
  checksum ^= val;
}
Serial.print("Extracted Checksum (HEX): ");
Serial.print(checksum, HEX);
if (checksum == hexstr_to_value(msg_checksum, CHECKSUM_SIZE)) { // compare calculated checksum to retrieved checksum
  Serial.print(" (OK)"); // calculated checksum corresponds to transmitted checksum!
} else {
  Serial.print(" (NOT OK)"); // checksums do not match
}
Serial.println("");
Serial.println("--------");
return tag;
}
long hexstr_to_value(char *str, unsigned int length) { // converts a     hexadecimal value (encoded as ASCII string) to a numeric value
  char* copy = malloc((sizeof(char) * length) + 1); 
  memcpy(copy, str, sizeof(char) * length);
  copy[length] = '\0'; 
  // the variable "copy" is a copy of the parameter "str". "copy" has an additional '\0' element to make sure that "str" is null-terminated.
  long value = strtol(copy, NULL, 16);  // strtol converts a null-terminated string to a long value
  free(copy); // clean up 
 return value;
}

`

This is a working demonstration of single read of tag using RDM6300.

OVERVIEW

This is simple article on how to connect ESP8266 chip with Arduino Micro controller development board. The ESP8266 is a low-cost Wi-Fi microchip with full TCP/IP stack and microcontroller capability produced by Chinese manufacturer Espressif Systems. The low price and easy to use features made ESP8266 popular among hardware hackers. It has two programmable GPIO pins and one RX and TX pins each.

Connecting ESP8266 adds WiFi capability to Arduino, So that we can control Arduino over WiFi, build web server etc. ESP8266 has its on micro controller itself, but with limited capabilities. Now, Let's look at how to connect this with Arduino UNO.

COMPONENTS

1. ARTDUINO UNO
2. ESP8266
3. BREADBOARD
4. JUMPER WIRES
5. 12V AC ADAPTER

ESP8266 PINOUT DIAGRAM

WIRING

UNO --- ESP8266
RX ----- RX
TX ----- TX
GND --- GND
3.3V --- VCC
3.3V --- CH_PD

STEPS

1. Do connection as above.
2. Open serial monitor in Arduino IDE and choose CR & NL and 9600 as baud rate.
3. Type AT in serial monitor and send. It will return OK on success.
4. Now try some Example codes given in Arduino IDE and hack around it. Happy hacking :)

If you have any questions, please comment below.

REFERENCE

1. Connect to ESP8266 ONLY using Arduino Uno

WIRING

HC-05 GND --- Arduino GND Pin
HC-05 VCC (5V) --- Arduino 5V
HC-05 TX --- Arduino Pin 10 (soft RX)
HC-05 RX --- Arduino Pin11 (soft TX)
HC-05 Key (PIN 34) --- Arduino Pin 9

Arduino Code

#include <SoftwareSerial.h>
SoftwareSerial BTSerial(10, 11); // RX | TX``

void setup()
{
  pinMode(9, OUTPUT);  // this pin will pull the HC-05 pin 34 (key pin) HIGH to switch module to AT mode
  digitalWrite(9, HIGH);
  Serial.begin(9600);
  Serial.println("Enter AT commands:");
  BTSerial.begin(38400);  // HC-05 default speed in AT command more
}

void loop()
{

  // Keep reading from HC-05 and send to Arduino Serial Monitor
  if (BTSerial.available())
    Serial.write(BTSerial.read());

  // Keep reading from Arduino Serial Monitor and send to HC-05
  if (Serial.available())
    BTSerial.write(Serial.read());
}

STEPS

1. Do connection as per diagram.
2. Burn the above code to arduino.
3. Open Arduino serial monitor.
4. Select Both NL & CR option right-bottom part of serial monitor.
5. Type AT+ROLE=1 and press send, It will return OK on success.
6. Type AT+NAME=newname to change device name.
7. Type AT+NAME? to test device name.
8. Type AT+ROLE=0 to change to slave mode again.
9. Done.

NOTE: If you use AT+ORGL command, your bluetooth module will restore to default settings, so the baud rate, device name, password all will reset. The baud rate of most of modules are 34800. So after resetting to default config, you should use 34800 as baud rate in your Arduino code instead of 9600.

Reference:

• HC-05 DOcumentation : http://www.electronicaestudio.com/docs/istd016A.pdf
• Instructable : http://www.instructables.com/id/Modify-The-HC-05-Bluetooth-Module-Defaults-Using-A/

The memory palace is an interesting technique used to remember simple to complex list of items efficiently and easily. The idea behind this technique is to make a imaginary connection or links between the objects that you want to remember. If it's numbers that you want to remember, then convert/map that numbers in to some visual objects. Then create a story around those objects in imaginary palace. Next time when you want to remember those objects in the same order, you can just take a simple walk through the memory palace. You can easily remember the the objects in the same order easily by doing a just walk. This works.

This works because our visual memory is more powerful than verbal memory. So, next time when you go grocery shopping, just create a story of potatoes and onions instead of feeding in your phone. At the first the time, it may take some time. But when you practice it, you will master it.

Ref : How to memorize fast and easily