Sensor de temperatura NST1002 de Novosense / Sudo Null IT News
Se afirma que el sensor es muy preciso, +/- 0,1 grados para 0…+85 grados. C, en carcasa DFN-2L. Para todo el rango de temperatura -40 … +150 grados, la precisión es ligeramente peor, hasta +/- 0,5 grados. El sensor tiene un ADC de 15 bits, ocho dígitos para los grados y siete para la parte fraccionaria, lo que da una resolución de 1/128 o 0,0078125 grados. El tiempo para convertir y leer datos es de aproximadamente 32 milisegundos. Se conecta mediante un bus 1-Wire y tiene dos opciones de diseño: DFN-2L (1,6 x 0,8 mm) y TO-92S-2L (4,0 x 3,0 mm).
En la Fig. 1 se muestra un diagrama de conexión típico que requiere 2 patas de microcontrolador. GPIO1 se usa para controlar la comunicación, GPIO2 se usa para leer datos. Los parámetros del microcircuito se dan para +25°C, tensión de alimentación de +1,7V a +5,5V y una resistencia pull-up de 4,7 kOhm.
Arroz. 1 Esquema de conexión NST1002
El intercambio con el microcontrolador se muestra en la Fig. 2. Su inicio se inicia poniendo a cero la fuente de alimentación (GPIO1) por un tiempo de 200 microsegundos. Este pulso inicia el proceso de conversión de temperatura en el sensor. Dura unos 30 milisegundos y, al finalizar, el sensor emite un pulso de 17 microsegundos (que se muestra en la línea de puntos de la figura), que el microcontrolador lee a través de la línea GPIO2.
Arroz. 2 Intercambio de datos con el microcontrolador
Esto significa que el proceso se ha completado correctamente y el sensor está listo para transmitir datos. La transferencia de datos se produce poco a poco, restableciendo la línea de alimentación (GPIO1) a cero durante un tiempo de aproximadamente 1 a 2 microsegundos. En este caso, el sensor mantiene potencial cero durante aproximadamente 7…10 microsegundos (que significa “1”) o 18…21 microsegundos (que significa “0”). El intervalo entre pulsos de reinicio debe ser de al menos 60 microsegundos, por lo que se transmitirán 24 bits de datos en al menos 1440 microsegundos. Los datos se leen en consecuencia a través de la línea GPIO2; su formato se muestra en la Fig. 3.
Arroz. 3 Formato de datos recibidos
Los primeros 16 bits son datos, de los cuales el bit más significativo es el signo; los siguientes 8 bits son el código CRC en formato Maxim/Dallas. Los valores de temperatura negativos se transmiten en código complemento a dos. En la Figura 4 a continuación se muestra un ejemplo de cálculo de CRC. Tampoco es necesario leer los 24 bits. Para obtener la temperatura en grados enteros basta con leer los primeros 9 bits.
Cabe señalar que el proceso de lectura de datos debe comenzar a más tardar 5 milisegundos después del pulso de preparación. De lo contrario, el sensor entrará en estado inactivo y producirá los mismos datos todo el tiempo -> 0x18 0x6E 0xE0.
Arroz. 4 Ejemplo de cálculo CRC
El pulso listo, la lectura de 16 bits de datos y luego el pulso de inicio tomado por el analizador lógico se muestran en la Fig. 5 a continuación.
Arroz. 5 Datos del sensor NST1002-CDNR
La lectura de datos se organizó mediante un microcontrolador STM32F103C8T6 con una frecuencia de reloj de 72 MHz. Utilizando una interrupción del temporizador, se obtuvo una cuadrícula de tiempo con un paso de 5 microsegundos. La generación de señales y la lectura de datos se organizan en el controlador de interrupciones. Para minimizar el número de comprobaciones en él, se utiliza una serie de retrasos desde el principio de la secuencia para los bordes arr(25) (PB1 -> “0”; PB1 -> “1”) y un conjunto de retrasos para la lectura Se crearon los datos brr(24). Con su ayuda, primero se genera un pulso de 300 µs para restablecer el sensor NST1002; luego, después de aproximadamente 31 milisegundos, cuando se garantiza que el sensor producirá un pulso de finalización de la conversión, se generan pulsos de datos de lectura de bits.
Sin embargo, el error del tiempo de conversión del sensor no se indica en la documentación, por lo que puede ser más correcto esperar el pulso de preparación y comenzar a leer los datos inmediatamente después.
El código de formación de la matriz se proporciona a continuación. Se declaran como constantes y se encuentran en la memoria Flash; quizás colocarlos en la RAM acelere un poco el trabajo del controlador.
uint32_t index_arr = 0, index_brr = 0, index_data = 0;
uint32_t arr_data(90) = {0};
const uint32_t arr(25*2) = {
100/5, 400/5,
(31500+(60* 0))/5, (31505+(60* 0))/5,
(31500+(60* 1))/5, (31505+(60* 1))/5,
(31500+(60* 2))/5, (31505+(60* 2))/5,
(31500+(60* 3))/5, (31505+(60* 3))/5,
(31500+(60* 4))/5, (31505+(60* 4))/5,
(31500+(60* 5))/5, (31505+(60* 5))/5,
(31500+(60* 6))/5, (31505+(60* 6))/5,
(31500+(60* 7))/5, (31505+(60* 7))/5,
(31500+(60* 8))/5, (31505+(60* 8))/5,
(31500+(60* 9))/5, (31505+(60* 9))/5,
(31500+(60*10))/5, (31505+(60*10))/5,
(31500+(60*11))/5, (31505+(60*11))/5,
(31500+(60*12))/5, (31505+(60*12))/5,
(31500+(60*13))/5, (31505+(60*13))/5,
(31500+(60*14))/5, (31505+(60*14))/5,
(31500+(60*15))/5, (31505+(60*15))/5,
(31500+(60*16))/5, (31505+(60*16))/5,
(31500+(60*17))/5, (31505+(60*17))/5,
(31500+(60*18))/5, (31505+(60*18))/5,
(31500+(60*19))/5, (31505+(60*19))/5,
(31500+(60*20))/5, (31505+(60*20))/5,
(31500+(60*21))/5, (31505+(60*21))/5,
(31500+(60*22))/5, (31505+(60*22))/5,
(31500+(60*23))/5, (31505+(60*23))/5
};
const uint32_t brr(24) = {
(31515+(60* 0))/5,
(31515+(60* 1))/5,
(31515+(60* 2))/5,
(31515+(60* 3))/5,
(31515+(60* 4))/5,
(31515+(60* 5))/5,
(31515+(60* 6))/5,
(31515+(60* 7))/5,
(31515+(60* 8))/5,
(31515+(60* 9))/5,
(31515+(60*10))/5,
(31515+(60*11))/5,
(31515+(60*12))/5,
(31515+(60*13))/5,
(31515+(60*14))/5,
(31515+(60*15))/5,
(31515+(60*16))/5,
(31515+(60*17))/5,
(31515+(60*18))/5,
(31515+(60*19))/5,
(31515+(60*20))/5,
(31515+(60*21))/5,
(31515+(60*22))/5,
(31515+(60*23))/5
};Para hacer esto, cada 60 µs la línea de alimentación del sensor cae a “0” durante 5 microsegundos, luego sube a “1” y así sucesivamente 24 veces seguidas. El sensor NST1002 mantiene la línea en “0” durante aproximadamente 10 microsegundos (bit = “1”) o 20 microsegundos (bit = “0”).
Para leer el bit, leemos PB2 en un momento a 15us de la potencia de caída PB1 -> “0”. El bit de lectura se agrega a la variable, luego sus bits se desplazan hacia la izquierda y así sucesivamente 23 veces (excepto la última). El código del controlador de interrupciones se muestra a continuación.
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef* htim){
if(ccc == 1){
//HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, 0);
aaa++;
if(aaa == arr(index_arr)){
if((index_arr & 0x01) == 0) HAL_GPIO_WritePin(GPIOB, GPIO_PIN_1, 0);
else HAL_GPIO_WritePin(GPIOB, GPIO_PIN_1, 1);
index_arr ++;
}
if(aaa == brr(index_brr)){
if (HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_2)) dataBRR ++;
if(index_brr != 23) dataBRR = dataBRR << (1);
index_brr ++;
}
if(index_brr == 24){
if(index_data < 90){
arr_data(index_data) = dataBRR;
}else{
ccc = 0;
}
index_data ++;
dataBRR = 0;
aaa = 0;
index_arr = 0;
index_brr = 0;
}
//HAL_GPIO_WritePin(GPIOB, GPIO_PIN_3, 1);
}
}Desde el punto de vista del uso de los recursos de hardware del microcontrolador, esta solución no es óptima, pero sí bastante viable. El tiempo transcurrido en el controlador es de aproximadamente 1,2 microsegundos de 5, lo que permite al microcontrolador realizar otras tareas.
Los datos de temperatura experimental obtenidos de NST1002-CDNR con una velocidad de lectura de aproximadamente 30 veces por segundo se presentan a continuación en la Fig. 6. El sensor en sí estaba a temperatura ambiente en aire en calma y estaba envuelto en papel de aluminio para lograr lecturas estables.
Fig. 6 Datos de temperatura del sensor NST1002
La variación de temperatura declarada por Novosense es > 0,4 grados después de 1000 horas de funcionamiento a +125 grados C. Por lo tanto, el NST1002 representa una alternativa completamente valiosa a los sensores de temperatura de fabricantes americanos y europeos.
Expreso mi especial agradecimiento a la empresa. sistema de traducción automática por proporcionar muestras NST1002-CDNR.
Sensor de temperatura digital de bus único de alta precisión
