MPH110 L298 Driver

Foto MPH110

La nuova versione dell’MPH102 rimasterizzata con componenti SMD e con un nuovo layout molto più ordinato.


l’MPH110 è la nuova versione dell’MPH102, è meccanicamente identico al predecessore ma con componenti SMD e un layout ottimizzato per migliorarne il funzionamento.

Ordinalo subito su Katodo.com

È in grado di controllare due motori DC di media potenza, opportunamente raffreddato è in grado di pilotare due motori da 24V 2A anche se già per queste potenze consiglio di usare il RoboPonte più adatto a gestire potenze di centiania di watt.
Nato dall’esigenza di avere un pratico e versatile driver per motori per alcune esigenze amatoriali è diventato modulo molto semplice ed affidabile che permette di pilotare sia motori DC che motori passo passo unipolari.

Il Chip L298 integra due ponti ad H che si possono schematizzare così:
Schema interno L298

Funzionamento con motori DC

In caso di controllo di motori DC ogni motore va collegato tra i due terminali centrali del Ponte ( M1 e M2 ) e, assieme ai 4 transistor (TR1…TR4), funzionerà in configurazione H-bridge ( si noti la H disegnata dall’insieme TR1…4 e Mot ).
Il segnale EN serve ad abilitare/disabilitare il driver mentre ciascun ingresso IN1 e IN2 serve a controllare quale dei transistor chiudere.

Con IN1=IN2 saranno chiusi in contemporanea o i due transistor TR1 TR3 o TR2 TR4, il motore in questa condizione risulterà cortocircuitato e si presenterà come bloccato.

Pilotando i due segnali IN1 e IN2 con un segnale PWM sfasato di 90° tra i due ingressi sarà possibile far ruotare il motore nei due versi di marcia variando il PWM dal minimo al massimo. Il motore risulterà fermo col PWM al 50%.
Per generare i segnali di controllo opportuni ci sono due strade possibili, o usare un circuito esterno o usare dei particolari microcontrollori ( per esempio i PIC 18F4431 ) in grado di generare due uscite PWM in opposizione di fase.

Gli schemi

Lo schema della scheda è molto semplice come si può vedere in figura:

MPH110_SCHEME

Il cuore del circuito è il driver di potenza L298 che fa il grosso del lavoro.

Oltre a questo componente possiamo notare da DX a SX i diodi di ricircolo, le due resistenze di shunt, le resistenze di Pull-UP, il regolatore di tensione e il connettore di ingresso.

I diodi di ricircolo servono a proteggere i transistor presenti nel driver da eventuali extratensioni che lo potrebbero danneggiare, è importante che la corrente massima di lavoro dei diodi sia pari alla corrente assorbita dal carico anche se, essendo i disturbi di natura impulsiva, è sufficiente scegliere diodi con una corrente di picco alcune volte superiore a quella assorbita dal motore.

Le resistenze di shunt servono a misurare la corrente assorbita dal motore leggendo la caduta di tensione ai loro capi. Nel caso di pilotaggio di motori DC non sono obbligatorie e possono essere cortocircuitate mentre pilotando motori passo passo servono a regolare la corrente di pilotaggio.

Per il dimensionamento di queste resistenze vi consiglio di leggere con attenzione l’apposita sezione.

Le resistenze di Pull-Up servono a tenere attivo il driver nel caso non si utilizzi il segnale EN.

Il regolatore è un L7805 in formato TO92, serve ad alimentare la sezione digitale del driver e la tensione è riportata anche sul connettore di controllo da cui però sconsiglio di prelevare più di 30-40mA.

Sebbene sia possibile non montare il 7805 e prelevare l’alimentazione logica dalla scheda di controllo io lo sconsiglio per evitare il più possibile problemi di disturbi.

