• Articles
• admin

In questo articolo, ti mostrerò come costruire un pwm fan controller (DC) utilizzando un breve programma C, e alcune parti tra cui il Launchpad RM57L microcontrollore development kit. Consente agli utenti di variare in modo efficiente la velocità delle ventole PWM per ridurre i livelli di rumore e il consumo energetico. Questo progetto monitora automaticamente la temperatura dell’oggetto a cui è collegato il sensore di temperatura (in questo caso, un dissipatore di calore della CPU utilizzato per raffreddare un piccolo modulo termoelettrico) e controlla la velocità della ventola di conseguenza per ridurre al minimo il rumore e il consumo energetico. Di seguito è riportata una demo del controller della ventola in uso su un dispositivo di raffreddamento della CPU desktop.

Video: Kompulsa.

Prima di imparare a costruire un regolatore di velocità della ventola, aiuta a imparare come funzionano i vari metodi di controllo della velocità. Spiegherò due tecnologie chiave: controller di velocità resistivi e controller ventola PWM.

Regolatori di velocità resistivi

I regolatori di velocità resistivi controllano la velocità di un determinato motore del ventilatore resistendo al flusso di corrente dalla fonte di alimentazione al motore. Questo può essere fatto usando una combinazione di potenziometro e transistor o un altro circuito varistore. La precedente tecnologia è estremamente facile da costruire, ma fa sì che il transistor bruci un bel po ‘ della corrente che lo attraversa. Pertanto è inefficiente. PWM d’altra parte, impulsi la corrente completa on e off molte volte al secondo. Il transistor continuerà a sprecare un po ‘ di elettricità, ma non tanto.

PWM Speed Controller

Pulse width modulation è un metodo di controllo della corrente molto più complesso, superiore e sempre più comune che facilita il controllo delle velocità del motore, la luminosità della lampada, tra le altre cose in modo efficiente dal punto di vista energetico. I motivi principali per i controller del motore PWM includono il miglioramento dell’efficienza degli apparecchi e la riduzione dei livelli di rumore azionandoli a basse velocità ogni volta che è possibile.

Ho usato il kit di sviluppo MCU TI Launchpad RM57L per costruire questo controller della ventola (grazie a TI per inviarlo), ma questo codice può essere facilmente modificato per funzionare anche sul più economico Launchpad TMS57012 o sui Launchpad TMS57004 Launchpad.

Quando si impara a costruire un controller ventola pwm, aiuta a capire o imparare a eseguire le varie tecnologie / metodi così come i loro pregi e svantaggi. In questo modo, saprai esattamente quale usare e quando.

Questo articolo presuppone che tu abbia una certa esperienza di ingegneria elettrica e sappia come collegare in modo sicuro il transistor, il sensore e tutte le altre apparecchiature menzionate. Prova questo progetto a tuo rischio.

Indice

1. Elenco parti.
2. Preparazione dell’ambiente di sviluppo.
3. Iniziamo la codifica!

Questa presentazione richiede JavaScript.

Elenco parti

Tutti i prezzi sono in USD.

1. 2N6284G NPN Darlington BJT Transistor. BJT significa transistor a giunzione bipolare (conveniente perché ha un guadagno di corrente continua di 750).
2. Tre resistenze da 12 kOhm da 1/2 watt.
3. Scatola di giunzione con morsetti a vite o connettore a barra.
4. Texas Instruments Launchpad RM57L MCU (RM57L843) kit di sviluppo.
5. Termistore NTC da 10 kOhm con un valore B di 3435. ‘NTC’ significa che la sua resistenza diminuisce ogni volta che aumenta la temperatura.
6. 40mm x 40mm (o più grande, se non riesci a trovare quella dimensione) dissipatore di calore per il transistor.
7. Jumper wires/pin plugs per collegare i pin del kit di sviluppo al transistor e per collegare il transistor alla fonte di alimentazione (a meno che non si stia utilizzando una breadboard). Questi sono di solito nella gamma $3-6.
8. fonte di alimentazione da 12 o 5 volt.
9. 12 volt ventola della CPU, o un 5 volt ventola del computer portatile (questo progetto è destinato a tre o quattro fili ventole che supportano PWM). Questi sono in genere nella gamma $10-range 20.
10. CPU cooler (con dissipatore di calore e ventola inclusi) o qualsiasi altra combinazione di una ventola e un oggetto caldo che può essere raffreddato con esso. Ciò consente di guardare il controller della ventola automaticamente raffreddarsi e spegnere la ventola. Ho usato un dispositivo di raffreddamento della CPU con una ventola integrata. E ‘ la prova definitiva!

