ATtiny814 Power Analyzer
1.0.0
O analisador de energia é uma carga de corrente constante eletrônica programável com dois sensores de tensão lateral e corrente alta para uma análise automática de fonte de alimentação, conversores DC/DC, reguladores de tensão, baterias, carregadores, consumidores de energia e outros. O dispositivo pode ser controlado via interface serial USB usando um monitor serial ou o Python Skripts fornecido. Os dados podem ser exportados para espalhar programas de planilha ou analisar diretamente o Skript Python.
O circuito eletrônico de controle de carga, que consiste essencialmente em um amplificador operacional, um MOSFET e um resistor de derivação, garante que a mesma corrente flua, independentemente da tensão aplicada.
Para esse fim, uma derivação de 100mΩ que consiste em três resistores de 300mΩ em paralelo para a dissipação adequada do calor está localizada no circuito de carga, através do qual a corrente é medida. O OPAMP LMV321 Rail-a-Rail compara isso com o valor alvo, que é especificado pelo conversor digital para analógico (DAC) do Attiny por meio de um divisor de tensão e, portanto, controla o portão de um MOSFET de potência de nível lógico IRL540N, que, por sua vez, ajusta a corrente por sua maneira interna, dessa maneira.
A tensão e a corrente são medidas através de um resistor de derivação de 8mΩ do lado alto conectado a um INA219 com uma resolução de 4MV/1MA. Um segundo INA219 é conectado a outro resistor de derivação de 8mΩ entre o terminal PWR-In e PWR-Out. O INA219 é um monitor de derivação e energia atual com uma interface compatível com I²C. O dispositivo monitora queda de tensão de derivação e tensão de suprimento de barramento, com tempos de conversão programáveis e filtragem. Um valor de calibração programável, combinado com um multiplicador interno, permite leituras diretas de corrente em amperes. A resistência de derivação selecionada de 8mΩ permite uma influência muito pequena no circuito e uma medição com uma resolução de 1MA. Para uma medição precisa, um resistor de derivação com baixa tolerância (1% ou melhor) deve ser selecionado.
O analisador de energia é conectado via USB a um PC ou um Raspberrypi. Os comandos para o analisador podem ser enviados por meio de um monitor serial ou pelo Skript Python baseado em GUI. O analisador possui diferentes algoritmos de teste automáticos internos. Os dados coletados são enviados de volta através da interface serial/USB para o PC/RaspberryPi. O Attiny814 mede constantemente a potência e a temperatura do dissipador de calor. Ele controla o ventilador e corta a carga quando a temperatura fica muito quente.
O Attiny814 controla a carga fictícia eletrônica com seu conversor digital para analógico interno (DAC). Todas as suas 5 tensões de referência interna estão sendo usadas para obter a precisão e a resolução máxima do DAC. O DAC está conectado a um Opamp que atua como um amplificador de ganho de unidade que controla a resistência do 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
}Os comandos enviados pelo conversor USB-Srial são armazenados em um buffer de comando de 16 bytes. Isso é feito via interrupções para que o controle de carga e ventilador, por exemplo, possa continuar a funcionar em paralelo. Assim que um comando for completamente recebido, o sinalizador CMD_COMPL está definido. O analisador então extrai o comando e os 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, queimar os fusíveis e fazer upload do firmware (altere o dispositivo, programação e porta de acordo). O Python precisa ser instalado no seu PC para usar o aplicativo Python baseado na GUI. A maioria das distribuições Linux já inclui isso. Os usuários do Windows podem seguir estas instruções. Além disso, o Pyseial e o Tknter (8.6 ou o mais recente) devem ser instalados. No entanto, eles já estão incluídos na maioria das instalações do Python.
Os usuários do Windows também podem precisar instalar um driver para o adaptador CH330N/CH340N USB para serial. Isso não é necessário para usuários de Linux ou Mac.
O dispositivo pode ser operado de duas maneiras:
| Comando | Função |
|---|---|
| "eu" | transmite string de indentificação ("analisador de energia") |
| "V" | transmite o número da versão do firmware |
| "X" | encerrar o programa de teste atual |
| "S Current [MA] " | Defina a carga como uma corrente constante da corrente de carga |
| "R" | redefinir a carga no mínimo |
| "T" | Leia a corrente e a tensão de ambos os sensores e transmitam -os |
Este trabalho está licenciado sob a licença Creative Commons Attribution-ShareAlike 3.0. (http://creativecommons.org/license/by-sa/3.0/)