Sul connettore a 12 poli SV1 sono presenti tutti i segnali disposti in due file simmetriche, una per ciascuno stadio.
Due segnali sono la massa del circuito, due l’alimentazione a 5V poi, per ciascuno stadio, ci sono i segnali delle resistenze di shunt, il controllo dei due rami del ponte e l’enable.

Realizzazione pratica

La realizzazione dell’Hbridge MPH110 è agevolata dalla disponibilità del circuito stampato che si può vedere in figura:

PCB MPH110

PCB MPH110

Cablaggi

Di seguito un piccolo schemino per riassumere i cablaggi per il ponte.

Cablaggi MPH110
Schema connessioni MPH101

Adattatore per singolo canale PWM

Questo è lo schema del circuito adattatore per controllare due motori con due soli segnali PWM:

Adattatore per controllo motori dc con segnale PWM monofase.


Il circuito di pilotaggio è disegnato già doppio per usare il driver con due motori e gestisce anche il segnale di Enable che, se non necessario, può essere non collegato e sarà tenuto a 1 dalle resistenze di Pull-UP R2 e R3.

Tale schema prevede di pilotare alternativamente i due rami del ponte tramite un singolo segnale PWM.

Quando il duty-cicle del PWM sarà al 50% il motore risulterà perfettamente immobile, variando il duty-cicle verso 0% o verso il 100% il motore girerà via via più velocemente nei due sensi di marcia.

Una seconda soluzione prevede, per ciascun motore, l’uso di due segnali PWM generati in opposizione di fase direttamente dal micro, alcuni micro come i PIC della serie 18F4431 e similari permettono via HW di generare direttamente questi segnali e così facendo è possibile usare direttamente il ponte senza l’ausilio di altro HW.

Kit componenti

Su Katodo.com potete trovare sia il solo PCB che il ponte completo già assemblato e collaudato.

Elenco componenti

Per assemblare il driver servono pochissimi componenti come si vede nella seguente tabella.

Nome Valore Quantità Codice Katodo.com
PCB PCB MPH110 1 10.9010.0004
C5, C6 CONDENSATORE SMD 1206 Z25 Y5V 2,2uF 25V 2 10.1050.0001
D1 … D8 Diodo ES1G – 1.0 AMP. Super Fast 8 10.3010.0007
IC1 L298 DUAL FULL-BRIDGE DRIVER 1 10.3570.0001
IC3 UA78L05AIPK 1 10.5010.0006
R5-R8 Resistenze SMD 1% 0805 4K7 1 10.2040.0014
RSA, RSB Resistenze 0,05 Ohm 1W 1% SMD 2010 1 10.2050.0001
M1,M2,POW CONN 2poli passo5 vert vite c.s. 1 10.8060.0008

Realizzazione pratica

Assemblare il ponte è una operazione abbastanza semplice con il PCB che dovrebbe agevolare molto la cosa grazie alla serigrafia molto chiara.

Per ottenere un assemblaggio ottimale bisogna prestare attenzione a:

  • Ordine di montaggio dei componenti:
    Iniziare saldando quelli meno agevoli cercando di individuare quali sono da saldare prima.
    In questo caso consiglio di partire dal connettore centrale e poi saldare i componenti che si trovano immediatamente vicini per finire con quelli più esterni alla scheda.
  • Evitare saldature fredde scaldando con lo stagnatore sia il pin del componente che il pad sul circuito stampato e prestando attenzione che lo stagno aderisca bene ad entrambe le superfici.
  • Prestare attenzione al verso di inserimento dei diodi:

Rimozione dello Shunt


La resistenza per la misura della corrente può non essere necessaria e si può bypassare inserendo uno pezzo di reoforo di alcuni Cm negli appositi fori.

Programmazione

Funzioni in C per PIC con PWM avanzato

Ecco delle funzioni per l’uso del ponteH con i pic 18F4x31 scritte da Fabio Drago.

Le funzioni si compongono di due file:

motors.c

