ATtiny814 Power Analyzer
1.0.0
L'analyseur de puissance est une charge factice à courant constant électronique programmable avec deux capteurs de tension latérale et de courant élevés pour une analyse automatique des alimentations, des convertisseurs CC / DC, des régulateurs de tension, des batteries, des chargeurs, des consommateurs d'électricité et autres. L'appareil peut être contrôlé via l'interface série USB à l'aide d'un moniteur série ou du Skripts Python fourni. Les données peuvent être exportées vers des programmes de feuilles réparties ou être directement analysés par le Python Skript.
Le circuit de commande de charge électronique, qui se compose essentiellement d'un amplificateur opérationnel, d'un MOSFET et d'une résistance de shunt, garantit que le même courant circule quelle que soit la tension appliquée.
À cette fin, un shunt de 100 mΩ composé de trois résistances de 300mΩ en parallèle pour une discipation de chaleur appropriée est située dans le circuit de charge, via lequel le courant est mesuré. L'OPAMP Rail-to-Rail LMV321 le compare à la valeur cible, qui est spécifié par le convertisseur numérique interne à analogique (DAC) d'Attiny via un diviseur de tension et contrôle en conséquence la porte d'un MOSFET de niveau logique IRL540N, qui ajuste à son tour le courant par le biais de sa résistance interne.
La tension et le courant sont mesurés via une résistance de shunt de 8 mΩ côté haute connecté à un INA219 avec une résolution de 4 mV / 1 mA. Un deuxième INA219 est connecté à une autre résistance de shunt de 8mΩ entre le terminal PWR-IN-IN-IN et PWR-OUT. L'INA219 est un moniteur de shunt et d'alimentation en cours avec une interface compatible I²C. L'appareil surveille à la fois la chute de tension de shunt et la tension d'alimentation en bus, avec des temps de conversion programmables et le filtrage. Une valeur d'étalonnage programmable, combinée à un multiplicateur interne, permet des lectures directes du courant dans les ampères. La résistance au shunt sélectionnée de 8mΩ permet à la fois une très faible influence sur le circuit et une mesure avec une résolution de 1 mA. Pour une mesure précise, une résistance de shunt à faible tolérance (1% ou mieux) doit être sélectionnée.
L'analyseur d'alimentation est connecté via USB à un PC ou à un framborberpi. Les commandes à l'analyseur peuvent être envoyées via un moniteur en série ou par le Python Skript basé sur l'interface graphique. L'analyseur a différents algorithmes de test automatique intégrés. Les données collectées sont renvoyées via l'interface série / USB vers le PC / RaspberryPI. L'Attiny814 mesure constamment la puissance et la température du dissipateur thermique. Il contrôle le ventilateur et coupe la charge lorsque la température devient trop chaude.
L'Attiny814 contrôle la charge factice électronique avec son convertisseur numérique interne à analogique (DAC). Tous ses 5 tensions de référence internes sont utilisées afin d'obtenir la précision et la résolution maximales du DAC. Le DAC est connecté à un opamp qui agit comme un amplificateur de gain d'unité contrôlant la résistance du 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
}Les commandes envoyées via le convertisseur USB-SEREAL sont stockées dans un tampon de commande de 16 octets. Cela se fait via des interruptions afin que la charge et le contrôle du ventilateur, par exemple, puissent continuer à fonctionner en parallèle. Dès qu'une commande a été complètement reçue, l'indicateur CMD_COMPL est défini. L'analyseur extrait ensuite la commande et les arguments.
// 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 pour compiler, brûler les fusibles et télécharger le firmware (modifier le périphérique, programr et port en conséquence). Python doit être installé sur votre PC afin d'utiliser l'application Python basée sur l'interface graphique. La plupart des distributions Linux incluent déjà cela. Les utilisateurs de Windows peuvent suivre ces instructions. De plus, Pysérial et Tkinter (8.6 ou plus récents) doivent être installés. Cependant, ceux-ci sont déjà inclus dans la plupart des installations Python.
Les utilisateurs de Windows peuvent également avoir besoin d'installer un pilote pour l'adaptateur USB CH330N / CH340N USB. Ce n'est pas nécessaire pour les utilisateurs de Linux ou Mac.
L'appareil peut être utilisé de deux manières:
| Commande | Fonction |
|---|---|
| "je" | Transmet la chaîne d'indentification ("Power Analyzer") |
| "V" | Transmet le numéro de version du micrologiciel |
| "x" | terminer le programme de test actuel |
| "S chargement [ma] " | Réglez la charge sur un courant constant de chargement de chargement |
| "R" | Réinitialisez la charge au minimum |
| "t" | lire le courant et la tension des deux capteurs et les transmettre |
Ce travail est concédé sous licence Creative Commons Attribution-Sharealike 3.0 Unport Liced. (http://creativecommons.org/licenses/by-sa/3.0/)
