Skip to content
TheChatArchiveThe Chat Archive
gpt-4-0314· openaiHugging Face Suzhen/CodeChat

crie um sistema de SpaceVectorPWM para usar no esp32 com o framework do arduino, eu…

  1. User

    crie um sistema de SpaceVectorPWM para usar no esp32 com o framework do arduino, eu quero que o sistema do inversor seja modular e mega preciso nos calculos

  2. Assistant

    Para criar um sistema Space Vector PWM (SVPWM) para uso no ESP32 com o framework do Arduino, você precisará dividir o projeto em várias partes. Primeiro, vamos nos concentrar no desenvolvimento da parte de software utilizando o framework do Arduino e, em seguida, conectar o ESP32 aos módulos necessários para criar um inversor modular e extremamente preciso. Vou te guiar pelo processo passo a passo.

    Passo 1: Instalar e configurar o ambiente de desenvolvimento

    1. Instale o Arduino IDE no seu computador. Disponível em: https://www.arduino.cc/en/software
    2. Instale a placa "ESP32" no Arduino IDE.
      • Abra o Arduino IDE, vá em "Arquivo" > "Preferências" (ou "Arduino" > "Preferências" no macOS).

      • Adicione o seguinte URL no campo "URLs adicionais de gerenciador de placas": https://dl.espressif.com/dl/package_esp32_index.json

      • Vá em “Ferramentas” > “Placa” > “Gerenciador de placas…” e procure por "esp32". Instale a placa "esp32" desenvolvida pela Espressif Systems.

    Passo 2: Desenvolver a biblioteca SVPWM

    Crie um novo arquivo chamado "SVPWM.h" com a seguinte estrutura:

    #ifndef SVPWM_H
    #define SVPWM_H
    
    #include <Arduino.h>
    
    class SVPWM
    {
    public:
      SVPWM(uint8_t pinA, uint8_t pinB, uint8_t pinC);
      void begin(float frequency, uint8_t resolution);
      void setDutyCycle(float alpha, float beta);
    
    private:
      uint8_t _pinA, _pinB, _pinC;
      uint32_t _maxDuty, _halfDuty;
    
      void writePins(uint32_t dutyA, uint32_t dutyB, uint32_t dutyC);
    };
    
    #endif // SVPWM_H
    

    Crie outro arquivo chamado "SVPWM.cpp" contendo as funções e algoritmos do SVPWM:

    #include "SVPWM.h"
    
    SVPWM::SVPWM(uint8_t pinA, uint8_t pinB, uint8_t pinC)
        : _pinA(pinA), _pinB(pinB), _pinC(pinC)
    {
    }
    
    void SVPWM::begin(float frequency, uint8_t resolution)
    {
      _maxDuty = (1L << resolution) - 1;
      _halfDuty = _maxDuty >> 1;
    
      ledcSetup(0, frequency, resolution);
      ledcSetup(1, frequency, resolution);
      ledcSetup(2, frequency, resolution);
    
      ledcAttachPin(_pinA, 0);
      ledcAttachPin(_pinB, 1);
      ledcAttachPin(_pinC, 2);
    }
    
    void SVPWM::setDutyCycle(float alpha, float beta)
    {
      // Calcule as larguras de pulso dos vetores
      long dutyA = (long)((_halfDuty * alpha) + _halfDuty);
      long dutyB = (long)((_halfDuty * beta) + _halfDuty);
      long dutyC = _maxDuty - dutyA - dutyB;
    
      // Escreva os valores nos PWMs
      writePins(dutyA, dutyB, dutyC);
    }
    
    void SVPWM::writePins(uint32_t dutyA, uint32_t dutyB, uint32_t dutyC)
    {
      ledcWrite(0, dutyA);
      ledcWrite(1, dutyB);
      ledcWrite(2, dutyC);
    }
    

    Passo 3: Criar o sketch principal

    Crie um novo sketch no Arduino IDE e adicione o seguinte código:

    #include "SVPWM.h"
    
    // Defina os pinos PWM dos inversores
    const uint8_t PIN_A = 25;
    const uint8_t PIN_B = 26;
    const uint8_t PIN_C = 27;
    
    SVPWM svpwm(PIN_A, PIN_B, PIN_C);
    
    void setup()
    {
      // Inicializa SVPWM com frequência de 20kHz e resolução de 10 bits
      svpwm.begin(20000, 10);
    }
    
    void loop()
    {
      // Defina o ciclo de trabalho com valores alpha e beta com base nos requisitos do sistema
      svpwm.setDutyCycle(0.5, 0.1); // Exemplo de valores alpha e beta
    
      delay(100); // Defina o intervalo de atualização conforme necessário
    }
    

    Passo 4: Conectar os componentes eletrônicos

    Conecte os pinos A, B e C selecionados do ESP32 aos respectivos drivers de gate de seu inversor modular. Certifique-se de usar um circuito de proteção adequado e que os componentes suportem as especificações necessárias.

    Em resumo, criamos a biblioteca SVPWM para facilitar a implementação do SVPWM no ESP32. Você pode ajustar os valores de frequência e resolução do PWM para suas necessidades específicas e controlar o inversor usando os valores alpha e beta. Lembre-se de considerar as precauções de segurança ao trabalhar com eletrônicos de alta potência.

  3. User

    serão duas chaves IGBT para cada chave, lembre-se que deverá ter tambem o deadtime para evitar curtos ao trocar da chave A para a chave B do mesmo braço

  4. Assistant

    Para implementar o controle de deadtime, você pode modificar a biblioteca SVPWM adicionando funções para calcular e aplicar o deadtime apropriado. Aqui está uma versão atualizada da biblioteca SVPWM que inclui o controle de deadtime.

    1. Modifique "SVPWM.h" adicionando a variável _deadTime, assim como atualiza a função begin() para incluir o parâmetro float deadTimeMicros:
    #ifndef SVPWM_H
    #define SVPWM_H
    
    #include <Arduino.h>
    
    class SVPWM
    {
    public:
      SVPWM(uint8_t pinA1, uint8_t pinA2, uint8_t pinB1, uint8_t pinB2, uint8_t pinC1, uint8_t pinC2);
      void begin(float frequency, uint8_t resolution, float deadTimeMicros);
      void setDutyCycle(float alpha, float beta);
    
    private:
      uint8_t _pinA1, _pinA2, _pinB1, _pinB2, _pinC1, _pinC2;
      uint32_t _maxDuty, _halfDuty;
      uint32_t _deadTime;
    
      void writePins(uint32_t dutyA, uint32_t dutyB, uint32_t dutyC);
    };
    
    #endif // SVPWM_H
    
    1. Atualize "SVPWM.cpp" para incluir as alterações mencionadas:
    #include "SVPWM.h"
    
    SVPWM::SVPWM(uint8_t pinA1, uint8_t pinA2, uint8_t pinB1, uint8_t pinB2, uint8_t pinC1, uint8_t pinC2)
        : _pinA1(pinA1), _pinA2(pinA2), _pinB1(pinB1), _pinB2(pinB2), _pinC1(pinC1), _pinC2(pinC2)
    {
    }
    
    void SVPWM::begin(float frequency, uint8_t resolution, float deadTimeMicros)
    {
      _maxDuty = (1L << resolution) - 1;
      _halfDuty = _maxDuty >> 1;
      _deadTime = round(deadTimeMicros * frequency * (1L << resolution) / 1000000L);
    
      ledcSetup(0, frequency, resolution);
      ledcSetup(1, frequency, resolution);
      ledcSetup(2, frequency, resolution);
      ledcSetup(3, frequency, resolution);
      ledcSetup(4, frequency, resolution);
      ledcSetup(5, frequency, resolution);
    
      ledcAttachPin(_pinA1, 0);
      ledcAttachPin(_pinA2, 1);
      ledcAttachPin(_pinB1, 2);
      ledcAttachPin(_pinB2, 3);
      ledcAttachPin(_pinC1, 4);
      ledcAttachPin(_pinC2, 5);
    }
    
    void SVPWM::setDutyCycle(float alpha, float beta)
    {
      long dutyA1 = (long)((_halfDuty * alpha) + _halfDuty);
      long dutyA2 = max(0L, dutyA1 - _deadTime);
      
      long dutyB1 = (long)((_halfDuty * beta) + _halfDuty);
      long dutyB2 = max(0L, dutyB1 - _deadTime);
    
      long dutyC1 = _maxDuty - dutyA1 - dutyB1;
      long dutyC2 = max(0L, dutyC1 - _deadTime);
      
      writePins(dutyA1, dutyA2, dutyB1, dutyB2, dutyC1, dutyC2);
    }
    
    void SVPWM::writePins(uint32_t dutyA1, uint32_t dutyA2, uint32_t dutyB1, uint32_t dutyB2, uint32_t dutyC1, uint32_t dutyC2)
    {
      ledcWrite(0, dutyA1);
      ledcWrite(1, dutyA2);
      ledcWrite(2, dutyB1);
      ledcWrite(3, dutyB2);
      ledcWrite(4, dutyC1);
      ledcWrite(5, dutyC2);
    }
    
    1. Atualize o sketch principal para acomodar as alterações:
    #include "SVPWM.h"
    
    // Defina os pinos PWM dos chaves IGBT
    const uint8_t PIN_A1 = 25;
    const uint8_t PIN_A2 = 26;
    const uint8_t PIN_B1 = 27;
    const uint8_t PIN_B2 = 14;
    const uint8_t PIN_C1 = 12;
    const uint8_t PIN_C2 = 13;
    
    SVPWM svpwm(PIN_A1, PIN_A2, PIN_B1, PIN_B2, PIN_C1, PIN_C2);
    
    void setup()
    {
      // Inicializa SVPWM com frequência de 20kHz, resolução de 10 bits e um deadtime de 1 microssegundo
      svpwm.begin(20000, 10, 1.0);
    }
    
    void loop()
    {
      // Defina o ciclo de trabalho com valores alpha e beta com base nos requisitos do sistema
      svpwm.setDutyCycle(0.5, 0.1); // Exemplo de valores alpha e beta
    
      delay(100); // Defina o intervalo de atualização conforme necessário
    }
    

    Essas alterações incluem a adição do controle de deadtime no sistema SVPWM, a fim de evitar curtos-circuitos ao trocar entre a chave A e B no mesmo braço. A função writePins agora também controla as chaves IGBT complementares, aplicando o deadtime calculado. No exemplo acima, um deadtime de 1µs é usado, mas pode ser ajustado de acordo com as necessidades do sistema.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.