/******************************************************************************
 Libreria per l'utilizzo dei ponti H realizzati da Mauro Soligo con 18F4431
 Autore:        Mauro Soligo ( tratto dal lavoro di Fabio Drago per i 18F4431)
 Versione:      1.0
 Data:          15 Novembre 2007

 Note:
 Pic:            18f4431
 H-Bridge:    RoboPonte (HIP4081A)
 MiniPonteH (L298)
 Controllo:      Locked Anti Phase
 Frequenza:      9.8kHz, 19.5kHz, 39.0kHz
 Risoluzione:    12bits, 11bit, 10bit
******************************************************************************/

#include <p18cxxx.h>
#include "def.h"
#include "var.h"
#include "ptype.h"
#include  "def_motors.h"
#include  "var_motors.h"

/******************************************************************************
initMotors ( unsigned int period )

period : Valore per la generazione del periodo.

Note:
sono state definiti degli alias per le frequenze di lavoro piu' comuni:
PWM_PER_10K = 9.8kHz
PWM_PER_20K = 19.6kHz
PWM_PER_40K = 39.0kHz
******************************************************************************/

void initMotors(unsigned int period)
{       // Mette in Output i pin <RB0:5>
 //PORTB = PORTB & 0b11000000;

 // Power Timer Control
 PTCON0 = 0b11110000;        // 1:16 postscaler, 1:1 prescale, free running
 PTCON1 = 0b10000000;        // PWM time base ON, count up
 PTPERH = (unsigned char) (period >> 8);
 PTPERL = (unsigned char) (period);

/*                PWMCON0
 bit 7 Unimplemented: Read as ?0?
 bit 6-4 PWMEN2:PWMEN0: PWM Module Enable bits(1)
 111 = All odd PWM I/O pins enabled for PWM output(2)
 110 = PWM1, PWM3 pins enabled for PWM output
 101 = All PWM I/O pins enabled for PWM output(2)
 100 = PWM0, PWM1, PWM2, PWM3, PWM4 and PWM5 pins enabled for PWM output
 011 = PWM0, PWM1, PWM2 and PWM3 I/O pins enabled for PWM output
 010 = PWM0 and PWM1 pins enabled for PWM output
 001 = PWM1 pin is enabled for PWM output
 000 = PWM module disabled; all PWM I/O pins are general purpose I/O

*/
 // PWM Control
 //PWMCON0 = 0b01000000;        // 100 = PWM0, PWM1, PWM2, PWM3, PWM4 and PWM5 pins enabled for PWM output
 //PWMCON0 = 0b00100000;        // 010 = PWM0 and PWM1 pins enabled for PWM output
 PWMCON0 = 0b00110000;        // 011 = PWM0, PWM1, PWM2 and PWM3 I/O pins enabled for PWM output
 PWMCON1 = 0b11110000;        // 1:16 postscaler, updates abilitati, override asincrono

 //DTCON = 0x00;                        // dead time 0ns
 //DTCON = 0b01100000;        // Quarzo=20Mhz; prescaler=Fosc/4  dead time 6.4uSec...
 //DTCON = 0b00100000;        // Quarzo=20Mhz; prescaler=Fosc/2 dead time 3.2uSec...
 DTCON = 0b00100000;        // Quarzo=20Mhz; prescaler=Fosc/2 dead time 3.2uSec... 10000 = 32
 //DTCON = 0b00010000;        // Quarzo=20Mhz; prescaler=Fosc/2 dead time 1.6uSec... 01000 = 16 ( 10Mhz*4PLL -> 0,8uSec )
 //DTCON = 0b00001000;                // Quarzo=20Mhz; prescaler=Fosc/2 dead time 0.8uSec... 00100 = 8  ( 10Mhz*4PLL -> 0,4uSec )

 // Output Override
 OVDCOND = 0b00111111;        // L'output è controllato dal DutyCycle e TimeBase
 OVDCONS = 0b00000000;        // Tutti i pin sono INACTIVE quando in override

 // Fault Configuration
 FLTCONFIG = 0x00;        // Fault A e B disabilitati
 return ;
}

