ATmega16 + DS18B20 + LED + Matlab / Simulink = AR

Pensé en jugar con los sensores DS18B20 de alguna manera . Sí, no solo para obtener los valores de temperatura (lo que todos pueden hacer), sino también para visualizarlo de alguna manera. Había una idea simple. Ponemos la webcam. Encendemos la luz en un marco par, en uno extraño que apagamos. Reste la imagen: solo queda el flash. En él, estamos buscando la ubicación del sensor, que está físicamente conectado al LED en el espacio. Y luego el procesamiento matemático. Bueno, todo esto en una simulinka. Bajo katom se describe cómo recibir bellas imágenes. Y para aquellos que no quieren entender, sugiero mirar los experimentos al final del artículo.


Circuitería


El circuito es extremadamente simple. El corazón es el ATmega16. Todos los sensores DS18B20 se cuelgan en el mismo pin (en mi caso, en el PB0 del puerto PORTB). El pin en sí mismo es arrastrado a la tensión de alimentación a través de una resistencia de 4.7 kΩ. El esquema es escalable. Se puede hacer clic en la imagen.



Todos los LED están conectados al puerto PORTA a través de resistencias terminales. Un polígono gris significa que este LED está físicamente conectado al DS18B20. El pin de reinicio se eleva a través de una resistencia de 10 kΩ para evitar un reinicio accidental debido a interferencia. El microcontrolador tiene una velocidad de reloj de cuarzo de 16 MHz. Poner lo más cerca posible de las conclusiones. Los tanques de carga se utilizan internamente. Configurado mediante fusible. Separe los conectores ICP (para cargar firmware) y UART para "comunicación". Capacidades C1 (electrolito 10 μF) y C2 (cerámica 100 nF). Coloque lo más cerca posible de los pines de alimentación del microcontrolador. Se utiliza para evitar descargas accidentales durante la transferencia de carga.

Asamblea de circuitos

¿Qué es un polígono gris?

Firmware + algoritmo de trabajo


El firmware fue escrito en C en Atmel Studio 7 IDE. Las fuentes se publican en GitHub . El código está documentado al máximo.
El proyecto se divide en varios niveles de abstracción:
  • Hardware : el nivel más bajo, la unión máxima al hardware. Trabajar con la periferia del microcontrolador.
  • El middleware es el punto medio entre el hardware y los controladores. Por ejemplo, la implementación del protocolo 1-Wire.
  • Controladores - nivel de conductor. Por ejemplo, trabajando con el chip DS18B20.
  • Aplicación : el más alto nivel de abstracción. Por ejemplo, recibir y transmitir temperatura a través de UART.

Un vistazo rápido a la función principal. Primero viene la tabla de direcciones ROM. Es necesario que la dirección del sensor físicamente conectado al LED cero (colgado en el PA0 del puerto PORTA) esté en la posición cero, etc. Para obtener ROM, hay una función sendROMToUART . Solo necesita recordar que el sensor debe estar solo en el bus, de lo contrario habrá un conflicto de direcciones.
principal
int main(void)
{	
	const uint8_t ROM[][sizeof(ROM_T)] = /* ROM array */
	{
		{0x26, 0x00, 0x00, 0x04, 0x4B, 0x15, 0x89, 0x28}, // 0
		{0x71, 0x00, 0x00, 0x04, 0x4A, 0xC0, 0x65, 0x28}, // 1
		{0xA5, 0x00, 0x00, 0x04, 0x4A, 0xCB, 0xCE, 0x28}, // 2
		{0x41, 0x00, 0x00, 0x04, 0x4A, 0xAC, 0x65, 0x28}, // 3
		{0x22, 0x00, 0x00, 0x04, 0x4B, 0x06, 0x0D, 0x28}, // 4
		{0x86, 0x00, 0x00, 0x04, 0x4A, 0xF6, 0x46, 0x28}  // 5
	};
	
	uint8_t nDevices = sizeof(ROM) / sizeof(ROM_T); /* Number of DS18B20 devices */
	
	initUART(MYUBRR); /* Initialization of UART with appropriate baudrate */
	initTimer0(); /* Initialization of Timer/counter0 */
	initLED(nDevices); /* Initialization of LEDs */
	
	{ /* DS18B20s initialization */
		uint8_t nDevices = sizeof(ROM) / sizeof(ROM_T); /* Number of DS18B20 devices */
		ROM_T *pROM = (ROM_T *)&ROM; /* Pointer to ROM array */
		
		initDQ(); /* Initialization of DQ pin */
		
		while (nDevices--) /* For all DS18B20 */
			initDS18B20(pROM++, RESOLUTION_11BIT); /* Initialization of DS18B20 with appropriate resolution */
	}
	
	sei(); /* Global enable interrupts */
	
	while (1) /* Infinite loop */
	{
		sendTemperatureToUART((ROM_T *)&ROM, nDevices); /* Execute function routine */
	}
}

