Interfacciamento servomotore con braccio 7

Nel nostro precedente tutorial, abbiamo interfacciato il motore passo-passo con ARM7-LPC2148. In questo tutorial, controlleremo il servomotore con ARM7-LPC2148. Il servomotore ha un basso consumo energetico rispetto al motore passo-passo. Un servomotore interrompe il suo consumo energetico quando viene raggiunta la posizione desiderata, ma il motore passo-passo continua a consumare energia per bloccare l'albero nella posizione desiderata. I servomotori sono utilizzati principalmente nei progetti di robotica a causa della loro precisione e facilità d'uso.

In questo tutorial impareremo a conoscere il servomotore e come interfacciare il servo con ARM7-LPC2148. Un potenziometro è anche interfacciato per variare la posizione dell'albero del servomotore e un LCD per visualizzare il valore dell'angolo.

Servomotore

Un servomotore è una combinazione di motore CC, sistema di controllo della posizione e ingranaggi. La rotazione del servomotore è controllata applicando un segnale PWM ad esso, l'ampiezza del segnale PWM decide l'angolo di rotazione e la direzione del motore. Qui utilizzeremo il servomotore SG90 in questo tutorial, è uno dei più popolari ed economici. SG90 è un servo a 180 gradi. Quindi con questo servo possiamo posizionare l'asse da 0-180 gradi:

• Tensione di funzionamento: + 5 V.
• Tipo di ingranaggio: plastica
• Angolo di rotazione: da 0 a 180 gradi
• Peso: 9 g
• Coppia: 2,5 kg / cm

Prima di poter iniziare la programmazione per il servomotore, dovremmo sapere quale tipo di segnale deve essere inviato per il controllo del servomotore. Dovremmo programmare l'MCU per inviare segnali PWM al filo di segnale del servomotore. All'interno del servomotore è presente un circuito di controllo che legge il ciclo di lavoro del segnale PWM e posiziona l'albero dei servomotori nella rispettiva posizione come mostrato nella figura sotto

Ogni 20 millisecondi il servomotore controlla l'impulso. Quindi, regolare l'ampiezza dell'impulso del segnale per ruotare l'albero del motore.

• Larghezza dell'impulso di 1 ms (1 millisecondo) per la rotazione del servo a 0 gradi
• Larghezza dell'impulso di 1,5 ms per rotazione a 90 gradi (posizione neutra)
• Ampiezza dell'impulso di 2 ms per la rotazione del servo a 180 gradi.

Prima di collegare il servo a ARM7-LPC2148, puoi testare il tuo servo con l'aiuto di questo circuito del tester del servomotore. Controlla anche come un servomotore può essere interfacciato con altri microcontrollori:

• Controllo servomotore utilizzando Arduino
• Interfacciamento servomotore con microcontrollore 8051
• Controllo servomotore tramite MATLAB
• Controllo servomotore con Raspberry Pi
• Interfacciamento del servomotore con MSP430G2
• Interfacciamento del servomotore con STM32F103C8

Controllo del servomotore utilizzando LPC2148 PWM e ADC

Un servomotore può essere controllato da LPC2148 utilizzando PWM. Fornendo il segnale PWM al pin PWM del SERVO con un periodo di 20 ms e una frequenza di 50 Hz, possiamo posizionare l'albero del servomotore intorno a 180 gradi (da -90 a +90).

Un potenziometro viene utilizzato per variare il ciclo di lavoro del segnale PWM e ruotare l'albero del servomotore, questo metodo viene implementato utilizzando il modulo ADC in LPC2148. Quindi abbiamo bisogno che entrambi i concetti PWM e ADC siano implementati in questo tutorial. Quindi, si prega di fare riferimento ai nostri tutorial precedenti per imparare PWM e ADC in ARM7-LPC2148.

• Come utilizzare PWM in ARM7-LPC2148
• Come utilizzare ADC in ARM-LPLC2148

Pin PWM e ADC in ARM7-LPC2148

L'immagine sotto mostra i pin PWM e ADC in LPC2148. Le caselle gialle indicano i (6) pin PWM e la casella nera indicano i (14) pin ADC.

Componenti richiesti

Hardware

• ARM7-LPC2148
• Modulo display LCD (16x2)
• Servomotore (SG-90)
• Regolatore di tensione 3,3 V.
• Potenziometro 10k (2 no)
• Breadboard
• Collegamento dei cavi

Software

• Keil uVision5
• Strumento Flash Magic

Schema elettrico e collegamenti

La tabella seguente mostra la connessione tra servomotore e ARM7-LPC2148:

PERNI SERVO	ARM7-LPC2148
ROSSO (+ 5V)	+ 5V
MARRONE (GND)	GND
ARANCIONE (PWM)	P0.1

Il pin P0.1 è l'uscita PWM di LPC2148.

La tabella seguente mostra le connessioni del circuito tra LCD e ARM7-LPC2148.

