Arduino Arduino

20 Pages·2017·0.42 MB·Spanish

Arduino
Contingut
• 1 Arduino
¤ 1.1 Códigos ejemplo
(cid:224) 1.1.1 Pins E/S
(cid:215) 1.1.1.1 Salidas básicas Arduino
(cid:215) 1.1.1.2 Salidas básicas Arduino con ATmega328
(cid:215) 1.1.1.3 Entradas/Salidas básicas Arduino
(cid:215) 1.1.1.4 Entradas/Salidas básicas Arduino con ATmega328
(cid:224) 1.1.2 I2C
(cid:215) 1.1.2.1 I2C: Dispositivo Maestro envía texto y pide respuesta a dos dispositivos esclavos
(cid:215) 1.1.2.2 I2C: Dispositivo Esclavo recibe texto y responde cuando el máster pide respuesta
(cid:224) 1.1.3 SPI
(cid:215) 1.1.3.1 SPI: Maestro envía datos por SPI
(cid:215) 1.1.3.2 SPI: Esclavo recibe datos por SPI e interrupción (y AVR)
(cid:215) 1.1.3.3 SPI: Esclavo recibe datos por SPI e interrupción y responde un nuevo byte (y AVR)
(cid:224) 1.1.4 Serie USART
(cid:215) 1.1.4.1 Serie: Modifica el valor de los pins 12 y 13 mediante puerto serie
(cid:215) 1.1.4.2 Serie: Recibe un carácter por encuesta (polling), incrementa su valor y lo envía
(cid:215) 1.1.4.3 Serie: (AVR) Recibe un carácter por encuesta (polling), incrementa su valor y lo envía
(cid:215) 1.1.4.4 Serie: (AVR) Recibe un carácter por interrupción, incrementa su valor y lo envía
(cid:215) 1.1.4.5 Serie: (AVR) Recibe string por el puerto serie, y lo vuelve a enviar añadiendo CRLF (por polling)
(cid:215) 1.1.4.6 Serie: (AVR) Recibe string por el puerto serie por interrupción, añade los caracteres a un buffer, y lee el
buffer por partes indicando el número de bytes a leer
(cid:224) 1.1.5 TIMERS
(cid:215) 1.1.5.1 Timers: (AVR) Utiliza la interrupción del Timer 1 (16bits) para parpadear un Led cada 5 segundos
(cid:215) 1.1.5.2 Timers: (AVR) Utiliza la interrupción del Timer 2 (8bits) para parpadear un Led cada 1 segundo
(cid:224) 1.1.6 PWM
(cid:215) 1.1.6.1 Fast PWM mediante analogWrite (Timer2)
(cid:215) 1.1.6.2 Fast PWM mediante registros ATMega328 (Timer2)
(cid:215) 1.1.6.3 Fast PWM mediante analogWrite (Timer0)
(cid:215) 1.1.6.4 Fast PWM mediante registros ATMega328 (Timer0)
(cid:215) 1.1.6.5 Fast PWM mediante registros ATMega328 (Timer1)
(cid:224) 1.1.7 Contadores ATmega
(cid:215) 1.1.7.1 Activa un contador por registros. Cuenta hasta 65535 (0xFFFF)
(cid:215) 1.1.7.2 Activa un contador por registros. Cuenta hasta 15 (0x000F)
(cid:215) 1.1.7.3 Activa un contador por registros y activa interrupción al sobrepasar 65535 (0xFFFF)
(cid:215) 1.1.7.4 Activa un contador por registros y activa interrupción al sobrepasar el valor de OCR5A
(cid:224) 1.1.8 Entrada Analógica ADC
(cid:215) 1.1.8.1 Lee el valor de una entrada analógica y parpadea LED (Arduino)
(cid:215) 1.1.8.2 Lee el valor de una entrada analógica y parpadea LED (Registros ATmega)
(cid:224) 1.1.9 Guardar datos EEPROM
(cid:215) 1.1.9.1 Guardar nuevo valor de retardo de delay (Arduino)
(cid:224) 1.1.10 Modo Sleep
(cid:215) 1.1.10.1 Intermitente de 1 segundo en modo Sleep e interrupción Timer 2 mediante instrucciones Arduino
(cid:215) 1.1.10.2 Intermitente de 1 segundo en modo Sleep e interrupción Timer 2 mediante AVR y ASM ATmega328
(cid:215) 1.1.10.3 Modo Sleep y despertar por interrupción 0
¤ 1.2 Funciones y ejemplos
(cid:224) 1.2.1 Strings
(cid:215) 1.2.1.1 Separa String en dos partes separadas por un carácter
(cid:215) 1.2.1.2 Separa String en tres partes separadas por dos caracteres
(cid:215) 1.2.1.3 Separa busca un String dentro de otro String
(cid:215) 1.2.1.4 Devuelve el tamaño de un string de tipo char array
(cid:215) 1.2.1.5 Concatena varios char arrays
(cid:224) 1.2.2 Serie
(cid:215) 1.2.2.1 Lee caracteres del puerto serie 0 hasta que encuentra el carácter indicado
(cid:215) 1.2.2.2 Lee la cantidad de caracteres indicados del puerto serie 0
(cid:215) 1.2.2.3 Escribe un string de array de chars por puerto serie 0
¤ 1.3 Hardware
(cid:224) 1.3.1 LCD
(cid:215) 1.3.1.1 1602 (2x16)
(cid:224) 1.3.2 Ultrasonidos
(cid:215) 1.3.2.1 HC-SR04
(cid:224) 1.3.3 Configurar módulo Bluetooth HC-05 o similar con Arduino
(cid:215) 1.3.3.1 Módulo Bluetooth v.4 BLE HM-10
(cid:215) 1.3.3.2 Módulo Bluetooth v.4 BLE HC-10 / AT-09/ CC41A / MLT-BT05
¤ 1.4 Enlaces Arduino
Arduino
Datasheet ATMega328
Códigos ejemplo
Pins E/S
Salidas básicas Arduino
Corresponde al programa blink.ino del ejemplo en que se configura como salida el pin 13 de la placa Arduino, y se cambia el valor de la salida
alternativamente cada segundo. El pin 13 esta conectado a un LED.
void setup() {
pinMode(13,OUTPUT); // Configura el pin 13 como salida. Si no se configura no funcionaria como salida
}
void loop() {
digitalWrite(13, HIGH); // pone el led a 1
delay(1000); // espera un segundo
digitalWrite(13, LOW); // pone el led a 0
delay(1000); // espera un segundo
}
Salidas básicas Arduino con ATmega328
Equivalente al anterior pero modificando los registro del microcontrolador ATmega. (Registros en C:\Program Files
(x86)\Arduino\hardware\tools\avr\avr\include\avr\iom328p.h)
void setup() {
DDRB |= (1<<DDB5); // Pone a 1 el bit DDB5 del registro DDRB, ya que el pin 13 esta conectado a la salida PB5 del ATmega328 (PB7 en ATmega2560)
}
void loop() {
PORTB |= (1<<PORTB5); // Pone a uno el bit PORTB5 del registro PORTB que corresponde a la salida PB5
delay(1000); // espera un segundo
PORTB &= (0xFE<<PORTB5); // Pone a cero la salida PB5
delay(1000); // espera un segundo
}
Entradas/Salidas básicas Arduino
Lee el estado del pin 7, y lo escribe en el pin 13 que esta conectado a un led.
int a;
void setup() {
pinMode(13,OUTPUT); //Configura pin 13 como salida
pinMode(7,INPUT); //Configura pin 7 como entrada
}
void loop() {
a=digitalRead(7); //Lee el pin 7
digitalWrite(13, a); //Escribe en el pin 13 la lectura del pin 7
}
Entradas/Salidas básicas Arduino con ATmega328
Equivalente al anterior pero modificando los registro del microcontrolador ATmega.
int a;
void setup() {
DDRB |= (1<<DDB5); // Configura como salida el pin PB5 que corresponde al pin 13 de la placa
DDRD &= (0xFE<<DDD7); // Configura como entrada el pin PD7 que corresponde al pin 7 de la placa
}
void loop() {
a=PIND & (1<<PIND7); // Lee el bit PIND7 del registro PIND que corresponde al pin PD7
if (a==0){ // Si el resultado de la lectura es 0, es que
PORTB &= (0<<PORTB5); // Pone a cero el bit PORTB5 del registro PORTB que corresponde a la salida PB5
} // si se ha leido 0 en el pin PD7
else{
PORTB |= (0xFE<<PORTB5); // sino se ha leido 0, es que es uno y pone a uno el pin PB5
}
}
I2C
I2C: Dispositivo Maestro envía texto y pide respuesta a dos dispositivos esclavos
//Placa Arduino UNO y NANO
//I2C SDA: AN4, SCL:AN5
#include <Wire.h>
String rep="";
void setup() {
Wire.begin();
Serial.begin(9600);
Serial.println("Inici Mestre");
}
void loop() {
Wire.beginTransmission(0b0100); // transmite al dispositivo esclavo 4
Wire.write("M4"); //Envia "M4" al dispositivo esclavo 4 la sin esperar respuesta
Wire.endTransmission(); // para transmisión (no necesario si se sigue transmitiendo al mismo dispositivo)
delay(1000);
rep="";
Wire.requestFrom(4,6); //Solicita 6 bytes al dispositivo esclavo 4
while (Wire.available()) // espera a recibir todos los caracteres
{
char c = Wire.read(); // recibe byte a byte como carácter
rep+=c;
}
Serial.println(rep);
delay(200);
Wire.beginTransmission(8); // transmite al dispositivo esclavo 8
Wire.write("M8"); //Envía "M8" al dispositivo esclavo 8 sin esperar respuesta
Wire.endTransmission(); // para transmisión
delay(1000);
rep="";
Wire.requestFrom(8,6); //Solicita 6 bytes al dispositivo esclavo 8
while (Wire.available()) // Mientra haya datos a recibir
{
char c = Wire.read(); // recibe un byte como carácter
rep+=c;
}
Serial.println(rep);
delay(200);
}
I2C: Dispositivo Esclavo recibe texto y responde cuando el máster pide respuesta
//Placa Arduino UNO y NANO
//I2C SDA: AN4, SCL:AN5
#include <Wire.h>
String rebut="";
int incrM4=0;
void setup() {
Wire.begin(4); // Configura dirección 4 como esclavo I2C
Wire.onReceive(recibeEvento); // configura el evento de recibir texto
Wire.onRequest(requestEvento); // configura el evento de pedir respuesta
Serial.begin(9600);
Serial.println("Inici Esclau 4");
}
void loop() {
// No hace nada en el loop(). Solo por eventos
}
void recibeEvento(int byterecibe)
{ // Lee información recibida del maestro sin enviar respuesta y comprueba si es "M4"
rebut="";
while (Wire.available()>=1)
{
char c=Wire.read();
rebut +=c;
}
if (rebut=="M4")
{
Serial.print(rebut);
Serial.print(" ");
Serial.println(incrM4);
incrM4++;
}
}
void requestEvento()
{ //Responde al requerimiento de respuesta del máster de 6 bytes
Wire.write("hello4");
}
SPI
SPI: Maestro envía datos por SPI
//Arduino Uno
//SPI: 10 (SS), 11 (MOSI), 12 (MISO), 13 (SCK).
#include <SPI.h>
void setup (void)
{
Serial.begin(115200);
digitalWrite(SS, HIGH);
SPI.begin ();
SPI.setClockDivider(SPI_CLOCK_DIV8);
}
void loop (void)
{
char c;
digitalWrite(SS, LOW); // Activa el esclavo SPI destino, SS es pin 10 en Arduino Uno
// Envia "Hola, mundo\n" por SPI, carácter a carácter
for (const char * p = "Hola, mundo!\n" ; c = *p; p++) {
SPI.transfer (c);
Serial.print(c);
}
digitalWrite(SS, HIGH); // Desactiva el esclavo SPI destino
delay (1000);
}
SPI: Esclavo recibe datos por SPI e interrupción (y AVR)
Aprovecha las librerias SPI de Arduino, pero utiliza instrucciones de AVR para modo esclavo
//Arduino Uno
//SPI: 10 (SS), 11 (MOSI), 12 (MISO), 13 (SCK).
#include <SPI.h>
char buf [100];
volatile byte pos;
volatile boolean fin_recepcion;
void setup (void)
{
Serial.begin (9600);
pinMode(SS,INPUT);//Configura pins del esclavo. SS corresponde al pin 10 en Uno
pinMode(MISO, OUTPUT);
//Las instrucciones básicas de Arduino no permiten modo esclavo
SPCR |= _BV(SPE); // Activa el modo esclavo SPI del Atmega328 de Arduino Uno.
pos = 0; // Prepara variables de la interrupción
fin_recepcion = false;
SPI.attachInterrupt(); // Asigna interrupción de recepción del SPI
}
void loop (void)
{
if (fin_recepcion)//Espera fin de recepción para enviar
{
buf [pos] = 0;
Serial.println (buf);
pos = 0;
fin_recepcion = false;
}
}
ISR (SPI_STC_vect)// Rutina de interrupción recepción SPI
{
byte c = SPDR; // lee el byte recibido en el SPI Data Register
if (pos < sizeof buf) // añade el byte al buffer si hay espacio
{
buf [pos++] = c;
if (c == '\n') // Al encontrar '\n' indica fin de recepción
fin_recepcion = true;
}
}
SPI: Esclavo recibe datos por SPI e interrupción y responde un nuevo byte (y AVR)
Aprovecha las librerias SPI de Arduino, pero utiliza instrucciones de AVR para modo esclavo
//Arduino Nano
//SPI: 10 (SS), 11 (MOSI), 12 (MISO), 13 (SCK).
#include "pins_arduino.h"
// what to do with incoming data
byte command = 0;
void setup (void)
{
pinMode(SS,INPUT);
// have to send on master in, *slave out*
pinMode(MISO, OUTPUT);
// turn on SPI in slave mode
SPCR |= _BV(SPE);
// turn on interrupts
SPCR |= _BV(SPIE);
} // end of setup
// SPI interrupt routine
ISR (SPI_STC_vect)
{
byte c = SPDR;
switch (command)
{
// no command? then this is the command
case 0:
command = c;
SPDR = 0;
break;
// add to incoming byte, return result
case 'a':
SPDR = c + 15; // add 15
break;
// subtract from incoming byte, return result
case 's':
SPDR = c - 8; // subtract 8
break;
} // end of switch
} // end of interrupt service routine (ISR) SPI_STC_vect
void loop (void)
{
// if SPI not active, clear current command
if (digitalRead (SS) == HIGH)
command = 0;
} // end of loop
Serie USART
Serie: Modifica el valor de los pins 12 y 13 mediante puerto serie
La función serialEvent() no corresponde a la interrupción del puerto serie, sino que se ejecuta tras cada ciclo de loop()
//Al recibir el texto "led12\n" o "led13\n" cambia el valor de la salida del
//pin correspondiente (0-->1; 1-->0)
String inString = "";
boolean stringComplete=false;
boolean val13=LOW;
void setup() {
Serial.begin(9600);
pinMode (12,OUTPUT);
pinMode (13,OUTPUT);
}
void loop() {
if (stringComplete) {
inString.trim(); // Elimina el carácter '\n' del final y los caracteres no imprimibles
if (inString=="led12"){
digitalWrite(12,!digitalRead(12));
Serial.print("Led12:");
Serial.println(digitalRead(12));
}
if (inString=="led13"){
val13=!val13;
digitalWrite(13,val13);
Serial.print("Led13:");
Serial.println(val13);
}
inString = "";
stringComplete=false;
}
}
void serialEvent() {
while (Serial.available()) {
char inChar = (char)Serial.read();
inString += inChar;
if (inChar == '\n') {
stringComplete = true;
}
}
}
Serie: Recibe un carácter por encuesta (polling), incrementa su valor y lo envía
void setup() {
Serial.begin(9600);
}
void loop() {
if (Serial.available()) {
char inChar = (char) Serial.read()+1;
Serial.print(inChar);
}
}
Serie: (AVR) Recibe un carácter por encuesta (polling), incrementa su valor y lo envía
Equivalente al anterior sin utilizar la librería "Serial" y configurando los registros del AVR. Este código utiliza un 20% de la memoria del código en que
se utiliza la librería.
#include <avr/io.h>
#define USART_BAUDRATE 9600
uint8_t TempData;
void setup() {
IniciaUSART0();
}
void loop() {
// Receive data
TempData = USART0RecibeByte();
// Increment received data
TempData++;
//Send back to terminal
USART0EnviaByte(TempData);
}
void IniciaUSART0()
{
// Configura velocidad baudios. F_CPU Arduino Uno = 16000000 (16MHz)
unsigned int UBRR_VALUE = (((F_CPU / (USART_BAUDRATE * 16UL))) - 1);
UBRR0H = (uint8_t)(UBRR_VALUE>>8);
UBRR0L = (uint8_t)UBRR_VALUE;
// UCSR0A= x0xxxx0x, UCSR0B=00011000, UCSR0C=00000110
// Configura la comunicación a 8 data bits (UCSZ02=0,UCSZ01=1, UCSZ00=1
// no parity, 1 stop bit, usart asíncrona
UCSR0A = 0;
UCSR0B = 0;
UCSR0C = 0;
UCSR0C |= (1<<UCSZ01)|(1<<UCSZ00);
// Habilita la transmisión y la recepción
UCSR0B |= (1<<RXEN0)|(1<<TXEN0);
}
void USART0EnviaByte(uint8_t Datou8)
{
// Espera a que se haya enviado el byte previo, comprobando la activación del bit
// de registro de datos vacío (UDRE0) del UCSR0A
while(!(UCSR0A&(1<<UDRE0))){};
// Al vaciarse, envia el byte
UDR0 = Datou8;
}
uint8_t USART0RecibeByte()
{
// Espera a que se haya recibido un byte en el registro de datos (UDR0), comprobando
// la activación del bit de recepción completa (RXC0) del UCSR0A
while(!(UCSR0A&(1<<RXC0))){};
// Devuelve la lectura del registro de datos
return UDR0;
}
Serie: (AVR) Recibe un carácter por interrupción, incrementa su valor y lo envía
Equivalente al anterior pero utilizando la interrupción de recepción
#include <avr/io.h>
#define USART_BAUDRATE 9600
uint8_t TempData;
void setup() {
IniciaUSART0();
}
void loop() {
}
void IniciaUSART0()
{
// Configura velocidad baudios. F_CPU Arduino Uno = 16000000 (16MHz)
unsigned int UBRR_VALUE = (((F_CPU / (USART_BAUDRATE * 16UL))) - 1);
UBRR0H = (uint8_t)(UBRR_VALUE>>8);
UBRR0L = (uint8_t)UBRR_VALUE;
// UCSR0A= x0xxxx0x, UCSR0B=10011000, UCSR0C=00000110
// Configura la comuniación a 8 data bits (UCSZ02=0,UCSZ01=1, UCSZ00=1
// no parity, 1 stop bit, usart asíncrona
UCSR0A = 0;
UCSR0B = 0;
UCSR0C = 0;
UCSR0C |= (1<<UCSZ01)|(1<<UCSZ00);
// Habilita la transmisión, la recepción y la interrupción de recepción
UCSR0B |= (1<<RXEN0)|(1<<TXEN0)|(1<<RXCIE0);
}
void USART0EnviaByte(uint8_t Datou8)
{
// Espera a que se haya enviado el byte previo, comprobando la activación del bit
// de registro de datos vacio (UDRE0) del UCSR0A
while(!(UCSR0A&(1<<UDRE0))){};
// Al vaciarse, envia el byte
UDR0 = Datou8;
}
uint8_t USART0RecibeByte()
{
// Espera a que se haya recibido un byte en el registro de datos (UDR0), comprobando
// la activación del bit de recepción completa (RXC0) del UCSR0A
while(!(UCSR0A&(1<<RXC0))){};
// Devuelve la lectura del registro de datos
return UDR0;
}
ISR(USART_RX_vect){ // USART Rx Complete UCSR0B=1xx1xxxx
// Receive data
TempData = USART0RecibeByte();
// Increment received data
TempData++;
//Send back to terminal
USART0EnviaByte(TempData);
}
// Otras interrupciones USART
// #define USART_UDRE_vect /* USART, Data Register Empty */UCSR0B=xx111xxx
// #define USART_TX_vect /* USART Tx Complete */ UCSR0B=x1xx1xxx
Serie: (AVR) Recibe string por el puerto serie, y lo vuelve a enviar añadiendo CRLF (por polling)
Lee carácteres por el puerto serie hasta encontrar el carácter indicado o TIMEOUT, lo graba en un string tipo array de char y vuelve a enviarlo por el
puerto serie añadiendo los carácteres de fin de linea CRLF (\r\n)
#include <avr/io.h>
#define USART_BAUDRATE 9600
#define TIMEOUTS 5000
char dadarep[250];
char finlinea[3]={'\r','\n','\0'};
void setup() {
IniciaUSART0();
}
void loop() {
leeseriehasta(dadarep,';');
escribeserie(dadarep);
escribeserie(finlinea);
// Al no usar interrupciones, se podria mezclar el uso del puerto serie mediante los registros con las funciones Serial de Arduino
// Serial.print("Escribe nuevo string:");
}
void IniciaUSART0()
{
unsigned int UBRR_VALUE = (((F_CPU / (USART_BAUDRATE * 16UL))) - 1);
UBRR0H = (uint8_t)(UBRR_VALUE>>8);
UBRR0L = (uint8_t)UBRR_VALUE;
// UCSR0A= x0xxxx0x, UCSR0B=00011000, UCSR0C=00000110
UCSR0A = 0;
UCSR0B = 0;
UCSR0C = 0;
UCSR0C |= (1<<UCSZ01)|(1<<UCSZ00);
UCSR0B |= (1<<RXEN0)|(1<<TXEN0);
}
int leeseriehasta(char datolee[], char caracter){
unsigned long toutini;
int ind=0;
char leebyte;
toutini=millis();
do
{
if (UCSR0A&(1<<RXC0)){
leebyte=UDR0;
datolee[ind]=leebyte;
ind++;
}
} while(((millis()-toutini)<TIMEOUTS) & (leebyte!=caracter));
datolee[ind]='\0';
return ind;
}
int escribeserie(char datoescribe[]){
unsigned long toutini;
int ind=0;
toutini=millis();
char lee;
do
{
lee=datoescribe[ind];
if (lee!='\0'){
if (UCSR0A&(1<<UDRE0)){
UDR0=lee;
ind++;
}
}
} while (((millis()-toutini)<TIMEOUTS) & (lee!='\0'));
return ind;
}
Serie: (AVR) Recibe string por el puerto serie por interrupción, añade los caracteres a un buffer, y lee el buffer por partes indicando el
número de bytes a leer
Lee carácteres por el puerto serie por interrupcion y lee el buffer de 3 en 3 bytes (o menos). La cantidad de bytes de contiene el buffer se puede leer en
la variable indserbuf
#include <avr/io.h>
#define USART_BAUDRATE 9600
#define TIMEOUTS 5000
#define SERBUFSIZE 10 //Tamaño máximo del buffer
char serbuf[SERBUFSIZE + 1]; //Crea el buffer con un carácter más, para el carácter null ('\0') de final
int indserbuf = 0; //Indice del buffer. Corresponde al tamaño acual del buffer
char finlinea[3] = {'\r', '\n', '\0'}; // Array de fin de linea con CR LF
char lectbuf[20];
String a;
char ap[5];
int bt;
void setup() {
IniciaUSART0();
}
void loop() {
escribeserie("buffer_actual: ");
escribeserie(serbuf); // Escribe el contenido del buffer por el puerto serie
escribeserie(finlinea);
escribeserie("tamanyo_buffer: ");
a = String(indserbuf, DEC); //Convierte el tamaño del buffer a String
a.toCharArray(ap, 5); //Convierte el String con el tamaño del buffer a string de array de char
escribeserie(ap); //Escribe el valor del tamaño del buffer por el puerto serie
escribeserie(finlinea);
escribeserie("lectura_buffer: ");
bt = leeseriebuffer(lectbuf, 3); //Lee 3 bytes del buffer y los bytes leidos
escribeserie(lectbuf); //Escribe los carácteres leidos
escribeserie(finlinea);
escribeserie("tamanyo_leido: ");
a = String(bt, DEC); //Convierte el valor de los bytes leidos
a.toCharArray(ap, 5);
escribeserie(ap); //Escribe el valor de los bytes leidos
escribeserie(finlinea);
delay(2000);
}
int leeseriebuffer(char lectura[], int nbytes) {
UCSR0B |= (0 << RXCIE0)| (0 << RXCIE0); // Deshabilita la recepción de nuevos carácteres
int byteslee;
if (nbytes >= indserbuf) { // Si el valor de los bytes pedidos a leer es mayor o igual al tamaño
byteslee = indserbuf; // actual de buffer, devuelve todo el buffer
for (int i = 0; i <= indserbuf; i++) {
lectura[i] = serbuf[i];
}
indserbuf = 0;
serbuf[0] = {0}; //serbuf[0]='\0' // Borra el buffer completo
UCSR0B |= (1 << RXCIE0)| (1 << RXCIE0); // Habilita la recepción de nuevos carácteres
return byteslee;
}
if (nbytes < indserbuf) { // Si el valor de los bytes pedidos a leer es mayor o igual al tamaño
byteslee = nbytes; // actual de buffer, devuelve los carácteres solicitados
for (int i = 0; i < nbytes; i++) {
lectura[i] = serbuf[i];
}
for(int i=nbytes; i<=SERBUFSIZE; i++) { // Elimina los carácteres leidos y desplaza todos
serbuf[i-nbytes] = serbuf[i]; // los carácteres del array el mismo número de bytes leidos
}
indserbuf-=nbytes;
UCSR0B |= (1 << RXCIE0)| (1 << RXCIE0); // Habilita la recepción de nuevos carácteres
return nbytes;
}
UCSR0B |= (1 << RXCIE0)| (1 << RXCIE0); // Habilita la recepción de nuevos carácteres
return 0;
}
ISR(USART_RX_vect) { // Interrupción de recepción por puerto serie. USART Rx Complete UCSR0B=1xx1xxxx
if (indserbuf < SERBUFSIZE) { // Si el buffer no esta lleno, lee y añade el caracter recibido
while (!(UCSR0A & (1 << RXC0))) {};
serbuf[indserbuf] = UDR0;
indserbuf++;
serbuf[indserbuf] = '\0'; // Añade el fin de array de char al final del array
}
}
void IniciaUSART0()
{
// Configura velocidad baudios. F_CPU Arduino Uno = 16000000 (16MHz)
unsigned int UBRR_VALUE = (((F_CPU / (USART_BAUDRATE * 16UL))) - 1);
UBRR0H = (uint8_t)(UBRR_VALUE >> 8);
UBRR0L = (uint8_t)UBRR_VALUE;
// UCSR0A= x0xxxx0x, UCSR0B=10011000, UCSR0C=00000110
// Configura la comuniación a 8 data bits (UCSZ02=0,UCSZ01=1, UCSZ00=1
// no parity, 1 stop bit, usart asíncrona
UCSR0A = 0;
UCSR0B = 0;
UCSR0C = 0;
UCSR0C |= (1 << UCSZ01) | (1 << UCSZ00);
// Habilita la transmisión, la recepción y la interrupción de recepción
UCSR0B |= (1 << RXEN0) | (1 << TXEN0) | (1 << RXCIE0);
}
int escribeserie(char datoescribe[]) {
unsigned long toutini;
int ind = 0;
toutini = millis();
char lee;
do
{
lee = datoescribe[ind];
if (lee != '\0') {
if (UCSR0A & (1 << UDRE0)) {
UDR0 = lee;
ind++;
}
}
} while (((millis() - toutini) < TIMEOUTS) & (lee != '\0'));
return ind;
}
TIMERS
Timers: (AVR) Utiliza la interrupción del Timer 1 (16bits) para parpadear un Led cada 5 segundos
El Timer 1 es de 16 bits. Cuidado si utilizamos la libreria Servo de Arduino, ya que utiliza el Timer 1. Los timers 3, 4 y 5 del ATmega2560 funcionan de
forma similar al Timer 1
// Arduino Atmega328 interrupción timer1. www.engblaze.com
// Añadir librerias propias de microntroladores AVR como el Atmega328
// Valores de registros en: ...\Arduino\hardware\tools\avr\avr\include\avr\io.h
// y ...\Arduino\hardware\tools\avr\avr\include\avr\iom328p
// Limites teoricos tiempo para 16MHz:
// min. 62.5ns OCR1A=1, prescaler=1 (teorico); max. 4.194304s OCR1A=65535, prescaler=1024
#include <avr/io.h>
#include <avr/interrupt.h>
#define LEDPIN 13
int segundos;
void setup()
{
pinMode(LEDPIN, OUTPUT);
// Initialización Timer1 (16bits) (Cuidado, utilizado por libreria Arduino de servo)
cli(); // deshabilita interrupcions
TCCR1A = 0; // WGM11=0, WGM10=0, resto a 0
TCCR1B = 0; // Inicializamos el registro de control B
// Activa modo CTC(Clear Timer on Compare); WGM13=0,WGM12=1,WGM11=0, WGM10=0, para comparar con OCR1A
TCCR1B |= (1 << WGM12);
// CS12=1, CS11=0, CS10=1 para 1024 prescaler
TCCR1B |= (1 << CS10);
TCCR1B |= (1 << CS12);
// indica el valor del contador del timer para comparar y conseguir un timer de 1 segundo
// F=16MHz --> T=0.0000000625s= 625x10^-10
// resolución timer = prescaler * T =1024*625x10^-10 = 64x10-6
// tiempo = resolución timer * (valor contador timer + 1)
// valor contador timer = (tiempo/resolución timer)-1 = (1s/64x10-6)-1= 15624
OCR1A = 15624; //OCR1A del timer 1 es de 16 bits ==> valor máx. 65535
// Activa la interrupción para que se ejecute al comparar con el valor del registro OCR1A
TIMSK1 |= (1 << OCIE1A);
// Activa interrupciones
sei();
}
void loop()
{
// No hace nada ya que solo funciona la interrupción
}
ISR(TIMER1_COMPA_vect)
{
segundos++;
if (segundos == 5)
{
segundos = 0;
digitalWrite(LEDPIN, !digitalRead(LEDPIN));
}
}
Timers: (AVR) Utiliza la interrupción del Timer 2 (8bits) para parpadear un Led cada 1 segundo
Similar al timer1, pero el timer 2 es de 8 bits. El timer 2 es utilizado en la función tone() de Arduino. El timer 0, también de 8 bits, funciona igual que el
timer 2 pero las instrucciones delay(), millis(), micros() utilizan el timer 0 para su funcionamiento.
// Arduino Atmega328 interrupción timer2.
// Añadir librerias propias de microntroladores AVR como el Atmega328
// Valores de registros en: ...\Arduino\hardware\tools\avr\avr\include\avr\io.h
// y ...\Arduino\hardware\tools\avr\avr\include\avr\iom328p
// Limites teoricos timer 2 tiempo para 16MHz:
// min. 62.5ns OCR2A=1, prescaler=1 (teórico); max. 16.384ms OCR2A=255, prescaler=1024
#include <avr/io.h>
#include <avr/interrupt.h>
#define LEDPIN 13
int ms8;
void setup()
{
pinMode(LEDPIN, OUTPUT);
// Inicialización Timer1 (16bits) (Cuidado, utilizado por librería Arduino de servo)
cli(); // deshabilita interrupciones
TCCR2A = 0; // Inicializamos el registro de control A
TCCR2B = 0; // Inicializamos el registro de control B
// Activa modo CTC(Clear Timer on Compare); WGM22=0,WGM21=1,WGM20=0, para comparar con OCR2A
TCCR2A |= (1 << WGM21);
// CS22=1, CS21=1, CS20=1 para 1024 prescaler
TCCR2B |= (1 << CS20);
TCCR2B |= (1 << CS21);
TCCR2B |= (1 << CS22);
// indica el valor del contador del timer para comparar y conseguir un timer de 8ms (8ms*125=1s)
// F=16MHz --> T=0.0000000625s= 625x10^-10
// resolución timer = prescaler * T =1024*625x10^-10 = 64x10-6
// tiempo = resolución timer * (valor contador timer + 1)
// valor contador timer = (tiempo/resolución timer)-1 = (8ms/64x10-6)-1= 124
OCR2A = 124; //OCR2A del timer 2 es de 8 bits
// Activa la interrupción para que se ejecute al comparar con el valor del registro OCR2A
TIMSK2 |= (1 << OCIE2A);
// Activa interrupciones
sei();
}
void loop()
{
// No hace nada ya que solo se utiliza la interrupción
}
ISR(TIMER2_COMPA_vect)
{
ms8++;
if (ms8 == 125) //(8ms*125=1s)
{
ms8 = 0;
digitalWrite(LEDPIN, !digitalRead(LEDPIN));
}
}
PWM
Los Timers de Arduino tienen la posibilidad de trabajar como PWM. Cada timer en ATmega328 tiene 2 salidas PWM, y en ATmega2560 los timers 0 y 2
tienen 2 salidas PWM, y los timers 1,3,4 y 5 tienen 3 salidas PWM. Hay que tener en cuenta que si utilizamos el modo PWM, y queremos utilizar el
timer simultáneamente, la frecuencia del PWM dependerá del valor del timer configurado, además de otras limitaciones.
http://www.righto.com/2009/07/secrets-of-arduino-pwm.html
Fast PWM mediante analogWrite (Timer2)
// Este programa utiliza 1.062 bytes de memoria
void setup() {
pinMode(3,OUTPUT);
//Configura el duty cycle al 50% y la frecuencia es de 490Hz en el pin3 del Arduino Uno
analogWrite(3,127);
}
void loop() {
}
Fast PWM mediante registros ATMega328 (Timer2)
El programa equivalente a utilizar analogWrite pero mediante registros de ATmega328 es el siguiente:
// Este programa utiliza 650 bytes. Menos que utilizando analogWrite()
//Utilizaremos la salida OC2B del Timer 2 (pin3), y dejaremos la salida OC2A
//libre ya que corresponde al pin MOSI de comunicaciones SPI (pin11). Timer2 8bits (MAX=256=0xFF)
void setup() {
pinMode(3,OUTPUT); //Configura salida OC2B
// Deshabilita OC2A (COM2A1=0, COM2A0=0), configura OC2B modo no invertido (HIGH antes, LOW despues comparacion OCR2B)
// (COM2B1=1, COM2B0=0), Configura Fast PWM (TOP=0xFF=256) (WGM22=0,WGM21=1,WGM20=1)
TCCR2A = _BV(COM2B1) | _BV(WGM21) | _BV(WGM20); //_BV(COM2B1) es equivalente a (1 << COM2B1)
// Configura prescaler 128 (CS22=1,CS21=0,CS20=1) --> Frecuencia PWM= 16MHZ/128/256=490Hz
TCCR2B = _BV(CS22)|_BV(CS20);
//Valor OCR2B=((256*duty)/100)-1. Ej. Duty cycle=50%-->OCR2B=127
OCR2B=(uint8_t)(((256*50)/100)-1);
}
void loop() {
}
Fast PWM mediante analogWrite (Timer0)
Como que el Timer0 lo utiliza Arduino para calcular el tiempo de las instrucciones de tiempo como delay(), utilizando las instrucciones de referencia de
Arduino no hay problema para utilizar las salidas PWM del timer 0, como son los pines 5 y 6, simultaneamente con las instrucciones como delay(),
millis(), etc...
void setup() {
pinMode(6,OUTPUT);
pinMode(13,OUTPUT);
analogWrite(6,127); //La frecuencia del PWM en el pin6 de Arduino Uno es de 980Hz
}
void loop() {
digitalWrite(13, HIGH);
delay(1000);
digitalWrite(13, LOW);
delay(1000);
}
Fast PWM mediante registros ATMega328 (Timer0)
Si utilizamos el PWM del Timer0, hay que tener en cuenta de que para que funcionen correctamente las instrucciones de tiempo de Arduino como
delay(), el Timer0 está configurado con un preescalado por defecto de 64, con lo que si modificamos el preescalado en el registro TCCR0B, el tiempo
de las instrucciones delay(), millis(),etc... quedará modificado.
//Utilizaremos la salida OC0A del Timer 0 (pin6)
void setup() {
pinMode(13,OUTPUT);
pinMode(6,OUTPUT); //Configura salida OC0A
// Deshabilita OC0B (COM0B1=0, COM0B0=0), configura OC0A modo no invertido (HIGH antes, LOW después comparación OCR0A)
// (COM0A1=1, COM0A0=0), Configura Fast PWM (TOP=0xFF=256) (WGM02=0,WGM01=1,WGM00=1)
TCCR0A = _BV(COM0A1) | _BV(WGM01) | _BV(WGM00);
// Configura prescaler 64 (CS02=0,CS01=1,CS00=1) --> Frecuencia PWM= 16MHZ/64/256=980Hz
TCCR0B = _BV(CS01)|_BV(CS20);
//Si modificaramos el preescaler a otro valor, por ejemplo 256 (CS02=1,CS01=0,CS00=0),
//la frecuencia disminuiria a 16MHZ/256/256=245Hz, con lo que delay(1000) en lugar de realizar
//un retardo de 1 segundo, realizaria un retardo de 4 segundos.(TCCR0B = _BV(CS02);)
//Valor OCR0A=((256*duty)/100)-1. Ej. Duty cycle=50%-->OCR0A=127
OCR0A=(uint8_t)(((256*50)/100)-1);
}
void loop() {
digitalWrite(13, HIGH);
delay(1000);
digitalWrite(13, LOW);
delay(1000);
}
Fast PWM mediante registros ATMega328 (Timer1)
El timer 1 es de 16 bits y tiene más modos de funcionamiento que los timers 0 y 2 de 8 bits.
//El Timer1 es de 16 bits, pero como Fast PWM puede trabajar con 8, 9 o 10 bits.
//Utilizaremos la salida OC1A del Timer 1 (pin9)
void setup() {
pinMode(9,OUTPUT); //Configura salida OC1A
// Deshabilita OC1B (COM1B1=0, COM1B0=0), configura OC1A modo no invertido (HIGH antes, LOW después comparación OCR0A)
// (COM1A1=1, COM1A0=0), Configura Fast PWM 10bits (TOP=0x03FF=1024) (WGM13=0,WGM12=1,WGM11=1,WGM10=1)
TCCR1A = _BV(COM1A1) | _BV(WGM11)| _BV(WGM10);
// Configura prescaler 64 (CS12=0,CS11=1,CS10=1) --> Frecuencia PWM= 16MHZ/64/1024=244Hz
TCCR1B = _BV(CS10) |_BV(CS11) | _BV(WGM12);
//Valor OCR1A=((1024*duty)/100)-1. Ej. Duty cycle=50%-->OCR1A=512
OCR1A=(uint16_t)((((uint16_t)1024*50)/100)-1);
}
void loop() {
}
Contadores ATmega
Arduino no dispone de funciones para utilizar los contadores, ya que al ser comunes con loos temporizadores, no se podrían utilizar instrucciones como
delay() o el PWM, ya que utilizan el temporizador 0. Además la placas Arduino no proporcionan acceso a todos los pines de contaje externo, con lo que
estamos limitados en el uso de contadores. Por ejemplo, la placa Arduino UNO, si que tiene acceso a la entrada de contador T0 del pin del ATmega328
PD4 que corresponde al pin de la placa 4, y a T1 del pin del ATmega328 PD5 que corresponde a la entrada 5 de la placa. Sin embargo, en la placa
Arduino Mega 2560 solo podemos acceder a T0 del pin del ATmega2560 PD7 de la entrada de la placa 38, y a T5 del pin del ATmega2560 PL2 de la
entrada de la placa 47. No hay acceso ni a T1-PD6, ni T3-PE6, ni T4-PH7.
Activa un contador por registros. Cuenta hasta 65535 (0xFFFF)
Utilizaremos la placa Arduino Mega 2560 y el contador 5 de 16 bits, dejando libre el temporizador 0 para el uso de la instrucción delay(). La entrada T5
corresponde a la entrada 47 de la placa y al pin PL2. Es importante tener en cuenta que el contador es muy sensible a los rebotes ya que los cuenta,
con lo que es recomendable poner un circuito antirrebotes.
void setup() {
Serial.begin(9600);
// Configura como entrada PL2 - T5
DDRL &= ~(1<<DDL2); // Pone a 0 el bit DDL2 del registro DDRL, ya que T5 corresponde al pin 47 que esta conectado a la entrada PL2 en ATmega2560
PORTL |= (1 << PORTL2); // Pone a 1 el pin PL2 para activar pull-up y evitar cortocircuitos internos.
// WGM53=0, WGM52=0, WGM51=0, WGM50=0. Normal mode TOP 0xFFFF
TCCR5A = 0x0000; //WGM51=0, WGM50=0
// Activa el contador 5 con contaje por flanco de subida del pin externo T5 (PL2, entrada 47)
TCCR5B |= (1 << CS52) | (1 << CS51) | (1 << CS50); // WGM53=0, WGM52=0
}
void loop() {
Serial.println(TCNT5); //Envia por el puerto serie el valor del contador.
delay(1000);
}
Activa un contador por registros. Cuenta hasta 15 (0x000F)
Como el anterior, pero cuenta de 0 a 15 y al sobrepasar 15 vuelve a 0.
void setup() {
Serial.begin(9600);
DDRL &= ~(1<<DDL2); // Configura como entrada PL2 - T5
PORTL |= (1 << PORTL2);
// WGM53=0, WGM52=1, WGM51=0, WGM50=0. Modo CTC(Clear Timer on Compare Match) valor TOP en OCR5A
TCCR5A = 0x0000; //WGM51=0, WGM50=0
TCCR5B |= (1<<WGM52)|(1 << CS52) | (1 << CS51) | (1 << CS50); // WMGM53=0, WGM52=1
OCR5A=0x000F; //Valor TOP de contaje 15 (0x000F);
}
void loop() {
Serial.println(TCNT5);
delay(1000);
}
Activa un contador por registros y activa interrupción al sobrepasar 65535 (0xFFFF)
La interrupción por sobrepasamiento TOI, se activa solo al sobrepasar del máximo 65535, con lo que no se puede activar limitando el valor de contaje a
OCRnA. En este ejemplo se configura para que salte la interrupción al sobrepasar 65535
void setup() {
Serial.begin(9600);
// Configura como entrada PL2 - T5
DDRL &= ~(1<<DDL2);
PORTL |= (1 << PORTL2);
// WGM53=0, WGM52=0, WGM51=0, WGM50=0. Normal mode TOP 0xFFFF
TCCR5A = 0x0000; //WGM51=0, WGM50=0
// Activa el contador 5 con contaje por flanco de subida del pin externo T5 (PL2, entrada 47)
TCCR5B |= (1 << CS52) | (1 << CS51) | (1 << CS50); // WGM53=0, WGM52=0
cli(); // Deshabilita interrupciones;
TIMSK5 |= (1 << TOIE5); // Habilita interrupción de Timer por sobrepasamiento
sei(); // Habilita interrupciones;
}
void loop() {
if (TCNT5<65520)
{
TCNT5=65520; //Para no esperar, ponemos a 65520 (0xFFF0) para solo contar 15 hasta sobrepasar
}
Serial.println(TCNT5); //Envia por el puerto serie el valor del contador.
delay(1000);
}