ATtiny814 Power Analyzer
1.0.0
El analizador de potencia es una carga ficticia de corriente constante electrónica programable con dos sensores de voltaje lateral alto y corriente para un análisis automático de suministros de alimentación, convertidores DC/DC, reguladores de voltaje, baterías, cargadores, consumidores de energía y otros. El dispositivo se puede controlar mediante la interfaz serie USB utilizando un monitor serial o los skripts de Python proporcionados. Los datos se pueden exportar a programas de hoja de cálculo o ser analizados directamente por Python Skript.
El circuito de control de carga electrónica, que esencialmente consiste en un amplificador operativo, un MOSFET y una resistencia de derivación, asegura que la misma corriente fluya independientemente del voltaje aplicado.
Para este propósito, una derivación de 100mΩ que consta de tres resistencias de 300mΩ en paralelo para la disipación de calor adecuada se encuentra en el circuito de carga, a través de la cual se mide la corriente. El OPAMP LMV321 Rail-to Rail compara esto con el valor objetivo, que es especificado por el convertidor digital a analógico (DAC) del Attiny a través de un divisor de voltaje y, en consecuencia, controla la puerta de un nivel de potencia de nivel lógico IRL540N, que a su vez ajusta la corriente a través de su conjunto de resistencia interna de esta manera.
El voltaje y la corriente se miden a través de una resistencia de derivación de 8mΩ de lado alto conectado a un INA219 con una resolución de 4 mV/1 mA. Un segundo INA219 está conectado a otra resistencia de derivación de 8MΩ entre el terminal PWR-in y PWR-Out. El INA219 es un monitor actual de derivación y potencia con una interfaz compatible con I²C. El dispositivo monitorea tanto la caída de voltaje de derivación como el voltaje de suministro de bus, con tiempos de conversión programables y filtrado. Un valor de calibración programable, combinado con un multiplicador interno, permite lecturas directas de corriente en amperios. La resistencia de derivación seleccionada de 8MΩ permite una influencia muy pequeña en el circuito y una medición con una resolución de 1 mA. Para una medición precisa, se debe seleccionar una resistencia de derivación con una baja tolerancia (1% o mejor).
El analizador de potencia está conectado a través de USB a una PC o a RaspberryPI. Los comandos al analizador se pueden enviar a través de un monitor en serie o por el Python Skript basado en la GUI. El analizador tiene diferentes algoritmos de prueba automáticos incorporados. Los datos recopilados se devuelven a través de la interfaz serial/USB a la PC/RaspberryPi. El Attiny814 mide constantemente la potencia y la temperatura del disipador térmico. Controla el ventilador y corta la carga cuando la temperatura se calienta demasiado.
El Attiny814 controla la carga ficticia electrónica con su convertidor digital interno a analógico (DAC). Todos sus 5 voltajes de referencia internos se están utilizando para obtener la máxima precisión y resolución del DAC. El DAC está conectado a un OPAMP que actúa como un amplificador de ganancia de unidad que controla la resistencia del MOSFET.
// DAC reference voltages (load current = DAC voltage * R16 / (R15 + R16) / R_SHUNT)
// Reference voltages: 0.55V, 1.1V, 1.5V, 2.5V, 4.3V
const uint8_t DACREF [] = { 0x00 , 0x01 , 0x04 , 0x02 , 0x03 }; // CTRLA.DAC0REFSEL values
const uint16_t DACCUR [] = { 717 , 1434 , 1956 , 3260 , 5608 }; // max current in mA
uint8_t DACreference = 0 ; // start with 0.55V reference
// Setup the digital to analog converter (DAC)
void DAC_init ( void ) {
VREF_CTRLB |= VREF_DAC0REFEN_bm ; // enable DAC reference
_delay_us ( 25 ); // wait for Vref to start up
pinDisable ( DAC_PIN ); // disable digital input buffer
DAC0 . CTRLA = DAC_ENABLE_bm // enable DAC
| DAC_OUTEN_bm ; // enable output buffer
}
// Set the lowest reference voltage possible for the DAC to meet the load current
void DAC_setReference ( uint16_t current ) {
DACreference = 0 ;
if ( current > DACCUR [ 4 ]) current = DACCUR [ 4 ];
while ( current > DACCUR [ DACreference ]) DACreference ++ ;
DAC0 . DATA = 0 ;
VREF_CTRLA &= 0xf8 ;
VREF_CTRLA |= DACREF [ DACreference ];
_delay_us ( 25 );
}
// Set the DAC within the selected reference to the specified load current
void DAC_set ( uint16_t current ) {
if ( current > 5000 ) current = 5000 ;
if ( current > DACCUR [ DACreference ]) DAC0 . DATA = 255 ;
else DAC0 . DATA = ( uint32_t ) 255 * current / DACCUR [ DACreference ];
}
// Set the DAC and its reference to the specified load current
void DAC_setLoad ( uint16_t current ) {
DAC_setReference ( current ); // set suitable voltage reference
DAC_set ( current ); // set DAC according to desired load
}
// Reset the load to minimum
void DAC_resetLoad ( void ) {
DAC_setLoad ( 0 ); // reset the load to minimum
}Los comandos enviados a través del convertidor USB a serial se almacenan en un búfer de comandos de 16 bytes. Esto se realiza a través de interrupciones para que el control de carga y ventilador, por ejemplo, pueda continuar funcionando en paralelo. Tan pronto como se ha recibido completamente un comando, se establece el indicador CMD_COMPL. El analizador luego extrae el comando y los argumentos.
// UART definitions and macros
#define UART_BAUD 115200
#define UART_BAUD_RATE 4.0 * F_CPU / UART_BAUD + 0.5
#define UART_ready () (USART0.STATUS & USART_DREIF_bm)
// UART command buffer and pointer
#define CMD_BUF_LEN 16 // command buffer length
volatile uint8_t CMD_buffer [ CMD_BUF_LEN ]; // command buffer
volatile uint8_t CMD_ptr = 0 ; // buffer pointer for writing
volatile uint8_t CMD_compl = 0 ; // command completely received flag
// UART init
void UART_init ( void ) {
pinOutput ( TXD_PIN ); // set TX pin as output
USART0 . BAUD = UART_BAUD_RATE ; // set BAUD
USART0 . CTRLA = USART_RXCIE_bm ; // enable RX interrupt
USART0 . CTRLB = USART_RXEN_bm // enable RX
| USART_TXEN_bm ; // enable TX
}
// UART transmit data byte
void UART_write ( uint8_t data ) {
while (! UART_ready ()); // wait until ready for next data
USART0 . TXDATAL = data ; // send data byte
}
// UART RXC interrupt service routine (read command via UART)
ISR ( USART0_RXC_vect ) {
uint8_t data = USART0 . RXDATAL ; // read received data byte
if (! CMD_compl ) { // command still incomplete?
if ( data != 'n' ) { // not command end?
CMD_buffer [ CMD_ptr ] = data ; // write received byte to buffer
if ( CMD_ptr < ( CMD_BUF_LEN - 1 )) CMD_ptr ++ ; // increase and limit pointer
} else if ( CMD_ptr ) { // received at least one byte?
CMD_compl = 1 ; // set command complete flag
CMD_buffer [ CMD_ptr ] = 0 ; // write string terminator
CMD_ptr = 0 ; // reset pointer
}
}
}
// Wait for, read and parse command string
void CMD_read ( void ) {
while (! CMD_compl ) updateLoadSensors (); // maintain fan control
uint8_t i = 0 ;
cmd = CMD_buffer [ 0 ];
argument1 = 0 ; argument2 = 0 ;
while ( CMD_buffer [ ++ i ] == ' ' );
while ( CMD_buffer [ i ] > ' ' ) argument1 = argument1 * 10 + CMD_buffer [ i ++ ] - '0' ;
while ( CMD_buffer [ i ] == ' ' ) i ++ ;
while ( CMD_buffer [ i ] != 0 ) argument2 = argument2 * 10 + CMD_buffer [ i ++ ] - '0' ;
CMD_compl = 0 ;
}DEVICE=attiny814 PROGRMR=serialupdi PORT=/dev/ttyUSB0 make install para compilar, grabar los fusibles y cargar el firmware (cambie el dispositivo, el programa y el puerto en consecuencia). Python debe instalarse en su PC para usar la aplicación Python basada en GUI. La mayoría de las distribuciones de Linux ya incluyen esto. Los usuarios de Windows pueden seguir estas instrucciones. Además, se debe instalar Pyserial y Tkinter (8.6 o más nuevo). Sin embargo, estos ya están incluidos en la mayoría de las instalaciones de Python.
Los usuarios de Windows también pueden necesitar instalar un controlador para el adaptador CH330N/CH340N USB a serial. Esto no es necesario para los usuarios de Linux o Mac.
El dispositivo se puede operar de dos maneras:
| Dominio | Función |
|---|---|
| "i" | transmite cadena de sangría ("analizador de potencia") |
| "V" | transmite el número de versión de firmware |
| "incógnita" | Terminar el programa de prueba actual |
| "S de carga de carga [MA] " | Establezca la carga en una corriente constante de la corriente de carga |
| "R" | restablecer la carga al mínimo |
| "T" | Lea la corriente y el voltaje de ambos sensores y transmitirlos |
Este trabajo tiene licencia bajo Creative Commons Attribution-Sharealike 3.0 Licencia sin puerto. (http://creativecommons.org/licenses/by-sa/3.0/)
