Exploración de los conceptos básicos del microcontrolador

Una cosa es genial acerca de los circuitos integrados de microcontroladores, estos están disponibles en casi todas partes del mundo y minoristas electrónicos.

Introducción

Fundamentalmente, los dispositivos microcontroladores se utilizan popularmente en aplicaciones que implican evaluaciones del entorno circundante y en componentes electrónicos similares.

Puede encontrar que estos dispositivos se utilizan para mostrar un determinado parámetro, en aplicaciones de control de motores, iluminación LED, sensores de varios tipos, como sensor de inclinación, acelerómetro, medidor de velocidad, registradores de datos, controladores de temperatura, teclados, etc.

La comprensión principal con respecto a los microcontroladores se puede obtener refiriéndose al microcontrolador AVR Amega32, que es tan avanzado que a veces se le llama computadora dentro de un chip.

Este dispositivo está asignado para ejecutar una serie de comandos para formar un programa.

El lenguaje del programa que verá aquí es C ++. Podrás aprender este idioma con mayor profundidad en el curso aquí.

Cuando se trata de MCU, tiene la posibilidad de tener la opción de controlar y configurar todos sus pines.

Si se está cansando un poco con esto, simplemente relájese porque no es nada complejo en absoluto, se le facilitarán todos los aspectos de manera constante pero firme a medida que avancemos.

En un chip MCU, todos los pines, excepto Vdd y Vss, que son los pines de alimentación del chip, pueden asignarse con designaciones exclusivas.

Detalles de Pinout

Si miras el chip desde la parte superior, encontrarás una pequeña muesca triangular que indica el punto de partida desde donde comienzan los pines, es decir, el pin # 1 del chip comienza justo debajo de esta muesca.

A partir de este pin, encontrará 20 pines hasta la parte inferior en ese lado (izquierda) y otros 20 pines en el otro lado (derecha), continuando de abajo hacia arriba en el lado derecho.

Los primeros 8 pines que comienzan desde la muesca son los PBO-7 que forman los pines índice del IC, ya que todos los programas aquí comienzan con el índice cero.

La serie de pines anterior se denomina PUERTO B, mientras que hay otros conjuntos idénticos de puertos asignados de A a D.

Estos puertos podrían asignarse para aceptar y reconocer un dato alimentado llamado INPUT, y también para transmitir datos en alguna forma específica llamada OUTPUT.

Dos de los pines que vienen en la categoría general son los pines (+) / (-) que también se conocen como Vdd y GND.

Se puede ver un pin del PUERTO D (PDO-6) ubicado en el lado izquierdo del chip en el área inferior.

PD7, que es el pin # 7 del PUERTO D, se puede rastrear de forma independiente y comenzando la serie de pines del lado derecho.

Ahora avanzando desde el lado derecho del chip donde termina el PUERTO D, el PUERTO C comienza a contar hacia arriba en el orden.

Estos contribuyen a los muchos pines interesantes del MCU desde los analógicos hasta los digitales.

Estos pines se ofrecen para convertirse en entradas de detección para detectar los muchos parámetros a través de etapas de circuito analógico configuradas externamente.

Los pines anteriores constituyen el PUERTO A.

La conversión de analógico a digital a través de los pines anteriores podría entenderse con la ayuda de un ejemplo en el que un nivel de temperatura analógica detectado usando un sensor ordinario, como un termistor, se aplica a uno de los pines del PUERTO A que es fácilmente aceptado y convertido por el MCU para producir una lectura digital de cero a 255 grados F (una cifra de 8 bits que podría actualizarse para lograr una salida de 10 bits).

Otra característica que podría observarse adicionalmente en las MCU es el espacio de programación disponible o la memoria que determina el espacio para las variables y el programa especificado para el microcontrolador.

Además de esto, las MCU tienen un reloj incorporado asignado para contar los parámetros relevantes.

Las características del reloj permiten que la MCU se aplique a sí misma para muchos procesos de conteo diferentes que podrían ser rápidos en el rango de microsegundos dependiendo de la especificación del dispositivo particular, y también podrían ser más lentos en cualquier extensión deseada.

A estas alturas, es posible que haya entendido el concepto de microcontrolador hasta cierto punto y con respecto a sus puertos y pines.

Cómo crear un conector SPI desde el programador al microcontrolador

Ahora es el momento de profundizar un poco más en el tema e investigar el mundo de la programación.

Dicho esto, antes de realizar un procedimiento de carga de programa en el chip, debemos encontrar una forma adecuada de integrar el conector SPI (interfaz periférica en serie) con la MCU.