/******************************************************************************
setMotors ( unsigned char motor, int dc )
motor : Motore da impostare. motor = 1 | 2 | 3
dc : valore di dutycycle nel range  -2048 < dc < +2048
il dutycycle da impostare viene definito tramite la formula:
dutycycle = zero + dc * (risoluzione / 4096*)
4096 perch il range di dc  +/- 2048

Note:
- Si è deciso di utlizzare il range +/- 2048 per il dutycycle passato alla funzione
in modo da avere una risoluzione di 12 bit indipendentemente dalla risoluzione
effettiva legata alla frequenza di lavoro.
In questo modo si puo' cambiare la frequenza di lavoro dei motori senza dover
ritarare tutti i valori di duty cycle precedentemente calcolati.

- Il terzo motore ha i canali PWM invertiti quindi bisogna invertire la
direzione di rotazione rispetto agli altri due.
******************************************************************************/

unsigned char setMotor(unsigned char motor, unsigned char enable,  int dc)
{       unsigned int period;
 int dutycycle;                // nel range 0 - period
 // Controlla se i parametri sono corretti
 if ((motor < 0 ) || (motor > 3)) return 1;
 if ((dc > (PWM_LIMIT)) || (dc < -(PWM_LIMIT))) return 2;
 //if ((dc > 2048) || (dc < -2048)) return 2;
 //Gestisce il segnale Enable da inviare al driver di potenza.

#ifdef OPTO_BYPASS
 if(enable)
 {       switch ((unsigned char) motor)
 {       case 1 :        EN_MOT1 = EN_ATTIVO;
 break;
 case 2 :        EN_MOT2 = EN_ATTIVO;
 break;
 }
 }
 else
 {       switch ((unsigned char) motor)
 {
 case 1 :        EN_MOT1 = EN_DISATTIVO;
 break;
 case 2 :        EN_MOT2 = EN_DISATTIVO;
 break;
 }
 }
#else
 if(enable)
 {       switch ((unsigned char) motor)
 {       case 1 :        EN_MOT1 = EN_ATTIVO;
 break;
 case 2 :        EN_MOT2 = EN_ATTIVO;
 break;
 }
 }
 else
 {       switch ((unsigned char) motor)
 {       case 1 :        EN_MOT1 = EN_DISATTIVO;
 break;
 case 2 :        EN_MOT2 = EN_DISATTIVO;
 break;
 }
 }
#endif

 // Inverte il senso di rotazione del terzo canale
 if (motor ==3) dc = -1*dc;

 // legge la frequenza di lavoro per calcolare la risoluzione
 period = ((unsigned int)(PTPERH) << 8) + PTPERL;

 // calcola il dutycycle da applicare in base alla precisione
 switch ((unsigned int) period)
 {       case 0x3ff : dutycycle = 2048 +  dc; break;                  // 12 bit (4096)
 case 0x1ff : dutycycle = 1024 + (dc / 2); break;        // 11 bit (2048)
 case 0x0ff : dutycycle = 512  + (dc / 4); break;        // 10 bit (1024)
 }

 // Aggiorna i registri relativi al motore interessato
 switch (motor)
 {       case 1 : PDC0H = dutycycle >> 8 ; PDC0L = dutycycle; break;
 case 2 : PDC1H = dutycycle >> 8 ; PDC1L = dutycycle; break;
 case 3 : PDC2H = dutycycle >> 8 ; PDC2L = dutycycle; break;
 }

 return 0;
}

def_motors.h

#define OPTO_BYPASS     1
#define EN_ATTIVO        1
#define EN_DISATTIVO     0

#define PWM_LIMIT    1950    //Limita il massimo valore del DUTYcycle per evitare
 //condizioni di PWM con DutyCycle >= 95%

