Skip to main content

Latest Post

What is Industry 4.0?

  What is Industry 4.0 and what are some of the technologies that are driving it? Industry 4.0 is a term that refers to the fourth industrial revolution, which is characterized by the integration of digital technologies, such as artificial intelligence, cloud computing, big data, the internet of things, robotics, and 3D printing, into the manufacturing sector. Industry 4.0 aims to create smart factories that are more efficient, flexible, and responsive to customer needs and market changes. Some of the technologies that are enabling Industry 4.0 are: - Artificial intelligence (AI) : AI is the ability of machines to perform tasks that normally require human intelligence, such as reasoning, learning, decision-making, and problem-solving. AI can help optimize production processes, improve product quality, reduce costs, and enhance customer satisfaction. - Cloud computing: Cloud computing is delivering computing services, such as servers, storage, databases, software, and analytics, over t
Post a Comment

Mini Oscilloscope via Arduino Nano

What is an oscilloscope?

 An oscilloscope, formerly known as an oscillograph, is an instrument that graphically displays electrical signals and shows how those signals change over time. It measures these signals by connecting with a sensor, which is a device that creates an electrical signal in response to physical stimuli like sound, light, and heat. For instance, a microphone is a sensor that converts sound into an electrical signal.

Oscilloscopes are often used when designing, manufacturing, or repairing electronic equipment. Engineers use an oscilloscope to measure electrical phenomena and solve measurement challenges quickly and accurately to verify their designs or confirm that a sensor is working properly.

Scientists, engineers, physicists, repair technicians, and educators use oscilloscopes to see signals change over time. An automotive engineer might use an oscilloscope to correlate analog data from sensors with serial data from the engine control unit. Meanwhile, a medical researcher might use an oscilloscope to measure brain waves. There is no shortage of applications for this powerful instrument.


Requirements:

  • Arduino nano
  • OLED (128 x 64)
  • IN4148 (4)
  • Pushbuttons (4)
  • 10k VR
  • 100k, 100, 470k each one piece


Circuit Diagram:

Note:

  • buttons in order SELECT, UP, DOWN, HOLD
  • make sure you have installed the missing libraries

Code:

#include <Wire.h>

#include <Adafruit_GFX.h>

#include <Adafruit_SSD1306.h>

#include <avr/pgmspace.h>              

#include <EEPROM.h>



#define SCREEN_WIDTH 128              

#define SCREEN_HEIGHT 64              

#define REC_LENGTH 200            



#define OLED_RESET     -1      

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);



//

const char vRangeName[10][5] PROGMEM = {"A50V", "A 5V", " 50V", " 20V", " 10V", "  5V", "  2V", "  1V", "0.5V", "0.2V"};

const char * const vstring_table[] PROGMEM = {vRangeName[0], vRangeName[1], vRangeName[2], vRangeName[3], vRangeName[4], vRangeName[5], vRangeName[6], vRangeName[7], vRangeName[8], vRangeName[9]};
const char hRangeName[8][6] PROGMEM = {" 50ms", " 20ms", " 10ms", "  5ms", "  2ms", "  1ms", "500us", "200us"};    
const char * const hstring_table[] PROGMEM = {hRangeName[0], hRangeName[1], hRangeName[2], hRangeName[3], hRangeName[4], hRangeName[5], hRangeName[6], hRangeName[7]};



int waveBuff[REC_LENGTH];      

char chrBuff[10];            

String hScale = "xxxAs";

String vScale = "xxxx";



float lsb5V = 0.0055549;      

float lsb50V = 0.051513;      



volatile int vRange;          

volatile int hRange;          

volatile int trigD;          

volatile int scopeP;          

volatile boolean hold = false;

volatile boolean paraChanged = false;

volatile int saveTimer;        

int timeExec;                  



int dataMin;                  

int dataMax;                  

int dataAve;                  

int rangeMax;                  

int rangeMin;                  

int rangeMaxDisp;              

int rangeMinDisp;            

int trigP;                    

boolean trigSync;            

int att10x;                    



