Search Results

Back Character Displaying using 8X8 LED Matrix MAX7219 with Arduino Uno What is a Matrix Display? Dot-matrix LED display contains the group of LEDs as a two-dimensional array. They can display different types of characters or a group of characters. Dot-matrix LED display contains the group of LEDs as a two-dimensional array. They can display different types of characters or a group of characters. Dot-matrix display is manufactured in various dimensions. The arrangement of LEDs in the matrix pattern is made in either of the two ways: Row anode-column cathode or Row cathode-column anode. By using this dot matrix display we can reduce the number of pins required for controlling all the LEDs. Material Required: Material Quantity Arduino Uno 1 MAX 7219 Display Module 1 Jumper cables 5 Pinout Diagram: Circuit Diagram: Working: An LED dot matrix consists of an array of LEDs that are connected such that the anode of each LED is connected in the same column and the cathode of each LED is connected in the same row or vice versa . Here each dot represents circular lenses in front of LEDs. This is done to minimize the number of pins required to drive them. For example, an 8X8 matrix of LEDs would need 64 I/O pins, one for each LED pixel. By connecting all the anodes of LEDs in a column and all the cathodes together in a row, the required number of input and output pins is reduced to 16. Each LED will be addressed by its row and column number. Controlling the LED Matrix: Since all the LEDs in a matrix share their positive and negative terminals in each row and column, it is not possible controlling of each LED at the same time. The matrix controlled through each row very quickly by triggering the correct column pins to light the desired LED for that particular row. If the switching is done with a fixed rate, humans can’t see the displaying message, because the human eye can’t detect the images within the milliseconds. Thus the displaying of a message on an LED matrix must be controlled, with the rows being scanned sequentially at a rate greater than 40 MHz while sending out the column data at the same rate. This kind of control can be done by interfacing the LED matrix display with the microcontroller. Interfacing the LED Matrix Display with Microcontroller: Choosing a microcontroller for interfacing with the LED matrix display which is to be controlled is depends on the number of input and output pins needed for controlling all the LEDs in the given matrix display, the amount of current that each pin can source and sink, and the speed at which the microcontroller can send out control signals. With all these specifications, interfacing can be done for LED matrix display with a microcontroller. Tested Programming Code: A library needs to be downloaded and then to be installed. Go to Disk drive where your Arduino IDE is installed and then go to > Program Files>Arduino> Libraries> then Ctrl+V (Paste). https://github.com/riyas-org/max7219/tree/master/MaxMatrix https://github.com/riyas-org/max7219 : Main Link #include int DIN = 7; // DIN pin of MAX7219 module int CLK = 6; // CLK pin of MAX7219 module int CS = 5; // CS pin of MAX7219 module int maxInUse = 1; MaxMatrix m(DIN, CS, CLK, maxInUse); char A[] = {4, 8, B01111110, B00010001, B00010001, B01111110, }; char B[] = {4, 8, B01111111, B01001001, B01001001, B00110110, }; char smile01[] = {8, 8, B00111100, B01000010, B10010101, B10100001, B10100001, B10010101, B01000010, B00111100 }; char smile02[] = {8, 8, B00111100, B01000010, B10010101, B10010001, B10010001, B10010101, B01000010, B00111100 }; char smile03[] = {8, 8, B00111100, B01000010, B10100101, B10010001, B10010001, B10100101, B01000010, B00111100 }; void setup() { m.init(); // MAX7219 initialization m.setIntensity(8); // initial led matrix intensity, 0-15 } void loop() { // Seting the LEDs On or Off at x,y or row,column position m.setDot(6,2,true); delay(1000); m.setDot(6,3,true); delay(1000); m.clear(); // Clears the display for (int i=0; i<8; i++){ m.setDot(i,i,true); delay(300); } m.clear(); // Displaying the character at x,y (upper left corner of the character) m.writeSprite(2, 0, A); delay(1000); m.writeSprite(2, 0, B); delay(1000); m.writeSprite(0, 0, smile01); delay(1000); m.writeSprite(0, 0, smile02); delay(1000); m.writeSprite(0, 0, smile03); delay(1000); for (int i=0; i<8; i++){ m.shiftLeft(false,false); delay(300); } m.clear(); } Program Description: So first we need to include the MaxMatrix.h library, define the pins to which the module is connected, set how many modules we use and define the MaxMatrix object. For displaying characters, we need to define them in an array of characters or bytes, and here I have several examples. We can notice how the bits are forming the characters which are zeros and ones. In this case, they are rotated 90 degrees but the library example suggests using them in such a way so that would be easier later to implement the shift left custom function for scrolling a text. Precautions: 1. Double Check the connections before powering on the circuit. 2. Don’t use loose jumper cables. 3. Check Whether the proper board is selected from Arduino IDE. 4. Ensure proper placement of sensor for correct working. Conclusion: You can successfully program different characters on a matrix display, this display can be combined with many more displays to get a larger display area. Output:: Reference URL GET IN TOUCH We'd love to hear from you Contact Us

Back Interfacing of Touch Sensor with Arduino Uno. What is a Touch Sensor? This device uses your body as part of the circuit. When you touch the sensor pad, the capacitance of the circuit is changed and is detected. That detected change in capacitance results in the output changing states. Material Required: Material Quantity Arduino Uno 1 Touch Sensor 1 Jumper cables 4 Pinout Diagram: Pin of Touch sensor: 1. GND. 2. VCC. 3. SIG Circuit Diagram: Connect the Touch Sensor with Arduino as follows: GND pin of Touch sensor to GND of Arduino VCC pin of Touch Sensor to 5V of Arduino SIG pin of Touch Sensor to digital pin 2 of Arduino. Tested Programming Code: #define ctsPin 2 int ledPin = 13; // pin for the LED void setup() { Serial.begin(9600); pinMode(ledPin, OUTPUT); pinMode(ctsPin, INPUT); } void loop() { int ctsValue = digitalRead(ctsPin); if (ctsValue==HIGH) { digitalWrite(ledPin, HIGH); Serial.println("TOUCHED"); } else{ digitalWrite(ledPin,LOW); Serial.println("not touched"); } delay(500); } Precautions: Double check the connections before powering on the circuit. Don’t use loose jumper cables. Check whether proper board is selected from Arduino IDE. Ensure proper placement of Touch Sensor for correct working. Conclusion: Once your sketch is running, you have to see the Touch Sensor working by seeing the Serial monitor whenever it is being touched. Reference URL GET IN TOUCH We'd love to hear from you Contact Us

Back Interfacing of Pulse Rate Sensor with Arduino Uno. What is a Pulse Rate Sensor? The pulse sensor we are going to use is a plug and play heart rate sensor. This sensor is quite easy to use and operate. Place your finger on top of the sensor and it will sense the heartbeat by measuring the change in light from the expansion of capillary blood vessels. The pulse sensor module has a light which helps in measuring the pulse rate. When we place the finger on the pulse sensor, the light reflected will change based on the volume of blood inside the capillary blood vessels. Material Required: Material Quantity Arduino Uno 1 Pulse Rate Sensor 1 Jumper cables 6 LED 1 Pinout Diagram: Circuit Diagram: Connect the pulse sensor with Arduino as follows: GND pin of pulse sensor to GND of Arduino VCC of pulse sensor to 5V of Arduino A0 of pulse sensor to A0 of Arduino After that, connect the LED to pin 13 and GND of Arduino as shown in the figure below. Tested Programming Code: int PulseSensorPurplePin = 0; int LED13 = 13; int Signal; int Threshold = 550; void setup() { pinMode(LED13,OUTPUT); Serial.begin(9600); } void loop() { Signal = analogRead(PulseSensorPurplePin); Serial.println(Signal); if(Signal > Threshold){ digitalWrite(LED13,HIGH); } else { digitalWrite(LED13,LOW); } delay(10); } Precautions: Double check the connections before powering on the circuit. Don’t use loose jumper cables. Check whether proper board is selected from Arduino IDE. Ensure proper placement of pulse rate Sensor for correct working. Don’t lose hope if pulse rate Sensor does not run properly for the first time, try again. Conclusion: Once your sketch is running, you have to open your serial monitor. There you can see the Pulse Rate (BPM) on the sensor. Reference URL GET IN TOUCH We'd love to hear from you Contact Us

Back Measuring water flow rate and calculating quantity using Flow Sensor with Arduino. What is a Water Flow Sensor? The water flow sensor consists of a plastic valve body, a water rotor, and a hall-effect sensor. When water flows through the rotor, the rotor rolls. Its speed changes with different rates of flow. The hall-effect sensor outputs the corresponding pulse signal. This one is suitable to detect flow in a water dispenser or coffee machine. Specifications · Mini. Working Voltage: DC 4.5V · Max. Working Current: 15mA (DC 5V) · Working Voltage: DC 5V · Flow Rate Range: 1~30L/min · Operating Temperature: 80 C · Liquid Temperature: 120 · Operating Humidity: 35%~90%RH · Water Pressure: 1.75MPa Material Required: Material Quantity Arduino Uno 1 Water Flow Sensor 1 Jumper cables 3 Pinout Diagram: Working: This illustration gives a detailed working method of the Hall effect sensor-based water flow sensor, a turbine wheel embedded with a magnet is placed on a closed plastic envelope and a Hall effect sensor is placed, When the water flows through the pipeline, it makes the turbine wheel to rotate and hence the magnet flux interferes the hall sensor, the rate of interference depends on the speed of water flow, so the hall effect sensor produces pulse signal output, this pulse output can be calculated as water volume. Circuit Diagram: Connect the +5V wire to Arduino power pin 5V and Ground pin to Gnd then connect the Signal pin to Digital pin D2, this sensor has a control circuit hence there is no need for pull up resistor, some sensor requires to pull up resistors refer to the datasheet of water flow sensor before concluding hookup. Tested Programming Code: The code uses an external interrupt on the Arduino's digital pin 2. This is used to read the pulses coming from the flow meter. When the Arduino detects the pulse, it immediately triggers the pulseCounter() function. This function then counts the total number of pulses. In this Arduino flow rate sensor, for every liter of liquid passing through it per minute, it outputs about 4.5 pulses. Dividing the total pulse count by 4.5 will give you the total amount of liquid passing through it in liters per minute. Dividing that by 60 will give you the flow rate in liters per hour, which gives us the total amount or quantity of water/liquid that has passed through it. The sensor is accurate to within 3%. Code: byte statusLed = 13; byte sensorInterrupt = 0; byte sensorPin = 2; float calibrationFactor = 4.5; volatile byte pulseCount; float flowRate; unsigned int flowMilliLitres; unsigned long totalMilliLitres; unsigned long oldTime; void setup() { Serial.begin(38400); pinMode(statusLed, OUTPUT); digitalWrite(statusLed, HIGH); pinMode(sensorPin, INPUT); digitalWrite(sensorPin, HIGH); pulseCount = 0; flowRate = 0.0; flowMilliLitres = 0; totalMilliLitres = 0; oldTime = 0; attachInterrupt(sensorInterrupt, pulseCounter, FALLING); } void loop() { if((millis() - oldTime) > 1000) // Only process counters once per second { detachInterrupt(sensorInterrupt); flowRate = ((1000.0 / (millis() - oldTime)) * pulseCount) / calibrationFactor; oldTime = millis(); flowMilliLitres = (flowRate / 60) * 1000; totalMilliLitres += flowMilliLitres; unsigned int frac; Serial.print("Flow rate: "); Serial.print(int(flowRate)); Serial.print("."); frac = (flowRate - int(flowRate)) * 10; Serial.print(frac, DEC) ; Serial.print("L/min"); Serial.print(" Current Liquid Flowing: "); Serial.print(flowMilliLitres); Serial.print("mL/Sec"); Serial.print(" Output Liquid Quantity: "); Serial.print(totalMilliLitres); Serial.println("mL"); pulseCount = 0; attachInterrupt(sensorInterrupt, pulseCounter, FALLING); } } void pulseCounter() { pulseCount++; } Precautions: Double check the connections before powering on the circuit. Don’t use loose jumper cables. Check whether the proper board is selected from Arduino IDE. Ensure proper placement of sensor for correct working. Please keep your hardware away from water except, the water flow sensor. Conclusion: You can successfully measure the flow rate and quantity of the water flowing through a pipe through a cross-sectional area. This sensor can be deployed in many ways like water level automation systems, water meters, etc. Output: Situation Screenshot: Serial Monitor (Ctrl+Shift+M) Reference URL GET IN TOUCH We'd love to hear from you Contact Us

