TODOPIC
Otros Microcontroladores / Dispositivos programables => Microcontroladores 8 bits => Mensaje iniciado por: marvicdigital en 24 de Octubre de 2016, 23:38:59
-
Hola a todos.
Luego de volver a la vida microcontrolera :D, y con la idea de hacer cosas interesantes, proyectos y demás, emepece a estudiar lenguaje C++, retomar los micros PIC, luego los Freescale sin éxito me decido por probar en forma los Atmel.
Las razones son las siguientes:
Uso solo linux, la distro Mint18 para ser exactos, el Mplab XC8 va bien pero con sus inconvenientes como no soporta algunos pequeños procesadores o dan inconvenientes, sin contar con la escasas librerías....Freescale parece que tiene olvidado el linux por que las últimas versiones del Code Warrior solo son para Wiindows sin contar con mi limitante para adquirir un buen programador :oops:..
Asi que llevo unos buenos días leyendo aquí, allá, adquirí un Arduino uno y me ha gustado lo bien que trabaja el Atmega pero no me gusta no tener el control completo del microcontrolador para hacer travesuras :D..vamos que todo masticado y sacrificando a lo mejor potencia por comodidad..uhmm como que no 8).
Asi que paso por aca para pedir ayuda recomendaciones, guías y demás para empezar con esta familia..en mi pais, Colombia, se consigue los Atmega, los attiny y otro AT89,90 a un buen precio si los comparo con los Freescale y los PICs, que programador me recomiendan que me pueda servir enn linux; y si alguien trabaja con esta familia en linux me gustaría leer su experiencia y ayuda por supuesto ;-)..
Este programador me servirá para empezar?
http://dualtronica.com/microcontroladores/302-programador-atmel-avr-usbasp-usbisp.html (http://dualtronica.com/microcontroladores/302-programador-atmel-avr-usbasp-usbisp.html)
De antemano muchas gracias y espero poder iniciar bien con esta familia y no sentirme tan frustrado como me he sentido por estos días con las otras familias..
Un abrazo.
Saludos
-
Yo habia empezado con los pic y nunca pude hacer algo que me funcionara, siempre tenia que entrar al foro a buscar los problemas como lo hace otros muchos.
pero en fin cada loco con su Temas, el programador que pone en el Link, yo estuve problema con el y lo tire a la basura, le reclame al vendedor y me dijo que lo enviara al Distribuidor y deberia espera 2 semana, la cual descarte y lo tire a la basura,
Yo te recomendaria este http://www.fischl.de/usbasp/
Features
Works under multiple platforms. Linux, Mac OS X and Windows are tested.
No special controllers or smd components are needed.
Programming speed is up to 5kBytes/sec.
SCK option to support targets with low clock speed (< 1,5MHz).
Planned: serial interface to target (e.g. for debugging).
(http://www.todopic.com.ar/foros/imgtiny/6pryps.jpg)
yo lo uso cuando tengo que quemar varios micro, pero para experimentar uso mi STK500 :P
yo programo en Basic y uso Bascom AVR...
Saludos
-
si tienes arduino, ya tienes un programador de micros atmel
https://arduinogea.wikispaces.com/Programar+ATMega+desde+Arduino
http://elecrab.com/archives/646
-
El usbasp funciona en linux a través de avrdude o incluso a través del mismo IDE de Arduino
https://learn.sparkfun.com/tutorials/pocket-avr-programmer-hookup-guide/using-avrdude
para usar el programador usbasp en modo usuario añades un archivo en /etc/udev/rules.d cuyo contenido sea el siguiente
SUBSYSTEMS=="usb", ATTRS{idVendor}=="16c0", ATTRS{idProduct}=="05dc", MODE="0666"
Con eso podrás programar por ejemplo un attiny85 con
avrdude -p t85 -B 4 -c usbasp -U flash:w:blink.hex
Con la opción -c seleccionas el tipo de programador
En el caso que cuentes con un arduino, puedes mantener el bootloader del arduino y subir tus programas con
avrdude -F -V -c arduino -p ATMEGA328P -P /dev/ttyUSB0 -b 57600 -U flash:w:blink.hex
Este es un ejemplo para un arduino pro mini, sólo lo adaptas para al arduino que tengas
Para saber el bitrate te vas al directorio donde tienes instalado el arduino IDE y dentro de el te vas a hardware/arduino/avr
arduino-1.6.10/hardware/arduino/avr
Dentro de ese directorio te vas a encontrar 2 archivos:
programmers.txt
boards.txt
De ahí puedes obtener el bitrate para programar el arduino
## Arduino Pro or Pro Mini (5V, 16 MHz) w/ ATmega328
## -------------------------------------------------
pro.menu.cpu.16MHzatmega328=ATmega328 (5V, 16 MHz)
pro.menu.cpu.16MHzatmega328.upload.maximum_size=30720
pro.menu.cpu.16MHzatmega328.upload.maximum_data_size=2048
pro.menu.cpu.16MHzatmega328.upload.speed=57600 <------
pro.menu.cpu.16MHzatmega328.bootloader.low_fuses=0xFF
pro.menu.cpu.16MHzatmega328.bootloader.high_fuses=0xDA
pro.menu.cpu.16MHzatmega328.bootloader.extended_fuses=0x05
pro.menu.cpu.16MHzatmega328.bootloader.file=atmega/ATmegaBOOT_168_atmega328.hex
pro.menu.cpu.16MHzatmega328.build.mcu=atmega328p
pro.menu.cpu.16MHzatmega328.build.f_cpu=16000000L
## Arduino Pro or Pro Mini (5V, 16 MHz) w/ ATmega168
## -------------------------------------------------
pro.menu.cpu.16MHzatmega168=ATmega168 (5V, 16 MHz)
pro.menu.cpu.16MHzatmega168.upload.maximum_size=14336
pro.menu.cpu.16MHzatmega168.upload.maximum_data_size=1024
pro.menu.cpu.16MHzatmega168.upload.speed=19200 <------
pro.menu.cpu.16MHzatmega168.bootloader.low_fuses=0xff
pro.menu.cpu.16MHzatmega168.bootloader.high_fuses=0xdd
pro.menu.cpu.16MHzatmega168.bootloader.extended_fuses=0x00
pro.menu.cpu.16MHzatmega168.bootloader.file=atmega/ATmegaBOOT_168_diecimila.hex
pro.menu.cpu.16MHzatmega168.build.mcu=atmega168
pro.menu.cpu.16MHzatmega168.build.f_cpu=16000000L
Te dejo un makefile que usa como compilador el avr-gcc, junto con dos ejemplos que hacen D13 genere un tren de pulsos de periodo 100us
blink.c
#define F_CPU 16000000UL
#include <avr/io.h>
#include <util/delay.h>
int main(void)
{
DDRB |= 0B00100000;
while(1) {
PORTB |= 0B00100000;
_delay_us(50);
PORTB &= 0B11011111;
_delay_us(50);
}
}
interrupt.c
#define F_CPU 16000000UL
#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
void timer0_init()
{
//TCCR0B |= (1 << CS02)|(1<< CS00);
TCCR0B |= (1<< CS01) | ( 1 << CS00);
TCNT0 = 243;
TIMSK0 |= (1 << TOIE0);
sei();
}
ISR(TIMER0_OVF_vect)
{
PORTB ^= 0B00100000;
TCNT0 = 243;
}
int main(void)
{
DDRB |= 0B00100000;
timer0_init();
while(1) {}
}
Makefile (compila los dos proyectos al mismo tiempo)
all: blink.hex interrupt.hex
.SUFFIXES: .elf .hex .eep .lss .sym .upload .dsm
#CPU=m328p
CPU=atmega328p
XTAL=16000000 #Arduino 3.3v Pro
CFLAGS=-DTXBUFBITS=8 -DRXBUFBITS=8 -O
.elf.dsm:
avr-objdump --disassemble -S $^ >$@
.c.s:
avr-gcc $(CFLAGS) -Wall -mmcu=$(CPU) -S $^ -o $@
MAP=-Wl,"-Map" -Wl,"$@.map" -Wl,"--cref"
.c.o:
avr-gcc $(CFLAGS) -Wall -mmcu=$(CPU) $< -o $@ -c
.elf.hex:
avr-objcopy -O ihex -R .eeprom $< $@
blink.elf: blink.o
avr-gcc $(CFLAGS) -Wall -mmcu=$(CPU) $^ -o $@
interrupt.elf: interrupt.o
avr-gcc $(CFLAGS) -Wall -mmcu=$(CPU) $^ -o $@
clean:
rm -rf *.o *.elf *.map *.hex
-
Buenas. Realmente aprovechando el bootloader de arduino no te hace falta ningún programador externo, desde el propio arduino puedes cargar programas vía USB/USART. Así que si lo que quieres es programar en C o asm no tendrás problemas. Tendrás que usar el avrdude para gestionar la carga de programas, para linux hay bastante info si tienes dudas coméntalo por aquí. Para compilar los programas en C necesitarás avr gcc.
-
Para empezar con Atmel, lo mejor es una placa Arduino UNO:
(http://www.arduino.org/media/k2/galleries/90/A000073-Arduino-Uno-SMD-1front.jpg)
Tiene programador integrado (comunicación USB-serial + Bootloader) y un precio buenísismo (en los chinos)
Además podrás encontrar todo tipo de ayuda desde lo más básico.
Si te gusta controlar todo, puedes programar la placa directamente con gcc (gratuíto, libre, muy potente y totalmente funcional) y avrdude.
Si quieres hacer algo rápido, con el IDE es muy sencillo.
Un saludo.
-
Para programar otros Atmel o programar un micro Atmega fuera de la placa Arduino, puedes utilizar una placa Arduino o, mejor aún, un USBAsp:
(http://d1gsvnjtkwr6dd.cloudfront.net/large/AC-PG-USBASP_LRG.jpg)
Es muy barato y para empezar tendrás más que suficiente.
Saludos.
-
.
Mucho mejor un Teensy (Kinetis), que también lo puedes trabajar desde Arduino, y es mucho más potente. Hoy me ha llegado el nuevo Teensy 3.6, una pasada de bicho, también tengo el 3.2 y van geniales, ambos llevan bootloader, no necesitan programador.
Otra buena opción son los STM32.
-
Gua :-) ((:-))u muchas gracias por las buenas respuestas y apoyo...
Mil gracias a todos a Picuino, Snaut, tsk por el buen tutorial de comandos, a PalitroqueZ por la sugerencia del arduino Uno como programador, stk500 por tu consejo ..mil gracias a todo, esta mañana estuve por mi ciudad buscando materiales y esto es lo que encontré, para empezar:
(https://http2.mlstatic.com/atmega16-16pu-atmega-16-16pu-D_NQ_NP_936411-MLV20554693215_012016-F.jpg)
(http://app.webhub.la/media/uploads/store/d53a10d0-aafc-48c5-8035-f8ff7ea947d9.png)
(http://www.hobbyist.co.nz/sites/default/files/arduino-dccduino.jpg)
Y este
(http://blog.sitepoint.sk/wp-content/uploads/2016/03/usbasp.jpg)
Y bueno en la parte de software instale el Eclipse con el AVR plugin siguiendo este tutorial:
https://www.youtube.com/watch?v=lP4BRa2VJFA (https://www.youtube.com/watch?v=lP4BRa2VJFA)
Bueno ahi voy, mañana trataré de escribir el hola mundo y comenzar, aca postearè mis inquietudes y resultados..de nuevo agradezco ejemplitos que hallan por ahí para ir trasteando..mi horario para dedicarle es de 8 a 10 am hora Colombiana.
Ahora en la noche hecharé una ojeada a todos los links que me han dado ((:-))
Saludos.
-
Bueno sigo investigando un poco más y encontré esta página:
http://www.avr-tutorials.com (http://www.avr-tutorials.com)
Hay muy buena información :-)
..sigo buscando..
Edit1: Bueno buscando encontré este valiosisimo tutorial hecho por nuestro amigo Felix, que de paso agradezco enormemente y lo mejor aún funciona el link.. ((:-)) ((:-)) ((:-)) ((:-)) Felix mil gracias. ;-)
https://dl.dropboxusercontent.com/u/24861335/Felixls/tutoriales/TutorialAVRdesde0.pdf (https://dl.dropboxusercontent.com/u/24861335/Felixls/tutoriales/TutorialAVRdesde0.pdf)
saludos
-
Bueno, hola a todos.
Hoy primer dìa y queriendo hacer el primer hola mundo en Atmel :mrgreen:..me han surgido algunos problemas y dudas, por ejemplo:
tsk escribió:
Con eso podrás programar por ejemplo un attiny85 con
Código: [Seleccionar]
avrdude -p t85 -B 4 -c usbasp -U flash:w:blink.hex
Ya hice la prueba y agregue el archivo con la linea paraq que el avrdude me reconozca el usbasp, y hasta ahi todo va bien.
Conecto el usbasp a mi primer montaje con un Atmega16 que consiste en solo encender un led por el puerto D; acá el programa:
//#define F_CPU 10000000
#include <avr/io.h>
//#include <util/delay.h>
int main(void)
{
DDRD |= 0B00100000;
while(1) {
PORTD |= 0B00100000;
// _delay_us(50);
//PORTD &= 0B11011111;
// _delay_us(50);
}
}
Como ven, comenté algunas lineas entre ellas la de la frecuencia del procesador ya que el compilador me daba un warning, investigué un poco el posible motivo y puedo suponer que tiene que ver con la configuración de los fusibles del micro, y según el tutorial de Felix por defecto el Atmega8 viene on osc interno a 1 MHZ, me imagino que con el que uso debería ser igual ya que en el datasheet no veo nada especificado. Ahora las preguntas: :shock: :lol:
He leído que no es aconsejable usar el pin Reset como un puerto normal de salida ya que tendríamos que volver a programar los fuses del micro para volver a usarlo, esto es verdad? y como debo escribir la configuración de los fusibles en el programa o se hace aparte?
Hasta ahora no he querido programar el Atmega con el hex del ejemplo por temor a lo anterior.
Otra pregunta que tiene que ver con el Eclipse. lo instalé en mi portatil que tiene el mismo sistema operativo que este viejo PC,Linux Mint Sarah 64bits y lo curioso a la hora de crear un nuevo proyecto no me deja seleccionar el micro, sólo aparece la frecuencia del cristal, ya he desistalado el eclipse, reinstalado todo, los plugins y sigue igual, ya he investigado esto y parece que nadie ha podido solucionar esto, alguien sabe alguna sugerencia?
He estado leyendo el datasheet del Atmega16 y valla que es muy versatil para la época en la que salió y aún hoy en día :mrgreen:..
Agradezco mucho sus buenos consejos y enseñanzas, una pena no haber comenzado con esta familia hace años...como me está gustando estos micros ((:-))
Saludos
-
los fuses lo puede programar claro, el Reset si lo programa en el ISP, cuando lo vuelva a programa via ISP no te va a funcionar, yo siempre dejo el pin RESET con una Resistencia de 10K al +5v, buscate un Tutorial de AVR GCC,
Te aconsejo que use el buscador del Foro, y si la informacion esta perdida por algun link avisame y la busco o la subo, Tengo un Tutorial, pero subir a una pagina no me atrevo y hoy en dia no me gustaria hacerlo...
Saludos y nos comenta...
-
Ok Stk500, mil gracias me pongo en la tarea.
:-)
Saludos
-
Hola!! Estuve leyendo en este tema para mi es mejor que intale studio7 estas muy buenos y es gratis en ATMEL. :-/ :-/
Para aprender y practicar el tutorial muy buenos te dejo en este link. :P
http://microcontroladores-mrelberni.com
Saludos!!
-
Ok Stk500, mil gracias me pongo en la tarea.
:-)
Saludos
Aqui te pongo un Link en español, con el tutorial AVR GGC para Linux, aunque yo no uso Linux ;-)
pero se' que te va a servir muchos y te saca de dudas
http://www.linuxfocus.org/Castellano/Archives/lf-2004_11-0352.pdf
Aqui te dejo un link para calcular los Fuses, asi sabra cuando le hace cambios a los Fuses y ponerlo en previo o DEFAULT..
http://www.engbedded.com/fusecalc/
Espero te sirva!!!
Saludos
-
Ok Stk500, mil gracias me pongo en la tarea.
:-)
Saludos
Aqui te pongo un Link en español, con el tutorial AVR GGC para Linux, aunque yo no uso Linux ;-)
pero se' que te va a servir muchos y te saca de dudas
http://www.linuxfocus.org/Castellano/Archives/lf-2004_11-0352.pdf
Aqui te dejo un link para calcular los Fuses, asi sabra cuando le hace cambios a los Fuses y ponerlo en previo o DEFAULT..
http://www.engbedded.com/fusecalc/
Espero te sirva!!!
Saludos
Mil gracias, ya hoy le damos el hola mundo al Atmega16 :-/ ..de nuevo gracias a todos por sus aportes al foro y a este tema ((:-))
saludos
-
Hola Atmel16...
((:-)) ((:-))
Feliz de la vida :-/ :-/ ((:-))
Muchas gracias sacaré un espacio para sacar un buen tutorial..
Saludos
-
me alegro que le tenga el gustazo a los atmel ya!!! :P
Saludos
-
Si te sirve de dato, hice mi primer imcursión en los atmel con un arduino nano v3 que aprendí a programar directamente en C. El lenguaje de arduino me limitaba con el asunto de las interrupciones.
Después me compré varios atmega328 y attiny2313 con encapsulado pdip, y no use más el arduino. Habia iniciado el asunto en un linux ubuntu con la ide de arduino instalada, como funcionó, complete instalando el avr-gcc y lo manejaba salvajemente desde la línea de comando, según las indicaciones de:
https://balau82.wordpress.com/2011/03/29/programming-arduino-uno-in-pure-c/
Suelo cargar sus programas con bootloader que supe encontrar a 1, 4 y 8mhz, sin cristal externo. Optiboot es la palabra para su busqueda por la web. Empleando esas interfases usb-serial/ttl (ft232 y yerbas)
-
Si te sirve de dato, hice mi primer imcursión en los atmel con un arduino nano v3 que aprendí a programar directamente en C. El lenguaje de arduino me limitaba con el asunto de las interrupciones.
Después me compré varios atmega328 y attiny2313 con encapsulado pdip, y no use más el arduino. Habia iniciado el asunto en un linux ubuntu con la ide de arduino instalada, como funcionó, complete instalando el avr-gcc y lo manejaba salvajemente desde la línea de comando, según las indicaciones de:
https://balau82.wordpress.com/2011/03/29/programming-arduino-uno-in-pure-c/
Suelo cargar sus programas con bootloader que supe encontrar a 1, 4 y 8mhz, sin cristal externo. Optiboot es la palabra para su busqueda por la web. Empleando esas interfases usb-serial/ttl (ft232 y yerbas)
Muchas gracias por la ayuda. :)
Ahora tengo una duda, cuando uso la función _delay_ms(), parece que no funcionara correctamente, entiendo que no da más de 250ms usando el inRC a 1MHz, pero me da la sensación que no llega ni a eso he medido y obtengo una frecuencia en el puerto DDRD0 de 7Hz con los 250ms, por supuesto agrego #define F_CPU 1000000 antes de agregar la libreria delay, y cuando compilo me da un warning sin errores..no se si es que me falta configurar algo en el compilador o es algo que tenga que ver con los fuses que aún no toco..
Alguna sugerencia se los agradezco mucho.
Saludos.
-
Que raro que no te den los tiempos, estás midiendo en tiempo real ¿no?, en el simulador, nunca funcionan,
Al #define F_CPU xxxxxx lo suelo poner antes que cualquier cosa en mi código.
Subi en un archivo de texto comprimido esas advertencias de tu compilador.
-
Que raro que no te den los tiempos, estás midiendo en tiempo real ¿no?, en el simulador, nunca funcionan,
Al #define F_CPU xxxxxx lo suelo poner antes que cualquier cosa en mi código.
Subi en un archivo de texto comprimido esas advertencias de tu compilador.
Hola.
Bueno parece ser que le problema es el compilador, por que con el Eclipse funciona los tiempos definidos muy bien..parece que hay que configurar bien el codeblocks, o podría ser un bug de la versión 16.01..ya veremos..
Por estos días he estado ocupado en actividades familiares, solo hasta hoy volví para ver cuál era el problema..ya comienzo a escalar con esta maravilla de procesadores,,,,seriamente estoy muy contento con esta familia... :-) :mrgreen: ((:-))
Gracias y a estudiar...
Saludos
-
Te dejo un enlace mio: http://elecrab.com/tutoriales para empezar con atmel de 8 bits que no he continuado escribiendo.
Los microcontroladores de 8 bits están bien para empezar y tener una idea de que es un microcontrolador, pero a partir de ahí te recomiendo que mires otro tipos de microcontroladores como ARM Cortex-M que te darán muchas más posibilidades de proyectos, y a día de hoy es lo que más se usa.
Saludos.
-
Muchas gracias Jorge555..si sigo con mi estudio de esta familia creo que en unos pocos meses estaré con los ARM que es la idea que también tenía.. :D..y gracias por tus tutoriales....
Saludos.
PD: Una pena el enlace no va :? ..si la tienes actualizada o los tutoriales por ahí a la mano te los agradecería enormemente.
Saludos
-
Si funka la página de de Jorge. Dale al botón menú y aparecen los enlaces.
Esos micros ARM tienen la contra que no hay variedad en encapsulado pdip. Ahi queda excluido el "hobbista".
En Argentina supe encontrar algunos en esas plaquitas de prototipos. Pero no me decido, más bien porque no tengo la necesidad. Aunque si la curiosidad.
Para lo único que se me viene a la cabeza uN ARM en caso es investigar un medidor de energía o un voltímetro/amperímetro true RMS empleando el conversor de 12bit y más frecuencia de muestreo que suelen tener.
Con esto del ADC los Atmega328p vienen en desventaja frente a los pic, resulta que tienen una velocidad menor de muestreo.
Aunque segun dicen se comportsn mejor frente al ruido. Cosa que experimentaré porque tengo un cacharro con pic que no anda ni para atrás. Es un velocímetro de cadencia. Cuando enciendo el motor de la moto, enloquece....
-
Hola de nuevo.
Ya solucioné el problema con el CodeBlocks, que creo que va a ser el que voy a usar..
La solución es la siguiente:
Aclaro que tengo la versión 16.01.
Me voy a: Settings >> Compiler
Acá se supone que debemos tener seleccionado el "GNU GCC Compiler for AVR"
luego seleccionamos la pestaña "Search directories" luego en "Compiler" y editamos la ubicación asi:
Está es "/usr " y editamos asi: "/usr/lib/avr/include/avr" ..queda este punto asi:
(http://img.photobucket.com/albums/v672/marvicdigital/Pantallazo-2016-11-08%2010-51-38.png)
Luego seleccionamos la pestaña continua llamada "Linker" y editamos con lo siguiente:
"/usr/lib/avr/lib/"
(http://img.photobucket.com/albums/v672/marvicdigital/Pantallazo-2016-11-08%2010-53-23.png)
Pongan tal como está la imagen sin poner demás un "/" ......Espero sirva de ayuda..
Saludos
-
Hola de nuevo, voy a poner el siguiente código para saber si se puede mejorarñ se trata de usar un sw rotatorio, uso la referencia KY-040 para arduino:
Uso el puerto D de la siguiente forma:
D0 = salida hacia un led indicando la dirección hacia la derecha
D1= Salida hacia un led indicando la dirección hacia la izquierda
D6= entrada A del Sw activando las pullups y agregando un RC para los antirebotes.
D5= entrada B del Sw activando las pullups y agregando un RC para los antirebotes.
Como no me he podido acostumbrar a usar los puertos con el desplazamiento de bits y de usar mascaras decidí usar una estructura de manejo de bits, si hay alguna sugerencia para hacerlo más corto y comodo acepto sugerencias. :mrgreen:
#define F_CPU 10000000UL
#include <avr/io.h>
#include <util/delay.h>
typedef struct DDDbits_t{
unsigned char dd0 :1;
unsigned char dd1 :1;
unsigned char dd2 :1;
unsigned char dd3 :1;
unsigned char dd4 :1;
unsigned char dd5 :1;
unsigned char dd6 :1;
unsigned char dd7 :1;
}volatile *DDDbits;
typedef struct PDbits_t{
unsigned char PO0 :1;
unsigned char PO1 :1;
unsigned char PO2 :1;
unsigned char PO3 :1;
unsigned char PO4 :1;
unsigned char PO5 :1;
unsigned char PO6 :1;
unsigned char PO7 :1;
}volatile *PDbits;
typedef struct PINDbits_t{
unsigned char PI0 :1;
unsigned char PI1 :1;
unsigned char PI2 :1;
unsigned char PI3 :1;
unsigned char PI4 :1;
unsigned char PI5 :1;
unsigned char PI6 :1;
unsigned char PI7 :1;
}volatile *PIDbits;
#define PORTDbits (*(PDbits)_SFR_MEM_ADDR(PORTD))
#define DDRDbits (*(DDDbits)_SFR_MEM_ADDR(DDRD))
#define PINDbits (*(PIDbits)_SFR_MEM_ADDR(PIND))
#define INPUT 0
#define OUTPUT 1
#define ON 1
#define OFF 0
void configurar_puertos();
void configurar_puertos(){
DDRDbits.dd0=OUTPUT;//Puerto D0 como salida.
DDRDbits.dd1=OUTPUT; //Puerto D1 como entrada.
DDRDbits.dd5=INPUT; //D5 entrada
DDRDbits.dd6=INPUT; //D6 Entrada
PORTDbits.PO5=ON; //Activamovs PULL-UP en el puertoD5.
PORTDbits.PO6=ON; //Activamovs PULL-UP en el puertoD6.
}
#define Encoder_A PINDbits.PI6
#define Encoder_B PINDbits.PI5
int main(void)
{
// Insert code
configurar_puertos();
_delay_ms(100);
while(1){
if(Encoder_A==0){ //Gira el encoder hacia
if(Encoder_B==0){ // la derecha?
PORTDbits.PO0 = ON;
_delay_ms(100);
}
}
if(Encoder_A==1) { //Gira el encoder hacia
if(Encoder_B==0){ // la izquierda?
PORTDbits.PO1 = ON;
_delay_ms(100);
}
}
PORTD &= ~(1<<PD0); // no he podido aprenderme este método
PORTD &= ~(1<<PD1);
}
return 0;
}
Las estructuras las aprendí por estos días en un blog y con el fabuloso tutorial de Avr de Felix 8)..
Saludos y agradezco sugerencias que me puedan enseñar.
-
Buenas gente, Les tengo una consulta, Tengo Windows 10 y quisiera saber a traves de que harware puedo bajar el programa del Eclipse al AVR. ¿Sera que el usbasp sera suficiente para esto?
El Eclipse ya lo tengo preparado con su plugin de AVR. Es mas, el programa lo simulo en Proteus, pero ya es hora de poder verlo funcionar de enserio.
De nuevo, Gracias y Saludos.
-
Que tal MaiJuanEm,
Para realizar la programación del AVR (bajar el archivo hex a la memoria del microcontrolador); como bien mencionas necesitas del programamdor USBasp. Pero el software de programamción es el AVRDude y existe un IDE para este que se llama AVRDUDESS. Creo que el AVRDude, lo puedes integrar a Eclipse, pero yo nunca lo he usado así. Puedes buscar en el interner cómo integrar el AVRdude a Eclipse, hay bastente información al respecto.
Pero lo más sencillo es usarlo con su "propio" IDE, que es el AVRDUDESS.
Saludos,
elreypic.