Lo siguiente es la inicialización de los periféricos y el DS-ok con la resolución adecuada. El período de muestreo de temperatura depende de ello. Para 11 bits, esto es 375 ms. En un bucle infinito, el programa lee continuamente la temperatura de cada sensor y la envía a través de UART.

El trabajo con LED se basa en interrupciones. Por UART viene la ID del LED 2 veces seguidas en un marco par e impar. Al principio, el LED se ilumina. El temporizador se apaga después de un cierto tiempo (en mi caso, 15 ms). La segunda vez es simplemente ignorada. El temporizador está configurado en modo CTC para que se produzca una interrupción una vez cada 1 ms.
codigo
volatile uint8_t ledID = 0; /* Current ledID value */
volatile uint8_t ledID_prev = 255;  /* Previous ledID value */
volatile uint8_t duration = FLASH_DURATION; /* Flash duration value */

ISR(USART_RXC_vect) /* UART interrupt handler */
{
	ledID = UDR; /* Assign ledID to receive via UART value */
	if (ledID != ledID_prev) /* If current ledID equal to previous value */
	{
		turnOnLED(ledID); /* Turn on the ledID LED */
		timer0Start(); /* Start Timer0 */
		ledID_prev = ledID; /* Previous ledID assign to current */
		duration = FLASH_DURATION; /* Update LED flash duration */
	}
}

ISR(TIMER0_COMP_vect) /* Timer0 compare interrupt handler */
{
	if (--duration == 0) /* Decrement Duration value each 1ms and if it reach to 0 */
	{
		timer0Stop(); /* Stop Timer0 */
		turnOffAllLED(); /* Turn off all LEDs */
		timer0Clear(); /* Clear Timer0 counter register */
	}
}

Las secciones de código sensibles al tiempo, que son señales de 1 cable, están envueltas en una construcción ATOMIC_BLOCK . Todos los ajustes básicos se realizan en global.h . UART opera a una velocidad de 250,000. Rápido y sin errores para cuarzo de 16 MHz. El controlador DS18B20 tiene la funcionalidad mínima necesaria para este proyecto. El resto, ver el código. Habrá preguntas, pregunte, no sea tímido. También me gustaría recordarle sobre la configuración de los fusibles. Necesitan establecer la capacidad de reloj desde el cuarzo externo, de lo contrario será desde el generador interno (y está a un máximo de 8 MHz y no es muy estable). Bueno, programe el bit CKOPT, de lo contrario el cuarzo por encima de 8 MHz no comenzará. Tengo fusible alto = 0xD9 , fusible bajo = 0xFF .

Modelo Simulink + algoritmo de operación


Versión de la Matlab R2015b . En el Simulink , además de la biblioteca incorporada, que se utiliza principalmente Computer Vision System Toolbox y Imagen Adquisición de herramientas . Todo el modelo y los archivos relacionados se cargan en GitHub . A continuación se muestra una descripción detallada con ejemplos ilustrativos. Todas las imágenes son clicables.

Módulo WebCamTemp