void setup() {

  pinMode(2, INPUT_PULLUP);    

  pinMode(8, INPUT_PULLUP);    

  pinMode(9, INPUT_PULLUP);    

  pinMode(10, INPUT_PULLUP);  

  pinMode(11, INPUT_PULLUP);  

  pinMode(12, INPUT);          

  pinMode(13, OUTPUT);        



 

  if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C))

  {

   

    for (;;);                              

  }

  loadEEPROM();                            

  analogReference(INTERNAL);              

  attachInterrupt(0, pin2IRQ, FALLING);    

  startScreen();                          

}



void loop() {

  digitalWrite(13, HIGH);

  setConditions();                        

  readWave();                              

  digitalWrite(13, LOW);                  

  dataAnalize();                          

  writeCommonImage();                      

  plotData();                              

  dispInf();                              

  display.display();                        

  saveEEPROM();                            

  while (hold == true) {                  

    dispHold();

    delay(10);

  }

}



void setConditions() {  

 

  strcpy_P(chrBuff, (char*)pgm_read_word(&(hstring_table[hRange])));  

  hScale = chrBuff;                                                  



 

  strcpy_P(chrBuff, (char*)pgm_read_word(&(vstring_table[vRange])));

  vScale = chrBuff;                                                  



  switch (vRange) {            

    case 0: {                    

       

        att10x = 1;              

        break;

      }

    case 1: {                    

       

        att10x = 0;            

        break;

      }

    case 2: {                    

        rangeMax = 50 / lsb50V;  

        rangeMaxDisp = 5000;    

        rangeMin = 0;

        rangeMinDisp = 0;

        att10x = 1;              

        break;

      }

    case 3: {                    

        rangeMax = 20 / lsb50V;

        rangeMaxDisp = 2000;

        rangeMin = 0;

        rangeMinDisp = 0;

        att10x = 1;              

        break;

      }

    case 4: {                    

        rangeMax = 10 / lsb50V;  

        rangeMaxDisp = 1000;

        rangeMin = 0;

        rangeMinDisp = 0;

        att10x = 1;              

        break;

      }

    case 5: {                    

        rangeMax = 5 / lsb5V;    

        rangeMaxDisp = 500;

        rangeMin = 0;

        rangeMinDisp = 0;

        att10x = 0;              

        break;

      }

    case 6: {                    

        rangeMax = 2 / lsb5V;    

        rangeMaxDisp = 200;

        rangeMin = 0;

        rangeMinDisp = 0;

        att10x = 0;              

        break;

      }

    case 7: {                  

        rangeMax = 1 / lsb5V;    

        rangeMaxDisp = 100;

        rangeMin = 0;

        rangeMinDisp = 0;

        att10x = 0;            

        break;

      }

    case 8: {                    

        rangeMax = 0.5 / lsb5V;

        rangeMaxDisp = 50;

        rangeMin = 0;

        rangeMinDisp = 0;

        att10x = 0;            

        break;

      }

    case 9: {                    

        rangeMax = 0.2 / lsb5V;  

        rangeMaxDisp = 20;

        rangeMin = 0;

        rangeMinDisp = 0;

        att10x = 0;              

        break;

      }

  }

}



void writeCommonImage() {    

  display.clearDisplay();                  

  display.setTextColor(WHITE);              

  display.setCursor(86, 0);                

  display.println(F("av    V"));            

  display.drawFastVLine(26, 9, 55, WHITE);  

  display.drawFastVLine(127, 9, 55, WHITE);



  display.drawFastHLine(24, 9, 7, WHITE);  

  display.drawFastHLine(24, 36, 2, WHITE);  

  display.drawFastHLine(24, 63, 7, WHITE);  



  display.drawFastHLine(51, 9, 3, WHITE);  

  display.drawFastHLine(51, 63, 3, WHITE);  



  display.drawFastHLine(76, 9, 3, WHITE);  

  display.drawFastHLine(76, 63, 3, WHITE);  



  display.drawFastHLine(101, 9, 3, WHITE);  

  display.drawFastHLine(101, 63, 3, WHITE);



  display.drawFastHLine(123, 9, 5, WHITE);  

  display.drawFastHLine(123, 63, 5, WHITE);



  for (int x = 26; x <= 128; x += 5) {

    display.drawFastHLine(x, 36, 2, WHITE);

  }

  for (int x = (127 - 25); x > 30; x -= 25) {

    for (int y = 10; y < 63; y += 5) {

      display.drawFastVLine(x, y, 2, WHITE);

    }

  }

}



