Skip to content
The Chat Archive
gpt-4o-2024-05-13· OpenAI WildChat-4.8M (AI2)

set frequency arduino due

  1. User

    set frequency arduino due

  2. Assistant

    Setting the frequency of a PWM (Pulse Width Modulation) signal on an Arduino Due can be done by configuring the timers and setting appropriate registers. The Arduino Due is based on the Atmel SAM3X8E ARM Cortex-M3 CPU.

    Here is a basic guide to setting PWM frequency on the Arduino Due:

    Using PWM Library

    1. Include the PWM library: First, you need to install the Arduino Due PWM library if you don't have it installed. You can do this through the Arduino Library Manager.
    2. Example Code: You can use the library functions to set the PWM frequency. Here's how you can do it in code:
    #include <PWM.h>  // Include the PWM library
    
    // PWM setup constants
    const int pwmPin = 8;   // Pin number for PWM output
    int frequency = 1000;   // Desired frequency in Hz (change this value as needed)
    int dutyCycle = 128;    // Initial duty cycle (0-255 for 8-bit resolution)
    
    void setup() {
      // Initialize the PWM library
      InitTimersSafe();
      
      // Set the PWM frequency 
      SetPinFrequency(pwmPin, frequency);
      
      // Write initial duty cycle 
      pwmWrite(pwmPin, dutyCycle);
    }
    
    void loop() {
      // Add your code here to change duty cycle or frequency at runtime if needed
    }
    

    Manual Method (Direct Register Manipulation)

    If you prefer to have more control over the timers and registers, you can manually manipulate the registers. Here is an example showing how to change the frequency of a PWM signal on pin 6 of the Arduino Due:

    void setup() {
      // Set PWM frequency
      pmc_enable_periph_clk(PWM_INTERFACE_ID);                           // Enable PWM peripheral clock
      PWMC_ConfigureClocks(1000 * 256, 0, VARIANT_MCK / 2);              // Set PWM frequency: 1000*256 ticks per cycle, prescaler is 2
    
      PIOC->PIO_PDR |= PIO_PDR_P21;                                      // Disable PIO (pin mode on pin 6)
      PIOC->PIO_ABSR |= PIO_ABSR_P21;                                    // Set the peripheral type for the pin (B peripheral)
      PWMC_ConfigureChannel(PWM, 7, 0, 0);                               // Configure PWM channel (channel 7 for pin 6)
      
      PWMC_SetDutyCycle(PWM, 7, 128);                                    // Set the duty cycle (0-255 for 8-bit resolution)
      PWMC_EnableChannel(PWM, 7);                                        // Enable PWM channel
    }
    
    void loop() {
      // Your code here to change duty cycle or frequency
      // Example: dynamically change the duty cycle
      // PWMC_SetDutyCycle(PWM, 7, updatedDutyCycle);
    }
    

    Explanation:

    1. pmc_enable_periph_clk(PWM_INTERFACE_ID): Enables the clock for the PWM peripheral.
    2. PWMC_ConfigureClocks(1000 * 256, 0, VARIANT_MCK / 2): Configures the PWMC controller clocks. The first parameter is the frequency, multiplied by the number of ticks per cycle (256 for 8-bit resolution).
    3. PIO_PDR and PIO_ABSR register manipulations configure the pin's peripheral functions.
    4. PWMC_ConfigureChannel, PWMC_SetDutyCycle, and PWMC_EnableChannel set up the PWM channel, duty cycle, and enable it, respectively.

    Conclusion

    These methods allow you to control the frequency of PWM signals on the Arduino Due, useful for applications needing variable motor control, LED dimming, or custom signal generation. Pick the method best suited to your comfort level and application requirements.

  3. User

    установка частоты 60 Гц на arduino due на пины 3 и 5

  4. Assistant

    Для установки частоты PWM сигнала 60 Гц на пины 3 и 5 на Arduino Due, нужно сконфигурировать соответствующие таймеры и регистры. Вот пример кода, который поможет вам достичь этого:

    Пример кода

    Этот код настраивает частоту 60 Гц с помощью манипуляции регистрами. Обратите внимание, что PWM на пинах 3 и 5 Arduino Due связан с PWM каналами 7 и 6 соответственно.

    #include <Arduino.h>
    
    void setup() {
      // Enable PWM clock
      pmc_enable_periph_clk(PWM_INTERFACE_ID);
    
      // Disable PIO (pin mode) and set peripheral type for output pins 3 and 5
      PIOC->PIO_PDR |= PIO_PDR_P7 | PIO_PDR_P5;
      PIOC->PIO_ABSR |= PIO_ABSR_P7 | PIO_ABSR_P5;
    
      // Configure PWM clocks (frequency configuration: 60 Hz)
      PWMC_ConfigureClocks(60 * 256, 0, VARIANT_MCK);  // 60 Hz frequency with 8-bit resolution
    
      // Configure PWM channel for pin 3 (PWM channel 7)
      PWMC_ConfigureChannel(PWM, 7, PWM_CMR_CPRE_CLKA, 0, 0);
      PWMC_SetPeriod(PWM, 7, 255);  // Set the period for 8-bit resolution
      PWMC_SetDutyCycle(PWM, 7, 127);  // Set initial duty cycle (50%)
      PWMC_EnableChannel(PWM, 7);
    
      // Configure PWM channel for pin 5 (PWM channel 6)
      PWMC_ConfigureChannel(PWM, 6, PWM_CMR_CPRE_CLKA, 0, 0);
      PWMC_SetPeriod(PWM, 6, 255);  // Set the period for 8-bit resolution
      PWMC_SetDutyCycle(PWM, 6, 127);  // Set initial duty cycle (50%)
      PWMC_EnableChannel(PWM, 6);
    }
    
    void loop() {
      // Your code to adjust the duty cycle dynamically
      // For example:
      // PWMC_SetDutyCycle(PWM, 7, newDutyCycleForPin3);
      // PWMC_SetDutyCycle(PWM, 6, newDutyCycleForPin5);
    }
    

    Объяснение кода:

    1. Инициализация таймеров:

      pmc_enable_periph_clk(PWM_INTERFACE_ID);
      

      Включает тактирование для PWM интерфейса.

    2. Настройка выводов:

      PIOC->PIO_PDR |= PIO_PDR_P7 | PIO_PDR_P5;
      PIOC->PIO_ABSR |= PIO_ABSR_P7 | PIO_ABSR_P5;
      

      Отключает режим PIO (режим ввода/вывода) и назначает пинам 3 и 5 периферийные функции.

    3. Конфигурация частоты PWM:

      PWMC_ConfigureClocks(60 * 256, 0, VARIANT_MCK);
      

      Настраивает генератор тактовых сигналов PWM на частоту 60 Гц с 8-битным разрешением.

    4. Настройка каналов PWM:

      PWMC_ConfigureChannel(PWM, 7, PWM_CMR_CPRE_CLKA, 0, 0);
      PWMC_SetPeriod(PWM, 7, 255);
      PWMC_SetDutyCycle(PWM, 7, 127);
      PWMC_EnableChannel(PWM, 7);
      

      Конфигурирует канал PWM для пина 3 (канал 7), задает период и начальный коэффициент заполнения.

      То же самое выполняется для пина 5 (канал 6).

    Этот пример создает PWM сигнал с частотой 60 Гц и начальным коэффициентом заполнения 50% на пинах 3 и 5. Вы можете изменять коэффициент заполнения в функции loop(), используя PWMC_SetDutyCycle() для соответствующих каналов.

  5. User

    установка pwm сигнала на частоте 60 Гц на arduino due на пины 3 и 5

  6. Assistant

    Для установки PWM сигнала с частотой 60 Гц на Arduino Due для пинов 3 и 5, вам потребуется манипулировать таймерами и регистрами контроллера напрямую. Ниже предоставлен пример кода, который конфигурирует PWM сигнал с частотой 60 Гц и начальным коэффициентом заполнения 50%.

    Пример Кода

    void setup() {
      // Включаем тактовую частоту для PWM интерфейса
      pmc_enable_periph_clk(PWM_INTERFACE_ID);
      
      // Настройка частоты PWM: 60 Гц
      PWMC_ConfigureClocks(60 * 255, 0, VARIANT_MCK);  // 60 Гц при 8-битном разрешении
      
      // Настройка вывода 3 (соответствует PWM каналу 7)
      PIOC->PIO_PDR |= PIO_PDR_P7;              // Отключаем режим GPIO для пина 3 (PC7)
      PIOC->PIO_ABSR |= PIO_ABSR_P7;            // Назначаем периферию B для пина 3 (PC7)
    
      // Конфигурация PWM канала 7 для пина 3
      PWMC_ConfigureChannel(PWM, 7, PWM_CMR_CPRE_CLKA, 0, 0);
      PWMC_SetPeriod(PWM, 7, 255);              // Настройка периода для 8-битного разрешения
      PWMC_SetDutyCycle(PWM, 7, 128);           // Устанавливаем начальный коэффициент заполнения 50%
      PWMC_EnableChannel(PWM, 7);
    
      // Настройка вывода 5 (соответствует PWM каналу 6)
      PIOC->PIO_PDR |= PIO_PDR_P5;              // Отключаем режим GPIO для пина 5 (PC5)
      PIOC->PIO_ABSR |= PIO_ABSR_P5;            // Назначаем периферию B для пина 5 (PC5)
    
      // Конфигурация PWM канала 6 для пина 5
      PWMC_ConfigureChannel(PWM, 6, PWM_CMR_CPRE_CLKA, 0, 0);
      PWMC_SetPeriod(PWM, 6, 255);              // Настройка периода для 8-битного разрешения
      PWMC_SetDutyCycle(PWM, 6, 128);           // Устанавливаем начальный коэффициент заполнения 50%
      PWMC_EnableChannel(PWM, 6);
    }
    
    void loop() {
      // Здесь вы можете добавить код для динамического изменения коэффициента заполнения
    
      // Пример: изменение коэффициента заполнения для пина 3
      // PWMC_SetDutyCycle(PWM, 7, новый_коэффициент_заполнения);
    
      // Пример: изменение коэффициента заполнения для пина 5
      // PWMC_SetDutyCycle(PWM, 6, новый_коэффициент_заполнения);
    }
    

    Объяснение кода

    1. Включение тактовой частоты для периферии PWM:

      pmc_enable_periph_clk(PWM_INTERFACE_ID);
      

      Эта команда включает тактовую частоту для интерфейса PWM.

    2. Настройка частоты PWM

      PWMC_ConfigureClocks(60 * 255, 0, VARIANT_MCK);
      

      Здесь конфигурируется частота PWM в 60 Гц с использованием внутреннего тактового сигнала микроконтроллера и 8-битного разрешения (255 шагов).

    3. Настройка вывода 3:

      PIOC->PIO_PDR |= PIO_PDR_P7;
      PIOC->PIO_ABSR |= PIO_ABSR_P7;
      

      Деактивирует режим GPIO и назначает периферию на пин 3 (PC7).

    4. Конфигурация и включение PWM канала:

      PWMC_ConfigureChannel(PWM, 7, PWM_CMR_CPRE_CLKA, 0, 0);
      PWMC_SetPeriod(PWM, 7, 255);
      PWMC_SetDutyCycle(PWM, 7, 128);
      PWMC_EnableChannel(PWM, 7);
      

      Эти команды конфигурируют и включают PWM канал 7 для вывода на пин 3 с заданной частотой в 60 Гц и начальным коэффициентом заполнения 50%.

    Для пина 5 (PWM канал 6) выполняются аналогичные операции.

    Этот код создает PWM сигнал с частотой 60 Гц на пинах 3 и 5. Вы можете изменять коэффициент заполнения, используя функцию PWMC_SetDutyCycle(), чтобы динамически регулировать сигнал в функции loop().

  7. User

    программы для разбери и ардуино реализующие передачи с распберри двух коэффициент заполнения шим сигналов которые ардуино дуе должна должна генерировать

  8. Assistant

    Для реализации системы, где Raspberry Pi отправляет два коэффициента заполнения (duty cycle) на Arduino Due для генерации PWM сигналов, необходимо написать соответствующие программы для обеих платформ. Код на Raspberry Pi будет отправлять данные по последовательному порту, а код на Arduino Due будет принимать эти данные и использовать их для управления сигналами PWM.

    Ниже приведены образцы кода для обеих платформ.

    Raspberry Pi (Отправка данных через последовательный порт)

    На Raspberry Pi будем использовать Python с библиотекой pyserial для отправки данных:

    import serial
    import time
    
    # Настраиваем последовательный порт
    ser = serial.Serial('/dev/ttyUSB0', 115200, timeout=1)
    
    def send_pwm_duty_cycles(duty_cycle1, duty_cycle2):
        # Формируем строку с коэффициентами заполнения, разделенными запятой
        data = f"{duty_cycle1},{duty_cycle2}\n"
        ser.write(data.encode())  # Отправляем строку
    
    try:
        while True:
            # Пример: отправляем коэффициенты заполнения 128 и 192
            send_pwm_duty_cycles(128, 192)
            time.sleep(1)  # Задержка 1 секунда для примера
    except KeyboardInterrupt:
        ser.close()
    

    Arduino Due (Прием данных и генерация PWM сигналов)

    На Arduino Due используйте следующий код для приема данных и управления PWM:

    void setup() {
      Serial.begin(115200);  // Настройка последовательного порта
      
      pmc_enable_periph_clk(PWM_INTERFACE_ID);  // Включаем тактовую частоту для PWM интерфейса
      PWMC_ConfigureClocks(60 * 255, 0, VARIANT_MCK);  // 60 Гц при 8-битном разрешении
    
      // Настройка вывода 3 (соответствует PWM каналу 7)
      PIOC->PIO_PDR |= PIO_PDR_P7;  
      PIOC->PIO_ABSR |= PIO_ABSR_P7;
      PWMC_ConfigureChannel(PWM, 7, PWM_CMR_CPRE_CLKA, 0, 0);  
      PWMC_SetPeriod(PWM, 7, 255);  
      PWMC_EnableChannel(PWM, 7);
    
      // Настройка вывода 5 (соответствует PWM каналу 6)
      PIOC->PIO_PDR |= PIO_PDR_P5;  
      PIOC->PIO_ABSR |= PIO_ABSR_P5;
      PWMC_ConfigureChannel(PWM, 6, PWM_CMR_CPRE_CLKA, 0, 0);
      PWMC_SetPeriod(PWM, 6, 255);
      PWMC_EnableChannel(PWM, 6);
    }
    
    void loop() {
      // Проверяем есть ли данные в последовательном порту
      if (Serial.available() > 0) {
        String incomingData = Serial.readStringUntil('\n');  // Читаем строку до символа новой строки
    
        // Разбираем строку на два числа
        int commaIndex = incomingData.indexOf(',');
        if (commaIndex > -1) {
          int dutyCycle1 = incomingData.substring(0, commaIndex).toInt();
          int dutyCycle2 = incomingData.substring(commaIndex + 1).toInt();
    
          // Устанавливаем коэффициенты заполнения для PWM каналов
          PWMC_SetDutyCycle(PWM, 7, dutyCycle1);  // Пин 3 / канал 7
          PWMC_SetDutyCycle(PWM, 6, dutyCycle2);  // Пин 5 / канал 6
        }
      }
    }
    

    Пояснение кода

    Raspberry Pi

    1. Настройка последовательного порта:

      ser = serial.Serial('/dev/ttyUSB0', 115200, timeout=1)
      

      '/dev/ttyUSB0' должен быть заменен на ваш конкретный порт.

    2. Отправка данных:

      def send_pwm_duty_cycles(duty_cycle1, duty_cycle2):
          data = f"{duty_cycle1},{duty_cycle2}\n"
          ser.write(data.encode())
      

      Формирует строку с коэффициентами заполнения, разделенную запятыми, и отправляет ее по последовательному порту.

    Arduino Due

    1. Настройка последовательного порта:

      Serial.begin(115200);
      
    2. Настройка и включение PWM каналов: аналогично предыдущему примеру.

    3. Чтение данных из последовательного порта и установка коэффициентов заполнения:

      if (Serial.available() > 0) {
        String incomingData = Serial.readStringUntil('\n');
        ...
        int dutyCycle1 = incomingData.substring(0, commaIndex).toInt();
        int dutyCycle2 = incomingData.substring(commaIndex + 1).toInt();
        PWMC_SetDutyCycle(PWM, 7, dutyCycle1);  // Пин 3 / канал 7
        PWMC_SetDutyCycle(PWM, 6, dutyCycle2);  // Пин 5 / канал 6
      }
      

    Этот код обеспечит передачу коэффициентов заполнения с Raspberry Pi на Arduino Due и генерацию соответствующих PWM сигналов на пинах 3 и 5.

  9. User

    Есть система в которй raspberry pi передает по usb два числа на ардуино due, которые затем ардуино использует чтобы сгенерировать ШИМ сигнал для которого эти числа являются коэффициентом заполнения. При этом ШИМ сигнал не запускается. Как исправить программу? const int frequency = 60; float kz_fb; // коэффициент заполнения от 6 до 12 float kz_lr; // коэффициент заполнения от 6 до 12 int tcrc_fb = frequency * 10000 + 100000; int tcrc_lr = frequency * 10000 + 100000; String LTrack; String RTrack;

    void setup() { Serial.begin(9600); pinMode(LED_BUILTIN, OUTPUT);

    pinMode(3, OUTPUT); pinMode(5, OUTPUT);

    // 3 пин PMC->PMC_PCER1 |= PMC_PCER1_PID34; // Включение питания для таймера TC7 - Timer Counter 2 channel 1 IS TC7 // 5 пин PMC->PMC_PCER1 |= PMC_PCER1_PID33;

    // 3 пин PIOC->PIO_PDR |= PIO_PDR_P28; // The pin is no more driven by GPIO PIOC->PIO_ABSR |= PIO_PC28B_TIOA7; // Periperal type B - See page 859 // 5 пин PIOC->PIO_PDR |= PIO_PDR_P25;
    PIOC->PIO_ABSR |= PIO_PC25B_TIOA6;

    // 3 пин TC2->TC_CHANNEL[1].TC_CMR = TC_CMR_TCCLKS_TIMER_CLOCK1 // MCK/2, clk on rising edge | TC_CMR_WAVE // Waveform mode | TC_CMR_WAVSEL_UP_RC // UP mode with automatic trigger on RC Compare | TC_CMR_ACPA_CLEAR // Clear TIOA7 on RA compare match -- See page 883 | TC_CMR_ACPC_SET; // Set TIOA7 on RC compare match

    // 5 пин
    TC2->TC_CHANNEL[0].TC_CMR = TC_CMR_TCCLKS_TIMER_CLOCK1 | TC_CMR_WAVE | TC_CMR_WAVSEL_UP_RC | TC_CMR_ACPA_CLEAR | TC_CMR_ACPC_SET;

    //---------------------------------------------- // 3 пин - вперёд/назад TC2->TC_CHANNEL[1].TC_RC = tcrc_fb; //<********************* Frequency = (Mck/2)/TC_RC Hz = 20 KHz TC2->TC_CHANNEL[1].TC_RA = (kz_fb * tcrc_fb) / 100; //<******************** Duty cycle = (TC_RA/TC_RC) * 100 %

    TC2->TC_CHANNEL[1].TC_IER = TC_IER_CPCS; // Interrupt on RC compare match NVIC_EnableIRQ(TC7_IRQn);

    TC2->TC_CHANNEL[1].TC_CCR = TC_CCR_SWTRG | TC_CCR_CLKEN; // Software trigger TC7 counter and enable

    // 5 пин - влево/вправо TC2->TC_CHANNEL[0].TC_RC = tcrc_lr;
    TC2->TC_CHANNEL[0].TC_RA = (kz_lr * tcrc_lr) / 100;

    TC2->TC_CHANNEL[0].TC_IER = TC_IER_CPCS; NVIC_EnableIRQ(TC6_IRQn);

    TC2->TC_CHANNEL[0].TC_CCR = TC_CCR_SWTRG | TC_CCR_CLKEN;

    }

    void TC6(float kz_fb, float kz_lr) { /if (kz_fb == 9.0) { digitalWrite(LED_BUILTIN, LOW); // turn the LED on (HIGH is the voltage level) delay(1000); // wait for a second digitalWrite(LED_BUILTIN, HIGH); // turn the LED off by making the voltage LOW delay(1000);
    }
    /

    //------------------------------------------- // 3 пин - вперёд/назад TC2->TC_CHANNEL[1].TC_RC = tcrc_fb; //<********************* Frequency = (Mck/2)/TC_RC Hz = 20 KHz TC2->TC_CHANNEL[1].TC_RA = (kz_fb * tcrc_fb) / 100; //<******************** Duty cycle = (TC_RA/TC_RC) * 100 %

    TC2->TC_CHANNEL[1].TC_IER = TC_IER_CPCS; // Interrupt on RC compare match NVIC_EnableIRQ(TC7_IRQn);

    TC2->TC_CHANNEL[1].TC_CCR = TC_CCR_SWTRG | TC_CCR_CLKEN; // Software trigger TC7 counter and enable // 5 пин - влево/вправо TC2->TC_CHANNEL[0].TC_RC = tcrc_lr;
    TC2->TC_CHANNEL[0].TC_RA = (kz_lr * tcrc_lr) / 100;

    TC2->TC_CHANNEL[0].TC_IER = TC_IER_CPCS; NVIC_EnableIRQ(TC6_IRQn);

    TC2->TC_CHANNEL[0].TC_CCR = TC_CCR_SWTRG | TC_CCR_CLKEN; //-----------------------------------------------

    TC2->TC_CHANNEL[1].TC_RA = (kz_fb * tcrc_fb) / 100; //<******************** Duty cycle = (TC_RA/TC_RC) * 100 % TC2->TC_CHANNEL[0].TC_RA = (kz_lr * tcrc_lr) / 100;
    }

    void loop() {

    if (Serial.available() > 0) { int combinedNumber = Serial.parseInt();

    int number1 = (combinedNumber >> 4) & 0xF; 
    int number2 = combinedNumber & 0xF;        
    
    kz_fb = number1;
    kz_lr = number2;
    
    
    Serial.println(number1);  
    

    }

    // kz_fb = 9.0; // kz_lr = 10.0;

    TC6(kz_fb, kz_lr);
    

    }

  10. Assistant

    Для решения проблемы с отсутствием генерации ШИМ сигнала на Arduino Due, давайте модифицируем ваш код, чтобы обеспечить правильную передачу данных и настройку таймеров. Назначим функции обработки прерываний таймеров и исправим передачу коэффициентов заполнения по последовательному порту.

    Модифицированный код

    Arduino Due

    const int frequency = 60;
    float kz_fb = 9.0; // начальный коэффициент заполнения для пина 3
    float kz_lr = 10.0; // начальный коэффициент заполнения для пина 5
    int tcrc_fb = frequency * 10000 + 100000;
    int tcrc_lr = frequency * 10000 + 100000;
    
    void setup() {
      Serial.begin(9600);
      pinMode(LED_BUILTIN, OUTPUT);
      pinMode(3, OUTPUT);
      pinMode(5, OUTPUT);
      
      // Включение питания для таймеров TC6 и TC7
      PMC->PMC_PCER1 |= PMC_PCER1_PID34;                     
      PMC->PMC_PCER1 |= PMC_PCER1_PID33;
      
      // Настройка пина 3 (PWM канал TC7)
      PIOC->PIO_PDR |= PIO_PDR_P28;                          
      PIOC->PIO_ABSR |= PIO_PC28B_TIOA7;                     
      
      // Настройка пина 5 (PWM канал TC6)
      PIOC->PIO_PDR |= PIO_PDR_P25;                          
      PIOC->PIO_ABSR |= PIO_PC25B_TIOA6;                     
      
      // Конфигурация таймера для пина 3
      TC2->TC_CHANNEL[1].TC_CMR = TC_CMR_TCCLKS_TIMER_CLOCK1 | // MCK/2, clk on rising edge
                                   TC_CMR_WAVE |                // Waveform mode
                                   TC_CMR_WAVSEL_UP_RC |        // UP mode with automatic trigger on RC Compare
                                   TC_CMR_ACPA_CLEAR |          // Clear TIOA7 on RA compare match
                                   TC_CMR_ACPC_SET;             // Set TIOA7 on RC compare match
      
      // Конфигурация таймера для пина 5
      TC2->TC_CHANNEL[0].TC_CMR = TC_CMR_TCCLKS_TIMER_CLOCK1 |
                                  TC_CMR_WAVE |
                                  TC_CMR_WAVSEL_UP_RC |
                                  TC_CMR_ACPA_CLEAR |
                                  TC_CMR_ACPC_SET;           
    
      // Установка периодов и начальных коэффициентов заполнения
      TC2->TC_CHANNEL[1].TC_RC = tcrc_fb;  
      TC2->TC_CHANNEL[1].TC_RA = (kz_fb * tcrc_fb) / 100;  
    
      TC2->TC_CHANNEL[0].TC_RC = tcrc_lr;  
      TC2->TC_CHANNEL[0].TC_RA = (kz_lr * tcrc_lr) / 100;
    
      // Разрешение прерываний по сравнению с RC
      TC2->TC_CHANNEL[1].TC_IER = TC_IER_CPCS;
      NVIC_EnableIRQ(TC7_IRQn);
    
      TC2->TC_CHANNEL[0].TC_IER = TC_IER_CPCS;
      NVIC_EnableIRQ(TC6_IRQn);
    
      // Запуск таймеров
      TC2->TC_CHANNEL[1].TC_CCR = TC_CCR_SWTRG | TC_CCR_CLKEN;
      TC2->TC_CHANNEL[0].TC_CCR = TC_CCR_SWTRG | TC_CCR_CLKEN;
    }
    
    void loop() {
      // Проверяем, есть ли данные в последовательном порту
      if (Serial.available() > 0) {
        // Читаем данные до новой строки
        String data = Serial.readStringUntil('\n');
        int commaIndex = data.indexOf(',');
    
        if (commaIndex != -1) {
          int number1 = data.substring(0, commaIndex).toInt();
          int number2 = data.substring(commaIndex + 1).toInt();
    
          // Обновляем коэффициенты заполнения
          kz_fb = number1;
          kz_lr = number2;
    
          // Обновляем значения коэффициентов заполнения
          updatePWM();
        }
      }
    }
    
    void updatePWM() {
      // 3 пин - вперёд/назад
      TC2->TC_CHANNEL[1].TC_RA = (kz_fb * tcrc_fb) / 100;  
      // 5 пин - влево/вправо
      TC2->TC_CHANNEL[0].TC_RA = (kz_lr * tcrc_lr) / 100;
    }
    
    void TC7_Handler() {
      // Очистка прерывания
      TC_GetStatus(TC2, 1);
    }
    
    void TC6_Handler() {
      // Очистка прерывания
      TC_GetStatus(TC2, 0);
    }
    

    Пояснение

    1. Инициализация последовательного порта и пинов: Код инициализирует последовательный порт и назначает пины 3 и 5 для использования в режиме PWM.

    2. Включение таймеров: Включается питание на таймеры TC6 и TC7, и они настраиваются для генерации PWM сигнала.

    3. Установка периодов и начальных коэффициентов заполнения: Период задается через регистр TC_RC, а коэффициент заполнения — через TC_RA.

    4. Включение прерываний и запуск таймеров: Устанавливаются прерывания и таймеры запускаются.

    5. Чтение данных из последовательного порта в функции loop(): Данные считываются до новой строки и разбиваются на два числа, которые затем используются для обновления коэффициентов заполнения.

    6. Функция updatePWM(): Обновляет коэффициенты заполнения для соответствующих каналов.

    7. Прерывания TC6_Handler и TC7_Handler: Обрабатывают прерывания от таймеров.

    Эти изменения должны помочь вам исправить проблемы с генерацией ШИМ сигнала. Убедитесь, что данные передаются правильно и что таймеры правильно конфигурированы для генерации сигналов нужной частоты.