Back Interfacing of MQ2 (gas) sensor with Arduino Uno. What is a MQ2 (gas) Sensor? The Gas Sensor (MQ2) module is useful for gas leakage detection (home and industry). It is suitable for detecting H2, LPG, CH4, CO, Alcohol, Smoke or Propane. Due to its high sensitivity and fast response time, measurement can be taken as soon as possible. The sensitivity of the sensor can be adjusted by potentiometer. Material Required: Material Quantity Arduino Uno 1 MQ2 (gas) Sensor 1 Jumper cables 6 LED 1 Pinout Diagram: Circuit Diagram: Connect the pulse sensor with Arduino as follows: GND pin of MQ2 (gas) sensor to GND of Arduino VCC of MQ2 (gas) sensor to 5V of Arduino A0 of MQ2 (gas) sensor to A0 of Arduino D0 of MQ2 (gas) sensor to D2 of Arduino. If needed. After that, connect the LED to pin 13 and GND of Arduino as shown in the figure below. The LED will blink according to the MQ2 (gas) sensor. Tested Programming Code: Const int gaspin = A0; float sensorValue ; //variable to store sensor value void setup () { pinMode(gaspin,INPUT); Serial . begin ( 9600 ); // sets the serial port to 9600 Serial . println ( "Gas sensor warming up!" ); delay ( 20000 ); // allow the MQ-6 to warm up } void loop () { sensorValue = analogRead ( gaspin ); // read analog input pin 0 Serial . print ( "Sensor Value: " ); Serial . print ( sensorValue ); if ( sensorValue > 300 ) { Serial . print ( " | Smoke detected!" ); } Serial . println ( "" ); delay ( 2000 ); // wait 2s for next reading } Precautions: 1. Double check the connections before powering on the circuit. 2. Don’t use loose jumper cables. 3. Check whether proper board is selected from Arduino IDE. 4. Ensure proper placement of MQ2 (gas) Sensor for correct working. 5. Don’t lose hope if Sensor does not run properly for the first time, try again. Conclusion: Once your sketch is running, you have to open your serial monitor. There you can see the value of gas present in air by the sensor. Reference URL GET IN TOUCH We'd love to hear from you Contact Us

Back Interfacing 2 Channel Relay Module with Arduino and control High Voltage AC (current). What is a Relay Module? A Relay is a device that helps microcontrollers (or microcontroller-based boards) like Arduino to switch on or off different household appliances like motors, lights, water heaters, television, fans, etc. The relay module for Arduino is one of the most powerful applications for Arduino as it can be used to control both A.C and D.C devices by simply controlling the relay by giving 5V. A relay is a switch that is operated electrically by an electromagnet. A relay can be used to control high voltage electronic devices such as motors as well as low voltage electronic devices such as a light bulb or a fan. Relays work on the principle of electromagnetism. When the electricity is provided to the relay coil then it acts like a magnet and changes the state of the switch. The part which powers the relay module is completely isolated from the part which turns ON or OFF. This is why we can control a 220V appliance by simply controlling it using the 5V Arduino. you should also read getting started projects of Arduino. Material Required: Material Quantity Arduino Uno 1 Relay module (2 Channel) 1 Jumper cables 6 Switching Source 1 Cable, Plug, Socket 1 Pinout Diagram: HL-52S Relay Module As an example, for this Arduino Relay Tutorial, we will use the HL-52S 2 channel relay module, which has 2 relays with a rating of 10A @ 250 and 125 V AC and 10A @ 30 and 28 V DC. The high voltage output connector has 3 pins, the middle one is the common pin, and as we can see from the markings one of the two other pins is for a normally open connection and the other one for a normally closed connection. On the other side of the module, we have these 2 sets of pins. The first one has 4 pins, a Ground and a VCC pin for powering the module, and 2 input pins In1 and In2. The second set of pins has 3 pins with a jumper between the JDVcc and the Vcc pin. With a configuration like this, the electromagnet of the relay is directly powered by the Arduino Board and if something goes wrong with the relay the microcontroller could get damaged. Circuit Diagram: For better understanding let’s see the circuit schematics of the relay module in this configuration. So we can see that the 5 volts from our microcontroller connected to the Vcc pin for activating the relay through the Optocoupler IC are also connected to the JDVcc pin which powers the electromagnet of the relay. So in this case we got no isolation between the relay and the microcontroller. To isolate the microcontroller from the relay, we need to remove the jumper and connect a separate power supply for the electromagnet to the JDVcc and the Ground pin. Now with this configuration, the microcontroller doesn’t have any physical connection with the relay, it just uses the LED light of the Optocoupler IC to activate the relay. There is one more thing to be noticed from this circuit schematics. The input pins of the module work inversely. As we can see the relay will be activated when the input pin will be LOW because in that way the current will be able to flow from the VCC to the input pin which is low or ground, and the LED will light up and activate the relay. When the input pin will be HIGH there will be no current flow, so the LED will not light up and the relay will not be activated. High Voltage Warning Before we continue with this tutorial, I will warn you here that we will use High Voltage which if incorrectly or improperly used could result in serious injuries or death. So be very cautious of what you are doing because I take no responsibility for any of your actions. How to use the relay module with the High Voltage devices First, let’s take a look at the circuit diagram. As previously described we will use a 5V Adapter as a separate power supply for the electromagnet connected to the JDVcc and the Ground pin. The Arduino’s 5V pin will be connected to the Vcc pin of the module and PIN 7 to the In1 input pin for controlling the relay. Now for the HIGH Voltage part, we need a power plug, a socket, and a cable with two wires. One of the two wires will be cut and connected to the common and the normally open pin of the module output connector. So with this configuration when we will activate the relay we will get the high voltage circuit closed and working. Here’s how made the cable. So I bought a plug, a socket, and a cable. Then I carefully cut the cable and cut one of the wires as shown in the picture below and connect them to the normally open connection pins of the relay module. Also connected the ends of the cable to the plug and the socket. Tested Programming Code: Now what’s left for this tutorial is to make a simple code and test the relay module and how it will work. Here’s the simple code, we will just use the PIN 7 for controlling the relay, so we will define it as output and make a program that will just activate and deactivate the relay every 3 seconds. I will mention once again here that the input of the module works inversely so a logic low at the input will activate the relay and vice versa. int in1 = 7; void setup() { pinMode(in1, OUTPUT); digitalWrite(in1, HIGH); } void loop() { digitalWrite(in1, LOW);delay(3000); digitalWrite(in1, HIGH); delay(3000); } There is a demonstration of this example at the end of the video of this tutorial. I tested 3 devices on it. First a 100W light bulb, then a desk lamp, and a fan heater. All of these devices work on 220V. Precautions: 1. Double-check the connections before powering on the circuit. 2. Don’t use loose jumper cables. 3. Check whether the proper board is selected from Arduino IDE. 4. Ensure proper placement of Relay Module for correct working. 5. Use proper measures before using AC electricity. Conclusion: So that’s how we can control any High Voltage Device using Arduino or any other microcontroller. And of course, the possibilities are now endless, for example, we can control the devices using a TV Remote, Bluetooth, SMS, Internet, and so on. Reference URL GET IN TOUCH We'd love to hear from you Contact Us

Time Out This page isn’t available right now. But we’re working on a fix, ASAP. Try again soon. Go Back

PROJECTS 8×8 LED Matrix MAX7219 Tutorial with Scrolling Text & Android Control via Bluetooth ​ Read More Interfacing GPS with Arduino (Neo-6M-001) In this tutorial we will learn how to use a GPS Module with Arduino. Neo 6M (Ublox NEO6MV2) is a I2C compliant GPS module. This post discusses details on wiring Ublox Neo 6M with Arduino or an USB to Serial/TTL adapter, basic interactions with module using serial communication, using u -center GUI in visualizations, as well as using TinyGPS library to extract fine grained results from the module output. Read More Analog Joystick Interfacing with Arduino UNO. In this tutorial we will learn how to interface an Analog Joystick with the Arduino Uno and checking the values on the Serial Monitor. Read More Interfacing of MQ2 (gas) sensor with Arduino Uno. In this tutorial we will learn how to interface a MQ2 (gas) Sensor with the Arduino Uno Read More Interfacing of LDR Sensor Module with Arduino Uno. In this tutorial we will learn how to interface a LDR sensor Module with the Arduino Uno. Read More Interfacing of RFID Module with Arduino Uno. In this tutorial we will learn how to interface a RFID module with the Arduino Uno. Read More Measuring Distance using Ultrasonic Sensor with Arduino In this project we will learn the basics of how to measure distance using an ultrasonic sensor with an Arduino, which further can be used for controlling other parameters of a robot or many other applications. Read More Measuring Humidity and temperature using DHT11 sensor with Arduino. In this tutorial, we will learn how to use a DHT (DHT11 version) Temperature and Humidity Sensor. It’s accurate enough for most projects that need to keep track of humidity and temperature readings. We will be using a Library specifically designed for these sensors that will make our code short and easy to write. Read More 4*4 Keypad Interfacing with Arduino UNO. In this tutorial, we will learn how to interface a 4*4 Keypad with the Arduino Uno and check the values on the Serial Monitor. Read More Interfacing of Touch Sensor with Arduino Uno. In this tutorial, we will learn how to interface a Touch Sensor with the Arduino Uno. Read More Interfacing of Pulse Rate Sensor with Arduino Uno. In this tutorial we will learn how to interface a Pulse Rate Sensor with the Arduino Uno. Read More Finding an obstacle using IR Sensor with Arduino In this project we will learn the basics of how to find for an obstacle using an Infrared sensor with an Arduino, which further can be used for controlling other parameters of a robot and many other applications too. Read More Interfacing of Force Pressure Sensor with Arduino Uno. In this tutorial we will learn how to interface a Force Pressure Sensor with the Arduino Uno. Read More Displaying a text message on LCD Display using 16X2 Segment Display with Arduino. : In this tutorial we will learn how to interface a 16×2 LCD (liquid crystal display) with the Arduino Uno. Read More Interfacing of Metal Touch Sensor with Arduino. In this tutorial we will learn how to interface a Metal Touch Sensor with the Arduino Read More Interfacing with MQ-3 Alcohol Sensor Module ​ Read More Interfacing of 28BYJ Stepper Driver with Arduino. In this tutorial we will learn how to interface a Flex Sensor with the Arduino Uno. Read More Interfacing of Buzzer with Arduino Uno. In this tutorial, we will learn how to interface a Buzzer with the Arduino Uno. Read More Interfacing of 4 Digit Segment Display with Arduino Uno. In this tutorial, we will learn how to interface a 4-digit segment display with the Arduino Uno. Read More Interfacing 2 Channel Relay Module with Arduino and control High Voltage AC (current). In this tutorial, we will learn how to interface a 2 channel relay module with the Arduino Uno. Read More Measuring water flow rate and calculating quantity using Flow Sensor with Arduino. In this tutorial, we will learn how to use a water flow sensor with Arduino. We will use the serial monitor for printing the water flow rate in liters per hour and the total of liters flowing since starting. So, let's get started! Read More Interfacing of GSM 800 L Modules with Arduino. In this tutorial we will learn how to interface GSM 800L Module with the Arduino Uno. Read More Bluetooth Controlled Car Using Arduino Uno. This project shows how you can build a car which can be controlled by your Smartphone using an android application via Bluetooth. Read More Interfacing of Laser Diode with Arduino Uno. In this tutorial we will learn how to interface a Laser Diode with the Arduino Uno. Read More Interfacing of Temperature Sensor (LM35) with Arduino Uno. In this tutorial we will learn how to interface a Temperature Sensor with the Arduino Uno. Read More Motion Detection using PIR Sensor with Arduino In this Arduino Tutorial we will learn how a PIR Sensor works and how to use it with the Arduino Board for detecting motion. Read More Interfacing of Sound sensor with Arduino Uno. In this tutorial we will learn how to interface a Sound Sensor with the Arduino Uno. Read More Interfacing Colour Sensor with Arduino (TCS3200) : In this tutorial, we will learn how to use a colour sensor with Arduino. We will use the serial monitor for printing the colour values. So let's get started! This sensor is used for detecting primary colours (red, green and blue, or RGB)—colours that are physically available in LEDs in one package; for example, common cathode or common-cathode RGB LED. We can display primary colours and also generate specific colours by modifying the Arduino code. Read More Character Displaying using 8X8 LED Matrix MAX7219 with Arduino Uno In this Arduino project we will learn how to control 8×8 LED Matrix using the MAX7219 driver and the Arduino board. Read More Measuring soil moisture using Soil Moisture Sensor with Arduino (Y-38) In this tutorial, we will learn how to read soil moisture data using Analog Soil Moisture Sensor on the Arduino Platform. We are reading data from Analog Moisture Sensor, so we will get readings in the range 0 to 1023. Lesser the value means lesser the moisture in the soil. Read More Interfacing of Rain Drop Sensor with Arduino Uno. In this tutorial we will learn how to interface a Rain Drop Sensor with the Arduino Uno. Read More