Sin embargo, incluso después de esto, no podemos simplemente presionar el SPI en los pines de MCU, ¿verdad? Tampoco podemos permitir que los cables extendidos del SPI se inserten directamente en la placa de pruebas. Esto también puede causar una configuración incorrecta de los cables conectados con los pines incorrectos que hacen malas conexiones.

Por lo tanto, para hacer las cosas absolutamente impecables, realizamos los procedimientos en un pequeño tablero en el que obtenemos los pines metálicos de conexión requeridos, también llamados 'encabezado' soldados. Estos pines de encabezado ahora podrían usarse para conectarse con el conector SPI. Las conexiones de este encabezado pueden terminarse en otros pines de encabezado paralelo que se pueden usar para las conexiones de la placa de pruebas.

Por lo tanto, el conjunto anterior ahora forma una plataforma de conexión intermedia cómoda y confiable para el SPI al MCU.

Upil ahora todo se ve bien y perfecto, así que pasemos a ganar con respecto al programador que se requiere entre su PC y la MCU.

Podría haber una gran cantidad de empresas que fabrican y venden estas unidades de programación, por lo que adquirirlas no debería ser un problema para usted, como Adafruit Industries, USBtinyISP o Sparkfun, etc.

Algunos de estos podrían verse completamente diferentes a los tipos convencionales, pero básicamente tienen todo idéntico y siguen las reglas de programación estándar y pueden usarse como una interfaz entre su PC y el microcontrolador AVR.

Sin embargo, asegúrese de pensar, si está utilizando alguna otra MCU y no un AVR Atmega32, es posible que deba buscar un programador compatible correspondientemente para ese chip MCU en particular.

Puede observarse que bastantes de estos programadores emplean controladores idénticos, algo de lo que hay que ocuparse y aprenderemos más sobre ello en los capítulos siguientes.

Conectar su PC con el chip microcontrolador es realmente básico, y le encantaría saber lo sencillo que se requieren los procedimientos para ello. Así que presionemos el botón de inmediato.

Hacer la placa de interfaz SPI explicada anteriormente no es difícil, se trata de hacer que su soldador funcione a través de todas las conexiones en las dos filas de pines de encabezado que se muestran en una pequeña placa de uso general.

La figura anterior muestra los detalles de conexión que tendría que seguir al interconectar los cables entre los encabezados.

Para simplificar aún más las cosas, repasemos los siguientes detalles de conexión para el mismo consultando la imagen de arriba:

El pin SPI que comienza desde la parte superior izquierda va al 'Master IN, Slave OUT' (MISO)

El pin SPI del centro a la izquierda se conecta con el pin del reloj (SCK)

El pin SPI en la parte inferior izquierda se une con el Reset. (Aprenderemos detalladamente sobre este pin en los siguientes tutoriales)

SPI relevante a la parte inferior derecha se conecta con el pin GND de la MCU, GND se refiere al pin que forma la línea de suministro cero o el riel negativo (relativo) del suministro.

SPI que termina en el encabezado medio derecho se enlaza con el pin 'Master Out, Slave IN' (MOSI) de la MCU.

El SPI que sale del encabezado superior derecho está conectado con el (+) de la MCU, que es obviamente el Vdd o el pin de suministro positivo de la MCU.

Eso es.

Conecte los dos conectores como se explica y su placa de interfaz SPI estará lista para las acciones necesarias.

Para obtener más ayuda, puede consultar la figura que se muestra arriba, su placa de interfaz final debería verse así después de que todas las conexiones de cables se hayan realizado correctamente con la ayuda de la discusión anterior.

Espero que ya haya construido la interfaz SPI como se explicó en el tutorial anterior, y ahora es el momento de asegurarnos de que nuestra computadora acepte el programador que necesitamos integrar entre la PC y la MCU.

Hacer un código de programación simple para una MCU

Tomamos una unidad USBTinyISP disponible en Sparkfun, para vincular la computadora con el microcontrolador.

Sabemos que cualquier sistema operativo de computadora, como Windows, requerirá controladores sin los cuales sería inútil cargar nada en la computadora, por lo que nuestro programador necesitará controladores para cargar en su computadora.

Echemos un vistazo a los procedimientos necesarios para instalar los controladores en el sistema operativo de su computadora, aquí tomamos el ejemplo del sistema operativo Windows 7 con especificaciones de 32 bits o 64 bits.

Abra sparkfun.com y haga clic en 'Pocket AVR programmer page'. El enlace se puede visualizar fácilmente dentro de la página.

