Arduino Temperature Web Server

 

The idea is to build a simple temperature Web Server that show the temperature and it changes the format of the website when it riches or gets over the one set on the Arduino sketch.

For this project I wanted a simple design since I don´t have too much knowledge of HTML programming but thanks to the internet there are no such thing like that excuse “I didn’t find information” or “It’s so difficult and I didn’t found a book of it”

I made a simple course on http://www.codecademy.com/ and the good thing is that is FREE!!!

 

Ok, enough of talking that much let´s get down to business.

For this exercise we’ll use:

1 x Arduino UNO or Arduino MEGA or Arduino Leonardo

1 x Ethernet Shield

1 x LM35 Temperature Sensor

 

This is the code for the Temperature Web Server:

/////////////////////////////////////////////////////////////////////////////////////
  AUTOR: JUAN BIONDI                                               FECHA:       FEBRERO/2014      
  PROGRAMA:    			                                   VERSION:     1.0               
  DISPOSITIVO: ATMEL 328                                           COMPILADOR:  AVR               
  ENTORNO:     PROTEUS                                             SIMULADOR:   VSM        
  TARJETA DE PROGRAMACION:                                         DEBUGGER:                      
/////////////////////////////////////////////////////////////////////////////////////

  Web Server
 
 A simple web server that shows the value of the analog input pins.
 using an Arduino Wiznet Ethernet shield. 
 
 Circuit:
 * Ethernet shield attached to pins 10, 11, 12, 13
 * Analog inputs attached to pin A4 
 
 This pin has a temperature sensor (LM35)

/////////////////////////////////////////////////////////////////////////////////////
*/

/////////////////////////////////////////////////////////////////////////////////////
// LIBRERIAS                                                                       //
/////////////////////////////////////////////////////////////////////////////////////

#include <SPI.h>
#include <Ethernet.h>