void readWave() {                            

  if (att10x == 1) {                        

    pinMode(12, OUTPUT);                    

    digitalWrite(12, LOW);                  

  } else {                                  

    pinMode(12, INPUT);                    

  }



  switch (hRange) {                          



    case 0: {                              

        timeExec = 400 + 50;                

        ADCSRA = ADCSRA & 0xf8;              

        ADCSRA = ADCSRA | 0x07;              

        for (int i = 0; i < REC_LENGTH; i++)

        {    

          waveBuff[i] = analogRead(0);      

          delayMicroseconds(1888);          

        }

        break;

      }



    case 1: {                                

        timeExec = 160 + 50;                

        ADCSRA = ADCSRA & 0xf8;              

        ADCSRA = ADCSRA | 0x07;              

        for (int i = 0; i < REC_LENGTH; i++)

        {    

          waveBuff[i] = analogRead(0);      

          delayMicroseconds(688);          

        }

        break;

      }



    case 2: {                              

        timeExec = 80 + 50;                  

        ADCSRA = ADCSRA & 0xf8;              

        ADCSRA = ADCSRA | 0x07;            

        for (int i = 0; i < REC_LENGTH; i++)

        {    

          waveBuff[i] = analogRead(0);      

          delayMicroseconds(288);            

        }

        break;

      }



    case 3: {                                

        timeExec = 40 + 50;                  

        ADCSRA = ADCSRA & 0xf8;            

        ADCSRA = ADCSRA | 0x07;              

        for (int i = 0; i < REC_LENGTH; i++)

        {     // 200

          waveBuff[i] = analogRead(0);      

          delayMicroseconds(88);            

        }

        break;

      }



    case 4: {                                

        timeExec = 16 + 50;                  

        ADCSRA = ADCSRA & 0xf8;              

        ADCSRA = ADCSRA | 0x06;              

        for (int i = 0; i < REC_LENGTH; i++)

        {    

          waveBuff[i] = analogRead(0);       // MakeIdea

          delayMicroseconds(24);             //

        }

        break;

      }



    case 5: {                                

        timeExec = 8 + 50;                  

        ADCSRA = ADCSRA & 0xf8;              

        ADCSRA = ADCSRA | 0x05;              

        for (int i = 0; i < REC_LENGTH; i++)

        {  

          waveBuff[i] = analogRead(0);      

          delayMicroseconds(12);            

        }

        break;

      }



    case 6: {                                

        timeExec = 4 + 50;                  

        ADCSRA = ADCSRA & 0xf8;            

        ADCSRA = ADCSRA | 0x04;              

        for (int i = 0; i < REC_LENGTH; i++)

        {    

          waveBuff[i] = analogRead(0);      

          delayMicroseconds(4);              

          // MakeIdea

          asm("nop"); asm("nop"); asm("nop"); asm("nop"); asm("nop"); asm("nop"); asm("nop"); asm("nop"); asm("nop"); asm("nop");

          asm("nop"); asm("nop"); asm("nop");

        }

        break;

      }



    case 7: {                                

        timeExec = 2 + 50;                  

        ADCSRA = ADCSRA & 0xf8;            

        ADCSRA = ADCSRA | 0x02;              

        for (int i = 0; i < REC_LENGTH; i++)

        {

          waveBuff[i] = analogRead(0);      

          // Hemant

          asm("nop"); asm("nop"); asm("nop"); asm("nop"); asm("nop"); asm("nop"); asm("nop"); asm("nop"); asm("nop"); asm("nop");

          asm("nop"); asm("nop"); asm("nop"); asm("nop"); asm("nop"); asm("nop"); asm("nop"); asm("nop"); asm("nop"); asm("nop");
            asm("nop"); asm("nop"); asm("nop"); asm("nop"); asm("nop"); asm("nop"); asm("nop"); asm("nop"); asm("nop"); asm("nop");

        }

        break;

      }

  }

}