A continuación, busque 'controlador de Windows' en documentos y simplemente haga clic en él.

Esto le proporcionará el archivo pocketprog-driver.zip en su computadora.

Vaya a su computadora, busque la ubicación de descarga y simplemente descomprima el archivo descargado en una carpeta.

En caso de que su computadora sea un sistema operativo de 64 bits, debe seguir algunos pasos más como se indica a continuación, con un sistema operativo de 32 bits, puede comenzar directamente la instalación desde el archivo descomprimido.

Para 64 bits, siga estos, para 32 bits simplemente ignore:

Busque en Google 'libusb sourceforge' y haga clic en la última versión de este enlace.

Encontrará algunos archivos adicionales, sin embargo, le interesaría encontrar el archivo bib, es decir: libusb-win32-bin - #. #. #. #. Zip

Ahora, busque esta ubicación de descarga en su computadora, descomprímala y guárdela en una de las carpetas.

En esta carpeta, navegue sobre la carpeta bin, procediendo a la carpeta amd64.

Vería un par de carpetas aquí como: ghcalled libusb0.dll y libusb0.sys.

Querría cambiarles el nombre como: libusb0_x64.dll y libusb0_x64.sys.

Ahora deberá copiar los archivos anteriores en la carpeta pocketprog-driver, simplemente sobrescriba los archivos en la versión existente.

Para instalar los controladores anteriores, le interesaría el siguiente método, que es bastante poco convencional en su tipo:

Es un modo de 'agregar hardware heredado'.

Haga clic en 'Menú de inicio'

Luego proceda haciendo clic derecho en 'computadora'

Haga clic en 'Administrar', y finalmente haga clic en 'administrador de dispositivos'

A continuación, dentro del menú, elija 'Agregar hardware heredado'

Continúe presionando 'siguiente', hasta que se inserte el asistente

Siguiendo las instrucciones, haga clic en 'Instalar el hardware que necesitaría seleccionar de una lista Avanzada', esto hará que el icono del botón de radio ingrese a esa selección en particular. En realidad, es un botón de control de Windows que ahora aparecería como un círculo diminuto con un borde azul redondeado en su interior.

Ahora simplemente haga clic en 'Siguiente'

Esto le mostrará el menú 'Mostrar todos los dispositivos' en el que deberá hacer clic.

Después de esto, haga clic en el icono 'Utilizar disco'.

Con la ayuda del icono 'Examinar', vaya a la ubicación de la carpeta pocketprog-driver. Si la selección fue realizada correctamente por usted, visualizaría el archivo pocketprog.inf ubicado en esa carpeta en particular.

Haga doble clic sobre este archivo y seguramente verá cómo se instala el controlador en su PC.

¡¡Cambio y fuera !! Sigamos con nuestro próximo tutorial en la página siguiente.

A estas alturas, es posible que haya instalado el software necesario y haya creado la interfaz SPI.

Cómo transferir un programa a un chip de microcontrolador

El siguiente paso requerirá algunos componentes, como una placa de pruebas, un LED y una resistencia calculada para la aplicación prevista.

En esta sección, aprenderemos el método de prueba del programador y confirmaremos la instalación de los controladores y el software relevantes.

Para verificar si los controladores y el software se instalaron correctamente, implementaremos un programa simple conocido como avrdude.

El AVRdude es un programa asociado con la última instalación de WinAVR sin el cual la transferencia real del archivo a la MCU no puede ser posible.

Este programa es un formato de archivo .hex que esencialmente se vuelve comprensible para la MCU para las ejecuciones requeridas.

En caso de que la verificación no sea exitosa, el programador no podrá realizar la transferencia del archivo.

Veamos rápidamente cómo podemos implementar el procedimiento de prueba con la ayuda de las siguientes instrucciones:

Abra el indicador de DOS (sistema operativo de disco) haciendo clic en 'menú de inicio' y escribiendo cmd.exe en el cuadro de búsqueda dado.

Ahora, la ejecución del AVRdude se puede realizar simplemente escribiendo avrdude –c usbtiny –p m32 sobre el indicador de DOS. Tan pronto como esto se implemente, el DOS reconocerá instantáneamente si la conexión fue exitosa.

