El microcontrolador Nano V3 está escondido detrás de la 5ta. puerta de este calendario de adviento. Uno puede llamarlo el hermano pequeño del microcontrolador Uno. Se puede utilizar para implementar proyectos en los que la dimensión más pequeña es un requisito importante. Básicamente ofrece todo lo necesario para evaluar sensores o controlar actuadores. Los detalles importantes se pueden encontrar en la Hoja de datos y en Pinout que también están vinculados en la tienda AZ. Usted debe tener ambos a mano cuando se inicia un proyecto.
La información más importante son los 13 pines digitales que se pueden utilizar como entradas y salidas. Además, hay disponibles ocho pines analógicos con convertidor analógico a digital, que también se pueden usar como pines digitales. La comunicación con otros dispositivos o componentes se realiza a través de I2C (A4 y A5), USART (D0 y D1) o interfaz SPI (D10, D11 y D12). Los pines D2 y D3 se pueden usar para interrupciones externas.
En la contribución de adviento del 03 Diciembre ya se mostró cómo instalar el Arduino IDE y cargar el ejemplo de Blink en el Uno. Esto funciona exactamente igual para el microcontrolador Nano. Para el Chip Ch340 que está en la placa, es posible que necesite instalar un Driver para que el microcontrolador Nano V3 sea reconocido en un puerto COM virtual (la página vinculada está en idioma chino. Presione el botón azul grande. El archivo ZIP contiene el controlador. Asegúrese de usar un sistema de 32 o 64 bits).
Conexión de Microcontrolador
Luego, cuando conecte el Nano, seleccione el Arduino Nano en Tools-> Board. Como procesador el ATmega328P (Old Bootloader). En los Blogs de AZ encontrará una Contribución de Albert vu, que describe cómo "flashear" el Bootloader para que ya no tenga que elegir el antiguo Bootloader. Ahora debería aparecer un puerto COM debajo del item de menú "Port". El número detrás de él varía.
 |
Para probar, cargue el ejemplo intermitente en el microcontrolador (Sketch -> upload, o Ctrl + U). En el tablero hay un LED a bordo, que debería parpadear después de la carga exitosa (el LED está conectado al Pin D13 por cierto. La constante LED_BUILTIN se refiere a este Pin).
Los sensores o resistencias cambiantes (potenciómetros, también Poti) proporcionan un voltaje que se puede medir en las entradas analógicas. En el Nano Board, se integran convertidores analógicos a digitales, que convierten estos valores físicos. Con la función analogRead (número PIN) se obtiene un valor entre 0 y 1023. Si desea cambiar este rango, por ejemplo, si necesita de 0 a 255, se puede usar la función map(value, fromLow, fromhigh, toLow, y tohigh) utilizar (para más información, ver aqui).
|
Parámetro |
Función |
|
valor |
Valor de entrada (por ejemplo AnalogRead()) |
|
deBaja |
rango de fuente inferior (aquí 0) |
|
deAlto |
rango de fuente superior (aquí 1023) |
|
ToLow |
rango objetivo inferior (aquí 0) |
|
y alta |
rango objetivo superior (aquí 255) |
Entrada analógica
El Arduino IDE y bibliotecas integradas proporcionan un montón de muestra ketches. Así también para los Pines analógicos. Abra el Sketch en el menú File -> examples -> 03. Analog input. Este es un ejemplo modificado de Blink en el que un potenciómetro regula la velocidad de parpadeo. Conecte todo como se muestra en el siguiente Fritzing y descargue el ejemplo en el Nano:
 |
Las conexiones exteriores del potenciómetro están conectadas a 5V y GND, el contacto medio (grinder) a A0. Así es como se define en el ejemplo Ketch. El ledPin 13 es (como se mencionó anteriormente) el contacto con el LED de a bordo. Si ejecuta el programa en el Nano, puede usar el potenciómetro para ajustar la Pausa para cambiar entre encendido y apagado, aumentando o disminuyendo las pausas intermitentes.
Los valores de entrada 0 a 1023 se pasan aquí directamente como una Pausa. La especificación en el delay()-La función se especifica en milisegundos. Entonces alcanzamos pausas entre 0 y 1023 ms. pero si queremos establecer pausas entre 1 y 5 segundos (1000 y 5000 ms), entonces aquí viene lo mencionado anteriormente map()-Feature en el juego.
Después de la línea para leer, agregue la siguiente línea:
// leer el valor del sensor:
sensorValue = analogRead(sensorPin);
//re-insertado:
sensorValue = map(sensorValue, 0, 1023, 1000, 5000);
Esto sobrescribe el valor leído anteriormente, que ahora se convierte (scaled) al nuevo rango de valores. Los descansos deberían ser mucho más largos.
Nota: la función delay() proporciona descansos reales en el flujo del programa. Por lo tanto, el cambio al bote solo tendrá efecto cuando termine el descanso. Para cambiar esto, un programa sin bloqueo sería más adecuado. Vea el sketch de ejemplo bajo 02. Digital - > BlinkWithoutDelay. Allí se muestra cómo se realiza la conmutación del LED con las mediciones de tiempo. Con el Poti tendría que cambiar el intervalo.
El truco con los LED atenuados
Como regla general, el brillo de un LED no se puede cambiar a través de la tensión, como es el caso con las lámparas incandescentes. Utilice un truco que asegura que el LED solo se enciende y apaga durante un tiempo muy corto. Esto sucede tan rápidamente que nos ve como si el LED fuera más oscuro cuanto más corto sea el tiempo de encendido y apagado. Podemos cambiar el Sketch anterior un poco para ver el efecto. En lugar de delay() utilizamos delayMicroseconds() para los descansos, y establecemos el valor objetivo para cambiar el rango de 1000 y 5000 en el 0 y 10. Esto se puede cambiar girando el potenciómetro el brillo del LED a bordo.
Sin embargo, si desea hacer esto correctamente, utilice la llamada Pulse Width Modulation (PWM). Donde Hoja de datos puede ver qué Pines son capaces de esto. A menudo, una Tilde se imprime en el tablero además de los números PIN (una lying S) para identificar los Pines PWM.
Conecte un LED (no olvide la resistencia) al Pin 9 y cargue el ejemplo "Fading" en file-> examples-> 3.Analog on the Nano. El LED ahora debería pulsar.
 |