Time Out This page isn’t available right now. But we’re working on a fix, ASAP. Try again soon. Go Back

PROJECTS 8×8 LED Matrix MAX7219 Tutorial with Scrolling Text & Android Control via Bluetooth ​ Read More Interfacing GPS with Arduino (Neo-6M-001) In this tutorial we will learn how to use a GPS Module with Arduino. Neo 6M (Ublox NEO6MV2) is a I2C compliant GPS module. This post discusses details on wiring Ublox Neo 6M with Arduino or an USB to Serial/TTL adapter, basic interactions with module using serial communication, using u -center GUI in visualizations, as well as using TinyGPS library to extract fine grained results from the module output. Read More Analog Joystick Interfacing with Arduino UNO. In this tutorial we will learn how to interface an Analog Joystick with the Arduino Uno and checking the values on the Serial Monitor. Read More Interfacing of MQ2 (gas) sensor with Arduino Uno. In this tutorial we will learn how to interface a MQ2 (gas) Sensor with the Arduino Uno Read More Interfacing of LDR Sensor Module with Arduino Uno. In this tutorial we will learn how to interface a LDR sensor Module with the Arduino Uno. Read More Interfacing of RFID Module with Arduino Uno. In this tutorial we will learn how to interface a RFID module with the Arduino Uno. Read More Measuring Distance using Ultrasonic Sensor with Arduino In this project we will learn the basics of how to measure distance using an ultrasonic sensor with an Arduino, which further can be used for controlling other parameters of a robot or many other applications. Read More Measuring Humidity and temperature using DHT11 sensor with Arduino. In this tutorial, we will learn how to use a DHT (DHT11 version) Temperature and Humidity Sensor. It’s accurate enough for most projects that need to keep track of humidity and temperature readings. We will be using a Library specifically designed for these sensors that will make our code short and easy to write. Read More 4*4 Keypad Interfacing with Arduino UNO. In this tutorial, we will learn how to interface a 4*4 Keypad with the Arduino Uno and check the values on the Serial Monitor. Read More Interfacing of Touch Sensor with Arduino Uno. In this tutorial, we will learn how to interface a Touch Sensor with the Arduino Uno. Read More Interfacing of Pulse Rate Sensor with Arduino Uno. In this tutorial we will learn how to interface a Pulse Rate Sensor with the Arduino Uno. Read More Finding an obstacle using IR Sensor with Arduino In this project we will learn the basics of how to find for an obstacle using an Infrared sensor with an Arduino, which further can be used for controlling other parameters of a robot and many other applications too. Read More Interfacing of Force Pressure Sensor with Arduino Uno. In this tutorial we will learn how to interface a Force Pressure Sensor with the Arduino Uno. Read More Displaying a text message on LCD Display using 16X2 Segment Display with Arduino. : In this tutorial we will learn how to interface a 16×2 LCD (liquid crystal display) with the Arduino Uno. Read More Interfacing of Metal Touch Sensor with Arduino. In this tutorial we will learn how to interface a Metal Touch Sensor with the Arduino Read More Interfacing with MQ-3 Alcohol Sensor Module ​ Read More Interfacing of 28BYJ Stepper Driver with Arduino. In this tutorial we will learn how to interface a Flex Sensor with the Arduino Uno. Read More Interfacing of Buzzer with Arduino Uno. In this tutorial, we will learn how to interface a Buzzer with the Arduino Uno. Read More Interfacing of 4 Digit Segment Display with Arduino Uno. In this tutorial, we will learn how to interface a 4-digit segment display with the Arduino Uno. Read More Interfacing 2 Channel Relay Module with Arduino and control High Voltage AC (current). In this tutorial, we will learn how to interface a 2 channel relay module with the Arduino Uno. Read More Measuring water flow rate and calculating quantity using Flow Sensor with Arduino. In this tutorial, we will learn how to use a water flow sensor with Arduino. We will use the serial monitor for printing the water flow rate in liters per hour and the total of liters flowing since starting. So, let's get started! Read More Interfacing of GSM 800 L Modules with Arduino. In this tutorial we will learn how to interface GSM 800L Module with the Arduino Uno. Read More Bluetooth Controlled Car Using Arduino Uno. This project shows how you can build a car which can be controlled by your Smartphone using an android application via Bluetooth. Read More Interfacing of Laser Diode with Arduino Uno. In this tutorial we will learn how to interface a Laser Diode with the Arduino Uno. Read More Interfacing of Temperature Sensor (LM35) with Arduino Uno. In this tutorial we will learn how to interface a Temperature Sensor with the Arduino Uno. Read More Motion Detection using PIR Sensor with Arduino In this Arduino Tutorial we will learn how a PIR Sensor works and how to use it with the Arduino Board for detecting motion. Read More Interfacing of Sound sensor with Arduino Uno. In this tutorial we will learn how to interface a Sound Sensor with the Arduino Uno. Read More Interfacing Colour Sensor with Arduino (TCS3200) : In this tutorial, we will learn how to use a colour sensor with Arduino. We will use the serial monitor for printing the colour values. So let's get started! This sensor is used for detecting primary colours (red, green and blue, or RGB)—colours that are physically available in LEDs in one package; for example, common cathode or common-cathode RGB LED. We can display primary colours and also generate specific colours by modifying the Arduino code. Read More Character Displaying using 8X8 LED Matrix MAX7219 with Arduino Uno In this Arduino project we will learn how to control 8×8 LED Matrix using the MAX7219 driver and the Arduino board. Read More Measuring soil moisture using Soil Moisture Sensor with Arduino (Y-38) In this tutorial, we will learn how to read soil moisture data using Analog Soil Moisture Sensor on the Arduino Platform. We are reading data from Analog Moisture Sensor, so we will get readings in the range 0 to 1023. Lesser the value means lesser the moisture in the soil. Read More Interfacing of Rain Drop Sensor with Arduino Uno. In this tutorial we will learn how to interface a Rain Drop Sensor with the Arduino Uno. Read More

