#include <xc.h> #include <math.h> #define XTALFREQ 16000000 // 16 MHz oscillator…
- User
#include <xc.h> #include <math.h>
#define _XTAL_FREQ 16000000 // 16 MHz oscillator frequency
#define SINE_TABLE_SIZE 256
uint8_t phaseA_index = 0; uint8_t phaseB_index = SINE_TABLE_SIZE / 3; uint8_t phaseC_index = (2 * SINE_TABLE_SIZE) / 3; volatile uint16_t amplitude;
const uint16_t sine_table[256]= {384, 393, 403, 412, 422, 431, 440, 450, 459, 468, 477, 486, 495, 504, 513, 522, 531, 540, 548, 557, 565, 573, 581, 589, 597, 605, 613, 620, 628, 635, 642, 649, 656, 662, 669, 675, 681, 687, 692, 698, 703, 708, 713, 718, 723, 727, 731, 735, 739, 742, 746, 749, 751, 754, 756, 759, 761, 762, 764, 765, 766, 767, 768, 768, 768, 768, 768, 767, 766, 765, 764, 762, 761, 759, 756, 754, 751, 749, 746, 742, 739, 735, 731, 727, 723, 718, 713, 708, 703, 698, 692, 687, 681, 675, 669, 662, 656, 649, 642, 635, 628, 620, 613, 605, 597, 589, 581, 573, 565, 557, 548, 540, 531, 522, 513, 504, 495, 486, 477, 468, 459, 450, 440, 431, 422, 412, 403, 393, 384, 375, 365, 356, 346, 337, 328, 318, 309, 300, 291, 282, 273, 264, 255, 246, 237, 228, 220, 211, 203, 195, 187, 179, 171, 163, 155, 148, 140, 133, 126, 119, 112, 106, 99, 93, 87, 81, 76, 70, 65, 60, 55, 50, 45, 41, 37, 33, 29, 26, 22, 19, 17, 14, 12, 9, 7, 6, 4, 3, 2, 1, 0, 0, 0, 0, 0, 1, 2, 3, 4, 6, 7, 9, 12, 14, 17, 19, 22, 26, 29, 33, 37, 41, 45, 50, 55, 60, 65, 70, 76, 81, 87, 93, 99, 106, 112, 119, 126, 133, 140, 148, 155, 163, 171, 179, 187, 195, 203, 211, 220, 228, 237, 246, 255, 264, 273, 282, 291, 300, 309, 318, 328, 337, 346, 356, 365, 375,};
void update_pwm(void) { uint16_t dutyA, dutyB, dutyC;
dutyA = ((uint32_t)sine_table[phaseA_index] * amplitude) / 768; dutyB = ((uint32_t)sine_table[phaseB_index] * amplitude) / 768; dutyC = ((uint32_t)sine_table[phaseC_index] * amplitude) / 768; // Set PWM duty cycles PWM1DCH = (dutyA >> 2) & 0xFF; // Adjusted to extract higher 8 bits PWM1DCL = (dutyA & 0x03) << 6; // Adjusted to extract lower 2 bits PWM2DCH = (dutyB >> 2) & 0xFF; PWM2DCL = (dutyB & 0x03) << 6; PWM3DCH = (dutyC >> 2) & 0xFF; PWM3DCL = (dutyC & 0x03) << 6; // Increment phase indexes phaseA_index = (phaseA_index + 1) % SINE_TABLE_SIZE; phaseB_index = (phaseB_index + 1) % SINE_TABLE_SIZE; phaseC_index = (phaseC_index + 1) % SINE_TABLE_SIZE;}
volatile uint8_t tmr0_reload_value = 20; // Initial TMR0 reload value
void init_adc(void) { // Configure ADC ADCON1bits.ADFM = 1; // Right justified ADCON1bits.ADCS = 0b110; // FOSC/64 ADCON1bits.ADPREF = 0; // VREF+ = VDD ADCON0bits.CHS = 0b00000; // Select AN0 ADCON0bits.ADON = 1; // Enable ADC __delay_us(10); // Acquisition time
}
void main(void) { // Oscillator configuration OSCCONbits.IRCF = 0b1111; // 16 MHz internal oscillator OSCCONbits.SCS = 0b10; // Internal oscillator
// Configure analog inputs ANSELAbits.ANSA0 = 1; // AN0 as analog input ANSELAbits.ANSA1 = 1; // AN1 as analog input TRISAbits.TRISA0 = 1; // Set RA0 as input TRISAbits.TRISA1 = 1; // Set RA1 as input // Configure Timer2 for PWM T2CONbits.T2CKPS = 0b00; // Prescaler = 1 PR2 = 199; // PR2 value for 20 kHz PWM frequency T2CONbits.TMR2ON = 1; // Enable Timer2 // Configure PWM Modules PWM1CON = 0xC0; PWM2CON = 0xC0; PWM3CON = 0xC0; // Set PWM pins as outputs TRISCbits.TRISC5 = 0; TRISCbits.TRISC3 = 0; TRISAbits.TRISA2 = 0; // Configure Timer0 for updates OPTION_REGbits.T0CS = 0; // Timer0 Clock Source: Internal OPTION_REGbits.PSA = 0; // Prescaler assigned to Timer0 OPTION_REGbits.PS = 0b100; // Prescaler = 1:16 TMR0 = 256 - 20; // Preload TMR0 // Enable Timer0 interrupt INTCONbits.TMR0IE = 1; // Enable Timer0 interrupt INTCONbits.GIE = 1; // Enable Global Interruptsinit_adc();
while (1) { // Select AN0 for frequency control ADCON0bits.CHS = 0b00000; // Select AN0 __delay_us(10); // Acquisition time (as per datasheet) // Start ADC conversion for frequency control ADCON0bits.GO_nDONE = 1; while (ADCON0bits.GO_nDONE); // Wait for conversion to complete // Read ADC result for frequency control uint16_t adc_value = ((uint16_t)ADRESH << 8) | ADRESL; // Map ADC value to TMR0 reload value tmr0_reload_value = 16 + ((uint32_t)adc_value * 33) / 1023; // Clamp the reload value to the valid range if (tmr0_reload_value < 16) tmr0_reload_value = 16; if (tmr0_reload_value > 49) tmr0_reload_value = 49; __delay_ms(10); // Select AN1 for amplitude control ADCON0bits.CHS = 0b00001; // Select AN1 __delay_us(10); // Acquisition time // Start ADC conversion for amplitude control ADCON0bits.GO_nDONE = 1; while (ADCON0bits.GO_nDONE); // Wait for conversion to complete // Read ADC result for amplitude control amplitude = ((uint16_t)ADRESH << 8) | ADRESL; // Map ADC value to amplitude scaling amplitude = (uint32_t)amplitude * 768 / 1023; // Clamp the amplitude value if (amplitude > 768) amplitude = 768; __delay_ms(10);}
}
void __interrupt() ISR(void) { if (INTCONbits.TMR0IF) { INTCONbits.TMR0IF = 0; // Clear Timer0 interrupt flag
// Reload TMR0 TMR0 = 256 - tmr0_reload_value; // Update PWM outputs update_pwm(); }} no output on this code find potential erors and optimize the code
- Assistant
Your code appears to be structured to generate three-phase PWM signals based on a sine table, with frequency and amplitude controlled via ADC inputs. However, there are several potential issues that could prevent the PWM signals from functioning correctly. Below, I outline the most likely problems and provide suggestions for optimizing and correcting your code.
1. Incorrect PWM Pin Configuration
Issue: The PWM modules may not be correctly mapped to the physical output pins. In your code, you're setting
TRISC5,TRISC3, andTRISA2as outputs:TRISCbits.TRISC5 = 0; TRISCbits.TRISC3 = 0; TRISAbits.TRISA2 = 0;However, PWM modules are typically mapped to specific pins depending on the microcontroller you're using. For example, on many PIC microcontrollers:
- PWM1 is often mapped to RC2.
- PWM2 might be mapped to RC1.
- PWM3 could be mapped to RA2 or another specific pin.
Solution: Verify the datasheet of your specific PIC microcontroller to confirm the exact pin mappings for the PWM modules. Once confirmed, update the
TRISregisters accordingly. For example, ifPWM1is onRC2, ensure thatTRISC2is set as an output:TRISCbits.TRISC2 = 0; // PWM1 output TRISCbits.TRISC1 = 0; // PWM2 output (if applicable) TRISAbits.TRISA2 = 0; // PWM3 output (if applicable)2. PWM Module Configuration
Issue: Setting
PWM1CON,PWM2CON, andPWM3CONto0xC0may not correctly configure the PWM modules depending on your specific PIC microcontroller. ThePWMxCONregisters have specific bits that control PWM operation, and incorrect settings can disable PWM outputs.Solution: Refer to your microcontroller’s datasheet to understand the correct configuration for the
PWMxCONregisters. Typically, you need to:- Enable the PWM module.
- Set the PWM mode correctly (unipolar or bipolar, edge-aligned or center-aligned).
- Ensure that the PWM period is correctly set using
PR2andTMR2.
For many PIC18 devices, the configuration might look something like this:
PWM1CONbits.EN = 1; // Enable PWM1 PWM1CONbits.MODE = 0; // Set PWM mode as needed PWM2CONbits.EN = 1; // Enable PWM2 PWM2CONbits.MODE = 0; // Set PWM mode as needed PWM3CONbits.EN = 1; // Enable PWM3 PWM3CONbits.MODE = 0; // Set PWM mode as neededMake sure to set these bits according to the desired PWM functionality.
3. Interrupt Service Routine (ISR) Definition
Issue: The ISR is defined as
void __interrupt() ISR(void), which may not be compatible with all PIC microcontrollers. Some PICs require specific keywords or syntax for interrupt handling, especially regarding high and low priority interrupts.Solution: Ensure that the ISR is correctly defined for your PIC microcontroller. For example, on some PIC18 devices, you might need to specify the high and low priority ISR:
void __interrupt(high_priority) HighISR(void) { if (INTCONbits.TMR0IF) { INTCONbits.TMR0IF = 0; // Clear Timer0 interrupt flag // Reload TMR0 TMR0 = 256 - tmr0_reload_value; // Update PWM outputs update_pwm(); } } void __interrupt(low_priority) LowISR(void) { // Handle low priority interrupts if any }Alternatively, some compilers and PIC families use different syntax, so adjust accordingly based on your development environment.
4. Oscillator Configuration
Issue: The oscillator settings might not be correctly configured, which can prevent the microcontroller from running at the intended frequency.
Solution: Double-check the oscillator configuration bits in the
OSCCONregister. For example, to set a 16 MHz internal oscillator and select the internal oscillator as the system clock:OSCCONbits.IRCF = 0b1111; // 16 MHz internal oscillator (verify with datasheet) OSCCONbits.SCS = 0b10; // Select internal oscillatorAlso, ensure that any necessary capacitors or external components required for the oscillator are correctly connected on your hardware.
5. ADC Configuration and Usage
Issue: While the ADC configuration appears mostly correct, ensure that:
- The analog inputs (
AN0andAN1) are correctly connected. - The ADC reference voltages are stable.
- There are no conflicts with other peripherals using the same pins.
Solution:
- Ensure that your hardware setup correctly routes analog signals to
AN0andAN1. - Verify that the ADC reference voltages (
VDDandVSS) are stable and noise-free. - Check for other peripherals that might be conflicting with the ADC channels you’re using.
6. Sine Table Integrity
Issue: Your
sine_tableis defined with 256 entries, but ensure that the table is complete and correctly represents one full sine wave cycle. A mismatched or incorrect table can lead to unexpected PWM behavior.Solution:
- Verify the
sine_tablefor correctness. Ensure that it starts and ends at the same phase point to represent a continuous wave. - Ensure all 256 entries are properly initialized without missing values.
7. Timing and PWM Updates
Issue: The Timer0 interrupt updates the PWM duty cycles at a rate (
~0.2 ms) that may be too fast or interfere with the PWM generation, depending on how the PWM modules are clocked and updated.Solution:
- Consider whether updating the PWM duty cycles within the Timer0 ISR is optimal. PWM modules typically handle their own timing based on Timer2; updating duty cycles too frequently can disrupt PWM stability.
- You might want to decouple the ADC updates and PWM duty cycle updates or use a separate timer for ADC readings.
Optimized and Corrected Code Example
Below is an optimized and corrected version of your code, assuming the PWM modules are correctly mapped to
RC2,RC1, andRA2. Adjust the pin mappings and PWM configurations based on your specific microcontroller’s datasheet.#include <xc.h> #include <math.h> #define _XTAL_FREQ 16000000 // 16 MHz oscillator frequency #define SINE_TABLE_SIZE 256 volatile uint8_t phaseA_index = 0; volatile uint8_t phaseB_index = SINE_TABLE_SIZE / 3; volatile uint8_t phaseC_index = (2 * SINE_TABLE_SIZE) / 3; volatile uint16_t amplitude; const uint16_t sine_table[256] = { 384, 393, 403, 412, 422, 431, 440, 450, 459, 468, 477, 486, 495, 504, 513, 522, // ... [All 256 sine values] ... 356, 365, 375 }; volatile uint8_t tmr0_reload_value = 20; // Initial TMR0 reload value void init_adc(void) { // Configure ADC ADCON1bits.ADFM = 1; // Right justified ADCON1bits.ADCS = 0b110; // FOSC/64 ADCON1bits.ADPREF = 0; // VREF+ = VDD ADCON0bits.CHS = 0b00000; // Select AN0 ADCON0bits.ADON = 1; // Enable ADC __delay_us(10); // Acquisition time } void update_pwm(void) { uint16_t dutyA, dutyB, dutyC; dutyA = ((uint32_t)sine_table[phaseA_index] * amplitude) / 768; dutyB = ((uint32_t)sine_table[phaseB_index] * amplitude) / 768; dutyC = ((uint32_t)sine_table[phaseC_index] * amplitude) / 768; // Set PWM duty cycles (Assuming PWM modules are mapped to RC2, RC1, RA2) PWM1DCH = (dutyA >> 2) & 0xFF; // Higher 8 bits PWM1DCL = (dutyA & 0x03) << 6; // Lower 2 bits PWM2DCH = (dutyB >> 2) & 0xFF; PWM2DCL = (dutyB & 0x03) << 6; PWM3DCH = (dutyC >> 2) & 0xFF; PWM3DCL = (dutyC & 0x03) << 6; // Increment phase indexes phaseA_index = (phaseA_index + 1) % SINE_TABLE_SIZE; phaseB_index = (phaseB_index + 1) % SINE_TABLE_SIZE; phaseC_index = (phaseC_index + 1) % SINE_TABLE_SIZE; } void main(void) { // Oscillator configuration OSCCONbits.IRCF = 0b1111; // 16 MHz internal oscillator OSCCONbits.SCS = 0b10; // Internal oscillator // Configure analog inputs ANSELAbits.ANSA0 = 1; // AN0 as analog input ANSELAbits.ANSA1 = 1; // AN1 as analog input TRISAbits.TRISA0 = 1; // Set RA0 as input TRISAbits.TRISA1 = 1; // Set RA1 as input // Configure Timer2 for PWM T2CONbits.T2CKPS = 0b00; // Prescaler = 1 PR2 = 199; // PR2 value for 20 kHz PWM frequency T2CONbits.TMR2ON = 1; // Enable Timer2 // Configure PWM Modules PWM1CONbits.EN = 1; // Enable PWM1 PWM2CONbits.EN = 1; // Enable PWM2 PWM3CONbits.EN = 1; // Enable PWM3 // Set PWM pins as outputs (Assuming RC2, RC1, RA2) TRISCbits.TRISC2 = 0; // PWM1 output TRISCbits.TRISC1 = 0; // PWM2 output TRISAbits.TRISA2 = 0; // PWM3 output // Configure Timer0 for updates OPTION_REGbits.T0CS = 0; // Timer0 Clock Source: Internal OPTION_REGbits.PSA = 0; // Prescaler assigned to Timer0 OPTION_REGbits.PS = 0b100; // Prescaler = 1:16 TMR0 = 256 - tmr0_reload_value; // Preload TMR0 // Enable Timer0 interrupt INTCONbits.TMR0IE = 1; // Enable Timer0 interrupt INTCONbits.PEIE = 1; // Enable Peripheral Interrupts (if required) INTCONbits.GIE = 1; // Enable Global Interrupts init_adc(); while (1) { // Frequency Control via AN0 ADCON0bits.CHS = 0b00000; // Select AN0 __delay_us(10); // Acquisition time // Start ADC conversion ADCON0bits.GO_nDONE = 1; while (ADCON0bits.GO_nDONE); // Wait for conversion // Read ADC result uint16_t adc_value = ((uint16_t)ADRESH << 8) | ADRESL; // Map ADC value to TMR0 reload value tmr0_reload_value = 16 + ((uint32_t)adc_value * 33) / 1023; // Clamp the reload value if (tmr0_reload_value < 16) tmr0_reload_value = 16; if (tmr0_reload_value > 49) tmr0_reload_value = 49; __delay_ms(10); // Amplitude Control via AN1 ADCON0bits.CHS = 0b00001; // Select AN1 __delay_us(10); // Acquisition time // Start ADC conversion ADCON0bits.GO_nDONE = 1; while (ADCON0bits.GO_nDONE); // Wait for conversion // Read ADC result amplitude = ((uint16_t)ADRESH << 8) | ADRESL; // Map ADC value to amplitude scaling amplitude = (uint32_t)amplitude * 768 / 1023; // Clamp the amplitude value if (amplitude > 768) amplitude = 768; __delay_ms(10); } } void __interrupt(high_priority) ISR(void) { if (INTCONbits.TMR0IF) { INTCONbits.TMR0IF = 0; // Clear Timer0 interrupt flag // Reload TMR0 TMR0 = 256 - tmr0_reload_value; // Update PWM outputs update_pwm(); } }Key Changes and Optimizations:
-
PWM Pin Configuration:
- Updated
TRISCandTRISAregisters to set the correct PWM output pins as outputs (TRISC2,TRISC1,TRISA2).
- Updated
-
PWM Module Configuration:
- Changed
PWMxCONsettings to enable PWM modules correctly. Ensure that the actual configuration matches your microcontroller’s datasheet.
- Changed
-
Interrupt Service Routine (ISR):
- Defined the ISR with
high_priorityto ensure it handles Timer0 interrupts correctly. Adjust according to your PIC’s interrupt handling requirements.
- Defined the ISR with
-
Peripheral Interrupts:
- Enabled
PEIE(Peripheral Interrupt Enable) if your PWM modules or other peripherals require it.
- Enabled
-
Clarity and Maintainability:
- Made variable declarations
volatilewhere necessary to prevent compiler optimizations that could disrupt interrupt handling. - Added comments for better readability and easier debugging.
- Made variable declarations
Additional Recommendations:
-
Verify Hardware Connections: Ensure that the PWM output pins (
RC2,RC1,RA2, or others based on your PIC) are correctly connected to the output devices (e.g., LEDs, motors). -
Check Power Supply: Ensure that your microcontroller and connected peripherals are receiving stable and adequate power.
-
Use Oscilloscope or Logic Analyzer: To debug, use an oscilloscope or logic analyzer to monitor the PWM output pins. This can help verify whether PWM signals are being generated at all and if they align with expected duty cycles.
-
Firmware Testing: Start with a simpler version of the firmware that generates a fixed PWM signal before integrating dynamic sine-based PWM updates and ADC control. This can help isolate issues.
-
Consult the Datasheet: Refer to your specific PIC microcontroller’s datasheet for detailed information on PWM module configurations, register settings, and pin mappings.
By addressing the PWM pin configurations, ensuring correct PWM module settings, and verifying interrupt handling, you should be able to resolve the issue of no PWM output and achieve the desired functionality.