Para controlar el LED externo con el potenciómetro, añadimos ambos Sketches juntos:
int ledPin = 9; // Led conectado al pin digital 9
int sensorPin = A0; / / seleccione el pin de entrada para el potenciómetro
int fadevalue = 0; // variable para almacenar el valor procedente del sensor
void setup() {}
void loop() {
fadeValue = analogRead(sensorPin);
fadeValue = map(fadeValue, 0, 1023, 0, 255);
analogWrite(ledPin, fadeValue);
}Si establece el valor en el código minimizado, entonces el acortado se ve así:
void setup() { }
void loop() {
analogWrite(9, map(analogRead(A0), 0, 1023, 0, 255));}
}
La funcionalidad sigue siendo la misma.
Entrada digital
A menudo necesitamos botones como opción de entrada. Ya sea para iniciar o detener un proceso u otras funciones. Aquí los Pines digitales se pueden utilizar con relativa facilidad. Sin embargo, se debe tener cuidado de que en este caso los botones no simplemente cierren los circuitos. Por esta razón, las resistencias Pullup o Pulldown deben usarse para definir claramente los estados en los Pines. En el Nano, las resistencias Pullup están integradas en cada Pin digital. Estos son setup() habilitado cuando el Pin respectivo se inicializa como entrada:
pinMode (buttonPin, INPUT_PULLUP);
Esta es entonces la entrada sin embargo active low. Esto significa que el estado bajo del pin ahora está activo, es decir, encendido. Por el contrario, HIGH es el estado de apagado. El ejemplo Ketch "DigitalInputPullup" en file -> examples -> 2. Digital muestra de nuevo cómo funciona. El botón está conectado entre el pin D2 y GND.
También puede construir esto con resistencias externas. Entonces no necesita la resistencia interna. En el ejemplo Ketch "Button", la información describe el circuito para una resistencia Pull-down y explica cómo se utilizan las entradas digitales. El diagrama del circuito se ve así:
 |
