Top 10 Websites to get your SEO report for Free!

Top 10 Websites To Get Your SEO Report For Free!

1. Woorank
Woorank is the best SEO Website & Analysis Tool to help developers boosting their client’s websites. It supports one analysis per week for a customer using it as free, and nearly unlimited website analysis for paid members. Also is supports free 7 days trial mode, but for that it require your Credit card information.

2. Seotoolscentral
It is similar to Woorank and it provides site  and keyword optimization tool. Not so user friendly as woorank but a nice alternative.

3. Xinureturns
Xinureturns shows how well your site is doing in popular search engines, social bookmarking and other site statistics. Now it is redirecting to

4. Opensiteexplorer
Get data on up to 1,000 links which consider on Domain authority,Page authority,Linking Root Domains etc. Also supports PRO mode, which will give you an insight about Facebook Shares, likes, twitter tweets, google's +1s etc etc. Typically for a new website it takes 45-60 days to appear in its result.

5. Sitereportcard
SiteReportCard provides free website analysis, optimization and promotion tools.It also checks for page load time and Broken links. For using it you first need to become a registered user.

6. Spydermate
Spydermate is another great website for SEO which also stores data for comparing your site in history. You have to start Free Trial Mode for using it for free.
Alexa is a comprehensive website traffic based ranking system, which will display your website rank among all other websites in the world. It has many option to audit your website which you are going to find very nice.

8. Lipperhey
Lipperhey your own SEO to-do list website where you can optimize your site,keyword position, improvement plan etc. You will be needing to register to get your free report.

9. SEOrush
SEOrush is a one touch resource which provides you a FREE SEO report for your website. A very easy to use website, with a very nice outlook of the design.

10.  Seositecheckup
SEO Site Checkup can analyze your site and give recommendations so that your site will load faster, rank higher for your search terms, and get more visitors. Very easy to use site, you will love its suggestions.

This review of Digital iVision Labs is completely neutral, nobody has paid us or contacted us for such things.

Does Arduino IDE Supports OpenCV Libraries

A common question, that we have received through e-mails is that "Does Arduino IDE Supports OpenCV Libraries?"

Our answer is no, if you are going to try using the function of "highgui.h" in an Arduino program, even if u have correctly installed this library in Arduino, by copying it in the libraries directory, it will show lots of errors.
Arduino IDE is not made to support OpenCV libraries directly, yes through 3rd party software we can make the application made through OpenCV working with Arduino Board, but compilation of Arduino Language Code is not at all possible through Arduino IDE.

OpenCV libraries are designed and highly optimised for the x86 or x64 platform and equire much bigger  memory than the Arduino having. Its designed to interface with video or images served by some sort of file system or hardware driver not present for Arduino. Also the Highgui is a GUI library which really has no relevance to arduino.

If anyone want to use OpenCV, the person need to do that part on a computer (ie PC/MAC etc) and interface that with the arduino. Otherwise should start coding their own processing algorithms for Arduino!

Types of MATLAB file extension….a pet name to recognize the file type…

Since all the files which we save have one or other extension, with which the computer recognize in which platform /software it needs to open that file for future uses. The same applies for MATLAB. Here are the important file extensions which MATLAB provides.
They are as follow….

1)     Figure Files: -
Extension: -“.fig”
These files contains MATLAB figure. He plot, figure, image, etc. are stored with the extension of .fig by default. (You can specify the format of image you would like to store by selecting the format type from the drop down list which appears while saving the figure.)

2)     M-Files: -
Extension: - “.m” 
M-Files are standard ASCII text files. There are two types of these files
a)     Script files
b)    Function files
The built- functions in MATLAB are M-files most of which reside on computer in precompiled format. It may possible that you may not find the built-in function as per your requirement. In that case, you can create your own function which can be later used anywhere and whenever required in MATLAB program.  

3)     Mat- Files: -
Extension: - “.mat”
They are MATLAB binary file for storing variables. These files can also be easily transfer to other systems.  They contain a machine signature in the file header. Matlab checks the signature when it loads a file and, if a signature indicates that a file is foreign, performs the necessary conversion.

4)     Mex Files: -
Extension: - “.mex…” 
Matlab provides an interface to external programs written in the C and FORTAN languages.
You can call C or FORTAN subroutines from MATLAB as if they were built in functions. These callable programs are referred to as MEX-files. They are dynamically linked subroutines that the MATLAB interpreter can automatically load and execute.
(Platform specific, e.g. ".mexmac" for the Mac, ".mexglx" for Linux, etc.)

Third-party File extension

1)     .jkt 
GPU Cache file generated by Jacket for MATLAB (AccelerEyes)

2)     .mum 
MATLAB CAPE-OPEN Unit Operation Model File (AmsterCHEM)

P.S: - The first four file extensions are much of our use.
Hope to see you in next tutorial….!!!

Written By,

Student @ VIT University

Digital Pins Of Arduino

Digital Pins

The pins on the Arduino can be configured as either inputs or outputs. This document explains the functioning of the pins in those modes. While the title of this document refers to digital pins, it is important to note that vast majority of Arduino (Atmega) analog pins, may be configured, and used, in exactly the same manner as digital pins.

Properties of Pins Configured as INPUT

Arduino (Atmega) pins default to inputs, so they don't need to be explicitly declared as inputs with pinMode(). Pins configured as inputs are said to be in a high-impedance state. One way of explaining this is that input pins make extremely small demands on the circuit that they are sampling, say equivalent to a series resistor of 100 megohm in front of the pin. This means that it takes very little current to move the input pin from one state to another, and can make the pins useful for such tasks as implementing a capacitive touch sensor, reading an LED as a photodiode, or reading an analog sensor with a scheme such as RCTime.
This also means however, that input pins with nothing connected to them, or with wires connected to them that are not connected to other circuits, will report seemingly random changes in pin state, picking up electrical noise from the environment, or capacitively coupling the state of a nearby pin.

Pullup Resistors

Often it is useful to steer an input pin to a known state if no input is present. This can be done by adding a pullup resistor (to +5V), or a pulldown resistor (resistor to ground) on the input, with 10K being a common value.
There are also convenient 20K pullup resistors built into the Atmega chip that can be accessed from software. These built-in pullup resistors are accessed in the following manner.
pinMode(pin, INPUT);           // set pin to input
digitalWrite(pin, HIGH);       // turn on pullup resistors

Note that the pullup resistors provide enough current to dimly light an LED connected to a pin that has been configured as an input. If LED's in a project seem to be working, but very dimly, this is likely what is going on, and the programmer has forgotten to use pinMode() to set the pins to outputs.
Note also that the pullup resistors are controlled by the same registers (internal chip memory locations) that control whether a pin is HIGH or LOW. Consequently a pin that is configured to have pullup resistors turned on when the pin is an INPUT, will have the pin configured as HIGH if the pin is then swtiched to an OUTPUT with pinMode(). This works in the other direction as well, and an output pin that is left in a HIGH state will have the pullup resistors set if switched to an input with pinMode().
NOTE: Digital pin 13 is harder to use as a digital input than the other digital pins because it has an LED and resistor attached to it that's soldered to the board on most boards. If you enable its internal 20k pull-up resistor, it will hang at around 1.7 V instead of the expected 5V because the onboard LED and series resistor pull the voltage level down, meaning it always returns LOW. If you must use pin 13 as a digital input, use an external pull down resistor.

Properties of Pins Configured as OUTPUT

Pins configured as OUTPUT with pinMode() are said to be in a low-impedance state. This means that they can provide a substantial amount of current to other circuits. Atmega pins can source (provide positive current) or sink (provide negative current) up to 40 mA (milliamps) of current to other devices/circuits. This is enough current to brightly light up an LED (don't forget the series resistor), or run many sensors, for example, but not enough current to run most relays, solenoids, or motors.
Short circuits on Arduino pins, or attempting to run high current devices from them, can damage or destroy the output transistors in the pin, or damage the entire Atmega chip. Often this will result in a "dead" pin in the microcontroller but the remaining chip will still function adequately. For this reason it is a good idea to connect OUTPUT pins to other devices with 470Ω or 1k resistors, unless maximum current draw from the pins is required for a particular application.

pulseIn() Function Of Arduino Programming Language



Reads a pulse (either HIGH or LOW) on a pin. For example, if value is HIGH, pulseIn() waits for the pin to go HIGH, starts timing, then waits for the pin to go LOW and stops timing. Returns the length of the pulse in microseconds. Gives up and returns 0 if no pulse starts within a specified time out.
The timing of this function has been determined empirically and will probably show errors in longer pulses. Works on pulses from 10 microseconds to 3 minutes in length.


pulseIn(pin, value)
pulseIn(pin, value, timeout)


pin: the number of the pin on which you want to read the pulse. (int)
value: type of pulse to read: either HIGH or LOW. (int)
timeout (optional): the number of microseconds to wait for the pulse to start; default is one second (unsigned long)


the length of the pulse (in microseconds) or 0 if no pulse started before the timeout (unsigned long)



int pin = 7;
unsigned long duration;

void setup()
  pinMode(pin, INPUT);

void loop()
  duration = pulseIn(pin, HIGH);

shiftIn() Function Of Arduino Programming Language



Shifts in a byte of data one bit at a time. Starts from either the most (i.e. the leftmost) or least (rightmost) significant bit. For each bit, the clock pin is pulled high, the next bit is read from the data line, and then the clock pin is taken low.
Note: this is a software implementation; Arduino also provides an SPI library that uses the hardware implementation, which is faster but only works on specific pins.


byte incoming = shiftIn(dataPin, clockPin, bitOrder) 


dataPin: the pin on which to input each bit (int)
clockPin: the pin to toggle to signal a read from dataPin
bitOrder: which order to shift in the bits; either MSBFIRST or LSBFIRST.
(Most Significant Bit First, or, Least Significant Bit First)


the value read (byte)

shiftOut() Function Of Arduino Programming Language




Shifts out a byte of data one bit at a time. Starts from either the most (i.e. the leftmost) or least (rightmost) significant bit. Each bit is written in turn to a data pin, after which a clock pin is pulsed (taken high, then low) to indicate that the bit is available.
Note: if you're interfacing with a device that's clocked by rising edges, you'll need to make sure that the clock pin is low before the call to shiftOut(), e.g. with a call to digitalWrite(clockPin, LOW).
This is a software implementation; see also the SPI library, which provides a hardware implementation that is faster but works only on specific pins.



shiftOut(dataPin, clockPin, bitOrder, value)


dataPin: the pin on which to output each bit (int)
clockPin: the pin to toggle once the dataPin has been set to the correct value (int)
bitOrder: which order to shift out the bits; either MSBFIRST or LSBFIRST.
(Most Significant Bit First, or, Least Significant Bit First)
value: the data to shift out. (byte)




The dataPin and clockPin must already be configured as outputs by a call to pinMode().
shiftOut is currently written to output 1 byte (8 bits) so it requires a two step operation to output values larger than 255.

// Do this for MSBFIRST serial
int data = 500;
// shift out highbyte
shiftOut(dataPin, clock, MSBFIRST, (data >> 8));
// shift out lowbyte
shiftOut(data, clock, MSBFIRST, data);

// Or do this for LSBFIRST serial
data = 500;
// shift out lowbyte
shiftOut(dataPin, clock, LSBFIRST, data);
// shift out highbyte
shiftOut(dataPin, clock, LSBFIRST, (data >> 8));



For accompanying circuit.
//  Name    : shiftOutCode, Hello World                         //
//  Author  : Carlyn Maw,Tom Igoe                               //
//  Date    : 25 Oct, 2006                                      //
//  Version : 1.0                                               //
//  Notes   : Code for using a 74HC595 Shift Register           //
//          : to count from 0 to 255                            //

//Pin connected to ST_CP of 74HC595
int latchPin = 8;
//Pin connected to SH_CP of 74HC595
int clockPin = 12;
////Pin connected to DS of 74HC595
int dataPin = 11;

void setup() {
  //set pins to output because they are addressed in the main loop
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);

void loop() {
  //count up routine
  for (int j = 0; j < 256; j++) {
    //ground latchPin and hold low for as long as you are transmitting
    digitalWrite(latchPin, LOW);
    shiftOut(dataPin, clockPin, LSBFIRST, j);  
    //return the latch pin high to signal chip that it
    //no longer needs to listen for information
    digitalWrite(latchPin, HIGH);

noTone() Function Of Arduino Programming Language



Stops the generation of a square wave triggered by tone(). Has no effect if no tone is being generated.

NOTE: if you want to play different pitches on multiple pins, you need to call noTone() on one pin before calling tone() on the next pin.




pin: the pin on which to stop generating the tone



tone() Function-To Generate Square Wave From Arduino Pin

tone() (Function To Generate Square Wave From PWM Pins Of Arduino)


Generates a square wave of the specified frequency (and 50% duty cycle) on a pin. A duration can be specified, otherwise the wave continues until a call to noTone(). The pin can be connected to a piezo buzzer or other speaker to play tones.
Only one tone can be generated at a time. If a tone is already playing on a different pin, the call to tone() will have no effect. If the tone is playing on the same pin, the call will set its frequency.
Use of the tone() function will interfere with PWM output on pins 3 and 11 (on boards other than the Mega).

NOTE: if you want to play different pitches on multiple pins, you need to call noTone() on one pin before calling tone() on the next pin.



tone(pin, frequency)
tone(pin, frequency, duration)



pin: the pin on which to generate the tone
frequency: the frequency of the tone in hertz - unsigned int
duration: the duration of the tone in milliseconds (optional) - unsigned long

Arduino Board + Processing Software-Analogue bar graph

Arduino Board + Processing Software: Analogue bar graph

Bar Graph Generated Using Arduino+Processing Software
This is just a basic example of sending the arduino’s 6 analogue readings to a bar graph sketch made with processing. 

Arduino Code:
//Sending 8 bit reading (256) so analogue 
//reading can be sent in 1 byte
int Analogue0 = 0; // first analog sensor
int Analogue1 = 0; // second analog sensor
int Analogue2 = 0; // digital sensor
int Analogue3 = 0; // second analog sensor
int Analogue4 = 0; // second analog sensor
int Analogue5 = 0; // second analog sensor
int inByte = 0; // incoming serial byte
void setup()
 // start serial port at 9600 bps:
establishContact(); // send a byte to establish contact until Processing responds 
void loop()
 // if we get a valid byte, read analog ins:
 if (Serial.available() > 0) {
 // get incoming byte:
 inByte =;
 // read first analog input, divide by 4 to make the range 0-255:
 Analogue0 = analogRead(0)/4;
 // delay 10ms to let the ADC recover:
 // read second analog input, divide by 4 to make the range 0-255:
 Analogue1 = analogRead(1)/4;
 // read switch, multiply by 155 and add 100
 // so that you're sending 100 or 255:
 Analogue2 = analogRead(2)/4;
 Analogue3 = analogRead(3)/4;
 Analogue4 = analogRead(4)/4;
 Analogue5 = analogRead(5)/4;
// send sensor values:
 Serial.write(Analogue0 );
 Serial.write(Analogue1 );
 Serial.write(Analogue2 );
 Serial.write(Analogue3 );
 Serial.write(Analogue4 );
 Serial.write(Analogue5 );
void establishContact() {
 while (Serial.available() <= 0) {
 Serial.write('A'); // send a capital A
Processing code:
// Feel Free to edit these variables ///////////////////////////
String xLabel = "Analogue Inputs";
String yLabel = "Voltage (V)";
String Heading = "The Graph Sketch";
String URL = "01/02/2010";
float Vcc = 5.0; // the measured voltage of your usb
int NumOfVertDivisions=5; // dark gray
int NumOfVertSubDivisions=10; // light gray
int NumOfBars=6; // you can choose the number of bars, but it can cause issues
 // since you should change what the arduino sends
// if these are changed, background image has problems
// a plain background solves the problem
int ScreenWidth = 600, ScreenHeight=400;
// Serial port stuff ///////////////////////
import processing.serial.*;
Serial myPort;
boolean firstContact = false;
int[] serialInArray = new int[6];
int serialCount = 0;
int LeftMargin=100;
int RightMArgin=80;
int TextGap=50;
int GraphYposition=80;
float BarPercent = 0.4;
int value;
PFont font;
PImage bg;
int temp;
float yRatio = 0.58;
int BarGap, BarWidth, DivisounsWidth;
int[] bars = new int[NumOfBars];
void setup(){
// bg = loadImage("BG.jpg");
/// NB SETTINGS ////////////////////////////////////////////////////////
 myPort = new Serial(this, Serial.list()[2], 9600);
DivisounsWidth = (ScreenWidth-LeftMargin-RightMArgin)/(NumOfBars);
 BarWidth = int(BarPercent*float(DivisounsWidth));
 BarGap = DivisounsWidth - BarWidth;
 font = createFont("Arial",12);
void draw(){
// background(bg); // My one used a background image, I've
 background(250); // commented it out and put a plain colour
// Headings(); // Displays bar width, Bar gap or any variable.
// Send Recieve data //
void serialEvent(Serial myPort) {
// read a byte from the serial port:
 int inByte =;
if (firstContact == false) {
 if (inByte == 'A') {
 myPort.clear(); // clear the serial port buffer
 firstContact = true; // you've had first contact from the microcontroller
 myPort.write('A'); // ask for more
 else {
 // Add the latest byte from the serial port to array:
 serialInArray[serialCount] = inByte;
// If we have 6 bytes:
 if (serialCount > 5 ) {
for (int x=0;x<6;x++){
bars[x] = int (yRatio*(ScreenHeight)*(serialInArray[x]/256.0));
// Send a capital A to request new sensor readings:
 // Reset serialCount:
 serialCount = 0;
/////// Display any variables for testing here//////////////
void Headings(){
 fill(0 );
 text("BarWidth",50,TextGap );
 text("BarGap",250,TextGap );
 text("DivisounsWidth",450,TextGap );
 text(BarWidth,100,TextGap );
 text(BarGap,300,TextGap );
 text(DivisounsWidth,520,TextGap );
void PrintBars(){
int c=0;
 for (int i=0;i<NumOfBars;i++){
 rect(i*DivisounsWidth+LeftMargin, ScreenHeight-GraphYposition, BarWidth, -bars[i]);
 text(float(bars[i])/(yRatio*(ScreenHeight))*Vcc, i*DivisounsWidth+LeftMargin+BarWidth/2, ScreenHeight-bars[i]-5-GraphYposition );
 text("A", i*DivisounsWidth+LeftMargin+BarWidth/2 -5, ScreenHeight-GraphYposition+20 );
 text(i, i*DivisounsWidth+LeftMargin+BarWidth/2 +5, ScreenHeight-GraphYposition+20 );
void Axis(){
 for(float x=0;x<=NumOfVertSubDivisions;x++){
int bars=(ScreenHeight-GraphYposition)-int(yRatio*(ScreenHeight)*(x/NumOfVertSubDivisions));
 for(float x=0;x<=NumOfVertDivisions;x++){
int bars=(ScreenHeight-GraphYposition)-int(yRatio*(ScreenHeight)*(x/NumOfVertDivisions));
 line(LeftMargin-15, ScreenHeight-GraphYposition+2, ScreenWidth-RightMArgin-DivisounsWidth+50, ScreenHeight-GraphYposition+2);
void Labels(){
 for(float x=0;x<=NumOfVertDivisions;x++){
int bars=(ScreenHeight-GraphYposition)-int(yRatio*(ScreenHeight)*(x/NumOfVertDivisions));
Download Processing from

Arduino Graph Processing

Graph Using Arduino

This example shows you how to send a byte of data from the Arduino to a personal computer and graph the result. This is called serial communication because the connection appears to both the Arduino and the computer as a serial port, even though it may actually use a USB cable.
You can use the Arduino serial monitor to view the sent data, or it can be read by Processing (see code below), Flash, PD, Max/MSP, etc. 

Hardware Required

  • Arduino Board
  • Analog Sensor (potentiometer, photocell, FSR, etc.)
Software Required
  • Processing or
  • Max/MSP version 5


    Connect a potentiometer or other analog sensor to analog input 0.

    Arduino PIN Configuration 



    Code(Directly From


     A simple example of communication from the Arduino board to the computer:
     the value of analog input 0 is sent out the serial port.  We call this "serial"
     communication because the connection appears to both the Arduino and the
     computer as a serial port, even though it may actually use
     a USB cable. Bytes are sent one after another (serially) from the Arduino
     to the computer.

     You can use the Arduino serial monitor to view the sent data, or it can
     be read by Processing, PD, Max/MSP, or any other program capable of reading
     data from a serial port.  The Processing code below graphs the data received
     so you can see the value of the analog input changing over time.

     The circuit:
     Any analog input sensor is attached to analog in pin 0.
     created 2006
     by David A. Mellis
     modified 9 Apr 2012
     by Tom Igoe and Scott Fitzgerald

     This example code is in the public domain.

    void setup() {
      // initialize the serial communication:

    void loop() {
      // send the value of analog input 0:
      // wait a bit for the analog-to-digital converter
      // to stabilize after the last reading:

    /* Processing code for this example

     // Graphing sketch

     // This program takes ASCII-encoded strings
     // from the serial port at 9600 baud and graphs them. It expects values in the
     // range 0 to 1023, followed by a newline, or newline and carriage return

     // Created 20 Apr 2005
     // Updated 18 Jan 2008
     // by Tom Igoe
     // This example code is in the public domain.

     import processing.serial.*;

     Serial myPort;        // The serial port
     int xPos = 1;         // horizontal position of the graph

     void setup () {
     // set the window size:
     size(400, 300);      

     // List all the available serial ports
     // I know that the first port in the serial list on my mac
     // is always my  Arduino, so I open Serial.list()[0].
     // Open whatever port is the one you're using.
     myPort = new Serial(this, Serial.list()[0], 9600);
     // don't generate a serialEvent() unless you get a newline character:
     // set inital background:
     void draw () {
     // everything happens in the serialEvent()

     void serialEvent (Serial myPort) {
     // get the ASCII string:
     String inString = myPort.readStringUntil('\n');

     if (inString != null) {
     // trim off any whitespace:
     inString = trim(inString);
     // convert to an int and map to the screen height:
     float inByte = float(inString);
     inByte = map(inByte, 0, 1023, 0, height);

     // draw the line:
     line(xPos, height, xPos, height - inByte);

     // at the edge of the screen, go back to the beginning:
     if (xPos >= width) {
     xPos = 0;
     else {
     // increment the horizontal position:


    /* Max/MSP v5 patch for this example

Processing Sketch

Using the Processing sketch in the code sample above, you'll get a graph of the sensor's value. As you change the value of the analog sensor, you'll get a graph something like this:
Processing Software Graph

Build an Arduino Audio Spectrum Analyzer!

Try This Example at YOUR OWN RISK, It may resulting in burning of your arduino board or any other device if wrongly connected. We in anyway are not responsible for any damage incurred to you or your device. 

The TV-out ( library of Arduino, allows us to have NTSC monochrome (Black & White) video with only 2 pins & 2 resistors.  Generally on leaving the resolution at its default value i.e., 128x96, which there by translates to 16x12 text with default 8x8 font.  This code/example has been developed using version 0019 of Arduino IDE.  There should actually be virtually no difference, as long as Arduino operates on 5V DC power supply, i.e, no configuration changes. Older versions of Arduino which are using ATmega168 instead of   ATmega328 will not be able to run this, because the amount of memory they have is not enough!

So how to collect and process audio, so we have something to display on our little display.

The data collection process is a simple standard one. Useing an electret microphone (which will produce only a few milli Volts of output voltage, too low for Arduino to detect it) with an amplifier as the source of signal, which is then converted to digital form via the ADC of Analog pin 0 of the Arduino board.
For a spectrum analysis , we need to capture signal over the time, then process that data through discrete Fourier Transform. This will take an analog signal & convert to a Digital/Discrete Valued Signal. This will produce a remarkably good picture of the signal and if visual spectrum analyzer if looped over and over.
In this project, we have used code posted by a user to the Arduino forums
The above mentioned library will performs both the sampling and the Fast Fourier Transformation completely in C under 8 bit resolution.

Arduino Code: [Code Courtsey]

#include "TVout.h"
#include "fix_fft.h"                                               // This will perform 8 bit FFT
TVout TV;                                                             // Using Class TVout
char in[128], d[128], lpass[64];
char x=32, ylimit=90;
int i=0,v;
void setup()
    TV.begin(_NTSC,128,96);                             //To Init. the TV output, with a resolution 128x96.
    TV.print_str(2,2,"Realtime Printing");           // TVout library being used for x,y printing
    TV.print_str(2,11,"Spectrum Analyzer");      // printing statements in 8x8 default font value
    analogReference(DEFAULT);                       // Use default (5v) "aref"(analog reference) voltage.
    for (int z=0; z<64; z++) {lpass[z]=80;};       // fill the lpass[] array with all dummy data
void loop()
    for (i=0; i < 128; i++){                                   // not going for a accurate processing
      v = analogRead(0);                                      // as that will take time or too slow for this purpose
      d[i] = v/4 -128;                                            
       in[i] = 0;                                                     

    for (i=0; i< 64;i++){                                          // for , 60Hz output
      d[i] = sqrt(d[i] * d[i] + in[i] * in[i]);         
 The circuit required is a simple microphone and amplifier, as well as two resistors connected to D8 and D9 to provide video signal.

 Arduino Spectrum Analyzer with TV-Video Out - Schematic
Required Components:
(one)  "2n3904" NPN Transistor as Q1
(three)  1k Ohm Resistor as R2,R4 & R5
(one)  330 Ohm Resistor as R6
(one)  10k Ohm Resistor as R1
(one) 100k Ohm Resistor as R3
(one) Capacitor (Electrolytic), 3.3MFas C1
(one) Electret Mic as MIC1

If gain is not enough, try replacing Q1 (2n3904) with higher gain transistor or a darlington pair or even OP-AMPS can be used as they are readily available in the market, but then we have to modify the circuit a little bit. Video output is NTSC/PAL Composite, if it is necessary, a coupling capacitor & diode can be added.
Build an Arduino Audio Spectrum Analyzer
Build an Arduino Audio Spectrum Analyzer, Circuit Connection

Arduino TV-OUT Library

Library to Interface and See Arduino's Output On Television
Currently the output is NTSC or PAL at a resolution of 128x96 by default. The library currently works on ATmega168,328,1280,2560,644p,1284p,AT90USB1286 and more can be added by editing one file.


Beta1 for version 1.0 is out!!! It has some it changes the hardware connections as well as some of the function calls see the wiki for full details.


SYNC is on OCR1A and AUDIO is on OC2A
There are some timing issues with the m1284p, may be related to sanguino core.
m168,m328B 1D 7B 3NG,Decimila,UNO9711
m1280,m2560B 5A 7B 4Mega11A7(D29)10
m644,m1284pD 5A 7D 7sanguino13A7(D24)8
AT90USB1286B 5F 7B 4--------
Visit Link For More Info:

Arduino TV-OUT Demo Video

Arduino Tetris using TV-OUT

FFT Libraries for Arduino

All you need for Arduino FFT processing, Spectrum analysis using Arduino!

Download FFT Library :

Code :

Code For Plotting And Processing Graph & Spectrums in Arduino:


Open Music Lab Arduino FFT Library :

A good FFT Sketch : Fun with FFT on Arduino :