En el comando anterior, '-c' es una bandera de notificación que incluye la especificación del parámetro del programador 'usbtiny', mientras que la etiqueta '-p' identifica el dispositivo microcontrolador ('m32 indica Atmega32).

En caso de que haya utilizado una MCU diferente, deberá incluir los prefijos relevantes para la implementación.

Una vez finalizado el procedimiento anterior, puede escribir 'salir' sobre el indicador de DOS, y eso lo sacará de la ventana.

Si se está preguntando seriamente con respecto a los detalles de programación reales, bueno, para eso primero necesitaríamos soldar y construir el circuito LED analógico externo sobre el cual se podría implementar el programa, porque a menos que haya un sistema para reconocer la respuesta del MCU, la programación y el funcionamiento del microcontrolador no tendría ningún sentido.

Hacer la placa LED es muy simple, se trata de soldar los dos cables del LED sobre una pieza de veroboard y conectar la resistencia con uno de los cables del LED. La función de este LED es solo limitar la corriente al LED para que no se queme debido al exceso de voltaje y corriente de la salida de la MCU.

El valor de la resistencia se puede calcular utilizando la siguiente fórmula simple:

R = (Ub - LEDfwd) / I

Donde Ub es el voltaje de suministro, LEDfwd es el voltaje de funcionamiento óptimo del LED utilizado e I son sus amperios óptimos.

Supongamos que usamos un LED ROJO que tiene un voltaje directo de LED = 2.5V y corriente I = 20mA, la ecuación anterior se puede resolver de la siguiente manera:

Dado que el voltaje de MCU sería de 5 V, se puede expresar como:

R = (5 - 2.5) /. 02 = 125 ohmios, ¼ vatio, el valor más cercano es 120 ohmios.

Ahora tenemos el LED, una resistencia de 120 ohmios y un veroboard, simplemente interconecte los componentes anteriores como se indica en el diagrama con el microcontrolador.

Una vez hecho esto, la MCU podría programarse para la respuesta prevista en la configuración de LED anterior.

A continuación, la programación de la MCU.

Para permitir que el microcontrolador realice algunas implementaciones significativas, es imperativo escribir las instrucciones adecuadas en la MCU.

Cómo instalar un entorno de programación e investigar WinAVR

Para esto, probablemente podríamos usar nuestro propio 'editor de texto' en nuestra PC, aunque muchos de nosotros apreciaríamos el uso de un 'entorno de programación' más profesional en lugar de un editor de texto ordinario, simple porque este enfoque le permitiría disfrutar de algunos características interesantes incorporadas dentro de este paquete de 'entorno de programación'.

Apoyaría la creación y edición de programas a través de diferentes lenguajes y también los compilaría en un modo entregable fácilmente entendido y aceptado por un microcontrolador.

En última instancia, esto sería compatible con WinAVR y transferido al chip MCU en cuestión.

WinAVR también podría estar equipado para ejecutar muchas otras operaciones, como solucionar problemas de los programas y advertirnos sobre posibles errores de sintaxis y compilación. Discutiremos estos en nuestros tutoriales posteriores.

Le gustaría que el proceso de instalación de WinAVR fuera extremadamente rápido y ágil. Profundicemos en los detalles con los siguientes puntos:

Deberá descargar las últimas versiones de la carpeta de archivos de falsificación de origen de WinAVR. Encontrará información útil relacionada con esta descarga desde su sitio web oficial.

Se le solicitará a través de una consulta de seguridad, para que pueda responder si desea que se realice la descarga, se le solicita que el archivo que se descargará es un archivo ejecutable.

Descargue el archivo y comience el proceso de ejecución haciendo clic en él. Que comience la instalación.

El proceso lo guiará con algunas preguntas que se pueden responder para que pueda simplificar la instalación según su comodidad. Debería ignorar muchos de estos en sus formas predeterminadas, todo depende de usted seleccionar los que crea que son más adecuados para las acciones.

Hasta ahora, encontraría todo bastante normal y sencillo y encontrará algunas opciones en el menú de inicio. No se preocupe, solo algunos de estos usarían solo uno de los llamados 'bloc de notas del programador'.

Una vez que haga clic en este icono, se iniciará la interfaz de usuario para que pueda aplicar la escritura de los programas (como la creación y la edición). También sería testigo del programa que consta de comandos de menú para ayudarlo a compilar los códigos e incrustarlos en el microcontrolador.

El trabajo fundamental del bloc de notas del programador anterior es transformar un código legible por humanos que estaría escribiendo en una serie de instrucciones comprensibles solo para la MCU.

El siguiente tutorial cubrirá las pruebas del programador anterior para que podamos estar seguros con respecto a su compatibilidad con Windows y si se 'da la mano' perfectamente con su microcontrolador IC.

Cómo programar una MCU para encender un LED

Una vez que esto se confirme, procederemos a crear un pequeño código de 'no hacer nada', solo para asegurarnos de que el procedimiento de transferencia de código no encuentre errores.

Por supuesto que ahora estamos listos para implementar nuestro primer programa dentro del MCU, pero antes sería interesante resumir rápidamente lo que hicimos en el transcurso de nuestros tutoriales anteriores:

Adquirimos el microcontrolador AVR Atmel de acuerdo con nuestra especificación requerida aquí, hemos usado el ATMega32 para las ilustraciones. A continuación, aprendimos sobre los conceptos básicos del microcontrolador y la unidad programadora que es responsable de transferir un programa al chip MCU.

Más adelante, construimos el conector de interfaz SP que es esencial para que su computadora se pueda vincular con el microcontrolador para las acciones de programación.

Después de esto, confirmamos si los controladores se instalaron correctamente en la computadora para un sistema operativo de 32 bits y de 64 bits.

A continuación, instalamos el entorno de programación llamado Win AVR para facilitar la escritura de anuncios y la transferencia de los códigos al microcontrolador, seguido de la implementación del avrdude para verificar el programador con su PC y el microcontrolador interconectado.

Finalmente, en el capítulo anterior terminamos de construir el circuito LED / resistor y lo conectamos con las salidas MCU relevantes.

Eso es mucho trabajo, sin embargo, ¡es hora de comenzar de inmediato con algunas cosas de programación real!

Para empezar, querríamos dividir el microcontrolador en tres categorías, esto simplificaría mucho nuestra comprensión:

Control, detección y comunicación

Sería interesante saber que las funciones anteriores se pueden programar de muchas formas diferentes.

En nuestro primer programa intentaríamos ordenarle al microcontrolador que “controle” un parámetro externo, sí tienes razón, sería el LED que construimos recientemente.

Para ser precisos, le diremos a la MCU que encienda el LED conectado, sí, sé que esto parece bastante primitivo, pero la fase de inicio siempre debe ser fácil.

Continuando con el trabajo actual, hacer que la MCU controle el LED es bastante simple:

Para esto, instruimos al pin # 0 en el PUERTO B para producir los 5V requeridos para el LED.

Recuerde del tutorial anterior, conectamos el ánodo del LED al pin mencionado anteriormente del MCU.

Hay dos cosas esenciales que deben dirigirse a este pin de la MCU: 1) salida y 2) 5 voltios