// Valori di PTPER per le frequenze di lavoro piu' comuni
#define    PWM_PER_10K        0x03ff
#define PWM_PER_20K        0x01ff
#define PWM_PER_40K        0x00ff

#define EN_MOT1 LATBbits.LATB4   /* Enable del motore 1 */
#define EN_MOT2 LATBbits.LATB5   /* Enable del motore 2 */
#define EN_MOT3 LATBbits.LATB6   /* Enable del motore 3 */

main.c

/******************************************************************************
Programma Demo per l'utilizzo della libreria "motors.h"
Autore: 	Fabio DragoVersione:	1.0
Data:	09 Giugno 2006
Scopo:Questo programma inizializza i PWM per tre motori controllati in LAP.
Imposta i dutycycle a 1/4, 1/2 e 3/4 e poi attende all'infinito in mododa
poterli verificare con un analizzatore di stati logici.
Note:
******************************************************************************/
#include

#include "motors.h"

#pragma config OSC  = HSPLL  // Oscillatore PLL 4x attivo
#pragma config WDTEN = OFF  // Whatch dog disattivato
#pragma config PWRTEN = ON  // Power UP timer abilitato
#pragma config LVP  = OFF  // Programmazione LVP disabilitata
#pragma config BOREN = OFF  // Brown out Reset disabilitato
#pragma config BORV  = 42  // Tensione per Brown out Reset 4.2 Volt
#pragma config PWM4MX 	= RB5		// RB5 = PWM4

void initRB(void);

void main(void)
{
  initRB();
  initMotors( PWM_PER_20k);
  setMotor(1, 1024);
  setMotor(2, 0);
  setMotor(3, -1024);
  while(1);
  return;
}

void initRB(void)
{
// PINs Direction
TRISA = 0b11111111;		// Ananlogs and Encoder
TRISB = 0b11000000;		// uscite PWM e ICSP
TRISC = 0b10111001;		// I2C, RS232, pwm
TRISD = 0x00;			    // display lcd
TRISE = 0xf0;			    // led

// PINs Initial State
PORTA = 0xff;
PORTB = 0x00;
PORTC = 0x00;
PORTD = 0x00;
PORTE = 0x00;
INTCON  = 0;     		// Clear Interrupt
return;
}

Resistenze di Shunt

Le resistenze di SHUNT vengono attraversate dalla stessa corrente che pilota il motore e servono per poterla misurare potendo leggere ai loro capi una tensione proporzionale grazie alla legge di Ohm

V = I * R

Nel dimensionamento delle due resistenze bisogna però tenere presente due problematiche, una legata alla dissipazione in potenza e una legata all’ampiezza del segnale da misurare.

Per quanto riguarda la dissipazione in potenza la formula che la lega alla corrente e alla resistenza è

W = I^2 * R

E’ evidente quindi che all’aumentare della resistenza e a parità di corrente, la potenza dissipata aumenta.

È da tenere presente che questa potenza poi viene sottratta al motore e, infatti, considerando Vbat la tensione di alimentazione, Vmot quella del motore e Vs quella di shunt, la tensione che andrà realmente a pilotare il motore sarà

Vmot=Vbat-Vs

ed essendo sia la corrente che attraversa il motore e la resistenza sia Vbat fisse all’aumentare di Vs Vmot scenderà e scenderà la potenza erogabile dal motore

Pmot=Vmot*I

A questo punto è evidente quindi che tanto più piccola è la resistenza di shunt meglio è… ma non è del tutto vero, infatti questa resistenza ci serve per misurare la corrente e quindi deve essere tale da poter leggere con sufficente precisione la tensione ai suoi capi.

Dissipatore

Ora come ora non so bene come calcolare le dimensioni di un dissipatore per questo ponte… qualche suggerimento?

Questo sito usa Akismet per ridurre lo spam. Scopri come i tuoi dati vengono elaborati.