void dataAnalize() {                  

  int d;

  long sum = 0;



 

  dataMin = 1023;                        

  dataMax = 0;                            

  for (int i = 0; i < REC_LENGTH; i++)

  {  

    d = waveBuff[i];

    sum = sum + d;

    if (d < dataMin) {                    

      dataMin = d;

    }

    if (d > dataMax) {                    

      dataMax = d;

    }

  }



 

  dataAve = (sum + 10) / 20;              



 

  if (vRange <= 1) {                      

    rangeMin = dataMin - 20;              

    rangeMin = (rangeMin / 10) * 10;      

    if (rangeMin < 0) {

      rangeMin = 0;                      

    }

    rangeMax = dataMax + 20;              

    rangeMax = ((rangeMax / 10) + 1) * 10;

    if (rangeMax > 1020) {

      rangeMax = 1023;                    

    }



    if (att10x == 1) {                            

      rangeMaxDisp = 100 * (rangeMax * lsb50V);  

      rangeMinDisp = 100 * (rangeMin * lsb50V);  

    } else {                                      

      rangeMaxDisp = 100 * (rangeMax * lsb5V);

      rangeMinDisp = 100 * (rangeMin * lsb5V);

    }

  } else {                                  

   

  }



 

  for (trigP = ((REC_LENGTH / 2) - 51); trigP < ((REC_LENGTH / 2) + 50); trigP++)

  {

    if (trigD == 0) {                      

      if ((waveBuff[trigP - 1] < (dataMax + dataMin) / 2) && (waveBuff[trigP] >= (dataMax + dataMin) / 2)) {

        break;                            

      }

    } else {                                

      if ((waveBuff[trigP - 1] > (dataMax + dataMin) / 2) && (waveBuff[trigP] <= (dataMax + dataMin) / 2)) {

        break;

      }                                    

    }

  }

  trigSync = true;

  if (trigP >= ((REC_LENGTH / 2) + 50))

  {

    trigP = (REC_LENGTH / 2);

    trigSync = false;                      

  }

}



void startScreen() {                

  display.clearDisplay();

  display.setTextSize(1);            

  display.setTextColor(WHITE);      

  display.setCursor(10, 25);        

  display.println(F("Zameel Made"));  

  display.setCursor(10, 45);        

  display.println(F("Pocket Oscilloscope"));

  display.display();                

  delay(5000);

  display.clearDisplay();

  display.setTextSize(1);            

}



void dispHold() {                            

  display.fillRect(32, 12, 24, 8, BLACK);    

  display.setCursor(32, 12);

  display.print(F("Hold"));                  

  display.display();                        

}



void dispInf() {                            

  float voltage;

  //

  display.setCursor(2, 0);                  

  display.print(vScale);                    

  if (scopeP == 0) {                        

    display.drawFastHLine(0, 7, 27, WHITE);  

    display.drawFastVLine(0, 5, 2, WHITE);

    display.drawFastVLine(26, 5, 2, WHITE);

  }



 

  display.setCursor(34, 0);                  

  display.print(hScale);                    

  if (scopeP == 1) {                        

    display.drawFastHLine(32, 7, 33, WHITE);

    display.drawFastVLine(32, 5, 2, WHITE);

    display.drawFastVLine(64, 5, 2, WHITE);

  }



 

  display.setCursor(75, 0);                  

  if (trigD == 0) {

    display.print(char(0x18));              

  } else {

    display.print(char(0x19));                            

  }

  if (scopeP == 2) {      

    display.drawFastHLine(71, 7, 13, WHITE);

    display.drawFastVLine(71, 5, 2, WHITE);

    display.drawFastVLine(83, 5, 2, WHITE);

  }



 

  if (att10x == 1) {                        

    voltage = dataAve * lsb50V / 10.0;      

  } else {

    voltage = dataAve * lsb5V / 10.0;        

  }

  dtostrf(voltage, 4, 2, chrBuff);          

  display.setCursor(98, 0);                  

  display.print(chrBuff);                    

  //  display.print(saveTimer);                



  //

  voltage = rangeMaxDisp / 100.0;            

  if (vRange == 1 || vRange > 4) {          

    dtostrf(voltage, 4, 2, chrBuff);        

  } else {                                  

    dtostrf(voltage, 4, 1, chrBuff);        

  }

  display.setCursor(0, 9);

  display.print(chrBuff);                    



  voltage = (rangeMaxDisp + rangeMinDisp) / 200.0;

  if (vRange == 1 || vRange > 4) {          

    dtostrf(voltage, 4, 2, chrBuff);        

  } else {                                  

    dtostrf(voltage, 4, 1, chrBuff);        

  }

  display.setCursor(0, 33);

  display.print(chrBuff);                    



  voltage = rangeMinDisp / 100.0;            

  if (vRange == 1 || vRange > 4) {          

    dtostrf(voltage, 4, 2, chrBuff);        

  } else {

    dtostrf(voltage, 4, 1, chrBuff);        

  }

  display.setCursor(0, 57);

  display.print(chrBuff);                    



 

  if (trigSync == false) {                  

    display.setCursor(60, 55);              

    display.print(F("Unsync"));              

  }

}