Aprenderemos una forma a través de la cual podemos instruir al pin en particular para que se convierta en la salida de la MCU.

Una vez que esté configurado para ser la salida del chip, podemos indicarle que sea 'alto' (5V) o 'bajo' (0V) según se desee para una aplicación.

Dado que cualquier circuito lógico, como un MCU, los pines podrían ser una salida o una entrada y podrían configurarse para producir un nivel lógico alto o lógico bajo, los pines solo deben asignarse para ser un alto lógico o un bajo lógico. , no hay estados intermedios o indefinidos que no sean estos dos estados para microcontroladores o para cualquier IC digital para el caso. También se aplica lo mismo para todos y cada uno de los pines de la MCU.

En cuanto a las asignaciones de pines de entrada y salida, las entradas se colocarían para aceptar señales de etapas analógicas externas, mientras que las salidas serían responsables de interpretarlas en los estados lógicos especificados, o una frecuencia.

Aunque las asignaciones anteriores podrían realizarse de muchos métodos diferentes, estaríamos discutiendo uno de ellos en aras de la simplicidad. Sin embargo, debe tenerse en cuenta que, aunque el que se presentaría en este momento parece fácil e interesante, no es tan viable y no es un tipo recomendado para todas las aplicaciones de MCU, por la misma razón, se le presentarán métodos de programación más populares más adelante en el curso. . Estos programas permitirán que solo se asignen los pines deseados según las especificaciones sin afectar a los otros contiguos que posiblemente ya estén asignados para realizar otras funciones.

Sin embargo, en este momento no nos preocuparemos tanto por los otros pines y usaríamos solo los pines relevantes de interés, evitando complicaciones hasta cierto punto.

Para asignar un pin como salida, necesitamos emplear el Registro de dirección de datos (DDR). Si se pregunta qué significa el registro aquí, es simplemente un espacio en la MCU que permite que el microcontrolador responda de una manera específica.

Usando el DDR podemos configurar el pin para enviar un dato que es como una 'salida', o aceptar datos que tienen la forma de una 'entrada'.

