ATtiny814 Power Analyzer
1.0.0
Der Leistungsanalysator ist eine programmierbare elektronische Dummy -Last mit zwei Seitenspannung und Stromsensoren für eine automatische Analyse von Stromversorgungen, DC/DC -Wandlern, Spannungsregulatoren, Batterien, Ladegeräten, Stromverbrauchern und anderen. Das Gerät kann über die serielle USB -Schnittstelle mit einem seriellen Monitor oder dem bereitgestellten Python Skripts gesteuert werden. Daten können in Tabellenblattprogramme exportiert oder direkt vom Python Skript analysiert werden.
Der elektronische Laststeuerungskreis, der im Wesentlichen aus einem operativen Verstärker, einem MOSFET und einem Shunt -Widerstand besteht, stellt sicher, dass der gleiche Strom unabhängig von der angewendeten Spannung fließt.
Zu diesem Zweck befindet sich in der Lastkreis, über die der Strom gemessen wird, ein 100 -mΩ -Shunt, der aus drei 300 mΩ -Widerständen parallel zur ordnungsgemäßen Wärmeabteilung besteht. Der LMV321-Rail-to-Rail-Opamp vergleicht dies mit dem Zielwert, der durch den internen digitalen Digital-zu-Analog-Konverter (DAC) des Attiny über einen Spannungsteiler angegeben ist und entsprechend das Tor eines IRL540N-Logikpegel-LeistungsmOSFET steuert, was wiederum den Strom über den internen Widerstand anpasst.
Spannung und Strom werden über einen mit einer Auflösung von 4 mV/1 mA an eine INA219 verbundenen 8m Ω -Shunt -Widerstand gemessen. Ein zweiter INA219 ist mit einem weiteren 8mΩ-Shunt-Widerstand zwischen dem PWR-In und dem PWR-Out-Terminal verbunden. Der INA219 ist ein aktueller Shunt- und Leistungsmonitor mit einer I²C-kompatiblen Schnittstelle. Das Gerät überwacht sowohl Shunt -Spannungsabfall- als auch Busversorgungsspannung mit programmierbaren Umwandlungszeiten und Filterung. Ein programmierbarer Kalibrierungswert, kombiniert mit einem internen Multiplikator, ermöglicht direkte Anzeigen von Strom in Ampere. Der ausgewählte Shunt -Widerstand von 8m Ω ermöglicht sowohl einen sehr geringen Einfluss auf die Schaltung als auch eine Messung mit einer Auflösung von 1 mA. Für eine genaue Messung sollte ein Shunt -Widerstand mit geringer Toleranz (1% oder besser) ausgewählt werden.
Der Power Analyzer ist über USB mit einem PC oder einem RaspberryPI verbunden. Befehle an den Analysator können über einen seriellen Monitor oder über den GUI-basierten Python Skript gesendet werden. Der Analysator verfügt über unterschiedliche automatische Testalgorithmen. Die gesammelten Daten werden über die serielle Schnittstelle/USB an den PC/RaspberryPI zurückgesendet. Das ATTINY814 misst ständig die Leistung und Temperatur des Wärmekolbens. Es steuert den Lüfter und schneidet die Last ab, wenn die Temperatur zu heiß wird.
Das ATTINY814 steuert die elektronische Dummy -Last mit seinem internen digitalen bis Analogwandler (DAC). Alle 5 internen Referenzspannungen werden verwendet, um die maximale Genauigkeit und Auflösung des DAC zu erhalten. Der DAC ist mit einem Opamp verbunden, der als Einheitsverstärkerverstärker fungiert, der den Widerstand des MOSFET steuert.
// 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
}Befehle, die über den USB-to-Serial-Konverter gesendet wurden, werden in einem 16-Byte-Befehlspuffer gespeichert. Dies geschieht über Interrupts, damit die Last- und Lüftersteuerung beispielsweise weiterhin parallel laufen kann. Sobald ein Befehl vollständig empfangen wurde, wird das Flag CMD_COMPL gesetzt. Der Parser extrahiert dann den Befehl und die Argumente.
// 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 , um die Sicherungen zu kompilieren, die Sicherungen zu verbrennen und die Firmware zu laden (Geräte ändern, programmieren und port entsprechend). Python muss auf Ihrem PC installiert werden, um die GUI-basierte Python-Anwendung zu verwenden. Die meisten Linux -Verteilungen enthalten dies bereits. Windows -Benutzer können diese Anweisungen befolgen. Zusätzlich müssen pyserial und tkinter (8.6 oder neuer) installiert werden. Diese sind jedoch bereits in den meisten Python -Installationen enthalten.
Windows -Benutzer müssen möglicherweise auch einen Treiber für den seriellen Adapter des CH330N/CH340N USB installieren. Dies ist für Linux- oder Mac -Benutzer nicht erforderlich.
Das Gerät kann auf zwei Arten betrieben werden:
| Befehl | Funktion |
|---|---|
| "ich" | Übertragung der Einschlussstring ("Power Analyzer") |
| "V" | Überträgt die Firmware -Versionsnummer |
| "X" | Das aktuelle Testprogramm beenden |
| "S loadcurrent [ma] " | Last auf einen konstanten Laststrom einstellen |
| "R" | Setzen Sie die Last auf minimal zurück |
| "T" | Lesen Sie Strom und Spannung beider Sensoren und übertragen Sie sie |
Diese Arbeit ist unter Creative Commons Attribution-Sharealike 3.0 Unported Lizenz lizenziert. (http://creativecommons.org/licenses/by-sa/3.0/)