void plotData() {                  

  long y1, y2;

  for (int x = 0; x <= 98; x++) {

    y1 = map(waveBuff[x + trigP - 50], rangeMin, rangeMax, 63, 9);  

    y1 = constrain(y1, 9, 63);                                      

    y2 = map(waveBuff[x + trigP - 49], rangeMin, rangeMax, 63, 9);

    y2 = constrain(y2, 9, 63);                                    

    display.drawLine(x + 27, y1, x + 28, y2, WHITE);                

  }

}



void saveEEPROM() {                    

  if (paraChanged == true) {          

    saveTimer = saveTimer - timeExec;  

    if (saveTimer < 0) {              

      paraChanged = false;            

      EEPROM.write(0, vRange);        

      EEPROM.write(1, hRange);

      EEPROM.write(2, trigD);

      EEPROM.write(3, scopeP);

    }

  }

}



void loadEEPROM() {                

  int x;

  x = EEPROM.read(0);            

  if ((x < 0) || (x > 9)) {        

    x = 3;                        

  }

  vRange = x;



  x = EEPROM.read(1);            

  if ((x < 0) || (x > 7)) {        

    x = 3;                        

  }

  hRange = x;

  x = EEPROM.read(2);            

  if ((x < 0) || (x > 1)) {        

    x = 1;                        

  }

  trigD = x;

  x = EEPROM.read(3);            

  if ((x < 0) || (x > 2)) {        

    x = 1;                        

  }

  scopeP = x;

}



void pin2IRQ() {                  

 

 

  int x;                          

  x = PINB;                        



  if ( (x & 0x07) != 0x07) {      

    saveTimer = 5000;              

    paraChanged = true;          

  }



  if ((x & 0x01) == 0) {

    scopeP++;

    if (scopeP > 2) {

      scopeP = 0;

    }

  }



  if ((x & 0x02) == 0) {          

    if (scopeP == 0) {            

      vRange++;

      if (vRange > 9) {

        vRange = 9;

      }

    }

    if (scopeP == 1) {            

      hRange++;

      if (hRange > 7) {

        hRange = 7;

      }

    }

    if (scopeP == 2) {            

      trigD = 0;                  

    }

  }



  if ((x & 0x04) == 0) {          

    if (scopeP == 0) {            

      vRange--;

      if (vRange < 0) {

        vRange = 0;

      }

    }

    if (scopeP == 1) {            

      hRange--;

      if (hRange < 0) {

        hRange = 0;

      }

    }

    if (scopeP == 2) {            

      trigD = 1;                  

    }

  }



  if ((x & 0x08) == 0) {          

    hold = ! hold;                

  }


}

Post a Comment

Popular

Playing with Buttons