Back Bluetooth Controlled Car Using Arduino Uno. Material Required: Material Quantity Arduino Uno 1 12V DC Motor /BO motor 2 Jumper cables 15 HC-05 Bluetooth Module 1 Breadboard 1 Breadboard 1 This tutorial will teach you how to create your own Bluetooth controlled car. So let’s get started. This will be a Bluetooth controlled car so for this project we will be using HC-05 Bluetooth module to receive the controlling data packets. We will also need an android app which will be sending the controlling data packets to the Bluetooth module. We will use a third party application ( https://play.google.com/store/apps/details?id=com.broxcode.arduinobluetoothfree&hl=en to download) for this purpose. Let's build the hardware (Body of the car) The car which we are building for this project will be a dual motor car. Two 12 v 200 rpm DC or BO motors. You can use a readymade chassis. Circuit Now let us build the circuit. CODE : Here we will use the direction of rotation of motors to control the direction of the car. Forward - Both motors move in forward direction. Backward - Both motors move in backward direction. Left - Left motor moves backwards and right motor moves forward. Right - Left motor moves forwards and right motor moves backward. Stop - Both motors stop Tested Programming Code: #include AF_DCMotor motor1(1); //motor1 is the left motor AF_DCMotor motor2(2); //motor2 is the right motor int val; void setup() { Serial.begin(9600); motor1.setSpeed(255); //motor speed is set motor2.setSpeed(255); Stop(); } void loop() { bt=Serial.read(); if(val=='1') //when the bluetooth module recieves 1 the car moves forward { forward(); } if(val=='2') //when the bluetooth module recieves 2 the car moves backward { backward(); } if(val=='3') //when the bluetooth module recieves 3 the car moves left { left(); } if(val=='4') //when the bluetooth module recieves 4 the car moves right { right(); } if(val=='5') //when the bluetooth module recieves 5 the car stops { Stop(); } } void forward() { motor1.run(FORWARD); motor2.run(FORWARD); } void backward() { motor1.run(BACKWARD); motor2.run(BACKWARD); } void left() { motor1.run(BACKWARD); motor2.run(FORWARD); } void right() { motor1.run(FORWARD); motor2.run(BACKWARD); } void Stop() { motor1.run(RELEASE); motor2.run(RELEASE); } Precautions: 1. Double check the connections before powering on the circuit. 2. Don’t use loose jumper cables. 3. Check whether proper board is selected from Arduino IDE. 4. Ensure proper placement of Bluetooth and Motor driver for correct working. 5. Don’t lose hope if it does not run properly for the first time, try again. Reference URL GET IN TOUCH We'd love to hear from you Contact Us

Back Interfacing of Pulse Rate Sensor with Arduino Uno. What is a Pulse Rate Sensor? The pulse sensor we are going to use is a plug and play heart rate sensor. This sensor is quite easy to use and operate. Place your finger on top of the sensor and it will sense the heartbeat by measuring the change in light from the expansion of capillary blood vessels. The pulse sensor module has a light which helps in measuring the pulse rate. When we place the finger on the pulse sensor, the light reflected will change based on the volume of blood inside the capillary blood vessels. Material Required: Material Quantity Arduino Uno 1 Pulse Rate Sensor 1 Jumper cables 6 LED 1 Pinout Diagram: Circuit Diagram: Connect the pulse sensor with Arduino as follows: GND pin of pulse sensor to GND of Arduino VCC of pulse sensor to 5V of Arduino A0 of pulse sensor to A0 of Arduino After that, connect the LED to pin 13 and GND of Arduino as shown in the figure below. Tested Programming Code: int PulseSensorPurplePin = 0; int LED13 = 13; int Signal; int Threshold = 550; void setup() { pinMode(LED13,OUTPUT); Serial.begin(9600); } void loop() { Signal = analogRead(PulseSensorPurplePin); Serial.println(Signal); if(Signal > Threshold){ digitalWrite(LED13,HIGH); } else { digitalWrite(LED13,LOW); } delay(10); } Precautions: Double check the connections before powering on the circuit. Don’t use loose jumper cables. Check whether proper board is selected from Arduino IDE. Ensure proper placement of pulse rate Sensor for correct working. Don’t lose hope if pulse rate Sensor does not run properly for the first time, try again. Conclusion: Once your sketch is running, you have to open your serial monitor. There you can see the Pulse Rate (BPM) on the sensor. Reference URL GET IN TOUCH We'd love to hear from you Contact Us

Back 8×8 LED Matrix MAX7219 Tutorial with Scrolling Text & Android Control via Bluetooth Students now you know everything about how a matrix works, let’s move to some advanced part of it. 8×8 LED Matrix Scrolling Arduino Code Next let’s take a look at the scrolling text example and see what’s different. Below the code you will find its description. #include #include PROGMEM const unsigned char CH[] = { 3, 8, B00000000, B00000000, B00000000, B00000000, B00000000, // space 1, 8, B01011111, B00000000, B00000000, B00000000, B00000000, // ! 3, 8, B00000011, B00000000, B00000011, B00000000, B00000000, // " 5, 8, B00010100, B00111110, B00010100, B00111110, B00010100, // # 4, 8, B00100100, B01101010, B00101011, B00010010, B00000000, // $ 5, 8, B01100011, B00010011, B00001000, B01100100, B01100011, // % 5, 8, B00110110, B01001001, B01010110, B00100000, B01010000, // & 1, 8, B00000011, B00000000, B00000000, B00000000, B00000000, // ' 3, 8, B00011100, B00100010, B01000001, B00000000, B00000000, // ( 3, 8, B01000001, B00100010, B00011100, B00000000, B00000000, // ) 5, 8, B00101000, B00011000, B00001110, B00011000, B00101000, //* 5, 8, B00001000, B00001000, B00111110, B00001000, B00001000, // + 2, 8, B10110000, B01110000, B00000000, B00000000, B00000000, // , 4, 8, B00001000, B00001000, B00001000, B00001000, B00000000, // - 2, 8, B01100000, B01100000, B00000000, B00000000, B00000000, // . 4, 8, B01100000, B00011000, B00000110, B00000001, B00000000, // / 4, 8, B00111110, B01000001, B01000001, B00111110, B00000000, // 0 3, 8, B01000010, B01111111, B01000000, B00000000, B00000000, // 1 4, 8, B01100010, B01010001, B01001001, B01000110, B00000000, // 2 4, 8, B00100010, B01000001, B01001001, B00110110, B00000000, // 3 4, 8, B00011000, B00010100, B00010010, B01111111, B00000000, // 4 4, 8, B00100111, B01000101, B01000101, B00111001, B00000000, // 5 4, 8, B00111110, B01001001, B01001001, B00110000, B00000000, // 6 4, 8, B01100001, B00010001, B00001001, B00000111, B00000000, // 7 4, 8, B00110110, B01001001, B01001001, B00110110, B00000000, // 8 4, 8, B00000110, B01001001, B01001001, B00111110, B00000000, // 9 2, 8, B01010000, B00000000, B00000000, B00000000, B00000000, // : 2, 8, B10000000, B01010000, B00000000, B00000000, B00000000, // ; 3, 8, B00010000, B00101000, B01000100, B00000000, B00000000, // < 3, 8, B00010100, B00010100, B00010100, B00000000, B00000000, // = 3, 8, B01000100, B00101000, B00010000, B00000000, B00000000, // > 4, 8, B00000010, B01011001, B00001001, B00000110, B00000000, // ? 5, 8, B00111110, B01001001, B01010101, B01011101, B00001110, // @ 4, 8, B01111110, B00010001, B00010001, B01111110, B00000000, //A 4, 8, B01111111, B01001001, B01001001, B00110110, B00000000, // B 4, 8, B00111110, B01000001, B01000001, B00100010, B00000000, // C 4, 8, B01111111, B01000001, B01000001, B00111110, B00000000, // D 4, 8, B01111111, B01001001, B01001001, B01000001, B00000000, // E 4, 8, B01111111, B00001001, B00001001, B00000001, B00000000, // F 4, 8, B00111110, B01000001, B01001001, B01111010, B00000000, // G 4, 8, B01111111, B00001000, B00001000, B01111111, B00000000, // H 3, 8, B01000001, B01111111, B01000001, B00000000, B00000000, // I 4, 8, B00110000, B01000000, B01000001, B00111111, B00000000, // J 4, 8, B01111111, B00001000, B00010100, B01100011, B00000000, // K 4, 8, B01111111, B01000000, B01000000, B01000000, B00000000, // L 5, 8, B01111111, B00000010, B00001100, B00000010, B01111111, // M 5, 8, B01111111, B00000100, B00001000, B00010000, B01111111, // N 4, 8, B00111110, B01000001, B01000001, B00111110, B00000000, //O 4, 8, B01111111, B00001001, B00001001, B00000110, B00000000, // P 4, 8, B00111110, B01000001, B01000001, B10111110, B00000000, // Q 4, 8, B01111111, B00001001, B00001001, B01110110, B00000000, // R 4, 8, B01000110, B01001001, B01001001, B00110010, B00000000, // S 5, 8, B00000001, B00000001, B01111111, B00000001, B00000001, // T 4, 8, B00111111, B01000000, B01000000, B00111111, B00000000, // U 5, 8, B00001111, B00110000, B01000000, B00110000, B00001111, // V 5, 8, B00111111, B01000000, B00111000, B01000000, B00111111, // W 5, 8, B01100011, B00010100, B00001000, B00010100, B01100011, // X 5, 8, B00000111, B00001000, B01110000, B00001000, B00000111, // Y 4, 8, B01100001, B01010001, B01001001, B01000111, B00000000, // Z 2, 8, B01111111, B01000001, B00000000, B00000000, B00000000, // [ 4, 8, B00000001, B00000110, B00011000, B01100000, B00000000, // \ backslash 2, 8, B01000001, B01111111, B00000000, B00000000, B00000000, // ] 3, 8, B00000010, B00000001, B00000010, B00000000, B00000000, // hat 4, 8, B01000000, B01000000, B01000000, B01000000, B00000000, // _ 2, 8, B00000001, B00000010, B00000000, B00000000, B00000000, // ` 4, 8, B00100000, B01010100, B01010100, B01111000, B00000000, // a 4, 8, B01111111, B01000100, B01000100, B00111000, B00000000, // b 4, 8, B00111000, B01000100, B01000100, B00101000, B00000000, // c 4, 8, B00111000, B01000100, B01000100, B01111111, B00000000, // d 4, 8, B00111000, B01010100, B01010100, B00011000, B00000000, // e 3, 8, B00000100, B01111110, B00000101, B00000000, B00000000, // f 4, 8, B10011000, B10100100, B10100100, B01111000, B00000000, // g 4, 8, B01111111, B00000100, B00000100, B01111000, B00000000, //h 3, 8, B01000100, B01111101, B01000000, B00000000, B00000000, // i 4, 8, B01000000, B10000000, B10000100, B01111101, B00000000, // j 4, 8, B01111111, B00010000, B00101000, B01000100, B00000000, // k 3, 8, B01000001, B01111111, B01000000, B00000000, B00000000, // l 5, 8, B01111100, B00000100, B01111100, B00000100, B01111000, // m 4, 8, B01111100, B00000100, B00000100, B01111000, B00000000, // n 4, 8, B00111000, B01000100, B01000100, B00111000, B00000000, // o 4, 8, B11111100, B00100100, B00100100, B00011000, B00000000, // p 4, 8, B00011000, B00100100, B00100100, B11111100, B00000000, // q 4, 8, B01111100, B00001000, B00000100, B00000100, B00000000, // r 4, 8, B01001000, B01010100, B01010100, B00100100, B00000000, // s 3, 8, B00000100, B00111111, B01000100, B00000000, B00000000, // t 4, 8, B00111100, B01000000, B01000000, B01111100, B00000000, // u 5, 8, B00011100, B00100000, B01000000, B00100000, B00011100, //v 5, 8, B00111100, B01000000, B00111100, B01000000, B00111100, // w 5, 8, B01000100, B00101000, B00010000, B00101000, B01000100, // x 4, 8, B10011100, B10100000, B10100000, B01111100, B00000000, // y 3, 8, B01100100, B01010100, B01001100, B00000000, B00000000, // z 3, 8, B00001000, B00110110, B01000001, B00000000, B00000000, // { 1, 8, B01111111, B00000000, B00000000, B00000000, B00000000, // | 3, 8, B01000001, B00110110, B00001000, B00000000, B00000000, // } 4, 8, B00001000, B00000100, B00001000, B00000100, B00000000, // ~ }; int DIN = 7; // DIN pin of MAX7219 module int CLK = 6; // CLK pin of MAX7219 module int CS = 5; // CS pin of MAX7219 module int maxInUse = 2; MaxMatrix m(DIN, CS, CLK, maxInUse); byte buffer[10]; char text[]= "TechKnowSkola"; // Scrolling text void setup() { m.init(); // module initialize m.setIntensity(15); // dot matix intensity 0-15 } void loop() { printStringWithShift(text, 100); // (text, scrolling speed) } // Display=the extracted characters with scrolling void printCharWithShift(char c, int shift_speed) { if (c < 32) return; c -= 32; memcpy_P(buffer, CH + 7 * c, 7); m.writeSprite(32, 0, buffer); m.setColumn(32 + buffer[0], 0); for (int i = 0; i < buffer[0] + 1; i++) { delay(shift_speed); m.shiftLeft(false, false); } } // Extract the characters from the text string void printStringWithShift(char* s, int shift_speed) { while (*s != 0) { printCharWithShift(*s, shift_speed); s++; } } Now let’s move to the functioning of Bluetooth HC-05 Description: Here we have to include an additional library for the PROGMEN which is variable modifier and it’s used for storing data in the flash memory instead of SRAM. When we have a larger database of variables which are static, like in this case defining letters and characters, it’s better to store them in the flash memory because it’s much bigger, 32K bytes, compared to the 2K bytes of the SRAM. Next with a character array we define the scrolling text and in the loop section the custom function printStringWithShift, prints the scrolling text on the LED matrix with a scrolling speed defined in milliseconds with the second argument. The first thing that this custom function do is that it extracts the characters from the text string and then display these scrolling characters on the led matrix. The particular module that I have can be powered from 3.6 to 6 volts, because it comes on breakout board which contains a voltage regulator. However, the logic voltage level of the data pins is 3.3V. So, the line between the Arduino TX (Transmit Pin, which has 5V output) and the Bluetooth module RX (Receive Pin, which supports only 3.3V) needs to be connected through a voltage divider in order not to burn the module. On the other hand, the line between the Bluetooth module TX pin and the Arduino RX pin can be connected directly because the 3.3V signal from the Bluetooth module is enough to beaccepted as a high logic at the Arduino Board. Circuit Schematics: Here’s how we need to connect the module to the Arduino Board. Connecting the Smartphone to the HC-05 Bluetooth Module and the Arduino Now we are ready to connect the smartphone to the Bluetooth module and the Arduino. What we need to do here is to activate the Bluetooth and the smartphone will find the HC-05 Bluetooth module. Then we need to pair the devices and the default password of the HC-05 module is 1234. After we have paired the devices we need an application for controlling the Arduino. There are many application in the Play Store for this purpose which will work with the Arduino code that we wrote. However, I made my own custom application for this tutorial using the MIT App Inventor online application. This is a great and easy to use application for building Android application and in my next tutorial you can find a detailed step by step guide how to build your own custom Android application for your Arduino Project. Android App for Controlling 8×8 LED Matrix via Bluetooth Once we learned how the MAX7219 works, now we can make the third example which is a practical Arduino project where we will build a custom Android app to control the LED matrix via Bluetooth communication. Before we continue I would suggest you to check detailed tutorials on how to use the HC-05 Bluetooth module and how to build a custom Android app using the MIT App Inventor online application . Here’s the Arduino code and now let’s see the modifications compared to the previous example. /* 8x8 LED Matrix MAX7219 Scrolling Text Android Control via Bluetooth by Dejan Nedelkovsk i, www.HowToMechatronics.com Based on the following library: GitHub | riyas-org/max7219 https://github.com/riyas-org/max7219 */ #include #include #include PROGMEM const unsigned char CH[] = { 3, 8, B00000000, B00000000, B00000000, B00000000, B00000000, // space 1, 8, B01011111, B00000000, B00000000, B00000000, B00000000, // ! 3, 8, B00000011, B00000000, B00000011, B00000000, B00000000, // " 5, 8, B00010100, B00111110, B00010100, B00111110, B00010100, //# 4, 8, B00100100, B01101010, B00101011, B00010010, B00000000, // $ 5, 8, B01100011, B00010011, B00001000, B01100100, B01100011, // % 5, 8, B00110110, B01001001, B01010110, B00100000, B01010000, // & 1, 8, B00000011, B00000000, B00000000, B00000000, B00000000, // ' 3, 8, B00011100, B00100010, B01000001, B00000000, B00000000, // ( 3, 8, B01000001, B00100010, B00011100, B00000000, B00000000, // ) 5, 8, B00101000, B00011000, B00001110, B00011000, B00101000, // * 5, 8, B00001000, B00001000, B00111110, B00001000, B00001000, // + 2, 8, B10110000, B01110000, B00000000, B00000000, B00000000, // , 4, 8, B00001000, B00001000, B00001000, B00001000, B00000000, //- 2, 8, B01100000, B01100000, B00000000, B00000000, B00000000, // . 4, 8, B01100000, B00011000, B00000110, B00000001, B00000000, // / 4, 8, B00111110, B01000001, B01000001, B00111110, B00000000, // 0 3, 8, B01000010, B01111111, B01000000, B00000000, B00000000, // 1 4, 8, B01100010, B01010001, B01001001, B01000110, B00000000, // 2 4, 8, B00100010, B01000001, B01001001, B00110110, B00000000, // 3 4, 8, B00011000, B00010100, B00010010, B01111111, B00000000, // 4 4, 8, B00100111, B01000101, B01000101, B00111001, B00000000, // 5 4, 8, B00111110, B01001001, B01001001, B00110000, B00000000, // 6 4, 8, B01100001, B00010001, B00001001, B00000111, B00000000, // 7 4, 8, B00110110, B01001001, B01001001, B00110110, B00000000, // 8 4, 8, B00000110, B01001001, B01001001, B00111110, B00000000, // 9 2, 8, B01010000, B00000000, B00000000, B00000000, B00000000, // : 2, 8, B10000000, B01010000, B00000000, B00000000, B00000000, //; 3, 8, B00010000, B00101000, B01000100, B00000000, B00000000, // < 3, 8, B00010100, B00010100, B00010100, B00000000, B00000000, // = 3, 8, B01000100, B00101000, B00010000, B00000000, B00000000, // > 4, 8, B00000010, B01011001, B00001001, B00000110, B00000000, // ? 5, 8, B00111110, B01001001, B01010101, B01011101, B00001110, // @ 4, 8, B01111110, B00010001, B00010001, B01111110, B00000000, // A 4, 8, B01111111, B01001001, B01001001, B00110110, B00000000, // B 4, 8, B00111110, B01000001, B01000001, B00100010, B00000000, // C 4, 8, B01111111, B01000001, B01000001, B00111110, B00000000, // D 4, 8, B01111111, B01001001, B01001001, B01000001, B00000000, // E 4, 8, B01111111, B00001001, B00001001, B00000001, B00000000, // F 4, 8, B00111110, B01000001, B01001001, B01111010, B00000000, // G 4, 8, B01111111, B00001000, B00001000, B01111111, B00000000, // H 3, 8, B01000001, B01111111, B01000001, B00000000, B00000000, // I 4, 8, B00110000, B01000000, B01000001, B00111111, B00000000, // J 4, 8, B01111111, B00001000, B00010100, B01100011, B00000000, // K 4, 8, B01111111, B01000000, B01000000, B01000000, B00000000, // L 5, 8, B01111111, B00000010, B00001100, B00000010, B01111111, // M 5, 8, B01111111, B00000100, B00001000, B00010000, B01111111, // N 4, 8, B00111110, B01000001, B01000001, B00111110, B00000000, // O 4, 8, B01111111, B00001001, B00001001, B00000110, B00000000, // P 4, 8, B00111110, B01000001, B01000001, B10111110, B00000000, // Q 4, 8, B01111111, B00001001, B00001001, B01110110, B00000000, // R 4, 8, B01000110, B01001001, B01001001, B00110010, B00000000, // S 5, 8, B00000001, B00000001, B01111111, B00000001, B00000001, //T 4, 8, B00111111, B01000000, B01000000, B00111111, B00000000, // U 5, 8, B00001111, B00110000, B01000000, B00110000, B00001111, // V 5, 8, B00111111, B01000000, B00111000, B01000000, B00111111, // W 5, 8, B01100011, B00010100, B00001000, B00010100, B01100011, // X 5, 8, B00000111, B00001000, B01110000, B00001000, B00000111, // Y 4, 8, B01100001, B01010001, B01001001, B01000111, B00000000, // Z 2, 8, B01111111, B01000001, B00000000, B00000000, B00000000, // [ 4, 8, B00000001, B00000110, B00011000, B01100000, B00000000, // \ backslash 2, 8, B01000001, B01111111, B00000000, B00000000, B00000000, // ] 3, 8, B00000010, B00000001, B00000010, B00000000, B00000000, // hat 4, 8, B01000000, B01000000, B01000000, B01000000, B00000000, // _ 2, 8, B00000001, B00000010, B00000000, B00000000, B00000000, // ` 4, 8, B00100000, B01010100, B01010100, B01111000, B00000000, // a 4, 8, B01111111, B01000100, B01000100, B00111000, B00000000, //b 4, 8, B00111000, B01000100, B01000100, B00101000, B00000000, // c 4, 8, B00111000, B01000100, B01000100, B01111111, B00000000, // d 4, 8, B00111000, B01010100, B01010100, B00011000, B00000000, // e 3, 8, B00000100, B01111110, B00000101, B00000000, B00000000, // f 4, 8, B10011000, B10100100, B10100100, B01111000, B00000000, // g 4, 8, B01111111, B00000100, B00000100, B01111000, B00000000, // h 3, 8, B01000100, B01111101, B01000000, B00000000, B00000000, // i 4, 8, B01000000, B10000000, B10000100, B01111101, B00000000, // j 4, 8, B01111111, B00010000, B00101000, B01000100, B00000000, // k 3, 8, B01000001, B01111111, B01000000, B00000000, B00000000, // l 5, 8, B01111100, B00000100, B01111100, B00000100, B01111000, // m 4, 8, B01111100, B00000100, B00000100, B01111000, B00000000, // n 4, 8, B00111000, B01000100, B01000100, B00111000, B00000000, // o 4, 8, B11111100, B00100100, B00100100, B00011000, B00000000, // p 4, 8, B00011000, B00100100, B00100100, B11111100, B00000000, // q 4, 8, B01111100, B00001000, B00000100, B00000100, B00000000, // r 4, 8, B01001000, B01010100, B01010100, B00100100, B00000000, // s 3, 8, B00000100, B00111111, B01000100, B00000000, B00000000, // t 4, 8, B00111100, B01000000, B01000000, B01111100, B00000000, // u 5, 8, B00011100, B00100000, B01000000, B00100000, B00011100, // v 5, 8, B00111100, B01000000, B00111100, B01000000, B00111100, // w 5, 8, B01000100, B00101000, B00010000, B00101000, B01000100, // x 4, 8, B10011100, B10100000, B10100000, B01111100, B00000000, // y 3, 8, B01100100, B01010100, B01001100, B00000000, B00000000, // z 3, 8, B00001000, B00110110, B01000001, B00000000, B00000000, //{ 1, 8, B01111111, B00000000, B00000000, B00000000, B00000000, // | 3, 8, B01000001, B00110110, B00001000, B00000000, B00000000, // } 4, 8, B00001000, B00000100, B00001000, B00000100, B00000000, // ~ }; int dIn = 7; // DIN pin of MAX7219 module int clk = 6; // CLK pin of MAX7219 module int cs = 5; // CS pin of MAX7219 module int maxInUse = 2; // Number of MAX7219's connected MaxMatrix m(dIn, cs, clk, maxInUse); SoftwareSerial Bluetooth(8, 7); // Bluetooth byte buffer[10]; char incomebyte; int scrollSpeed = 100; char text[100] = "TechKnowSkola "; // Initial text message int brightness = 15; int count = 0; char indicator; void setup() { m.init(); // MAX7219 initialization m.setIntensity(brightness); // initial led matrix intensity, 0-15 Bluetooth.begin(38400); // Default communication rate of the Bluetooth module } void loop() { // Printing the text printStringWithShift(text, scrollSpeed); if (Bluetooth.available()) { // Checks whether data is comming from the serial port indicator = Bluetooth.read(); // Starts reading the serial port, the first byte from the incoming data // If we have pressed the "Send" button from the Android App, clear the previous text if (indicator == '1') { for (int i = 0; i < 100; i++) { text[i] = 0; m.clear(); } // Read the whole data/string comming from the phone and put it into text[] array. while (Bluetooth.available()) { incomebyte = Bluetooth.read(); text[count] = incomebyte; count++; } count = 0; } // Adjusting the Scrolling Speed else if (indicator == '2') { String sS = Bluetooth.readString(); scrollSpeed = 150 - sS.toInt(); // Milliseconds, subtraction because lower value means higher scrolling speed } // Adjusting the brightness else if (indicator == '3') { String sB = Bluetooth.readString(); brightness = sB.toInt(); m.setIntensity(brightness); } } } void printCharWithShift(char c, int shift_speed) { if (c < 32) return; c -= 32; memcpy_P(buffer, CH + 7 * c, 7); m.writeSprite(32, 0, buffer); m.setColumn(32 + buffer[0], 0); for (int i = 0; i < buffer[0] + 1; i++) { delay(shift_speed); m.shiftLeft(false, false); } } void printStringWithShift(char* s, int shift_speed) { while (*s != 0) { printCharWithShift(*s, shift_speed); s++; } } void printString(char* s) { int col = 0; while (*s != 0) { if (*s < 32) continue; char c = *s - 32; memcpy_P(buffer, CH + 7 * c, 7); m.writeSprite(col, 0, buffer); m.setColumn(col + buffer[0], 0); col += buffer[0] + 1; s++; } } Description: First we need to include the SoftwareSerial.h library which will enable the Bluetooth communication and define some variables needed for the program. In the setup section we need to initialize the Bluetooth at its default baud rate of 38400 bits per second. I set the initial text message to be “TechKnowSkola” with 100 milliseconds delay scrolling speed. Next, in the loop section, using the Bluetooth.available() function we check whether there is incoming data from the serial port and if that’s true using the Bluetooth.read function we start reading the serial port, one byte each iteration. So the first incoming byte will be always stored into the “indicator” variable and according to it choose whether we will change the text message, the scrolling speed or the brightness of the LED matrix. If we take a look at the Android app code blocks we can notice that when the “Send” button is clicked, first we send the indication byte, in this case “1”, which means we want the change the text message. In order to do that, at the Arduino side, we will clear the whole character array and also clear the LED matrix display. Then in the “while” loop we will read the rest of the data in the serial port, and that’s the messaged typed in the text box of the Android app. In case the indication variable is “2”, that means we have changed the position of the scrolling speed slider, so we will read its new value using the Bluetooth.readString() function and adjust the scrolling speed. In the same way we adjust the brightness of the LEDs. You can download the app from the following link: https://drive.google.com/open?id=1xvR_tyTF-zzdrqc6RrdHlcD5FRICIbs5 Reference URL GET IN TOUCH We'd love to hear from you Contact Us

Back Interfacing of Sound sensor with Arduino Uno. What is a Sound Sensor? The Sound Sensor Module provides an easy way to detect sound and is generally used for detecting sound Intensity. This Module can be used Security, Switch and Monitoring applications. Its accuracy can be easily Adjusted for the convenience of the usage. It uses a Microphone which supplies the input to an amplifier, peak detector and buffer. When a Sensor detects a sound , it processes an output signal voltage which is sent to microprocessor , and performs further processing. Material Required: Material Quantity Arduino Uno 1 Sound Sensor 1 Jumper cables 5 Resistor 1(1k ohm) Pinout Diagram: Circuit Diagram: Parameter Value VCC 5 V DC from your Arduino Ground GND from your Arduino Out Connect to Digital Input Pin Tested Programming Code: //Arduino Sound Detection Sensor Module int soundDetectedPin = 10; // Use Pin 10 as our Input int soundDetectedVal = HIGH; // This is where we record our Sound Measurement boolean bAlarm = false; unsigned long lastSoundDetectTime; // Record the time that we measured a sound int soundAlarmTime = 500; // Number of milli seconds to keep the sound alarm high void setup () { Serial.begin(9600); pinMode (soundDetectedPin, INPUT) ; // input from the Sound Detection Module } void loop () { soundDetectedVal = digitalRead (soundDetectedPin) ; // read the sound alarm time if (soundDetectedVal == LOW) // If we hear a sound { lastSoundDetectTime = millis(); // record the time of the sound alarm // The following is so you don't scroll on the output screen if (!bAlarm){ Serial.println("LOUD, LOUD"); bAlarm = true; } } else { if( (millis()-lastSoundDetectTime) > soundAlarmTime && bAlarm){ Serial.println("quiet"); bAlarm = false; } } } Precautions: 1. Double check the connections before powering on the circuit. 2. Don’t use loose jumper cables. 3. Check whether proper board is selected from Arduino IDE. 4. Ensure proper placement of Sound Sensor for correctworking. 5. Don’t lose hope if Sound Sensor does not run properly for the first time, try again. Conclusion: Once your sketch is running, you will want to open your serial monitor. Make some loud noises and and view the results Reference URL GET IN TOUCH We'd love to hear from you Contact Us

Back Interfacing of RFID Module with Arduino Uno. What is RFID? Radio-Frequency Identification ( RFID ) is the use of radio waves to read and capture information stored on a tag attached to an object. A tag can be read from up to several feet away and does not need to be within direct line-of-sight of the reader to be tracked. Material Required: Material Quantity Arduino Uno 1 Rfid module 1 Jumper cables 8 Pinout Diagram: Circuit Diagram: Connect the RFID module with Arduino as follows: GND pin of RFID module to GND of Arduino VCC pin of RFID module to 5V of Arduino SDA pin of RFID module to digital pin 10 of Arduino SCK pin of RFID module to digital pin 13 of Arduino. MOSI pin of RFID module to digital pin 11 of Arduino. MISO pin of RFID module to digital pin 12 of Arduino. RST pin of RFID module to digital pin 9 of Arduino. IRQ pin of RFID module is not connected Download RFID Library We need to download the library for RFID. Go to sketch >> include library >> window open >> go to search bar and type <> you see a link >> click on that link and install. Tested Programming Code: #include #include #define RST_PIN 9 #define SS_PIN 10 MFRC522 rfid(SS_PIN, RST_PIN); MFRC522::MIFARE_Key key; void setup() { Serial.begin(9600); SPI.begin(); rfid.PCD_Init(); } void loop() { if( ! rfid.PICC_IsNewCardPresent()||! rfid.PICC_ReadCardSerial()) { return; } MFRC522::PICC_TypepiccType = rfid.PICC_GetType(rfid.uid.sak); String sd = ""; for (byte i = 0; i < 4; i++) { sd += (rfid.uid.uidByte[i] < 0x10 ? "0" : "") + String(rfid.uid.uidByte[i], HEX) + (i!=3 ? ":" : ""); } sd.toUpperCase(); Serial.print("Tap card key: "); Serial.println(sd); rfid.PICC_HaltA (); rfid.PCD_StopCrypto1 (); } Precautions: Double check the connections before powering on the circuit. Don’t use loose jumper cables. Check whether proper board is selected from Arduino IDE. Ensure proper placement of RFID module Sensor for correct working. Conclusion: Once your sketch is running, you have open serial monitor and then put your RFID tag on RFID module. Reference URL GET IN TOUCH We'd love to hear from you Contact Us

Back Interfacing Colour Sensor with Arduino (TCS3200) What is a Color Sensor? A colour sensor can determine different colours. They will utilize a means of emitting light and then look at the reflected light to determine an object’s colour. This will give the machine the actual colour of that object. These sensors are in use in quite a few different applications today. You can find them in quality control systems, packaging systems, and more. Specifications: · Power: 2.7V to 5.5V · Size: 28.4 x 28.4mm (1.12 x 1.12″) · Interface: digital TTL · High-resolution conversion of light intensity to frequency · Programmable colour and full-scale output frequency · Communicates directly to the microcontroller Material Required: Material Quantity Arduino Uno 1 Colour Sensor 1 Jumper cables 10 Pinout Diagram: Working: The TCS230 senses colour light with the help of an 8 x 8 array of photodiodes. Then using a Current-to-Frequency Converter the readings from the photodiodes are converted into a square wave with a frequency directly proportional to the light intensity. Finally, using the Arduino Board we can read the square wave output and get the results for the colour. If we take a closer look at the sensor we can see how it detects various colours. The photodiodes have three different colour filters. Sixteen of them have red filters, another 16 have green filters, another 16 have blue filters and the other 16 photodiodes are clear with no filters. Every 16 photodiodes are connected in parallel, so using the two control pins S2 and S3 we can select which of them will be read. So for example, if we want to detect red colour, we can just use the 16 red filtered photodiodes by setting the two pins to a low logic level according to the table. The sensor has two more control pins, S0 and S1 which are used for scaling the output frequency. The frequency can be scaled to three different preset values of 100 %, 20 % or 2%. This frequency-scaling function allows the output of the sensor to be optimized for various frequency counters or microcontrollers. Circuit Diagram: Tested Programming Code: First, we need to define the pins to which the sensor is connected and define a variable for reading the frequency. In the setup section, we need to define the four control pins as outputs and the sensor output as an Arduino input. Here we also need to set the frequency scaling, for this example, I will set it to 20%, and start the serial communication for displaying the results in the Serial Monitor. In the loop section, we will start with reading the red filtered photodiodes. For that purpose, we will set the two control pins S2 and S3 to low logic level. Then using the “pulseIn()” function we will read the output frequency and put it into the variable “frequency”. Using the Serial.print() function we will print the result on the serial monitor. The same procedure goes for the two other colours, we just need to adjust the control pins for the appropriate colour. Code: #define S0 4 #define S1 5 #define S2 6 #define S3 7 #define sensorOut 8 int frequency = 0; void setup() { pinMode(S0, OUTPUT); pinMode(S1, OUTPUT); pinMode(S2, OUTPUT); pinMode(S3, OUTPUT); pinMode(sensorOut, INPUT); digitalWrite(S0,HIGH); digitalWrite(S1,LOW); Serial.begin(9600);} void loop() { digitalWrite(S2,LOW); digitalWrite(S3,LOW); frequency = pulseIn(sensorOut, LOW); Serial.print("R= ");//printing name Serial.print(frequency);//printing RED color frequency Serial.print(" "); delay(100); digitalWrite(S2,HIGH); digitalWrite(S3,HIGH); frequency = pulseIn(sensorOut, LOW); Serial.print("G= "); Serial.print(frequency);Serial.print(" "); delay(100); digitalWrite(S2,LOW); digitalWrite(S3,HIGH);frequency pulseIn(sensorOut, LOW); Serial.print("B= ");//printing name Serial.print(frequency);//printing RED color frequency Serial.println(" "); delay(100); } Precautions: 1. Double-check the connections before powering on the circuit. 2. Don’t use loose jumper cables. 3. Check whether the proper board is selected from Arduino IDE. 4. Ensure proper placement of sensor for correct working. 5. Try it with different colours and see the change in values. Conclusion: You can successfully identify different colours using this sensor and can be deployed for many other purposes like item sorting, Rubiks cube solving etc. Output: Situation Screenshot: Serial Monitor (Ctrl+Shift+M) BLUE : GREEN : RED Reference URL GET IN TOUCH We'd love to hear from you Contact Us

Back Motion Detection using PIR Sensor with Arduino What is a PIR sensor? PIR sensors allow you to sense motion. They are used to detect whether a human has moved in or out of the sensor’s range. They are commonly found in appliances and gadgets used at home or for businesses. They are often referred to as PIR, "Passive Infrared", "Pyroelectric", or "IR motion" sensors. Following are the advantages of PIR Sensors − · Small in size · Wide lens range · Easy to interface· · Inexpensive · Low-power · Easy to use · Do not wear out Material Required: Material Quantity Arduino Uno 1 PIR Motion Sensor 1 Jumper cables 3 Pinout Diagram: Circuit Diagram: Working: The module actually consists of a Pyroelectric sensor which generates energy when exposed to heat. That means when a human or animal body will get in the range of the sensor it will detect a movement because the human or animal body emits heat energy in a form of infrared radiation. That’s where the name of the sensor comes from, a Passive Infra-Red sensor. And the term “passive” means that sensor is not using any energy for detecting purposes, it just works by detecting the energy given off by the other objects. The module also consists a specially designed cover named Fresnel lens, which focuses the infrared signals onto the pyroelectric sensor. You can adjust the sensor sensitivity and delay time via two variable resistors located at the bottom of the sensor board. Tested Programming Code: /* * PIR sensor tester */ int ledPin = 13; // choose the pin for the LED int inputPin = 2; // choose the input pin (for PIR sensor) int pirState = LOW; // we start, assuming no motion detected int val= 0; // variable for reading the pin status void setup() { pinMode(ledPin, OUTPUT); // declare LED as output pinMode(inputPin, INPUT); // declare sensor as input Serial.begin(9600); } void loop(){ val = digitalRead(inputPin); // read input value if (val == HIGH) { // check if the input is HIGH digitalWrite(ledPin, HIGH); // turn LED ON if (pirState == LOW) { // we have just turned on Serial.println("Motion detected!"); // We only want to print on the output change, not state pirState = HIGH; } } else { digitalWrite(ledPin, LOW); // turn LED OFF if (pirState == HIGH) { // we have just turned of Serial.println("Motion ended!"); // We only want to print on the output change, not state pirState = LOW; } } } Precautions: 1. Double Check the connections before powering on the circuit. 2. Don’t use loose jumper cables. 3. Check Whether proper board is selected from Arduino IDE. 4. Ensure proper placement of sensor for correct working. 5. Don’t come in range of the sensor, else it will be always triggering ON. Conclusion: You can successfully check for Motion Detection using an IR sensor. Many more other applications can be made using PIR Motion sensor as it has many possibilities to work with. Output: Once the sensor detects any motion, Arduino will send a message via the serial port to say that a motion is detected. The PIR sense motion will delay for certain time to check if there is a new motion. If there is no motion detected, Arduino will send a new message saying that the motion has ended. Situation Screenshot: Serial Monitor (Ctrl+Shift+M) Reference URL GET IN TOUCH We'd love to hear from you Contact Us

Back Measuring Distance using Ultrasonic Sensor with Arduino What is an Ultrasonic Sensor? An Ultrasonic sensor is a device that can measure the distance to an object by using sound waves. It measures distance by sending out a sound wave at a specific frequency and listening for that sound wave to bounce back. By recording the elapsed time between the sound wave being generated and the sound wave bouncing back, it is possible to calculate the distance between the sonar sensor and the object. Since it is known that sound travels through air at about 344 m/s (1129 ft/s), you can take the time for the sound wave to return and multiply it by 344 meters (or 1129 feet) to find the total round-trip distance of the sound wave. Round-trip means that the sound wave traveled 2 times the distance to the object before it was detected by the sensor; it includes the 'trip' from the sonar sensor to the object AND the 'trip' from the object to the Ultrasonic sensor (after the sound wave bounced off the object). To find the distance to the object, simply divide the round-trip distance in half. Pinout diagram: Material Required: Material Quantity Arduino Uno 1 Ultrasonic Sensor 1 Jumper cables 4 Circuit Diagram: Working: It emits an ultrasound at 40 000 Hz which travels through the air and if there is an object or obstacle on its path It will bounce back to the module. Considering the travel time and the speed of the sound you can calculate the distance. The HC-SR04 Ultrasonic Module has 4 pins, Ground, VCC, Trig and Echo. The Ground and the VCC pins of the module needs to be connected to the Ground and the 5 volts pins on the Arduino Board respectively and the trig and echo pins to any Digital I/O pin on the Arduino Board. In order to generate the ultrasound, you need to set the Trig on a High State for 10 µs. That will send out an 8 cycle sonic burst which will travel at the speed sound and it will be received in the Echo pin. The Echo pin will output the time in microseconds the sound waves traveled. For example, if the object is 10 cm away from the sensor, and the speed of the sound is 340 m/s or 0.034 cm/µs the sound wave will need to travel about 294 u seconds. But what you will get from the Echo pin will be double that number because the sound waves needs to travel forward and bounce backward. So in order to get the distance in cm we need to multiply the received travel time value from the echo pin by 0.034 and divide it by 2. Tested Programming Code: // defines pins numbers const int trigPin = 9; const int echoPin = 10; // defines variables long duration; int distance; void setup() { pinMode(trigPin, OUTPUT); // Sets the trigPin as an Output pinMode(echoPin, INPUT); // Sets the echoPin as an Input Serial.begin(9600); // Starts the serial communication } void loop() { // Clears the trigPin digitalWrite(trigPin, LOW); delayMicroseconds(2); // Sets the trigPin on HIGH state for 10 micro seconds digitalWrite(trigPin, HIGH); delayMicroseconds(10); digitalWrite(trigPin, LOW); // Reads the echoPin, returns the sound wave travel time in microseconds duration = pulseIn(echoPin, HIGH); // Calculating the distance distance= duration*0.034/2; // Prints the distance on the Serial Monitor Serial.print("Distance: "); Serial.println(distance); } Precautions: 1. Double Check the connections before powering on thecircuit. 2. Don’t use loose jumper cables. 3. Check Whether proper board is selected from Arduino IDE. 4. Ensure proper placement of sensor for correct working. Conclusion: You can Measure distance using this ultrasonic sensor, without use of any measuring tape or high priced instrument. Many more other applications can be made using ultrasonic sensor as it has many possibilities to work with. Reference URL GET IN TOUCH We'd love to hear from you Contact Us

Back Interfacing GPS with Arduino (Neo-6M-001) What is a GPS Module? Every single location in the entire globe can be specified in terms of geographical coordinates. The geographical coordinate is a system which specifies any given location on the earth surface as latitude and longitude. There are devices which can read the geographical coordinates of a place with the help of the signals received from a number of satellites orbiting the earth. The system of satellites which helps in the positioning of a place is called Global Positioning System (GPS). The devices which can read the geographical coordinates of a place with the help of at least four GPS satellites are called GPS Receiver or simply GPS module. Specifications: • Build in 18X18mm GPS antenna • Anti-jamming technology • 5Hz position update rate • Operating temperature range: -40 TO 85°C • UART TTL socket • EEprom to store settings Material Required: Material Quantity Arduino Uno 1 GPS Module 1 Jumper cables 4 Working: GPS satellites circle the Earth twice a day in a precise orbit. Each satellite transmits a unique signal and orbital parameters that allow GPS devices to decode and compute the precise location of the satellite. GPS receivers use this information and trilateration to calculate a user's exact location. Essentially, the GPS receiver measures the distance to each satellite by the amount of time it takes to receive a transmitted signal. With distance measurements from a few more satellites, the receiver can determine a user's position and display it. To calculate your 2-D position (latitude and longitude) and track movement, a GPS receiver must be locked on to the signal of at least 3 satellites. With 4 or more satellites in view, the receiver can determine your 3-D position (latitude, longitude and altitude). Generally, a GPS receiver will track 8 or more satellites, but that depends on the time of day and where you are on the earth. Once your position has been determined, the GPS unit can calculate other information, such as: Speed Bearing Track Trip dist istance to destination Download and install required libraries for GPS to work in Arduino IDE (i) SoftwareSerial library (ii) TinyGPS library Click on the highlighted link to download the Library. Circuit Diagram: Connection of Arduino UNO and GPS module : Connect the four pins from UBLOX to an Arduino as follows: Ublox - Arduino GND - GND TX - Digital pin (D3) RX - Digital pin (D4) Vcc - 5Vdc Here, I suggest you to use external power supply to power the GPS module because minimum power requirement for GPS module to work is 3.3 V and Arduino is not capable of providing that much voltage. Tested Programming Code: #include #include SoftwareSerial mySerial(3,4); TinyGPS gps; void gpsdump(TinyGPS &gps); void printFloat(double f, int digits = 2); void setup() { // Oploen serial communications and wait for port to open: Serial.begin(9600); // set the data rate for the SoftwareSerial port mySerial.begin(9600); delay(1000); Serial.println("uBlox Neo 6M"); Serial.print("Testing TinyGPS library v. "); Serial.println(TinyGPS::library_version()); Serial.println("by Mikal Hart"); Serial.println(); Serial.print("Sizeof(gpsobject) = "); Serial.println(sizeof(TinyGPS)); Serial.println(); } void loop() // run over and over { bool newdata = false; unsigned long start = millis(); // Every 5 seconds we print an update while (millis() - start < 5000) { if (mySerial.available()) { char c = mySerial.read(); //Serial.print(c); // uncomment to see raw GPS data if (gps.encode(c)) { newdata = true; break; // uncomment to print new data immediately! } } } if (newdata) { Serial.println("Acquired Data"); Serial.println("-------------"); gpsdump(gps); Serial.println("-------------"); Serial.println(); } } void gpsdump(TinyGPS &gps) { long lat, lon; float flat, flon; unsigned long age, date, time, chars; int year; byte month, day, hour, minute, second, hundredths; unsigned short sentences, failed; gps.get_position(&lat, &lon, &age); Serial.print("Lat/Long(10^-5 deg): "); Serial.print(lat); Serial.print(", "); Serial.print(lon); Serial.print(" Fix age: "); Serial.print(age); Serial.println("ms."); // On Arduino, GPS characters may be lost during lengthy Serial.print() // On Teensy, Serial prints to USB, which has large output buffering and // runs very fast, so it's not necessary to worry about missing 4800 // baud GPS characters. gps.f_get_position(&flat, &flon, &age); Serial.print("Lat/Long(float): "); printFloat(flat, 5); Serial.print(", "); printFloat(flon, 5); Serial.print(" Fix age: "); Serial.print(age); Serial.println("ms."); gps.get_datetime(&date, &time, &age); Serial.print("Date(ddmmyy): "); Serial.print(date); Serial.print(" Time(hhmmsscc): "); Serial.print(time); Serial.print(" Fix age: "); Serial.print(age); Serial.println("ms."); gps.crack_datetime(&year, &month, &day, &hour, &minute, &second, &hundredths, &age); Serial.print("Date: "); Serial.print(static_cast(month)); Serial.print("/"); Serial.print(static_cast(day)); Serial.print("/"); Serial.print(year); Serial.print(" Time: "); Serial.print(static_cast(hour+8)); Serial.print(":"); //Serial.print("UTC +08:00 Malaysia"); Serial.print(static_cast(minute)); Serial.print(":"); Serial.print(static_cast(second)); Serial.print("."); Serial.print(static_cast(hundredths)); Serial.print(" UTC +08:00 Malaysia"); Serial.print(" Fix age: "); Serial.print(age); Serial.println("ms."); Serial.print("Alt(cm): "); Serial.print(gps.altitude()); Serial.print(" Course(10^-2 deg): "); Serial.print(gps.course()); Serial.print(" Speed(10^-2 knots): "); Serial.println(gps.speed()); Serial.print("Alt(float): "); printFloat(gps.f_altitude()); Serial.print(" Course(float): "); printFloat(gps.f_course()); Serial.println(); Serial.print("Speed(knots): "); printFloat(gps.f_speed_knots()); Serial.print(" (mph): "); printFloat(gps.f_speed_mph()); Serial.print(" (mps): "); printFloat(gps.f_speed_mps()); Serial.print(" (kmph): "); printFloat(gps.f_speed_kmph()); Serial.println(); gps.stats(&chars, &sentences, &failed); Serial.print("Stats: characters: "); Serial.print(chars); Serial.print(" sentences: "); Serial.print(sentences); Serial.print(" failed checksum: "); Serial.println(failed); } void printFloat(double number, int digits) { // Handle negative numbers if (number < 0.0) { Serial.print('-'); number = -number; } // Round correctly so that print(1.999, 2) prints as "2.00" double rounding = 0.5; for (uint8_t i=0; i 0) Serial.print("."); // Extract digits from the remainder one at a time while (digits-- > 0) { remainder *= 10.0; int toPrint = int(remainder); Serial.print(toPrint); remainder -= toPrint; }} Precautions: 1. Double check the connections before powering on the circuit. 2. Don’t use loose jumper cables. 3. Check whether proper board is selected from Arduino IDE. 4. Ensure proper placement of sensor for correct working.. Conclusion: You can successfully measure the flow rate and quantity of the water flowing through a pipe through a cross sectional area. This sensor can be deployed in many ways like water level automation system, water meter etc. Output: After you have successfully uploaded your source code, open your serial monitor. Serial monitor will display the data that your gps required. If you didn’t get anything, make sure your connection is correct and try it outside or near the window where it is easy to get the signal. Signal may not reach inside a building. Situation Screenshot: Serial Monitor (Ctrl+Shift+M) Reference URL GET IN TOUCH We'd love to hear from you Contact Us

Back Interfacing of 28BYJ Stepper Driver with Arduino. What is so special about steppers? A stepper motor can move in accurate, fixed angle increments known as steps. For practical purposes, a stepper motor is a bit like a servo: you can tell it to move to a pre-defined position and can count on getting fairly consistent results with multiple repetitions. Servos though, are usually limited to a 0-180 degree range, while a stepper motor can rotate continuously, similar to a regular DC motor. The advantage of steppers over DC motors is that you can achieve much higher precision and control over the movement. The downside of using steppers is that they are a bit more complex to control than servos and DC motors . The 28BYJ-48 Stepper Motor Datasheet The 28BYJ-48 is a small, cheap, 5 volt geared stepping motors. These stepping motors are apparently widely used to control things like automated blinds, A/C units and are mass produced. Due to the gear reduction ratio of *approximately* 64:1 it offers decent torque for its size at speeds of about 15 rotations per minute (RPM). With some software “trickery” to accelerate gradually and a higher voltage power source (I tested them with 12 volts DC) I was able to get about 25+ RPM. These little steppers can be purchased together with a small breakout board for the Arduino compatible ULN2003 stepper motor driver for less than $5. Quite a bargain, compared to the price of a geared DC motor, a DC motor controller and a wheel encoder! The low cost and small size makes the 28BYJ-48 an ideal option for small robotic applications, and an excellent introduction to stepper motor control with Arduino. Here are the detailed specs of the 28BYJ-48 stepper motor. Motor Type Unipolar stepper motor Connection Type 5 Wire Connection (to the motor controller) Voltage 5-12 Volts DC Frequency 100 Hz Step mode Half-step mode recommended(8 step control signal sequence) Half-step mode: 8 step control signal sequence (recommended) 5.625 degrees per step / 64 steps per one revolution of the internal motor shaft Full Step mode: 4 step control signal Step angle sequence 11.25 degrees per step / 32 steps per one revolution of the internal motor shaft Manufacturer specifies 64:1 . Some patient and diligent people on the Arduino forums have disassembled the gear train of these little motors and determined that the exact gear ratio is in fact 63.68395:1 . My observations confirm their findings. These means that in the recommended half-step mode we will have:64 steps per motor rotation x 63.684 gear ratio = Gear ratio 4076 steps per full revolution (approximately). Wiring to the ULN2003 controller A (Blue), B (Pink), C (Yellow), D (Orange), E (Red, Mid- Point) Weight 30g Material Required: Material Quantity Arduino Uno 1 Stepper Driver 1 Jumper cables 6 Stepper Motor 1 Pinout Diagram: The motor has 4 coils of wire that are powered in a sequence to make the magnetic motor shaft spin. When using the full-step method, 2 of the 4 coils are powered at each step. The default stepper library that comes pre-installed with the Arduino IDE uses this method. The 28BYH-48 datasheet specifies that the preferred method for driving this stepper is using the half-step method, where we first power coil 1 only, then coil 1 and 2 together, then coil 2 only and so on…With 4 coils, this means 8 different signals, like in the table below. Circuit Diagram: Wiring the ULN2003 stepper motor driver to Arduino Uno : The ULN2003 stepper motor driver board allows you to easily control the 28BYJ-48 stepper motor from a microcontroller, like the Arduino Uno. One side of the board side has a 5 wire socket where the cable from the stepper motor hooks up and 4 LEDs to indicate which coil is currently powered. The motor cable only goes in one way, which always helps. On the side you have a motor on / off jumper (keep it on to enable power to the stepper). The two pins below the 4 resistors, is where you provide power to the stepper. Note that powering the stepper from the 5 V rail of the Arduino is not recommended. A separate 5-12 V 1 Amp power supply or battery pack should be used, as the motor may drain more current than the microcontroller can handle and could potentially damage it. In the middle of the board we have the ULN2003 chip. At the bottom are the 4 control inputs that should be connected to four Arduino digital pins . Hooking it up to the Arduino Connect the ULN2003 driver IN1, IN2, IN3 and IN4 to digital pin 3, 4, 5 and 6 respectively on the Arduino Uno. Connect the positive lead from a decent 5-12V battery pack to the “+” pin of the ULN2003 driver and the ground to the “-” pin. Make sure that the “on/off” jumper next to the “-” pin is on. If you power the Arduino from a different battery pack, connect the grounds together. Arduino stepper code and the AccelStepper library The default stepper library that comes pre-installed with the Arduino IDE supports the full-step method only and has limited features. It does not run the 28BYJ-48 motors very efficiently and getting two of them running at the same time for a differential drive robot is a bit more difficult. I came across example sketch by 4tronix that used the half-step method with no additional libraries. Their code worked well and I was able to modify it, so that I can run two steppers at the same time. Still, I was only able to get my stepper motor spinning fairly slow and it was getting quite warm, for some reason. Additionally, that sample code uses delays for the steps and that will cause some issues when we start adding more complex functions in the loop and hook up various sensors. Then I came across the AccelStepper library. It runs the 28BYJ-48 steppers very efficiently (they never go as hot as with the other options I tried) and also supports acceleration (which allows the stepper to get to a higher speed). The library uses non blocking code for the steps and has quite a few other nice features. After some messing around with the documentation and the examples I got everything up and running. Below is the code that will slowly accelerate the 28BYJ-48 in one direction, then decelerate to a stop and accelerate in the opposite direction. Naturally, make sure you download and install the AccelStepper library first! #include #define HALFSTEP 8 // Motor pin definitions #define motorPin1 3 // IN1 on the ULN2003 driver 1 #define motorPin2 4 // IN2 on the ULN2003 driver 1 #define motorPin3 5 // IN3 on the ULN2003 driver 1 #define motorPin4 6 // IN4 on the ULN2003 driver 1 // Initialize with pin sequence IN1-IN3-IN2-IN4 for using the AccelStepper with 28BYJ-48 AccelStepper stepper1 ( HALFSTEP , motorPin1 , motorPin3 , motorPin2 , motorPin4 ); void setup () { stepper1 . setMaxSpeed ( 1000.0 ); stepper1 . setAcceleration ( 100.0 ); stepper1 . setSpeed ( 200 ); stepper1 . moveTo ( 20000 ); } //--(end setup )--- void loop () { //Change direction when the stepper reaches the target position if ( stepper1 . distanceToGo () == 0 ) { stepper1 . moveTo (- stepper1 . currentPosition ()); } stepper1 . run (); } The code above will not push this motor to its limit. You can experiment with the acceleration and speed settings to see what is the best you can squeeze out. Note that for nigher speeds, you will likely need a higher voltage DC source. If you got your stepper running, here is the code that the StepperBot from the video above is running. You will need to adjust the speed, as well variables based on your base and wheel sizes, if you want to have your bot moving in a square path. #include #define HALFSTEP 8 // motor pins #define motorPin1 3 // IN1 on the ULN2003 driver 1 #define motorPin2 4 // IN2 on the ULN2003 driver 1 #define motorPin3 5 // IN3 on the ULN2003 driver 1 #define motorPin4 6 // IN4 on the ULN2003 driver 1 #define motorPin5 8 // IN1 on the ULN2003 driver 2 #define motorPin6 9 // IN2 on the ULN2003 driver 2 #define motorPin7 10 // IN3 on the ULN2003 driver 2 #define motorPin8 11 // IN4 on the ULN2003 driver 2 // Initialize with pin sequence IN1-IN3-IN2-IN4 for using the AccelStepper with 28BYJ-48 AccelStepper stepper1 ( HALFSTEP , motorPin1 , motorPin3 , motorPin2 , motorPin4 ); AccelStepper stepper2 ( HALFSTEP , motorPin5 , motorPin7 , motorPin6 , motorPin8 ); // variables int turnSteps = 2100 ; // number of steps for a 90 degree turn int lineSteps = - 6600 ; //number of steps to drive straight int stepperSpeed = 1000 ; //speed of the stepper (steps per second) int steps1 = 0 ; // keep track of the step count for motor 1 int steps2 = 0 ; // keep track of the step count for motor 2 boolean turn1 = false ; //keep track if we are turning or going straight next boolean turn2 = false ; //keep track if we are turning or going straight next void setup () { delay ( 3000 ); //sime time to put the robot down after swithing it on stepper1 . setMaxSpeed ( 2000.0 ); stepper1 . move ( 1 ); // I found this necessary stepper1 . setSpeed ( stepperSpeed ); stepper2 . setMaxSpeed ( 2000.0 ); stepper2 . move (- 1 ); // I found this necessary stepper2 . setSpeed ( stepperSpeed ); } void loop () { if ( steps1 == 0 ) { int target = 0 ; if ( turn1 == true ) { target = turnSteps ; } else { target = lineSteps ; } stepper1 . move ( target ); stepper1 . setSpeed ( stepperSpeed ); turn1 = ! turn1 ; } if ( steps2 == 0 ) { int target = 0 ; if ( turn2 == true ) { target = turnSteps ; } else { target = - lineSteps ; } stepper2 . move ( target ); stepper2 . setSpeed ( stepperSpeed ); turn2 = ! turn2 ; } steps1 = stepper1 . distanceToGo (); steps2 = stepper2 . distanceToGo (); stepper1 . runSpeedToPosition (); stepper2 . runSpeedToPosition (); } Tested Programming Code: #define IN1 3 #define IN2 4 #define IN3 5 #define IN4 6 int Steps = 4096; //4096 or 768 int cstep = 0; void setup() { Serial.begin(9600); pinMode(IN1, OUTPUT); pinMode(IN2, OUTPUT); pinMode(IN3, OUTPUT); pinMode(IN4, OUTPUT); } void loop() { for(int x=0;x