ÍNDICE DE CONTEÚDO
- Introdução a Digital Power com os processadores STM32F334 – Parte I
- Digital Power com STM32F334 – Conversor Buck para controle de LED de alto brilho – Parte II
- Digital Power com STM32F334 – Conversor Boost Síncrono – Parte III
- Digital Power com STM32F334 – Firmware do Conversor Boost Síncrono ‘Open Loop’ – Parte IV
- Digital Power com STM32F334 – Firmware do Conversor Boost Síncrono Closed Loop – Parte final
Olá caros leitores, como estão? Seguiremos neste artigo a série sobre conversão de energia digital com a placa STM32F334 Discovery fornecida pela STMicroelectronics. Nos primeiros dois artigos desvendamos as soluções para Digital Power fornecidas pela ST, assim falamos um pouco sobre o processador, bem como fizemos uma revisão de hardware da placa discovery. Agora iremos começar a parte realmente divertida, que é trazer os tradicionais (e analógicos) conversores estáticos de potência para o mundo do controle digital.
Neste artigo então vamos:
- Revisar o hardware para controle de LED de alto brilho da STM32F334 Discovery;
- Modelar de forma simples o conversor para controle desse LED;
- Configurar os periféricos específicos do microcontrolador STM32F334 (Timer de alta resolução e comparador);
- Implementar uma aplicaçao de controle de brilho digital para LED de potência.
O Hardware para controle de LED de alto brilho
Uma das coisas que esse que vos escreve mais gosta na série das placas Discovery é o hardware onboard fornecido para que o usuário possa avaliar algum periférico específico dos processadores STM32. Com a placa STM32F334 Discovery que temos em mãos não é diferente, nela temos onboard, entre as características já revisadas no artigo anterior, um circuito para controlar um imponente LED de alto brilho de cor branca.
ATENÇÃO: Nunca olhe diretamente para o LED quando ele estiver em pleno funcionamento, pode causar desconforto e até danos permanentes na visão. O experimento aqui descrito poderá ser reproduzido pelo usuário assumindo ele o próprio risco em caso.
Na figura 1 abaixo temos em detalhe o circuito de controle de brilho:
Vejam que o circuito é bem simples em si, agora olhem atentamente e vão perceber algo interessante. Sim, o circuito em torno do LED LD7 possui todos os componentes do conhecido DC-DC tipo Buck, porém em posições modificadas. Apesar de parecer estranho à primeira observação, esse tipo de arranjo Buck é utilizado principalmente onde custo é um fator crítico, pois se nos recordarmos da topologia original, o MOSFET de acionamento localiza-se no chamado High-Side. Em que isso implica? Bem, se ele for um canal N se faz necessário adotar o circuito de um dispendioso (e caro) gate driver, além de toda a periferia necessária para operar o circuito. Agora, se a solução for a de utilizar um canal P, pode sair um pouco mais barato, exceto pelo fato do MOSFET P ser em média mais caro que um equivalente tipo N, além da necessidade de alguma periferia para correto acionamento dele.
Ao usar um circuito com a topologia inverted-buck, ganhamos no acionamento que pode ser um simples MOSFET N pelo low side, além de em nada modificar o comportamento do circuito. A única desvantagem aparente desse arranjo, é que a tensão de saída do conversor não é mais referenciada no GND da discovery, mas sim em relação ao nó que contém L2 e C27.
Bem, já nos atentamos ao conversor, ao LED, e os sinais de controle? Vejam que dada a natureza do arranjo, eliminamos qualquer necessidade imediata de circuito para condicionamento de sinal. Assim o acionamento do MOSFET T3 é feito diretamente pela CPU da placa através do terminal PB12. O sensoriamento do circuito é realizado por R39. Esse pequeno resistor shunt captura a corrente de saída do conversor e passa por R37 e C26 que formam um filtro passa-baixas cuja função é limitar a reposta do circuito para algo em torno de 3MHz. Em seguida esse sinal é enviado (sim, sem amplificação) diretamente ao pino PB0 da CPU.
Modelando o conversor Buck para controle de corrente
Agora que já sabemos o hardware que temos em mãos, precisamos, antes de por qualquer coisa na CPU e fritar o LED, determinar alguns parâmetros de controle do pequeno Buck que vai atuar sobre nosso querido diodo. Antes de falar do conversor em si, leitores tomem nota:
- O LED pode ser encontrado pela referência: LE-CWC12100-D, 1W, Everluck;
- Segundo o Manual de hardware da placa discovery STM32F334 o LED drena 350mA @ 2.8V.
Bem, já sabemos o que nosso conversor vai controlar, vamos revisar rapidamente como funciona um conversor Buck. A figura abaixo mostra os dois possíveis estados de um conversor desse tipo:
Como alguns já devem saber um conversor Buck produz em sua saída uma tensão mais baixa que a de entrada. Tomando as figuras 1 e 2 de base e com condições iniciais nulas, ou seja, L e C sem qualquer energia armazenada, quando o transistor principal é acionado, o indutor é carregado progressivamente, armazenando essa energia até o instante dado por uma fração do periodo de chaveamento T. Ao término desse periodo o conversor troca de estado, nesse momento abrindo o MOSFET, a energia armazenada em no indutor L é transferida ao capacitor C através do diodo que agora encontra-se diretamente polarizado. E ao final do restante do periodo T, o ciclo se repete, porém o capacitor C1 agora carregado possui energia para alimentar a saída suficiente para aguardar nova transferência de energia ao final de uma nova fração de T. Ou seja, o valor dessa fração do periodo T em que o MOSFET é acionado (chamado não coicidentemente de ciclo ativo) é função da tensão de saída que aparece na carga (no nosso caso o LED).
Dispensando modelagens desnecessárias, podemos escrever a função de transferência do ponto de vista de tensão do nosso conversor Buck:
Onde Vin e Vout são as tensões de entrada e saída respectivamente, e D é fração do período de chaveamento T em que o MOSFET permanece acionado. Vale lembrar que essa equação só é valida se o circuito buck estiver operando em modo contínuo, ou seja, o período de chaveamento T possui um valor tal que apenas parte da energia do indutor L é transferida para o capacitor C, ou seja, ela nunca chega a zero. Sabendo disso podemos obter duas equações úteis para calcular o valor do capacitor C e da indutância L. Mais um detalhe, vamos admitir componentes ideais para facilitar as contas:
Lembrando, esse valor para o indutor L é o valor mínimo para que o conversor opere em modo contínuo.
De posse dessas três equações podemos modelar um conversor DC-DC Buck para qualquer valor de tensão ou corrrente de forma genérica, e para casos críticos, os valores obtidos servem de ponto de partida para que possam ser ajustados de forma experimental. Porém tem um pequeno detalhe, o controle de LEDs de um modo geral se realiza por corrente e não por tensão, além do mais se observarmos novamente a figura 1 vamos ver que não existe qualquer forma de medir a tensão de saída do circuito da discovery. Porém podemos mensurar a corrente que passa em algum ponto do circuito, mais especificamente a corrente do indutor IL.
Com isso podemos aplicar uma estratégia de controle por corrente, conhecida por CMC (Current Mode Controller) em que a corrente que carrega o indutor é função da corrente que queremos que apareça na nossa carga. Assim precisamos determinar que função é essa, para isso vou recorrer ao método chamado de “Charge Balance” que pode ser melhor compreendido em aqui. Retomemos às leis de Kirchoff no capacitor de saída para os dois estados do conversor:
- Para o instante de tempo t em que 0 < t < D.Ts
- Para o instante de tempo t em que D.Ts < t < Ts
O método Charge Balance faz uma estimação do conversor em estado estacionário, de forma simplista, para todo espaço de tempo t tendendo ao infinito a variação de corrente no capacitor tende a ser zero. Assim podemos proceder da seguinte forma:
Sim, é isso mesmo, a corrente do indutor é a mesma que circula na carga, de forma que se tomarmos seu valor conforme o hardware de medida provido na discovery, vamos poder regular o brilho do nosso LED.
Periféricos especiais para digital power do STM32F334
Já sabemos o que controlar e como controlar, porém uma pergunta que povoa a cabeça do leitor neste momento pode ser a que isso já era possível fazer com o Arduino. Mas se lembrarmos do artigo em que experimentamos controlar um conversor Boost com ele iremos nos recordar que isso é feito às custas de muita CPU, principalmente para rodar a malha de controle para corrigir a tensão de saída na carga.
É onde a linha de processadores para digital power da ST se sobressai até mesmo para uma aplicação simples como essa, dentre o conjunto poderoso de periféricos. Vamos explorar o timer de alta resolução para gerar o modulador de PWM, como o próprio nome já diz, a característica desse timer é sua altíssima resolução, de 217ps (sim, picossegundos!) para fins de comparação com esse timer é possível gerar um sinal de PWM com frequência próximas de 1MHz e granularidade de 12 bits, enquanto que com o Arduino, em máxima frequência de clock, é possível gerar apenas 78KHz com 8 bits de granularidade.
Outro grande diferencial desse timer é o seu crossbar, que pode acionar e desacionar as saídas PWM não só a partir dos eventos de comparação e quando o período expira, mas também pode vir de várias fontes externas, incluindo periféricos analógicos como o amplificador operacional e o comparador. Além disso o HRTIM possui até 10 canais de saída permitindo gerar as mais variadas combinações de forma de onda para controle de motores por exemplo (não usaremos nessa aplicação, mas nas próximas…).
Além do HRTIM, esse processador traz no seu conjunto de periféricos até 3 comparadores analógicos. Para quem tem uma familiaridade com fontes chaveadas ou não, comparadores de tensão são extremamente úteis para implementar proteções, ou mesmo controle em modo de corrente (como o nosso controle de LED), o COMP4 (usado em nossa aplicação) possui tempo de resposta rápida da rodem de 30ns (sim, nanossegundos), além disso, ele é integrável ao HRTIM, de forma que seu evento de comparação possa ser enviado ao crossbar para processamento (sem intervenção da CPU). O COMP4 (assim como os outros) possui multiplexação das entradas de forma que podemos selecionar várias fontes, entre elas…
…o DAC, sim o conversor digital-analógico de dois canais on-chip, podendo gerar o valor de setpoint do brilho do LED, que pode ser comparado ao sinal de feedback de corrente presente em PB0 agindo como um amplificador de erro, que envia seu sinal para controlar um gerador de PWM, então…
…sim caro leitor, com esses três periféricos podemos criar uma engine de controle de brilho de LED em malha fechada sem qualquer intervenção da CPU, ficando essa livre para realizar outras tarefas. Vejam só a ideia, baseada neste application note, porém com algumas modificações do método original:
Neste application note já existe uma aplicação de controle de dimming do LED na discovery. A aplicação aqui apresentada é uma derivação do método, removendo o uso do DMA para geração da compesação por rampa, uma vez que o nosso sistema raramente opera com o ciclo ativo acima de 50%, ela não se faz necessária. Além disso, utlizamos o HRTIM em modo continuo em uma frequência bem elevada, cerca de 250KHz, eis onde o HRTIM faz muita diferença pois podemos fazer um controlador bem “quieto” mas sem perder a granularidade de controle (em torno de 16mil passos!).
Aplicação, o firmware do controlador de brilho para LED
E finalmente chegamos à parte em que colocamos tudo junto, já sabemos o que vamos controlar, como devemos controlar e os recursos que temos para isso. O nosso firmware realiza uma sequência de passos muito simples uma vez que a principal complexidade está em configurar o hardware corretamente para que ele tome conta do controle enquanto o firmware interage com o usuário.
Para essa aplicação estou estreando minha instalação do OpenSTM32, uma IDE baseada em Eclipse voltada para os processadores da familia STM32, seu grande diferencial é o de ser de graça, e oferecer suporte a todas as linhas. Por enquanto existe apenas um port para Windows, mas já existe previsão de suporte em sistemas Linux e MAC no segundo semestre desse ano. Ela pode ser obtida aqui. E o projeto completo está aqui.
Falemos do firmware agora, utilizaremos de suporte o pacote de software fornecido pela STMicro para manipular os periféricos, a STDPeriph, que fornece em forma de APIs um jeito intuitivo de inicializar e comandar todos os periféricos da CPU da nossa placa. Apenas o HRTIM é configurado sem o uso dessa lib, dada as particularidades de operação. O único arquivo de usuário, main.c, pode ser visto abaixo.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 |
// // INTRODUCAO A DIGITAL POWER COM A STM32F334 // // @file main.c // @brief implementa uma engine de controle de brilho de LED closed loop // sem usar a CPU. // #include "stm32f30x.h" #include "stm32f3348_discovery.h" #include "stm32f30x_rcc.h" #include "stm32f30x_comp.h" #include "stm32f30x_hrtim.h" #include "stm32f30x_gpio.h" #include "stm32f30x_dac.h" // // Macros e constantes uteis: // #define TICK_FREQ 1000 //frequencia de updade do tick. #define SYSTICK_LOAD_VAL(x) (x == 0?0:(SystemCoreClock) /x) //recarga do systick #define BUTTON_SCAN_TIME 10 //periodo de scanning do botao em ms #define HRTIM_FREQ 250000 //Frequencia do PWM em HZ #define HRTIM_LOAD_VAL(x) (x == 0?0:((SystemCoreClock/x) * 64)) //VAlor de recarga do HRTIM #define DIMMING_MAX_VAL 400 //corresponde a corente de 350mA no led; #define DIMMING_MIN_VAL 10 //corresponde a um valor de baixa luminosidade. // // maquininha simples de estado do dimmer: // typedef enum { kdimmingUp = 0, kdimmingDown, }dim_state; // // Variaveis: // uint16_t bright = 0; uint32_t tickCounter = 0; dim_state dimmingMchn = kdimmingUp; // // HRTIM_Init() // @brief inicializa o hrtim em modo PWM // // static void HRTIM_Init(uint32_t freq) { GPIO_InitTypeDef gpio; gpio.GPIO_Pin = GPIO_Pin_12 ; gpio.GPIO_Mode = GPIO_Mode_AF; gpio.GPIO_OType = GPIO_OType_PP; gpio.GPIO_Speed = GPIO_Speed_Level_3; //Aciona o clock do HRTIM: RCC_APB2PeriphClockCmd(RCC_APB2Periph_HRTIM1, ENABLE); RCC_HRTIM1CLKConfig(RCC_HRTIM1CLK_PLLCLK); //Aciona o pino que queremos o HRTIM: RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOB, ENABLE); GPIO_Init(GPIOB, &gpio); GPIO_PinAFConfig(GPIOB, GPIO_PinSource12,GPIO_AF_13); //Configura o HRTIM para rodar da segguinte forma: // fpwm = 250KHz -- 15bits // set = CMP1 // reset = PER1 / CMP4 - EEV2 HRTIM1->HRTIM_MASTER.MCR = 0x00000000; //Derruba o master timer: HRTIM1->HRTIM_MASTER.MPER = HRTIM_LOAD_VAL(freq); //Acerta o periodo HRTIM1->HRTIM_TIMERx[2].TIMxCR = 0x00000000; //derruba o timer a ser usado HRTIM1->HRTIM_TIMERx[2].PERxR = HRTIM_LOAD_VAL(freq); //Acerta o periodo HRTIM1->HRTIM_TIMERx[2].CMP1xR = 14000; //Duty cicle inicial = 0 HRTIM1->HRTIM_TIMERx[2].SETx1R = 0x04; // quem faz set HRTIM1->HRTIM_TIMERx[2].RSTx1R = 0x08 | (1 << 22); //quem faz reset HRTIM1->HRTIM_TIMERx[2].OUTxR = 0x00; //seleciona a polaridade. HRTIM1->HRTIM_COMMON.OENR = 0x3FF;//habilita as saidas PWM. HRTIM1->HRTIM_TIMERx[2].TIMxCR = 0x08; //dispara o TIMERC em PWM HRTIM1->HRTIM_MASTER.MCR = 0x003F0008; //Habilita o master timer //Configura as fontes de eventos externos: HRTIM1->HRTIM_COMMON.EECR1 = (0x01 << 6); HRTIM1->HRTIM_COMMON.EECR1 |= (0x01 << 10); } // // AFE_Init() // @brief Inicializa o front-end de medida de corrente: // // static void AFE_Init(void) { GPIO_InitTypeDef gpio; COMP_InitTypeDef cmp; DAC_InitTypeDef dac; // // Coloca o GPIO que sera usado como comparador num estado conhecido // gpio.GPIO_Pin = GPIO_Pin_6 ; gpio.GPIO_Mode = GPIO_Mode_AN; gpio.GPIO_OType = GPIO_OType_PP; gpio.GPIO_Speed = GPIO_Speed_Level_3; //Configura o gpio que sera usado como Comparador RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA, ENABLE); GPIO_Init(GPIOA, &gpio); gpio.GPIO_Pin = GPIO_Pin_0 ; gpio.GPIO_Mode = GPIO_Mode_AN; gpio.GPIO_OType = GPIO_OType_PP; gpio.GPIO_Speed = GPIO_Speed_Level_3; //Configura o gpio que sera usado como Comparador RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOB, ENABLE); GPIO_Init(GPIOB, &gpio); gpio.GPIO_Pin = GPIO_Pin_1 ; gpio.GPIO_Mode = GPIO_Mode_AF; gpio.GPIO_OType = GPIO_OType_PP; gpio.GPIO_Speed = GPIO_Speed_Level_3; GPIO_Init(GPIOB, &gpio); GPIO_PinAFConfig(GPIOB, GPIO_PinSource1,GPIO_AF_8); //Configura o comparador: COMP_StructInit(&cmp); cmp.COMP_Mode = COMP_Mode_HighSpeed; cmp.COMP_BlankingSrce = COMP_BlankingSrce_None; cmp.COMP_InvertingInput = COMP_InvertingInput_DAC2OUT1; cmp.COMP_NonInvertingInput = COMP_NonInvertingInput_IO1; cmp.COMP_Output = COMP_Output_HRTIM1_EE2_2; cmp.COMP_OutputPol = COMP_OutputPol_NonInverted; //Inicializa o comparador: RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE); COMP_Init(COMP_Selection_COMP4,&cmp); COMP_Cmd(COMP_Selection_COMP4, ENABLE); //Configura o DAC: dac.DAC_WaveGeneration = DAC_WaveGeneration_None; dac.DAC_Trigger = DAC_Trigger_Software; dac.DAC_Buffer_Switch = DAC_BufferSwitch_Enable; //Inicializa e habilita o DAC: RCC_APB1PeriphClockCmd(RCC_APB1Periph_DAC2, ENABLE); DAC_Init(DAC2, DAC_Channel_1, &dac); DAC_SoftwareTriggerCmd(DAC2,DAC_Channel_1, ENABLE); DAC_Cmd(DAC2, DAC_Channel_1, ENABLE); } // // DAC_Update() // @brief Atualiza o valor do DAC utilizado como Vref do conversor: // static inline void DAC_Update(uint16_t dacVal) { if(dacVal > 4095) dacVal = 4095; DAC_SetChannel1Data(DAC2, DAC_Align_12b_R, dacVal); DAC_SoftwareTriggerCmd(DAC2,DAC_Channel_1, ENABLE); } // // HRPWM_Update // @brief atualiza o duty-cicle base do gerador de pwm // static inline void HRPWM_Update(uint16_t pwmVal) { HRTIM1->HRTIM_TIMERx[2].CMP1xR = pwmVal; } // // main() // @brief funcao principal, captura o estado do botao e regula // o brilho do led. // int main(void) { uint32_t scan = 0; // // Inicializa o analog front end, // esse bloco eh quem vai agir como loop control // AFE_Init(); DAC_Update(DIMMING_MIN_VAL); // // Sobe o pwm de alta resolucao, esse bloco vai trabalhar // em conjunto com o AFE aplicando um fator de // correcao ao PWM permitindo uma correcao ciclo a ciclo // em caso de step de carga ou elevacao de tensao. HRTIM_Init(HRTIM_FREQ); // //Configura o botao da discovery para ser usado como controle //de dimmer. // STM_EVAL_PBInit(BUTTON_USER,BUTTON_MODE_GPIO); // // Configura o systick counter para gerar uma // base tempo constante. // // SysTick->CTRL = 0x00; SysTick->LOAD = SYSTICK_LOAD_VAL(TICK_FREQ); SysTick->CTRL = 0x07; scan = tickCounter; for(;;) { //Escaneia o botao da placa a cada 10ms if(tickCounter - scan >= BUTTON_SCAN_TIME) { //Checa se o botao foi pressionado: if(STM_EVAL_PBGetState(BUTTON_USER) != 0) { //Avalia a maquininha de estados: switch(dimmingMchn) { case kdimmingUp: bright++; if(bright > DIMMING_MAX_VAL) { //Realiza wrap e troca de estado do dimmer dimmingMchn = kdimmingDown; bright = DIMMING_MAX_VAL; } break; case kdimmingDown: bright--; if(bright <= DIMMING_MIN_VAL) { //Realiza wrap e troca de estado do dimmer dimmingMchn = kdimmingUp; bright = DIMMING_MIN_VAL; } break; } // // Depois da maquina de estado avaliada // Atualizamos o valor de brilho desejado no led // pelo DAC, a engine configurada no hardware se // encarrega de buscar o brilho desjeado pelo usuario. // DAC_Update(bright); } scan = tickCounter; } } } // // SysTick_Handler() // @brief esta interrupcao atualiza o contador de // base de tempo. void SysTick_Handler(void) { tickCounter++; } |
As funções AFE_Init e HRTIM_Init são quem fazem todo o trabalho duro de configurar o hardware para operar em malha fechada. Em AFE_Init o comparador e DAC são configurados e roteados entre si. Dessa forma, a entrada inversora do comparador enxerga o sinal analógico do DAC número 2, e a entrada não inversora é roteada para observar constantemente o pino PB0 que está conectado ao resistor shunt de medida de corrente.. HRTIM_Init é função mais hardcoded aqui, ela sobe as chamadas timer-unit, e seleciona a frequência de chamamento, que foi escolhida em torno de 250KHz utilizando as equações 2 e 3. Uma vez que os valores de capacitor e indutância são dados, chegamos a um valor que mantém o circuito operando em modo contínuo para que o modelo de análise via Charge Balance seja válido. Além disso o registrador CMP1 é inicializado com um valor correspondente à aplicação dos 350mA ao LED, ou seja, o valor máximo de brilho, garantindo que esse nunca será excedido. Após a configuração básica do gerador de PWM, essa função prepara o crossbar para que o modulador fique sensível a eventos externos gerado pelo nosso amplificador de erro formado por DAC e COMP4, ao final os periféricos são disparados e a engine roda sem intervenção da CPU.
O restante do firmware é trivial, como a discovery só possui 1 botão de usuário, foi criada uma máquina de estados para que o usuário possa aumentar ou decrescer o valor de brilho desejado entre o range das constantes DIMMING_MIN_VAL e DIMMING_MAX_VAL. E para fechar uma rotina de scanning do botão, controlada para ocorrer a cada 10ms com a ajuda do SystickTimer, ajuda a garantir interação do usuário livre do efeito de bounce.
Vamos ver o sisteminha em ação? E aá vai um vídeo da aplicação rodando, vejam que o canal 1 do osciloscópio com escala de 100mV por divisão está conectado em PB0, ou seja, onde está o feedback de corrente do circuito. Já o canal 2 com escala de 2V por divisão encontra-se em PB12 que é o sinal de PWM vindo do microcontrolador. Vejam que legal!
STM32F334-Conversor-Buck.mov
5.35 MBE então caro leitor, o que achou? Seria interessante substituir um complexo e caro controle analógico por uma CPU que pode dar conta de controlar seu próximo projeto de iluminação LED? Além disso, seria legal deixar os periféricos da CPU tomar conta de controlar de forma precisa e robusta seu circuito de iluminação, enquanto que a CPU propriamente dita tome conta de tarefas de comunicação ou mesmo de cálculos de efeitos complexos uma vez que 72MHz com o set SIMD e a FPU fazem do STM32F334 um verdadeiro canhãozinho para construção de dispositivos de iluminação LED inteligente e robusta.
Espero que tenham gostado desse nosso primeiro experimento, e que este seja útil nos seus projetos. Na próxima parte do artigo, antes de seguirmos para o complexo buck-boost bidirecional onboard, vamos aproveitar o poderoso HRTIM na sua máxima capacidade e sintetizar algumas formas de onda com o filtro passa-baixas que vem embarcado na discovery.
Então é isso, até a próxima!
Série “Digital Power com STM32F334”
- Introdução a Digital Power com os processadores STM32F334 – Parte I
- Digital Power com STM32F334 – Conversor Buck para controle de LED de alto brilho – Parte II
- Digital Power com STM32F334 – Conversor Boost Síncrono – Parte III
- Digital Power com STM32F334 – Firmware Conversor Boost Síncrono “Open Loop” – Parte IV
Referências
Manual de hardware da placa discovery STM32F334
ERICKSON, W. Robert – Fundamentals of Power Electronics , 2001
AN4885 – High brightness LED dimming using the STM32F334 Discovery kit
OpenSTM32 – System Workbench for STM32
Projeto de firmware do controlador de brilho
Figura 1 – Fonte: Manual de hardware da placa STM32F334 Discovery
Muito bom o artigo Felipe! Texto com linguagem clara e direta…. Ainda com link do código fonte e com o application do fabricante. Se todos os artigos/posts na internet fossem dessa forma ninguém passaria trabalho 😉