Sin embargo, puede estar confundido con respecto a la palabra, ¿qué implica esto? Un dato agrega una tercera dimensión a los pines que pueden asignarse para estar continuamente en cero lógico (0V) o lógico alto (5V), pero ¿qué pasa con las señales que podrían variar rápidamente, como una frecuencia de pulsos? Una frecuencia estaría acompañada de lógicas altas y bajas (5V y 0V) que oscilan con algunos intervalos o períodos especificados, por lo que se orienta al tiempo y puede ajustarse con respecto al tiempo, por eso nos identificamos como 'datos' que significa un parámetro que indica una función relativa a otra función (estados lógicos y tiempo).

Un método para asignar pin0 como salida es escribiendo el siguiente código:

DDRB = 0b00000001

En el programa anterior, DDRB significa Registro de dirección de datos para PORT B ​​0b indica al compilador con respecto a la siguiente expresión binaria de un número, mientras que el '1' al final de la expresión indica la posición del pin0, que es su ubicación en el formulario. del primer pin del PUERTO B.

Si recuerdas, aprendimos que PORT B ​​asocia 8 pines con él (de 0 a pin7), y si notas que el código anterior también tiene 8 dígitos, lo que significa que cada dígito significa estos 8 pines del PORT B.

Ahora el siguiente procedimiento sería asignar 5V a este pin (pin0). Nuevamente, el principio de funcionamiento es idéntico al DDR expresado anteriormente a través del siguiente código binario:

PORTB = 0b00000001

Como puede verse, la única diferencia entre el código anterior y el anterior es que en este código hemos hecho uso del registro PORT. Este registro maneja específicamente las asignaciones de pines de ese puerto en particular para el que se ha colocado dentro de la MCU. Por lo tanto, nos permite asignar las lógicas de datos reales (0 o 1) para esos pines.

Ahora nos puede interesar discutir algunos acerca de los detalles aproximados de nuestro programa. Como sabemos que todos los programas requieren un espacio particular para iniciar la ejecución, esto se puede comparar con un chef que conoce todos los ingredientes de una receta en particular, pero no se le indica por dónde empezar.

La función 'principal' aquí es la ubicación donde cada uno de los programas C / C ++ inicia la ejecución. Por lo tanto, el principal puede crearse como:

int main (vacío)
{
}

Sin embargo, para permitir que el programa interprete los detalles de los registros DDR y PORT y su funcionamiento dentro del chip MCU, es necesario incluir una declaración adicional que puede consistir en todos los datos relacionados con el MCU AVR. Quizás quisiéramos agregar esta inclusión en todos nuestros programas.

#incluir
int main (vacío)
{
}

Tan pronto como se inicia la compilación, la sección del preprocesador del compilador se centra en el directorio AVR para identificar el archivo 'io.h'. La extensión '.h' aquí indica que es un archivo de encabezado, y que este código dentro del archivo se introduciría al principio (encabezado) del archivo fuente que se está creando, de ahí el nombre 'encabezado'.

Aquí en adelante podemos introducir las declaraciones DDR y PORT en nuestro código, porque la adición del archivo de encabezado io.h habría dirigido al compilador con respecto a ellas.

#incluir

int main (vacío)

{

DDRB = 0b00000001 // Registro de dirección de datos configurando el pin0 a la salida y los pines restantes como entrada

PORTB = 0b00000001 // Establecer pin0 a 5 voltios

}

Lo anterior fija la orientación del pin0 como salida, teniendo una magnitud de 5V. Sin embargo, todavía hay un problema que no está determinado para este pin, y es que este pin aún no se ha instruido para que se encienda indefinidamente mientras la MCU esté encendida. Este bucle de retroalimentación infinito aseguraría que este pin de la MCU no se apague, sino que continúe con la salida de 5V indefinidamente.

Aunque hay muchos métodos diferentes para aplicar una instrucción de bucle para un pin, intentaríamos emplear el bucle 'while' aquí. Como sugiere el nombre, el bucle 'while' le dice al microcontrolador que 'mientras' la energía está disponible, debe permanecer activado con los 5V asignados para el pinout asignado.

#incluir

int main (vacío)

{

DDRB = 0b00000001 // Registro de dirección de datos configurando el pin0 a la salida y los pines restantes como entrada

PORTB = 0b00000001 // Establecer pin0 a 5 voltios

mientras (1)

{

// El código estaría aquí si tuviera que ejecutarse una y otra y otra vez ... interminablemente

}

}

Es posible que desee tener en cuenta que, aquí hemos utilizado '1' en la forma de un argumento para el ciclo 'while', ya que todo excepto '0' podría considerarse un 'verdadero' lógico.