Consiglierei di collegare un dissipatore di calore al transistor se si alimentano ventole di grandi dimensioni (più grandi delle minuscole ventole da 80 mm che vengono tipicamente utilizzate per il raffreddamento della CPU desktop). Genererà una quantità significativa di calore.

Prepara il tuo ambiente di sviluppo

Il kit di sviluppo RM57L843 è il cuore di questo controller per ventole PWM (il modo in cui questi microcontrollori funzionano non è molto diverso da un Arduino, quindi non farti intimidire!). Il nostro primo passo per la costruzione di questo pwm fan controller è quello di impostare il nostro ambiente di sviluppo che useremo per programmare/flash il MCU.

Collegare il kit di sviluppo Launchpad RM57L alla porta USB del computer utilizzando il cavo fornito, quindi creare un account Texas Instruments in modo da poter scaricare l’IDE CCS. Useremo anche HALCoGen per questo esercizio. HALCoGen è un generatore di codice HAL che consente di configurare facilmente il vostro MCU utilizzando una GUI. In questo caso, lo useremo per configurare il convertitore analogico-digitale (il MibADC) e il modulo timer HET.

Scarica HALCoGen e CCS (assicurati di aver effettuato l’accesso al tuo account TI per CCS), quindi segui le istruzioni riportate di seguito per creare il tuo progetto HALCoGen.

Per prima cosa, crea un nuovo progetto in HALCoGen, seleziona il kit di sviluppo’ RM57Lx’, quindi vedrai un elenco delle sue varianti a destra dello schermo. In questo caso, c’è solo una variante: RM57L843ZWT. Selezionalo e assegna un nome al tuo progetto ‘PWM’ come mostrato di seguito. Immettere il percorso del progetto nel campo “Posizione”, prendere nota di esso e fare clic su OK. Memorizzeremo il nostro progetto CCS nella stessa directory. Il tuo progetto PWM dovrebbe trovarsi in una cartella denominata PWM, sotto la tua directory di lavoro, che chiameremo RM57L.

Al fine di costruire un controller ventola PWM, è necessario impostare timer che oscillare un piccolo elettrico on e off, e impostare la loro frequenza.

Quindi, abilitare i driver ADC1 e HET1 selezionando la scheda’ Driver Enable ‘ e selezionando le caselle come mostrato di seguito. Il convertitore analogico-digitale (ADC) verrà utilizzato per convertire la lettura del sensore di temperatura analogico in un valore digitale che possiamo utilizzare per determinare la temperatura, consentendo al controller della ventola di regolare la velocità della ventola di conseguenza. Il timer high-end (HET) verrà utilizzato per generare il nostro segnale PWM, che verrà utilizzato per controllare un semplice transistor BJT.

Consiglio di deselezionare il resto dei driver per risparmiare risorse di sistema (ad esempio: RAM e memoria flash).

È giunto il momento di configurare il convertitore analogico-digitale del nostro controller della ventola pwm (integrato nell’MCU Launchpad RM57L). Vai alla scheda ADC1 e imposta la dimensione FiFo su 1, poiché è tutto ciò di cui avremo bisogno per questo progetto. Selezionare anche Abilita Pin 7, come questo è ciò che ci collegherà il sensore di temperatura a. Il pin 7 è contrassegnato ‘AI1_7’ sul lato inferiore del kit di sviluppo Launchpad.

Come funziona la conversione da analogico a digitale

Procedere alla scheda HET1 dove si configurerà il timer PWM del controller della ventola (integrato nel kit di sviluppo RM57L), e il pin HET che controlla il transistor che alimenta la ventola e fare quanto segue, come mostrato nella schermata successiva.

Selezionare la scheda Pwm 0-7, impostare il campo di lavoro per PWM da 0 a 0. Questo imposta il ciclo di lavoro del segnale PWM su 0, quindi imposta il ciclo di lavoro della ventola che stai controllando su 0. Un ciclo di lavoro di 0 significa semplicemente che la ventola si spegne. Un altro modo per metterlo è: la percentuale del tempo in cui l’alimentazione sarà accesa è 0.