Un problema con los botones es que"rebote". Si le sorprende que a veces parezca que ha presionado el botón varias veces, esto se debe a este efecto físico. Puede resolver esto con condensadores o en software. El Sketch "Debounce" es un ejemplo de tal solución. Básicamente, se trata de detectar un empuje de un botón y luego ignorar el botón por un corto tiempo. Otro enfoque sería comprobar varias veces si el Botón sigue pulsado. Entonces está seguro de que no era una señal aleatoria y la pasa al programa.
En lugar de usar un botón, también puede simplemente mantener los extremos de dos puentes o cables enchufables juntos. Por ejemplo, si desea construir un sistema de alarma en Windows o doors, simplemente use contactos metálicos planos que están conectados a los Pines. Esto también es posible.
Fuentes externas del voltaje
A menudo desea utilizar su proyecto independientemente de una computadora. Esto también es necesario solo para cargar el boceto en el microcontrolador. Si desea usar una batería o una fuente de alimentación, entonces no necesita la PC. El Nano se puede suministrar con voltaje a través de tres conexiones. Por ejemplo, como en la PC, a través del puerto Mini USB. Allí puede conectar una fuente de alimentación de enchufe USB o un power bank.
Además, el Nano tiene una conexión VIN (entrada de voltaje). Allí puede aplicar un voltaje entre 7V y 12V. Ya sea con una fuente de alimentación de laboratorio, un bloque de 9V, un paquete de baterías con varias pilas AA o una batería LiPo con regulador de voltaje (las baterías LiPo generalmente ofrecen menos de 5V, por lo que el voltaje debe transformarse).
En la primera pequeña puerta del calendario de adviento de AZ estaba el Breadboard Kit, que contiene un módulo de fuente de alimentación. La tensión de 3,3 V o 5 V suministros. El 5V se puede conectar directamente al Pin de 5V (que de lo contrario se utiliza como fuente de voltaje para otros componentes), y el Nano se suministra con eso.
Agregar 5V al Pin VIN no es una buena idea, ya que debe haber al menos 7V allí, como dije. Para conectar más de 5V al Pin de 5V, también debe evitar destruir el Nano.
Pantalla apagada y entrada
Finalmente, se debe mencionar la posibilidad de gastar en el Monitor. Esto a veces es necesario para la depuración. La comunicación en serie entre el microcontrolador Nano y la PC se utiliza para esto. En setup() se inicializa de la siguiente manera:
Serial.begin(9600);
El valor en el soporte es la velocidad en baudios (es decir, la velocidad de transmisión). En el Arduino IDE, en el menú Tools, puede abrir el serial Monitor o el serial Plotter. El Plotter es muy adecuado para que los datos del sensor detecten tendencias. El serial Monitor emite valores o textos. Es importante que la velocidad en baudios, que se establece en la parte inferior derecha del Monitor, se establezca con el valor en la inicialización en el setup() coincida con eso.
Ahora puede insertar salidas de pantalla en cualquier punto de su código fuente con:
Serial.println(valor); // El valor variable se emite con salto de línea
Serial.print(valor); // El valor variable es salida sin salto de línea
Serial.println(valor, HEX); // El valor variable es la salida hexadecimal
Serial.println(valor, BIN); // El valor variable es binaer de la salida
Serial.println("Feliz Navidad!"); // Salida de texto
Esto significa que no es posible generar múltiples variables simultáneamente con una llamada. O usa múltiples llamadas de Serial.print(), o primero junta el Texto en una variable de cadena, que luego genera.
Nota: Sprintf no admite números de coma flotante (con %f) en una placa AVR en el Arduino IDE.
double kommaZahl_A = 12.345678;
double kommaZahl_B = 98.765432;
char kommaZahl_A_str[10];
char kommaZahl_B_str[10];
char ergebnisPuffer[10];
char ausgabePuffer[25];
void setup() {
// inicialización:
Serial.begin(115200);
// ***** salida única *****
Serial.print(kommaZahl_A, 2);// dos decimales
Serial.print(" + ");
Serial.print(kommaZahl_B, 2); // dos decimales
Serial.print(" = ");
// con salida del cálculo con cuatro decimales:
Serial.println(kommaZahl_A + kommaZahl_B, 4);
// * * * * * Ensamble como cadena y luego salida *****
String ausgabeString = String(kommaZahl_A, 2) + " + " + String(kommaZahl_B, 2) + " = " + String(kommaZahl_A + kommaZahl_B, 4);
Serial.println(ausgabeString);
// * * * * * ensamblar con sprintf y luego salida *****
dtostrf(kommaZahl_A, 5, 2, kommaZahl_A_str);
dtostrf(kommaZahl_B, 5, 2, kommaZahl_B_str);
dtostrf(kommaZahl_A + kommaZahl_B, 8, 4, ergebnisPuffer);
sprintf(ausgabePuffer, "%s + %s = %s", kommaZahl_A_str, kommaZahl_B_str, ergebnisPuffer);
Serial.println(ausgabePuffer);
}
void loop() { }
Cuestión:
12.35 + 98.77 = 111.1111
12.35 + 98.77 = 111.1111
12.35 + 98.77 = 111.1111
La entrada del teclado también es posible a través del serial Monitor. Para esto, use la consulta en Serial.available() y la función Serie.read() para leer los Bytes individuales que han llegado a través de la conexión serial. Escriba el byte en un char- Variable, en lugar de valores numéricos, las letras se emiten desde la tabla ASCII:
char temp;
void setup() {
Serial.begin(115200);
Serial.println("Espere a que la entrada de texto...");
}
void loop() {
while(Serial.available()) {
temp = Serial.read();
Serial.print(temp);
}
}
Cuestión:
|
Más consejos
Al abrir el serial monitor, se reinicia el microcontrolador conectado.
Las variables no deben almacenarse en el setup()- Función ser declarada. Preferiblemente fuera de las funciones como variables globales. Va a estar en el loop()- Función declarada, con cada bucle de ejecución nueva memoria está reservada para la misma Variable, lo que puede causar problemas en microcontroladores con poca memoria en algún momento.
Echa un vistazo a la Inglés Arduino Referencia para una descripción extensa de las funciones que se pueden utilizar en el Arduino IDE. También pruebe los ejemplos. Hay mucho por descubrir. Además, hay una serie de varias partes con el tema Programación Arduino IDE para principiantes en el área AZ Blog. Allí encontrará más trucos como la manipulación de puertos para inicializar y cambiar varios Pines digitales al mismo tiempo.
Les deseamos una feliz temporada de Adviento.
Andreas Wolter
para AZ-delivery Blog