Eso implica que la consideración del bucle 'while' nunca sería responsable de nada excepto de un 'verdadero' lógico, lo que significa que el pin en particular se engancharía con el estado especificado indefinidamente.

Se puede observar que el LED está ENCENDIDO a través del pin asignado permanentemente siempre que la MCU reciba energía a través de su Vdd y Vss.

Eso es todo, ahora tenemos el resultado que deseábamos obtener y finalmente podemos ver que suceda después de tanto trabajo duro, pero sin embargo, ver el dulce resultado de nuestro arduo trabajo es muy satisfactorio.

En los próximos tutoriales, aprenderemos cómo agregar una dimensión de 'tiempo' al LED anterior, es decir, cómo hacer que parpadee a una velocidad determinada.

En realidad, en la implementación anterior, el LED está parpadeando, pero la velocidad del bucle es tan rápida que es casi como un encendido permanente sobre la iluminación del LED.

Veremos cómo se puede agregar este bucle con un retraso según se desee para que el LED parpadee a ese ritmo de retraso.

Cómo hacer que un LED parpadee usando un microcontrolador AVR

En la última discusión, aprendimos cómo encender un LED a través de un microcontrolador, fue excelente, ¿no? ¡Puede que no sea tanto!

Aquí aprenderemos cómo darle vida a la iluminación LED anterior atribuyéndole una funcionalidad bidireccional, es decir, intentaremos hacer que parpadee o parpadee a una frecuencia o velocidad específica. También veremos cómo esta tasa se puede aumentar o disminuir según lo desee el usuario.

Echemos un vistazo a esto:

#incluir

#incluir

int main (vacío)

{

DDRB | = 1<< PINB0

mientras (1)

{

PORTB ^ = 1<< PINB0

_delay_ms (100)

}

}

Si se siente desconcertado con esos símbolos extraños (&, ^, | etc.) utilizados en la expresión anterior (& no está allí, pero podría usarse en otros códigos similares), aquí está la información relacionada que le interesaría conocer sobre estos :

Incluye muchos algoritmos lógicos estándar como AND, OR, NOT y XOR que se utilizan normalmente con el código anterior.

Estas funciones lógicas comparan específicamente los dos bits '1' y '0' de acuerdo con sus tablas de verdad asignadas.

Obtendremos una idea analizando la siguiente disposición de bits:

01001011 &
10001101
es igual a
00001001

En el código anterior, & se refiere a AND como se usa en la programación C.

Al leer las filas verticalmente, sugiere que 0 y 1 es igual a 0, 1 y 0 también es igual a 0, 0 y 0 es igual a 0, 1 y 1 es igual a 1. Leerlo es tan simple como eso. Estos son según la tabla de verdad de un operador AND.

Si evaluamos la siguiente tabla, indica el símbolo “|” que denota el uso de la funcionalidad 'OR', el '|' se puede encontrar justo a la izquierda de 'retroceso' en el teclado de su computadora:

01001011 |
10001101
es igual a
11001111

Idénticamente, esta tabla de verdad de una funcionalidad lógica OR indica que los bits 0 o 1 es igual a 1, 1 o 0 también es igual a 1, 0 o 0 es igual a 0, mientras que 1 o 1 es igual a 1.

La siguiente combinación de bits es para el operador lógico XOR denotado por ^ y puede estudiarse tal como lo hicimos con las tablas de verdad AND, OR:

01001011 ^
10001101
es igual a
11000110

Ahora continuemos con el primer programa y aprendamos qué significa la siguiente línea:

#incluir

A través de nuestros tutoriales anteriores, sabemos cómo funciona la expresión, por lo que no la reiteraremos; sin embargo, parece ser una nueva 'inclusión' expresada por #include que debe investigarse.

En este 'incluir' el delay.h nos permite algunos métodos fáciles de implementación.

Como sugiere el nombre, delay.h nos permite inducir un retraso en el programa en particular.

La siguiente expresión int main (void) podría omitirse de la discusión en curso, ya que ya hemos cubierto esto en nuestras publicaciones anteriores.

Luego viene la DDRB alterada.

A continuación se muestra la forma anterior, que no es una mejor manera de asignar los pines, ya que todos los pines del 0 al 7 se cambiaron para formar las entradas. Pero imagínese cuál sería la situación si quisiéramos crear un programa más largo que requiera esos pines para alguna otra funcionalidad. Por ejemplo, el pin2 podría ser necesario para aplicar una conmutación remota de un aparato. En ese caso, no apreciaríamos asignar lo mismo como entrada solo a través de prueba y error. Eso podría significar una respuesta incorrecta del transmisor remoto al receptor del aparato.

DDRB = 0b00000001

Preferimos influenciar solo un bit, hat pin0 bit, mirando la funcionalidad 'OR', esto podría ejecutarse a través de un enmascaramiento binario.

DDRB = DDRB | 0b00000001

Aquí está velado con una máscara 'OR': 0b00000001, aunque parece ser un número binario auténtico, en caso de que la DDRB anterior, por ejemplo: 0b01001010, luego aplicar un OR a esto mediante enmascaramiento podría dar: 0b01001010 | 0b00000001 = 0b01001011.

La diferencia resultante, como se pudo observar, es solo con el pin0, ¡cuyos bits han cambiado!

Al comprimir aún más la declaración anterior a través de C ++, se obtiene:

DDRB | = 0b00000001

Sin embargo, encontramos que hay aún más en el programa dado. Aunque puede parecer bastante legítimo y obvio, deberíamos aprovechar algunas de las declaraciones del archivo de encabezado io.h, especialmente cuando se crea fundamentalmente para nuestra conveniencia.

Entonces, si 'DDRB | = 1<< PINBO, why it’s like that?

1<< PINBO is implemented for applying the masking effect. The “1” indicates what may be introduced inside the mask, while the < < is simply the left shift functionality. It executes exactly as it’s named, and PINBO is the number of locations that the “1” would sequence across the left hand side. To be precise PINBO may be equivalent of a 0.

Entonces comenzamos con un 0b00000000, y ponemos un “1” para producir 0b0000001 y luego lo transferimos a las posiciones 0 de la izquierda, lo que da un 0b00000001 exactamente idéntico al anterior.

Ahora bien, si suponiendo que fuera PINB4, el enunciado podría expresarse como 1<< PINB4. I this case the “1” would be pushed to the left 4 locations producing: 0b00010000.

Tenga en cuenta que estamos empleando un índice cero, lo que significa que hay cuatro ceros después del '1'.

Ahora, procediendo al ciclo 'while' que habíamos notado anteriormente en el 'ciclo infinito'. Pero quizás ahora queremos que el microcontrolador implemente algunas de las ejecuciones deseadas. Esto solo puede ser factible dentro del bucle dado. Es el ciclo donde la secuencia particular se repite una y otra vez.

En caso de que la ejecución se colocara antes del ciclo, se habría implementado solo una vez.

Sin embargo, para hacer que el LED parpadee indefinidamente, sería necesario encender y apagar el PINB0 alternativamente dentro del bucle. Aquí también encontramos los retrasos que se están introduciendo, sin los cuales el parpadeo del LED sería imposible. Pero esto obligaría al LED a parpadear a una velocidad muy rápida, difícil de reconocer a simple vista, tendría que reducir la velocidad un poco para ser identificable con nuestros ojos.

Somos conscientes del procedimiento de configuración de un bit en particular en el número binario, pero no estamos seguros del método para aplicar un bit específico '0' en caso de que sea un '1' todavía.

El siguiente programa podría verse haciendo esto, pero también descubriremos que es posible que no esté visible en el programa.

Las dos declaraciones iniciales cambian el bit a “1” (5V, luces LED), luego se introduce una pausa de 100 ms.

El siguiente par de líneas convierte el bit PINB0 en '0' (voltaje cero, LED apagado), pero lo siento, la comparación AND no podrá ejecutar un '0' desde el bit, pero si usamos NOT '~' para la máscara binaria, podría convertir todos los 0 en 1 y viceversa.

Esto nos permitirá influir solo en el bit PINB0 y cambiarlo a '0'. El paréntesis se incluyó para contener la ejecución de enmascaramiento de modo que la operación NOT pudiera aplicarse para todas las máscaras y no simplemente sobre el '1' antes del desplazamiento a la izquierda '<<”.

PORTB | = 1<< PINB0
_delay_ms (100)
PORTB & = ~ (1<< PINB0)
_delay_ms (100)

Para crear los retrasos ON OFF o períodos de igual duración, podemos acortar las cuatro líneas anteriores a dos y aplicar la funcionalidad XOR en nuestro beneficio. Debe tenerse en cuenta que una ejecución XOR asigna un pin a un 1 en caso de que sea 0 y viceversa. Esta ejecución solo influiría en el PINB0. Como muchas veces se aplica el comando, simplemente convertiría el bit en lo opuesto a la lógica existente.

PORTB ^ = 1<< PINB0
_delay_ms (100)

¡HECHO! Su LED estaría parpadeando ahora según la velocidad establecida ... Sencillo, ¿no es así?