Inizieremo con un ciclo di lavoro di 0 in questo progetto perché regoleremo programmaticamente il ciclo di lavoro (e quindi la velocità della ventola) in modo tale che segua la temperatura del dissipatore di calore a cui è collegato il sensore di temperatura. Quando il ciclo di lavoro è impostato su 0, il controller della ventola spegne la ventola (0 corrisponde a 0%). Quindi, seleziona la coppia di caselle di controllo “Abilita” a sinistra del campo “Pin”. Che consente il segnale PWM. Inserisci 2 nel campo ‘Pin’, che è la porta HET 1, Pin 2, contrassegnato’ HET1_2 ‘ sul lato inferiore del Launchpad. Infine: immettere 10.000 (senza virgola) nel campo Periodo.

L’unità utilizzata in questo campo è il microsecondo. Un microsecondo è un milionesimo di secondo. Impostando questo campo su 10.000, il timer HET accenderà e spegnerà l’alimentazione ogni 10.000 microsecondi (ogni 0.01 secondi). A causa di questa rapida commutazione, non si noterà che l’alimentazione viene accesa e spenta, con conseguente funzionamento regolare e continuo della ventola.

Per completare la configurazione di HALCoGen, selezionare la scheda Pin 0-7. Qui è dove configurerai il pin RM57L a cui sarà collegata la base del transistor (attraverso il resistore da 12 kOhm, ovviamente). Selezionare la casella di controllo DIR nella sezione ‘Bit 2’ come mostrato di seguito per impostare il bit 2 alla direzione di uscita. Questo ci permette di accendere la ventola. Un pin può essere indicato come un bit, quindi ‘Bit 2’ in questo caso significa HET Pin 2.

Che cos’è un resistore?

Il valore di output (segnato DOUT nello screenshot qui sotto) è lo stato del pin, che può essere acceso (1) o spento (0). Assicurarsi che sia impostato su 0, quindi è spento quando l’MCU si avvia inizialmente.

Selezionare File > Salva progetto, quindi File > Genera codice (o premere F5). Guarda il riquadro “Output” in basso finché non dice che la generazione del codice è completa. Ora puoi passare alla configurazione CCS e, quando hai finito, puoi finalmente raccogliere le parti e costruire il controller della ventola.

Codifichiamo!

Avvia CCS e seleziona / crea una directory denominata RM57L come area di lavoro come mostrato di seguito. Crea un nuovo progetto in Code Composer Studio chiamato PWM, che verrà salvato nella radice della directory PWM dove vedrai il PWM.file hcg. PWM.hcg è il file di progetto HALCoGen. Come ho detto sopra, i file dei progetti CCS e HALCoGen devono trovarsi nella stessa directory per questo esercizio.

Collegare il kit di sviluppo Launchpad RM57L utilizzando il cavo USB in dotazione.

Alla tua destra, seleziona ‘RM57L8x’ dalla casella a discesa, poiché è quello che useremo. Quindi, selezionare la sonda di debug USB XDS110 dalla casella a discesa sottostante. Infine, selezionare ‘Progetto vuoto’ e fare clic su Fine.

Fai clic con il pulsante destro del mouse sul progetto PWM nel riquadro Project Explorer (si trova sul lato sinistro dello schermo), quindi aggiungi la cartella HALCoGen /includes dalla directory del progetto PWM al progetto CCS facendo clic sul pulsante cerchiato di seguito. Questi RM57L includono file costituiti da librerie e driver che rendono molto più facile scrivere programmi per l’MCU.

Vai a HL_sys_main.file c nel riquadro Project Explorer a sinistra sotto / PWM / source/. In quel file, incollare l’esempio di codice RM57L di seguito.

Il codice sorgente (esempio di codice Hercules RM57L)

Il seguente codice di esempio RM57L può essere caricato sul Launchpad tramite USB utilizzando Code Composer Studio. Ecco come dovrebbe apparire il tuo file sorgente:

Le letture della temperatura sono in °C.

HL_sys_main.c