Button Pushbuttons or switches connect two points in a circuit when you press them. This example turns on the built-in LED on pin 13 when you press the button. Hardware Arduino Board Momentary button or Switch 10K ohm resistor hook-up wires breadboard Circuit diagram Code // constants won't change. They're used here to // set pin numbers: const int buttonPin = 2 ;     // the number of the pushbutton pin const int ledPin =   13 ;      // the number of the LED pin // variables will change: int buttonState = 0 ;         // variable for reading the pushbutton status void setup () {   Serial . begin ( 9600 );   // initialize the LED pin as an output:   pinMode (ledPin, OUTPUT);   // initialize the pushbutton pin as an input:   pinMode (buttonPin, INPUT); } void loop () {   // read the state of the pushbutton value:   buttonState = digitalRead (buttonPin);   // Show the state of pushbutton on serial monitor   Serial . println (buttonState);   // check if the pushbutton is p
Post a Comment
Read more

Home Automation

A smart system made by using Node MCU dev board. What is Node MCU? NodeMCU is an open-source firmware for which open-source prototyping board designs are available. The name "NodeMCU" combines "node" and "MCU" (micro-controller unit). The term "NodeMCU" strictly speaking refers to the firmware rather than the associated development kits.  Both the firmware and prototyping board designs are open source. Requirments Node MCU 4 channel relay toggle switch * 4 Hi-links (220v ac to 5v dc) Circuit Diagram Program #ifdef ENABLE_DEBUG         #define DEBUG_ESP_PORT Serial         #define NODEBUG_WEBSOCKETS         #define NDEBUG #endif #include <Arduino.h> #include <ESP8266WiFi.h> #include "SinricPro.h" #include "SinricProSwitch.h" #include <map> #define WIFI_SSID         "your wifi name"     #define WIFI_PASS         "your wifi pass" #define APP_KEY           "this code is prov
Post a Comment
Read more

Turn LED On and Off Through LDR

  LDR An LDR ( Light Dependent Resistor ) is a component that has a (variable) resistance that changes with the light intensity that falls upon it. This allows them to be used in light sensing circuits. A photoresistor is made of a high resistance semiconductor. Hardware Required Arduino Board LED 220 ohm resistor LDR 10k ohms resistor Circuit Diagram Code int ldr=A0; //Set A0(Analog Input) for LDR. int value= 0 ; void setup () { Serial . begin ( 9600 ); pinMode ( 3 ,OUTPUT); } void loop () { value= analogRead (ldr); //Reads the Value of LDR(light). Serial . println ( "LDR value is :" ); //Prints the value of LDR to Serial Monitor. Serial . println (value); if (value< 300 )   {     digitalWrite ( 3 ,HIGH); //Makes the LED glow in Dark.   }   else   {     digitalWrite ( 3 ,LOW); //Turns the LED OFF in Light.   } }
Post a Comment
Read more

Temperature sensor

About the LM35 The LM35 is an inexpensive, precision Centigrade temperature sensor made by  Texas Instruments . It provides an output voltage that is linearly proportional to the Centigrade temperature and is, therefore, very easy to use with the Arduino. The sensor does not require any external calibration or trimming to provide accuracies of ±0.5°C at room temperature and ±1°C over the −50°C to +155°C temperature range. One of the downsides of the sensor is that it requires a negative bias voltage to read negative temperatures. So if that is needed for your project, I recommend using the DS18B20 or TMP36 instead. The TMP36 by Analog Devices is very similar to the LM35 and can read temperatures from -40°C to 125°C without any external components Note that the sensor operates on a voltage range of 4 to 30 V and that the output voltage is independent of the supply voltage. The LM35 is part of a series of analog temperature sensors sold by Texas Instruments. Other members of the series i
Post a Comment
Read more

MQ2 Gas Sensor

 About Gas Sensor The MQ series of gas sensors use a small heater inside with an electrochemical sensor. They are sensitive to a range of gasses and are used indoors at room temperature. The output is an analog signal and can be read with an analog input of the Arduino. The MQ-2 Gas Sensor module is useful for gas leakage detection in homes and industries. It can detect LPG, i-butane, propane, methane, alcohol, hydrogen, and smoke. Some modules have a built-in variable resistor to adjust the sensitivity of the sensor. Note:  The sensor becomes very hot after a while, don't touch it! Required  Arduino UNO Breadboard MQ-2 Gas sensor module Red, Green led 5mm 220 Ohm Buzzer The connections are pretty easy: The MQ-5 sensor Pin-> Wiring to Arduino Uno A0-> Analog pins D0-> none GND-> GND VCC-> 5V other components Pin-> Wiring to Arduino Uno D13-> +ve of buzzer GND-> -ve of buzzer D12-> anode of red light D11-> anode of green light GND-> cathode of red li
Post a Comment
Read more

Play a melody with a Piezo speaker

  Play a Melody using the tone() function This example shows how to use the  tone()  command to generate notes. It plays a little melody you may have heard before. Hardware Required Arduino board piezo buzzer or a speaker hook-up wires Making header file To make the pitches.h file, either click on the button just below the serial monitor icon and choose "New Tab", or use Ctrl+Shift+N. Then paste in the following code: /************************************************* * Public Constants *************************************************/ # define NOTE_B0 31 # define NOTE_C1 33 # define NOTE_CS1 35 # define NOTE_D1 37 # define NOTE_DS1 39 # define NOTE_E1 41 # define NOTE_F1 44 # define NOTE_FS1 46 # define NOTE_G1 49 # define NOTE_GS1 52 # define NOTE_A1 55 # define NOTE_AS1 58 # define NOTE_B1 62 # define NOTE_C2 65 # define NOTE_CS2 69 # define NOTE_D2 73 # define NOTE_DS2 78 # define NOTE_E2 82 # define NOTE_F2 87 # de
Post a Comment
Read more

Seven Segment Display Interfacing with Arduino

Seven-Segment Introduction  Let’s start the main part of this tutorial by answering a question: what is a seven-segment display? As its name suggests, a 7-segment device consists of 7  light-emitting diodes . These light-emitting diodes are arranged and packed inside a single display with a specific pattern in mind. If this pattern is controlled in a specific way by turning on and turning off LEDs, a seven-segment device will display a unique number. There is also an extra eighth LED on a seven-segment display which is used to display dots. This dot is sometimes used as a decimal point when we want to display a fractional value.  The picture below shows a seven-segment display and its pinout. The string of eight LEDs on the left side shows the internal connection and a picture on the right side shows how these LEDs are arranged to make a seven-segment display. Pin3 and 8 are common pins. These pins are used to provide either 5 volts or ground in common-anode and common cathode type dis
Post a Comment
Read more

Fade an LED

  Fade This example demonstrates the use of the  analogWrite()  function in fading an LED off and on. AnalogWrite uses  pulse width modulation (PWM) , turning a digital pin on and off very quickly with different ratio between on and off, to create a fading effect. Hardware Required Arduino board LED 220 ohm resistor hook-up wires Circuit Diagram Code int led = 9 ;           // the PWM pin the LED is attached to int brightness = 0 ;    // how bright the LED is int fadeAmount = 5 ;    // how many points to fade the LED by // the setup routine runs once when you press reset: void setup () {   // declare pin 9 to be an output:   pinMode (led, OUTPUT); } // the loop routine runs over and over again forever: void loop () {   // set the brightness of pin 9:   analogWrite (led, brightness);   // change the brightness for next time through the loop:   brightness = brightness + fadeAmount;   // reverse the direction of the fading at the ends of the fade:   if (brightness <= 0 || bri
Post a Comment
Read more

Fire Alarm with arduino

Flame Sensor A  flame detector  is a sensor designed to detect and respond to the presence of a flame or fire. Responses to a detected flame depend on the installation but can include sounding an alarm, deactivating a fuel line (such as a propane or a natural gas line), and activating a fire suppression system. The IR Flame sensor used in this project is shown below, these sensors are also called  Fire sensor modules  or  flame detector sensors  sometimes. There are different types of flame detection methods. Some of them are Ultraviolet detector, near IR array detector, infrared (IR) detector, Infrared thermal cameras, UV/IR detector, etc. When fire burns it emits a small amount of Infra-red light, this light will be received by the Photodiode (IR receiver) on the sensor module. Then we use an Op-Amp to check for a change in voltage across the IR Receiver, so that if a fire is detected the output pin (DO) will give 0V(LOW), and if the is no fire the output pin will be 5V(HIGH). In thi
Post a Comment
Read more