ARM7-LPC2148	LCD (16x2)
P0.4	RS (selezione registro)
P0.6	E (Abilita)
P0.12	D4 (Data pin 4)
P0.13	D5 (Data pin 5)
P0.14	D6 (Data pin 6)
P0.15	D7 (Data pin 7)
GND	VSS, R / W, K
+ 5V	VDD, A

La tabella seguente mostra i collegamenti tra ARM7 LPC2148 e potenziometro con regolatore di tensione 3.3V.

3.3V regolatore di tensione IC	Funzione pin	Perno ARM-7 LPC2148
1. Perno sinistro	- Ve di GND	Pin GND
2.Pin centrale	Uscita + 3,3 V regolata	All'ingresso del potenziometro e all'uscita del potenziometro su P0.28 di LPC2148
3.Pin destro	+ Ve da 5V INGRESSO	+ 5V

Punti da notare

1. Qui viene utilizzato un regolatore di tensione di 3,3 V per fornire il valore di ingresso analogico al pin ADC (P0.28) di LPC2148. Dato che stiamo utilizzando una potenza di 5 V, dobbiamo regolare la tensione con un regolatore di tensione di 3,3 V.

2. Viene utilizzato un potenziometro per variare la tensione tra (0 V e 3,3 V) per fornire l'ingresso analogico (ADC) al pin P0.28 di LPC2148

3. Il pin P0.1 di LPC2148 fornisce l'uscita PWM al servomotore per controllare la posizione del motore.

4. In base al valore dell'ingresso analogico (ADC), la posizione del servomotore cambia da (0 a 180 gradi) tramite il pin di uscita PWM in P0.1 di LPC2148.

Programmazione ARM7-LPC2148 per il controllo del servomotore

Per programmare ARM7-LPC2148 abbiamo bisogno dello strumento keil uVision e Flash Magic. Stiamo utilizzando il cavo USB per programmare ARM7 Stick tramite la porta micro USB. Scriviamo il codice usando Keil e creiamo un file esadecimale, quindi il file HEX viene aggiornato su ARM7 stick usando Flash Magic. Per saperne di più sull'installazione di keil uVision e Flash Magic e su come usarli, segui il link Primi passi con il microcontrollore ARM7 LPC2148 e programmalo usando Keil uVision.

Passaggi coinvolti nella configurazione di LPC2148 per PWM e ADC per controllare il servomotore

Passaggio 1: - Includere i file di intestazione necessari per la codifica LPC2148

#includere #includere #includere #includere

Passaggio 2: - La prossima cosa è configurare il PLL per la generazione di clock poiché imposta l'orologio di sistema e l'orologio periferico di LPC2148 secondo le necessità dei programmatori. La frequenza di clock massima per LPC2148 è 60 Mhz. Le seguenti righe vengono utilizzate per configurare la generazione del clock PLL.

void initilizePLL (void) // Funzione per utilizzare PLL per la generazione di clock { PLL0CON = 0x01; PLL0CFG = 0x24; PLL0FEED = 0xAA; PLL0FEED = 0x55; while (! (PLL0STAT & 0x00000400)); PLL0CON = 0x03; PLL0FEED = 0xAA; PLL0FEED = 0x55; VPBDIV = 0x01; }

Passaggio 3: - La prossima cosa da fare è selezionare i pin PWM e la funzione PWM di LPC2148 utilizzando il registro PINSEL. Usiamo PINSEL0 come usiamo P0.1 per l'uscita PWM di LPC2148.

PINSEL0 - = 0x00000008; // Impostazione del pin P0.1 di LPC2148 come PWM3

Passaggio 4: - Successivamente, dobbiamo RESETTARE i timer utilizzando PWMTCR (Registro di controllo del timer).

PWMTCR = 0x02; // Reimposta e disabilita il contatore per PWM

Quindi impostare il valore di prescala che decide la risoluzione di PWM è impostata.

PWMPR = 0x1D; // Valore del registro preliminare

Passaggio 5: - Successivamente, imposta PWMMCR (registro di controllo corrispondenza PWM) poiché imposta operazioni come ripristino, interruzioni per PWMMR0 e PWMMR3.

PWMMCR = 0x00000203; // Reimposta e interrompe in corrispondenza di MR0, interrompi in corrispondenza di MR3

Passaggio 6: - Il periodo massimo del canale PWM viene impostato utilizzando PWMMR0 e la tonnellata del ciclo di lavoro PWM è inizialmente impostata su 0,65 msec

PWMMR0 = 20000; // Periodo di tempo dell'onda PWM, 20 msec PWMMR3 = 650; // Tonnellata di onda PWM 0,65 msec

Passaggio 7: - Successivamente, è necessario impostare Latch Enable sui corrispondenti registri di corrispondenza utilizzando PWMLER

PWMLER = 0x09; // Abilitazione latch per PWM3 e PWM0

(Usiamo PWMMR0 e PWMMR3) Quindi abilita il bit corrispondente impostando 1 in PWMLER

Passaggio 8: - Per abilitare l'uscita PWM al pin, è necessario utilizzare PWMTCR per abilitare i contatori del timer PWM e le modalità PWM.

PWMPCR = 0x0800; // Abilita PWM3 e PWM 0, PWM controllato da un fronte PWMTCR = 0x09; // Abilita PWM e contatore

Passaggio 9: - Ora dobbiamo ottenere i valori del potenziometro per impostare il duty cycle del PWM dal pin ADC P0.28. Quindi, utilizziamo il modulo ADC in LPC2148 per convertire l'ingresso analogico dei potenziometri (da 0 a 3,3 V) nei valori ADC (da 0 a 1023).

Passaggio 10: - Per selezionare il pin ADC P0.28 in LPC2148, utilizziamo

PINSEL1 = 0x01000000; // Impostando P0.28 come ADC INPUT AD0CR = (((14) << 8) - (1 << 21)); // Impostazione dell'orologio e del PDN per la conversione A / D

Le seguenti righe catturano l'ingresso analogico (da 0 a 3,3 V) e lo convertono in valore digitale (da 0 a 1023). E poi questi valori digitali vengono divisi per 4 per convertirli in (da 0 a 255) e infine alimentati come uscita PWM nel pin P0.1 di LPC2148. Qui stiamo convertendo i valori da 0-1023 a 0-255 dividendoli per 4 poiché PWM di LPC2148 ha una risoluzione di 8 bit (28).

AD0CR - = (1 << 1); // Seleziona il canale AD0.1 nel ritardo del registro ADC (10); AD0CR - = (1 << 24); // Avvia la conversione A / D while ((AD0DR1 & (1 << 31)) == 0); // Controlla il bit DONE nel registro dati ADC adcvalue = (AD0DR1 >> 6) & 0x3ff; // Ottieni il RISULTATO dal registro dati ADC dutycycle = adcvalue / 4; // formula per ottenere i valori del duty cycle da (0 a 255) PWMMR1 = dutycycle; // imposta il valore del ciclo di esecuzione al registro di corrispondenza PWM PWMLER - = (1 << 1); // Abilita l'uscita PWM con il valore del ciclo di carico

Passaggio 11: - Successivamente, visualizziamo questi valori nel modulo Display LCD (16X2). Quindi aggiungiamo le seguenti righe per inizializzare il modulo display LCD

Void LCD_INITILIZE (void) // Funzione per preparare l'LCD { IO0DIR = 0x0000FFF0; // Imposta il pin P0.12, P0.13, P0.14, P0.15, P0.4, P0.6 come tempo di ritardo OUTPUT (20); LCD_SEND (0x02); // Inizializza lcd in modalità operativa a 4 bit LCD_SEND (0x28); // 2 righe (16X2) LCD_SEND (0x0C); // Visualizza sul cursore spento LCD_SEND (0x06); // Incremento automatico del cursore LCD_SEND (0x01); // Visualizza LCD_SEND chiaro (0x80); // Prima riga prima posizione }

Poiché abbiamo collegato l'LCD in modalità a 4 bit con LPC2148, dobbiamo inviare i valori da visualizzare come nibble per nibble (Upper Nibble & Lower Nibble). Quindi vengono utilizzate le seguenti righe.

void LCD_DISPLAY (char * msg) // Funzione per stampare i caratteri inviati uno per uno { uint8_t i = 0; while (msg! = 0) { IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((msg & 0xF0) << 8)); // Invia il nibble superiore IO0SET = 0x00000050; // RS HIGH & ENABLE HIGH per stampare i dati IO0CLR = 0x00000020; // RW LOW Modalità di scrittura delaytime (2); IO0CLR = 0x00000040; // EN = 0, RS e RW invariati (cioè RS = 1, RW = 0) tempo di ritardo (5); IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((msg & 0x0F) << 12)); // Invia il nibble inferiore IO0SET = 0x00000050; // RS & EN HIGH IO0CLR = 0x00000020; tempo di ritardo (2); IO0CLR = 0x00000040; tempo di ritardo (5); i ++; } }

Per visualizzare quei valori ADC e PWM usiamo le seguenti righe nella funzione int main () .

LCD_SEND (0x80); sprintf (displayadc, "adcvalue =% f", dutycycle); LCD_DISPLAY (displayadc); // Visualizza il valore ADC (da 0 a 1023) angle = (adcvalue / 5.7); // Formula per convertire il valore ADC in angolo (da o a 180 gradi) LCD_SEND (0xC0); sprintf (anglevalue, "ANGLE =%. 2f deg", angle); LCD_DISPLAY (anglevalue);

Di seguito sono riportati il ​​codice completo e la descrizione video del tutorial