Los bloques amarillos indican bloques de puertos COM. Por separado transmisor, receptor y configurador. La configuración del puerto debe coincidir exactamente con la del microcontrolador (velocidad, paridad, número de bits, etc.). El receptor toma la temperatura al agruparla en una matriz unidimensional de tamaño [n 1] de tipo int16 , donde n es el número de DS18B20 (tengo 6). Cada elemento de esta matriz se divide además por 16 . Esto es de la hoja de datos en la página 6. El transmisor envía el valor del contador actual a Counter . Simplemente enciende un LED particular. Marcando de 0 a n. Periodo 2 muestras. Los bloques responsables de mostrar / guardar la secuencia de video se agrupan en azul. Verde: bloques para recibir información de video. En realidad, la cámara web en sí. Hay muchas configuraciones diferentes según el fabricante. La imagen se muestra en tonos grises. Muy interesante El bloque Diff hace la diferencia entre los cuadros anteriores y actuales. El bloque impar Downsample solo resalta la diferencia encendida, no un LED encendido, pero no al revés. El bloque Downsample incluso omite cuadros cuando el LED está apagado.

Img diff
, — . ( ). , . 0.25.



Img gris
, — , . , . .



La pantalla de velocidad de fotogramas muestra el FPS actual. Todo el procesamiento está en el bloque de LED . Lo consideraremos de la siguiente manera.

Módulo LED


Violeta agrupa bloques de obtención de gaussianos 2D . Necesitamos dos: interferencia y opacidad . Se diferencian en sigma. Su centro está en el punto máximo (donde estaba encendido el LED). Las coordenadas se encuentran en el bloque Máximo . En lugar de generar constantemente tales Gaussianos (y el exponente es una operación matemática que consume mucho tiempo), se decidió eliminarlos. Para hacer esto, en el archivo m, se generan dos Int y Op con tamaños 2 veces más grandes con el centro en el medio, de los cuales, además, los necesarios simplemente se recortan con los bloques de interferencia de recorte y opacidad de recorte .

Ejemplo de trabajo
— . — . — . — . 0.25.



Los bloques de memoria están rodeados de verde. Su propósito es almacenar las coordenadas y gaussianos para cada LED. Consideramos con más detalle a continuación. El bloque de color A está destinado a construir una distribución de temperatura y un mapa de color. También se discutirá a continuación. Señal de unidad de composición Compositing mezclas de las dos imágenes Image1 y Image2 de la siguiente manera:


El bloque Insertar texto impone texto formateado (en este caso, temperatura) en la imagen. Acepta n variables y coordenadas en el formato [XY] . Puede seleccionar la fuente y su tamaño. Los bloques dentro del rectángulo rojo implementan el algoritmo de promedio móvil . Las transiciones se vuelven menos nerviosas, lo que preserva los nervios y agrada al ojo.

Ejemplo
, — 8- . ( ) .



Módulos de memoria


La interferencia de memoria y la opacidad de la memoria almacenan conjuntos Gaussianos 2D, Pts de memoria : coordenadas para cada LED.

Interferencia de memoria y opacidad de memoria
. Address . . . Delay LEDs ( , ). . Enable . , ( Maximum Threshold LEDs). — . . [H W n], HxW — -, n — /.

Pts de memoria
. . Permute Matrix , [Y X], [X Y].

Para colorear el módulo


Verde: procesamiento de opacidad . Resumir la matriz de entrada en la tercera dimensión. Lo normalizamos al máximo. Multiplique por el valor de ganancia (de 0 a 1) (1) . En total, tenemos una matriz con gaussianos superpuestos entre sí y una ganancia máxima . Se utiliza como factor para mezclar imágenes. Rojo: recibe un mapa de color de las temperaturas. Aquí un poco de matemática diferente, todos los mismos gaussianos. Se describe mediante la fórmula (2) . En términos generales, la temperatura en un punto arbitrario es el promedio ponderado de todos los sensores. Pero la influencia de cada sensor en una proporción porcentual es proporcional al valor de Gauss en él. La suma de todos se toma como 100%.