/* USER CODE BEGIN (1) */#include "HL_het.h" //The HET library we'll use for PWM.#include "HL_adc.h" //The ADC library we'll use to read the sensor./* USER CODE END */void main(void){/* USER CODE BEGIN (3) */adcData_t adc_data; //ADC Data Structure.adcData_t *adc_data_ptr = &adc_data; //ADC Data Pointer.unsigned int value; //The ADC value is stored in this variable.float resistance; //The resistance of the thermistor at the current temperature reading;float degperohm = 0.003267974; //Degrees per ohm of resistance.unsigned int temperature; //The temperature in degrees Celsius.hetInit(); //Initialize the HET module.adcInit(); //Initialize the ADC module.while(1) //ADC conversion loop.{ adcStartConversion(adcREG1, 1U); //Start conversion on ADC 1. while(!adcIsConversionComplete(adcREG1, 1U)); //Keep looping until the conversion is complete. adcGetData(adcREG1, 1U, adc_data_ptr); //Store conversion into ADC pointer value = (unsigned int)adc_data_ptr->value; resistance = 1000 * (4096 / value); temperature = degperohm * resistance;//Adjust the fan speed based on the temperature readings obtained above. pwmStart(hetRAM1, pwm0); if (temperature < 40) { pwmSetDuty(hetRAM1, pwm0, 0U); //0% duty cycle. Fan is switched off. } else if (temperature >= 40 && temperature <= 42) { //If the temp is between 40°C and 42°C, set the fan to 20%. pwmSetDuty(hetRAM1, pwm0, 20U); //20% duty cycle. Fan Speed 1. } else if (temperature >= 42 && temperature <= 44) { pwmSetDuty(hetRAM1, pwm0, 30U); //30% duty cycle. Fan Speed 2. } else if (temperature >= 44 && temperature <= 46) { pwmSetDuty(hetRAM1, pwm0, 40U); //40% duty cycle. Fan Speed 3. } else if (temperature >= 46 && temperature <= 48) { pwmSetDuty(hetRAM1, pwm0, 50U); //50% duty cycle. Fan Speed 4. } else if (temperature >= 48 && temperature <= 50) { pwmSetDuty(hetRAM1, pwm0, 60U); //60% duty cycle. Fan Speed 5. } else if (temperature >= 50 && temperature <= 52) { pwmSetDuty(hetRAM1, pwm0, 70U); //70% duty cycle. Fan Speed 6. } else if (temperature >= 52 && temperature <= 54) { pwmSetDuty(hetRAM1, pwm0, 80U); //80% duty cycle. Fan Speed 7. } else if (temperature >= 54 && temperature <= 56) { pwmSetDuty(hetRAM1, pwm0, 90U); //90% duty cycle. Fan Speed 8. } else if (temperature >= 56 && temperature <= 58) { pwmSetDuty(hetRAM1, pwm0, 100U); //100% duty cycle. Fan Speed 9 (full speed). } else if (temperature > 65) { //65 //Code to display a temperature warning. 65 °C is a bit hot, warn the user. } else if (temperature > 70) { //Code to shut the device down (70 °C just won't do, shut it off). }} //End of ADC conversion loop./* USER CODE END */}

Siete invitati a ridistribuire questo codice RM57L, a condizione di includere un link a questa pagina.

Inserisci sempre il tuo codice tra i commenti /* USER CODE BEGIN */ e /* USER CODE END*/, in modo che HALCoGen non lo cancelli dopo aver apportato modifiche al tuo progetto.

Ricordate sempre che la temperatura del dissipatore di calore sta per essere inferiore alla temperatura della CPU o qualsiasi dispositivo si sta raffreddando. Ciò significa che se il dissipatore di calore è di 70 °C, la CPU è ancora più calda di quella. È anche possibile progettare questo controller ventola pwm per misurare direttamente la temperatura della CPU e posizionare il termistore su di esso. Questo è più preciso, poiché la temperatura del dissipatore di calore è in ritardo rispetto alla temperatura della CPU.

Ciascuno dei valori ADC sono rappresentazioni digitali delle letture della temperatura del controller della ventola e ogni intervallo di valori rappresenta un intervallo di temperatura che richiede una certa quantità di flusso d’aria per raffreddarlo. Nel caso di questo termistore, un valore ADC inferiore corrisponde a una temperatura più alta e viceversa. Il codice è stato aggiornato per convertire i valori del convertitore analogico-digitale in letture di temperatura in gradi Celsius.