/////////////////////////////////////////////////////////////////////////////////////
// VARIABLES GLOBALES                                                              //
/////////////////////////////////////////////////////////////////////////////////////
// Enter a MAC address and IP address for your controller below.
// The IP address will be dependent on your local network:
byte mac[] = { 
  0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ip(192,168,1,30);

// Initialize the Ethernet server library
// with the IP address and port you want to use 
// (port 80 is default for HTTP):
EthernetServer server(4988);

/////////////////////////////////////////////////////////////////////////////////////
// FUNCIONES                                                                       //
/////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////
// CONFIGURACION                                                                   //
/////////////////////////////////////////////////////////////////////////////////////

void setup() {
 // Open serial communications and wait for port to open:
  analogReference(INTERNAL);
  Serial.begin(9600);
   while (!Serial) {
    ; // wait for serial port to connect. Needed for Leonardo only
  }


  // start the Ethernet connection and the server:
  Ethernet.begin(mac, ip);
  server.begin();
  Serial.print("server is at ");
  Serial.println(Ethernet.localIP());
}

/////////////////////////////////////////////////////////////////////////////////////
// PRINCIPAL                                                                       //
//                                                                                 //
/////////////////////////////////////////////////////////////////////////////////////
void loop() {
  // listen for incoming clients
  EthernetClient client = server.available();
  if (client) {
    Serial.println("new client");
    // an http request ends with a blank line
    boolean currentLineIsBlank = true;
    while (client.connected()) {
      if (client.available()) {
        char c = client.read();
        Serial.write(c);
        // if you've gotten to the end of the line (received a newline
        // character) and the line is blank, the http request has ended,
        // so you can send a reply
        if (c == '\n' && currentLineIsBlank) {
          // send a standard http response header
          client.println("HTTP/1.1 200 OK");
          client.println("Content-Type: text/html");
          client.println("Connection: close");  // the connection will be closed after completion of the response
          client.println("Refresh: 3");  // refresh the page automatically every 5 sec
          client.println();
          client.println("<!DOCTYPE HTML>");
          client.println("<html>");
          client.println("<style>");
          client.println("body {background-color:lightgray}");
          client.println("h1 {color:blue}");
          client.println("p {color:red}");
          client.println("</style>");
          client.println("<FONT FACE=currier > Demostracion de un servidor web para mostrar la temperatura </FONT>");
          client.println("<br>");
          client.println("<FONT FACE=currier >  del aula con un sensor LM35 y un escudo de Arduino.</FONT>");

   
  
          // output the value of the temperature of the sensor connected to the analog pin
          int sensorReading = analogRead(A4);
          float temperatura = (sensorReading*1.1*100) / 1024;
          client.println("<br>");
          client.println("<br>");
          client.print("<center>");
          client.print("<h1>");
          client.print("La temperatura leida es: ");
          client.print(temperatura);
          client.print(" C");
          client.print("</h1>");
          client.print("<center>");
          client.println("<br>");
          client.println("<br>");
          
/*
/////////////////////////////////////////////////////////////////////////////////////
          Now if the temperature is higher than the one we establish it will print on the 
          remote computer a text with the word WARNING in Spanish
/////////////////////////////////////////////////////////////////////////////////////
*/         
          
                
          if (temperatura >= 25)
            {
              //termometro();
                client.println("<div align=");
                String izquierda = "center";
                client.println(izquierda);
                client.println("<br>");
                client.print("<p>");
                client.println("!*****************************************************************************************************************************!");
                client.print("<p>");
                client.println("!___________@@@____@@_______@@____@@@@@____@@@@@___________@@@@_______@@@@________@@@@______________!");
                client.print("<p>");
                client.println("!_______@@_________@@________@@_______@@______@@____@@@______@@__@@_____@@___@@___@@_______@@___________!");
                client.print("<p>");
                client.println("!_______@@_________@@________@@_______@@______@@______@@_____@@____@@____@@_____@@_@@_______@@___________!");
                client.print("<p>");
                client.println("!_______@@_________@@________@@_______@@______@@______@@___@@@@@@@@___@@_____@@_@@_______@@__________!");
                client.print("<p>");
                client.println("!________@@_________@@______@@________@@______@@____@@@___@@________@@__@@___@@____@@_____@@____________!");
                client.print("<p>");
                client.println("!____________@@_________@@@__________@@@@@___@@@@@______@@__________@@_@@@@@________@@@@_____________!");
                client.print("<p>");
                client.println("!******************************************************************************************************************************!");
                //client.print("</p>");
                
            }
/*
/////////////////////////////////////////////////////////////////////////////////////
          End of the if to write the WARNING word
/////////////////////////////////////////////////////////////////////////////////////
*/             

          client.println("<br />"); 
          client.println("<img src=https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjlMaxA9ASwejD_RhQbITq5_lhXv_Ma8DsjEIsT4x3vVHavyYstYN0eT7SrTUEdr0UDLExDbFmhyIXORJHvVWlmtaxxbBIBpS7P51F2OjOJ_lvJAAc9htkeNFq09AWN6yeIPTVq57-RALY/s1600/CIFPN1.jpg alt=some_text>");
          client.println("<br />"); 
          client.println("</html>");
          break;
        }
        if (c == '\n') {
          // you're starting a new line
          currentLineIsBlank = true;
        } 
        else if (c != '\r') {
          // you've gotten a character on the current line
          currentLineIsBlank = false;
        }
      }
    }
    // give the web browser time to receive the data
    delay(1);
    // close the connection:
    client.stop();
    Serial.println("client disconnected");
  }
}

In the following images you can see how the web server was running on my local network without any problem.

Normal temperature

Showing a sign saying WARNING in Spanish because the temperature is over the value set on the Arduino sketch.

 

The next thing to see this from any computer we have to do some thing first:

1.- Open the port used for this application

This video explains really easy how to open ports on your router, remember that every router is different and it may change the configuration on it.

https://www.youtube.com/watch?v=aQXJ7sLSz14

2.- And finding your public IP address.

Here there is another video that shows you how to know your public IP address.

https://www.youtube.com/watch?v=yRrKKJHzHJo

 

You can download the file on the following link:

https://drive.google.com/folderview?id=0B7dtMeeMPK5rfnJCSVlRVTkxRzdSeHBMWDJ6THVPWmdHdm1kZ3NwNTYzSEJ5b0ZmdlFoMG8&usp=sharing

File name: Ethernet_temp.zip

Version of Proteus 8.1

 

BuzzNet Tags: Arduino

Arduino Serial communication and Proteus ISIS simulation

 

The serial communication on most devices is a transmission of data between the microcontroller to a computer or even to another microcontroller.

The Arduino serial port (also known as a UART or USART) that stands for Universal Synchronous/Asynchronous Receiver/Transmitter and provides the interface necessary for communication with modems and other serial devices.

For this type of communication you’ll need three cables (TX, RX, GND) and they stand for:

TX: Transmit pin

RX: Receive pin

Take into account that it is different with I2C and SPI where the labels and the pins are connected with each other, in serial communication the pins should be inverted and connected that way.

In the following picture you can see the schematic of the exercise.

The components used in this exercise were:

1 x LM35 Temperature sensor

1 x Arduino board

1 x Terminal debugger

I uploaded the code on the “Source Code” window, here you can see the window:

The code I uploaded was this:

/*
/////////////////////////////////////////////////////////////////////////////////////
  AUTOR: JUAN BIONDI                                               FECHA:       FEBRERO/2014      
  PROGRAMA:    TERMOMETRO (LM35)                                   VERSION:     1.0               
  DISPOSITIVO: ATMEL 328                                           COMPILADOR:  AVR               
  ENTORNO:     PROTEUS                                             SIMULADOR:   VSM        
  TARJETA DE PROGRAMACION:                                         DEBUGGER:                      
/////////////////////////////////////////////////////////////////////////////////////
The LM35 is a temperature sensor with a calibrated precision of 1ºC. It can measure from -55 C to 150 C.

The output is that one grade is equal to 10mV
150ºC = 1500mV
-55ºC = -550mV1
0ºC = 0mV

/////////////////////////////////////////////////////////////////////////////////////
*/


/////////////////////////////////////////////////////////////////////////////////////
// LIBRERIAS                                                                                                                   //
/////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////
// VARIABLES GLOBALES                                                                                              //
/////////////////////////////////////////////////////////////////////////////////////

//Declare the variables
#define pinA0 0
int valor_leido;
float Temperatura;
float Temp2;

/////////////////////////////////////////////////////////////////////////////////////
// FUNCIONES                                                                                                                 //
/////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////
// CONFIGURACION                                                                                                        //
/////////////////////////////////////////////////////////////////////////////////////

void setup() 
{
analogReference(INTERNAL); 	// Used for setting the analog reference to 1.1V
Serial.begin(9600);			//Start the serial communication
}


/////////////////////////////////////////////////////////////////////////////////////
// PRINCIPAL                                                                                                                    //
//                                                                                                                                       //
/////////////////////////////////////////////////////////////////////////////////////

void loop() 
{
valor_leido = analogRead(pinA0);	//Read the value of the analog pin

Temperatura = (valor_leido*1.1*100) / 1024;	//Convert that value to temperature

Serial.print("Temperatura: ");		//Print the information to the terminal window
Serial.print(Temperatura);
Serial.print("C ");

Temp2 = map(valor_leido,0,1023,0,11000);	//This is another conversion using the map function

Serial.print("Temperatura por map: ");
Serial.print(Temp2/100);
Serial.print("  Lectura digital: ");
Serial.println(valor_leido);

delay(1000);			//Set a delay so we can see each second the temperature we are measuring
  
}

I n the next picture you can see the information on the terminal debugger once we click on the play button.

You can download the file on the following link:

https://drive.google.com/folderview?id=0B7dtMeeMPK5rfnJCSVlRVTkxRzdSeHBMWDJ6THVPWmdHdm1kZ3NwNTYzSEJ5b0ZmdlFoMG8&usp=sharing

File name: Termometro.zip

Version of Proteus 8.1

Arduino SPI and Proteus ISIS simulation

 

The SPI stands for Serial Peripheral Interface which is a serial communication and it is used for short distance communications. It common uses are in sensor, LCDs and Secure digital cards.

It uses four (4) cables where 3 of them are the same for  each device (MOSI, MISO, SCK) and the fourth one is for selecting the device you want to talk to. There is a fifth cable that it is important in every communication and that is GND.

Probably you are wondering what do MOSI, MISO and SCK mean, right? Well those are the name for the pins on SPI communication and their names came from:

MOSI: Master Out Slave In

MISO: Master In Slave Out

SCLK: Signal Clock

SS: Slave Select

Let´s say you want to have two (2) devices on the SPI communication, so you’ll need six cables, three are common for the two devices and two separated SS for each device and finally GND.

 

 

These are the components I used to do the schematics:

1 x Arduino board

1 x AD5206 SPI Potentiometer

1 x SPI debugger

This is how it looks the schematic and how should everything be connected:

 

 

After everything was connected I wrote a code to change each potentiometer on the AD5206 to output a different value given by the microcontroller. Here you see that I wrote the code on the “Source code” window.

 

The code I used was this:

/*
////////////////////////////////////////////////////////////////////////////////////////////////////
  AUTOR: JUAN BIONDI                                               FECHA:       FEBRERO/2014      
  PROGRAMA:  Potentiometer SPI	                                   VERSION:     1.0               
  DISPOSITIVO: ATMEL 328                                           COMPILADOR:  AVR               
  ENTORNO:     PROTEUS                                             SIMULADOR:   VSM        
  TARJETA DE PROGRAMACION:                                         DEBUGGER:                      
////////////////////////////////////////////////////////////////////////////////////////////////////

  Control an Analog Devices AD5206 digital potentiometer.
  The AD5206 has 6 potentiometer channels. Each channel's pins are labeled
  A - connect this to voltage
  W - this is the pot's wiper, which changes when you set it
  B - connect this to ground.
 
 The AD5206 is SPI-compatible,and to command it, you send two bytes, 
 one with the channel number (0 - 5) and one with the resistance value for the
 channel (0 - 255).  
 
 The circuit:
  * All A pins  of AD5206 connected to +5V
  * All B pins of AD5206 connected to ground
  * An LED and a 220-ohm resisor in series connected from each W pin to ground
  * CS - to digital pin 10  (SS pin)
  * SDI - to digital pin 11 (MOSI pin)
  * CLK - to digital pin 13 (SCK pin)



////////////////////////////////////////////////////////////////////////////////////////////////////
*/


////////////////////////////////////////////////////////////////////////////////////////////////////
// LIBRERIAS                                                                                      //
////////////////////////////////////////////////////////////////////////////////////////////////////

#include <SPI.h>

////////////////////////////////////////////////////////////////////////////////////////////////////
// VARIABLES GLOBALES                                                                             //
////////////////////////////////////////////////////////////////////////////////////////////////////

// set pin 10 as the slave select for the digital pot:
const int slaveSelectPin = 10;

////////////////////////////////////////////////////////////////////////////////////////////////////
// FUNCIONES                                                                                      //
////////////////////////////////////////////////////////////////////////////////////////////////////

void digitalPotWrite(int address, int value) 
{
  // take the SS pin low to select the chip:
  digitalWrite(slaveSelectPin,LOW);
  
  
  //  send in the address and value via SPI:
  SPI.transfer(address);
  SPI.transfer(value);
  digitalWrite(slaveSelectPin,HIGH);		 // take the SS pin high to de-select the chip:
}
////////////////////////////////////////////////////////////////////////////////////////////////////
// CONFIGURACION                                                                                  //
////////////////////////////////////////////////////////////////////////////////////////////////////

void setup() 
{
  pinMode (slaveSelectPin, OUTPUT);		// set the slaveSelectPin as an output:
  SPI.begin(); 					// initialize SPI:
  
   for (int canal = 0; canal < 6; canal++) 	// Initialize all potentiometers to 0
   { 
     digitalPotWrite(canal, 0);
     delay(10);
   }

}


////////////////////////////////////////////////////////////////////////////////////////////////////
// PRINCIPAL                                                                                      //
//                                                                                                //
////////////////////////////////////////////////////////////////////////////////////////////////////
void loop() 
{
   int valor = random(0,255);  		// Select a random number from 0 to 255
   int canal = random (0,5);		// Select a random number from 0 to 5
   digitalPotWrite(canal,valor);	// Send the data to the potentiometer
   delay(1500);				//Delay to see the changes
  
}

As you can see in the code every section is described and it is pretty simple to make changes

Once the code and the schematic are done, you can click on the play button and it should appear the SPI debugger like in the next picture:

 

 

You can download the file on the following link:

https://drive.google.com/folderview?id=0B7dtMeeMPK5rfnJCSVlRVTkxRzdSeHBMWDJ6THVPWmdHdm1kZ3NwNTYzSEJ5b0ZmdlFoMG8&usp=sharing

File name: SPI.zip

Version of Proteus 8.1

Arduino I2C and Proteus ISIS simulation

 

Hi! today I want to talk about I2C protocol. This protocol was invented by Philips Semiconductor and it is a  multi-slave, multi-master, single-ended, serial computer bus.

This protocol is simple when you know what it does and how it does it. The best way to compare the I2C is with pipes (3 specifically) one is SDA that stands for Serial Data Line and SCL that means Serial Clock Line and last but not least Ground.

The reason why I say 3 is because we always have to have a reference when working on electronic to know what logic zero or a logic one is. Some people talk about only SDA and SCL but you must connect all GND together in order to communicate with the peripherals.

The following pictures how the devices should be connected.

           

 

Each line (SDA and SCL) should be connected to "pull-up" resistors. This is necessary because all devices SDA and SCL connections are "open drain" lines: they can force the voltage on the line to 0V, or "low", but can’t raise it to 5V, or "high". High and low are the electrical representations of the 1s and 0s that are the fundamental components of digital information. Adding these two resistors – and the bus needs only two, no matter how many devices are connected to it – ensures the voltage rises back to 5V without a short circuit.

As you can see in next picture, the master begins the communication by sending the start condition (S). The master continues by sending a unique 7-bit slave device address, with the most significant bit (MSB) first. The eighth bit after the start, read/not-write (), specifies whether the slave is now to receive (0) or to transmit (1). This is followed by an ACK bit issued by the receiver, acknowledging receipt of the previous byte. Then the transmitter (slave or master, as indicated by the bit) transmits a byte of data starting with the MSB. At the end of the byte, the receiver (whether master or slave) issues a new ACK bit. This 9-bit pattern is repeated if more bytes need to be transmitted.

           

 

In a write transaction (slave receiving), when the master is done transmitting all of the data bytes it wants to send, it monitors the last ACK and then issues the stop condition (P). In a read transaction (slave transmitting), the master does not acknowledge the final byte it receives. This tells the slave that its transmission is done. The master then issues the stop condition.

That is some information to have into account when working with I2C but the reality is that Arduino libraries handles everything for us and it makes it easier to talk to other devices via I2C protocol.

the next big thing is the schematic that we need to setup in order to make this happen, we´ll do it in Proteus ISIS and it should look like this:

 

As you can see I have in the schematics the following components:

1 x Arduino board

1 x DS1307 Real Time Clock

1 x 16x2 Character LCD display

1 x DS1621 Temperature sensor

2 x 4k7 Resistor

1 x Terminal debugger

1 x I2C debugger

 

After I have connected all the components, I have to tell Proteus how to simulate the code I want the Arduino to run and I did it in the option that says “source code”. You can see the window on the following picture:

 

 

This is the code I used:

 

/*
////////////////////////////////////////////////////////////////////////////////////////////////////
  AUTOR: JUAN BIONDI                                               FECHA:       FEBRERO/2014      
  PROGRAMA:    TERMOMETRO I2C DS1621                               VERSION:     1.0               
  DISPOSITIVO: ATMEL 328P                                          COMPILADOR:  AVR               
  ENTORNO:     PROTEUS                                             SIMULADOR:   VSM        
  TARJETA DE PROGRAMACION:                                         DEBUGGER:                      
////////////////////////////////////////////////////////////////////////////////////////////////////

The DS1621 is an Analog to digital converter for temperature

////////////////////////////////////////////////////////////////////////////////////////////////////
*/


////////////////////////////////////////////////////////////////////////////////////////////////////
// LIBRERIAS                                                                                      //
////////////////////////////////////////////////////////////////////////////////////////////////////
// Let´s include the libraries needed for the skecth

#include <Wire.h>
#include "RTClib.h"
#include <LiquidCrystal.h>

////////////////////////////////////////////////////////////////////////////////////////////////////
// VARIABLES GLOBALES                                                                             //
////////////////////////////////////////////////////////////////////////////////////////////////////
//Let´s declare the variables needed for the sketch

//int tempC = 0;
//int tempF = 0;
//int direccion = 0x48;

RTC_DS1307 rtc;
LiquidCrystal lcd(12,11,5,4,3,2);

////////////////////////////////////////////////////////////////////////////////////////////////////
// FUNCIONES                                                                                      //
////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////
// CONFIGURACION                                                                                  //
////////////////////////////////////////////////////////////////////////////////////////////////////

void setup() 
{
/*
Serial.begin (9600);
//Initiate the Serial communication

Wire.begin();					// Enable the communication
//Let´s cpnfigure the sensor
Wire.beginTransmission(direccion); 		//Start the device
Wire.write(0xAC);				//Write configuration command
Wire.write(0x02);				//Continue conversion
Wire.endTransmission();				//Stop the device 

Wire.beginTransmission(direccion); 		//Restart the device
Wire.write(0xEE);				//Start temperature conversion command

Wire.endTransmission();				//Stop the device
*/	

   lcd.begin(16,2);
   Serial.begin (9600);
   Wire.begin();
   rtc.begin();

   if (! rtc.isrunning())	
      {
      Serial.println("RTC is NOT running");
      rtc.adjust(DateTime(__DATE__,__TIME__));
      }
				
}


////////////////////////////////////////////////////////////////////////////////////////////
// PRINCIPAL                                                                                 //
//                                                                                        //
////////////////////////////////////////////////////////////////////////////////////////////
void loop() 
{

/*

//Delay to separate the communication and the measuring
delay(100);
Wire.beginTransmission(0x48);			//Start the device
Wire.write (0xAA);				//Read temperature command
Wire.endTransmission();				//Stop the device
Wire.requestFrom(0x48,1);			// We ask for a byte
tempC = Wire.read();				//We save the temperature in centigrades
tempF = tempC * 9 / 5 + 32;			//Make the conversion to Faranheit

//Let’s write the data to the terminal windows 
Serial.print("Temperatura: ");
Serial.print(tempC);
Serial.print(" C/ ");
Serial.print(tempF);
Serial.println(" F");
*/

   lcd.clear();
   DateTime now = rtc.now();
   lcd.setCursor (0,0);
   
   lcd.print(now.year(), DEC);
   lcd.print('/');
   lcd.print(now.month(), DEC);
   lcd.print('/');
   lcd.print(now.day(), DEC);
   lcd.print('/');
   lcd.setCursor (0,1);
   lcd.print(now.hour(), DEC);
   lcd.print(':');
   lcd.print(now.minute(), DEC);
   lcd.print(':');
   lcd.print(now.second(), DEC);
   lcd.println();
   
   ///////////////////////////////////////////////////////////////////////////////////////
   
   Serial.print(now.year(), DEC);
   Serial.print("/");
   Serial.print(now.month(), DEC);
   Serial.print("/");
   Serial.print(now.day(), DEC);
   Serial.print("/");
   Serial.print(now.hour(), DEC);
   Serial.print("/");
   Serial.print(now.minute(), DEC);
   Serial.print("/");
   Serial.print(now.second(), DEC);
   Serial.print("/");
   Serial.println();
   
   Serial.print(" since midnight 1/1/1970 = ");
   Serial.print(now.unixtime());
   Serial.print("s = ");
   Serial.print(now.unixtime() / 86400L);
   Serial.print("d");
  
}

 

Once you have the schematic and the code, you can click on the play button to test the code running with the Terminal debugger and the I2C debugger, it should look like this:

With these two debuggers you can check the data that it is being sent or received in the two protocols. This is why I spend some time writing about I2C protocol.

If you click on the “Schematic Capture” window you can the the display working and you can also change the simulated temperature.

 

 

You can download the files in this link:

https://drive.google.com/folderview?id=0B7dtMeeMPK5rfnJCSVlRVTkxRzdSeHBMWDJ6THVPWmdHdm1kZ3NwNTYzSEJ5b0ZmdlFoMG8&usp=sharing

File name: Temperature_I2C.zip

Version of Proteus 8.1

Simulating Arduino on Proteus ISIS

Just to give you a heads up I want to say that I will be posting about simulating Arduino Platform on Proteus ISIS which it does it really well.
It will be great for those of you that don´t have the last version of Proteus in the next video you can see how to install it. (the video is no mine)

And here you can download the library and files you need to do this.

http://www.zer07even.com/download/125-arduino-library-proteus-untuk-simulasi

BuzzNet Tags: Arduino,Proteus_ISIS

Arduino; a platform, company, hardware, software or name?

 

Well I have to say that is all of them, is a microcontroller platform which has became one of the most famous platform over the years.

It is a open source software and hardware, which has a huge community willing to help you with your projects. The Arduino UNO hardware for example consist on a basic microcontroller (Atmega328P) which is the brain of the platform.

This is the Atmega328P and combining this microcontroller with a well design PCB and a translator TTL-USB we have gotten the Arduino UNO which you can see in the next picture.

 

I´ll be referring only on the Atmel328P because you could also do the same only with the same microcontroller on a different printed circuit board. I will also use the Arduino Software or IDE (Integrate Development Environment) version 1.05 and other software like Proteus ISIS and Proteus ARES to design PCBs and to simulate how the microcontroller works.

Here you can see the schematic of the Arduino UNO platform, take into account that the TTL-USB translator is an Atmega16U2 and it has it own firmware to do this translation or conversion.

 

 

It has its own power regulating circuit to 5 volts is also has a switching circuit that lets you power the board from a USB port when there is no voltage on the power jack or vice versa.

BuzzNet Tags: Arduino

Arduino

In this section I´ll be posting some simulation of the Arduino board, some codes, schematics diagram to interface with it and last but not least, some tips about it.

 

 

Take into account I´ll be focusing on the microcontroller ATMEGA 328p for my class projects, in these projects we´ll be using Proteus ISIS to simulate the board (Arduino),Proteus ARES to create Printed circuit Boards to interface with the microcontroller and the Arduino IDE.

 

 

This time I´m just creating this post in order to add Arduino to the menu, so it will be easy to access to all the information I´ll be posting.

Stay tuned!

 

BuzzNet Tags: Arduino