Queda por considerar cómo la distribución de temperatura se convierte en un mapa de colores. Lo que se encierra en un círculo en azul convierte la temperatura específica en un valor entre 0 y 1. En la zona roja, el bloque Prelookup calcula el índice por el cual se busca el valor de rojo, verde y azul. La matriz de colores contiene 64 valores. Los intermedios se calculan por interpolación. De las características, hay dos modos: relativo y absoluto. En el lugar relativamente más frío y más caliente, corresponde el mínimo y el máximo de la matriz de entrada. En absoluto, hay algunos valores constantes. En el primero, es más conveniente mirar el perfil de distribución de temperatura. En el otro, sus cambios absolutos.

archivo m


Se ejecuta al principio, antes de la simulación, introduciendo variables en el espacio de trabajo.
codigo
H = 480; % Height of image
W = 640; % Width of image
minT = 20; % Min temperature
maxT = 25; % Max temperature
sigmaInt = 40; % Sigma interference
sigmaOp = 80; % Sigma opacity
gain = 1.0; % Gain value
T = 0.3; % Threshold value
nAvr = 8; % number of means
% ------------------------------------------------------
[M,N] = meshgrid(-W:W, -H:H); % Meshgrid function

R = sqrt(M.^2 + N.^2); % Distance from the center

Int = normpdf(R, 0, sigmaInt); % 2D gaussian for interference
Op = normpdf(R, 0, sigmaOp); % 2D gaussian for opacity

Int = Int/max(max(Int)); % Normalization of interference gaussian
Op = Op/max(max(Op)); % Normalization of opacity gaussian

clear M N R sigmaInt sigmaOp % Delete unused variables from memory

load('MyColormaps','mycmap'); % Load colormap


Contiene las principales variables de control entre las cuales:
  • H — .
  • W — .
  • minT — .
  • maxT — .
  • sigmaInt — Interference.
  • sigmaOp — Opacity.
  • gain — Factor.
  • T — .
  • nAvr — .

H y W deben coincidir con la corriente en el bloque WebCamera. minT y maxT afectan el mapa de color en modo de temperatura absoluta. T está configurado de 0 a 1. A veces, el puerto COM y la cámara web no están sincronizados. La fase de la imagen diferencial puede cambiar 180 °. Y donde debería haber un máximo, hay un mínimo. Y el sistema puede elegir una coordenada arbitraria que no se corresponde con la realidad. Para esto, hay un sistema de umbral. nAvr es el número de promedios en el promedio móvil. Cuanto más grande es, más suaves son las transiciones, pero se pierde relevancia (aparece un cambio de tiempo). Para comprender el efecto de las variables restantes, uno no puede resolverlo sin ejemplos ilustrativos.

Efecto SigmaInt
. , , . — .



Efecto SigmaOp
.



Ganar efecto
- . «» « » .



Los experimentos


Los siguientes son algunos experimentos.

Ventana abierta


Los sensores están dispersos en la cama junto a la ventana. La ventana se abre y se cierra después de un rato. Un buen ejemplo de la diferencia entre los modos relativo (izquierda) y absoluto (derecha). Usando el primero, es conveniente considerar la distribución, y el segundo, cómo se distribuye el frío o se restaura el calor.



Alféizar de la ventana


Los sensores están ubicados a lo largo del alféizar de la ventana. Se abre la ventana; el perfil cambia. Las zonas más frías y cálidas son claramente visibles.



¿Hace más calor en la parte superior?


Dicen que la parte superior es más cálida. Este experimento es una confirmación completa de esto. En el décimo segundo, la ventana se abre, en el 30, se cierra.



Conclusión


Tal esquema no reemplazará una cámara termográfica de pleno derecho. Pero no puede ver la propagación de las masas de aire. Y a un precio, este diseño es incomparablemente más bajo. Puedes usar un mapa de color diferente en él. Puede tomar otras funciones en lugar de gaussianas. Incluso puedes cambiar las leyes de la construcción. O reescriba a OpenCV + QT para mayor velocidad y conveniencia. Pero eso es lo que he concebido, lo he logrado. Solo por diversión .

Source: https://habr.com/ru/post/es390985/


All Articles