Scenario di esempio: Un intervallo di valori ADC da 310 a 320 può essere abbastanza alto da giustificare l’avviamento della ventola fino all ‘ 80%, in quanto indica che il nostro soggetto di prova (il dissipatore di calore e quindi la CPU) si sta riscaldando. Tuttavia, se il dissipatore di calore / ventola è abbastanza grande, questa velocità non dovrebbe essere necessaria la maggior parte del tempo. Questo è un caso in cui si consiglia di capitalizzare su un dissipatore di calore più grande.

D’altra parte, un intervallo di valori ADC da 340 a 350 può indicare che il dissipatore di calore è solo un po ‘ caldo e richiede solo che la ventola funzioni a un’impostazione molto bassa (20%), quindi sarà molto più silenzioso a questa impostazione. Ho impostato il ciclo di lavoro in base agli intervalli di valori ADC, anziché ai valori ADC esatti per evitare frequenti fluttuazioni di velocità. Consiglio vivamente di implementare una routine UART che trasmette le letture del convertitore analogico-digitale al computer in modo da poter vedere tutto ciò che accade in tempo reale. Rende il debug più facile, ed è anche informativo.

Le applicazioni utili per PWM includono, ma non sono limitate a:

1. Controllo della velocità del compressore del condizionatore d’aria e del frigorifero per una migliore efficienza e livelli di rumore ridotti.
2. Ha condotto la lampada dimming.
3. HEV/controllo della velocità del veicolo elettrico.
4. Regolatori della ventola di ventilazione.
5. Regolatori della ventola del radiatore, che possono risparmiare elettricità, gas e ridurre l’inquinamento acustico causato dalle auto sulle strade. La riduzione del rumore potrebbe anche aiutare le persone a dormire meglio di notte in alcuni casi.

Si prega di tenere presente che tutte le applicazioni di cui sopra richiedono una ventola che supporta PWM. Sfortunatamente, non tutti i fan sono costruiti per questo.

Configurazione hardware

Come ho detto all’inizio, questo articolo è stato scritto con il presupposto che si sa come utilizzare un transistor, e come collegare il sensore al Launchpad in modo sicuro.

Collegare il termistore alla porta ADC 1 pin 7 e il transistor alla porta HET 1 pin 2 del kit di sviluppo RM57L, utilizzando di conseguenza i tre resistori nell’elenco delle parti. Se si utilizza un dispositivo di raffreddamento della CPU (dissipatore + combo ventola incorporata), inserire il sensore di temperatura nel dissipatore di calore (assicurarsi di non consentire a nessuno dei terminali del sensore di entrare in contatto con il dissipatore di calore, che potrebbe essere elettricamente conduttivo). Collegare la ventola del dissipatore di calore al controller. I tutorial collegati di seguito ti aiuteranno a imparare come impostare la ventola, il pin ADC e il transistor.

Sparkfun spiega conversione analogico-digitale, e un esempio di base di una connessione del sensore ADC qui (che è quello che ho usato per questo progetto, tranne il mio sensore ha due cavi, piuttosto che i tre che il loro potenziometro fa). Spiegano anche i transistor qui.

Una volta che hai imparato che, si può avere il controller del ventilatore installato e funzionante in pochissimo tempo!

Sensore

L’ADC nel kit di sviluppo MCU RM57L converte le fluttuazioni di tensione analogiche causate dal termistore (o da qualsiasi sensore di temperatura utilizzato) in valori digitali memorizzati nella variabile di valore sopra. A causa del fatto che i valori ADC dipendono dal sensore che si sta utilizzando, è necessario utilizzare le specifiche nella documentazione del sensore per convertire le letture di temperatura in gradi.

Il sensore utilizzato per questo progetto era un termistore uxcell 3435B 10 kOhm. Un termistore è un resistore progettato per variare la sua resistenza con la temperatura (molto più di un resistore ordinario). Se un termistore è valutato a 10 kOhm, significa che la sua resistenza è di 10 kOhm a 25 °C.

NB: La resistenza di un dato termistore non varierà linearmente con la temperatura, motivo per cui i produttori di termistori forniranno un grafico temperatura vs resistenza e (a volte) i valori A, B e C per l’uso nell’equazione di Steinhart-Hart, che risolve questo problema.

Codice testato con successo con le versioni CCS: