OC SW - Software Output Compare

dsPIC30F dsPIC33F dsPIC33E dsPIC33C dsPIC33A PIC32

☀️ Light

The MCHP_OC_SW block provides interrupt-driven software output compare functionality. Unlike hardware OC which operates autonomously, this block uses timer interrupts to precisely time output pin changes, offering greater flexibility at the cost of CPU overhead.

The MCHP_OC_SW block provides interrupt-driven software output compare functionality. Unlike hardware OC which operates autonomously, this block uses timer interrupts to precisely time output pin changes, offering greater flexibility at the cost of CPU overhead.

Key Features

• Interrupt-driven timing - Software updates output pins via timer interrupts
• Multiple operational modes - Up/Down edges, Period control, Toggle
• Dynamic timing changes - Frequency and duty cycle adjustable at runtime
• Automatic timer allocation - Uses MCHP_Fun.TimerConfig() for resource management
• Flexible pin mapping - Works with any GPIO pin (not limited to OC pins)
• Period input support - Dynamic frequency control via Simulink signal

Comparison: OC_HW vs OC_SW

Device Support

Block Parameters

Channel Configuration

Operational Modes

Implementation Details

Software Algorithm

// Interrupt-driven output compare (Mode 3 example)
void __attribute__((__interrupt__, no_auto_psv)) _T2Interrupt(void)

    TMR2 = 0;            // Reset timer for next event
    IFS0bits.T2IF = 0;   // Clear interrupt flag
}

Timer Allocation

The block automatically allocates timers using MCHP_Fun.TimerConfig():

% Timer allocation example (from callback)
[TimerNbr, TimerName] = MCHP_Fun.TimerConfig(...
    blk, ...              % Block handle
    'OC_SW', ...          % Resource type
    Channel, ...          % Channel number
    MCHP ...              % MCHP structure
);

% Returns:
%   TimerNbr: Timer number allocated (2, 3, 4, 5, etc.)
%   TimerName: String identifier ('Timer2', 'Timer3', etc.)

Register Configuration

// Timer setup (example for Timer2)
T2CONbits.TON = 0;         // Stop timer during configuration
T2CONbits.TCS = 0;         // Internal clock (FCY)
T2CONbits.TCKPS = prescaler; // Set prescaler

PR2 = period_value;        // Set period
TMR2 = 0;                  // Clear timer count

IFS0bits.T2IF = 0;         // Clear interrupt flag
IEC0bits.T2IE = 1;         // Enable timer interrupt
T2CONbits.TON = 1;         // Start timer

// GPIO configuration
TRISAbits.TRISA0 = 0;      // Set as output
LATAbits.LATA0 = 0;        // Initialize low

Block Usage Examples

Example 1: Variable Frequency Square Wave

Application: Generate square wave with dynamically adjustable frequency

% Block parameters
Channel: 1
Mode: 32                   % Toggle mode
InputPeriod: 'is a block input'
PIN_OC1: 'RA0'

% Simulink model
[Frequency Command] → [1/f Calculator] → [Gain: FCY/2]
                   → [OC1_Toggle input]

% Example: For 1 kHz output at 60 MHz FCY
% Toggle period = 60,000,000 / (2 × 1000) = 30,000 counts
% This creates 1 kHz square wave (toggle every 500 µs)

Example 2: Precise Pulse Width Modulation

Application: Servo motor control with microsecond precision

% Block parameters
Channel: 1
Mode: 5                    % Up + Period
InputPeriod: 'is a parameter'
Period: 20000              % 20 ms for servo (50 Hz)
PIN_OC1: 'RB3'

% Simulink model
[Servo Angle -90 to +90] → [Gain & Offset: 1000-2000 µs]
                        → [OC1_Up input]

% Creates 1-2 ms pulses at 50 Hz for standard servo control
% Pulse width determines servo angle

Example 3: Asymmetric PWM for Power Supplies

Application: Buck converter with independent rise/fall timing

% Block parameters
Channel: 1
Mode: 3                    % Up & Down (independent control)
PIN_OC1: 'RC2'

% Simulink model
[Voltage Controller] → [Dead-time Compensator]
                    → [OC1_Up: Rising edge timing]
                    → [OC1_Down: Falling edge timing]

% Allows precise control of both edges for:
% - Dead-time insertion
% - Resonant switching optimization
% - Frequency modulation

Example 4: Multi-Channel Synchronized Outputs

Application: Three-phase waveform generation

% Block parameters
Channel: [1 2 3]
Mode: [32 32 32]           % Toggle mode for all
InputPeriod: 'is a parameter'
Period: 1000               % Base frequency

% Simulink configuration
% Three separate OC_SW blocks with phase-shifted initialization:
% Block 1: Initial state HIGH, starts at t=0
% Block 2: Initial state HIGH, starts at t=T/3
% Block 3: Initial state HIGH, starts at t=2T/3

% Creates 120° phase-shifted square waves

Timing Considerations

Interrupt Latency

        Typical latency: 10-50 instruction cycles
        Jitter sources: Other interrupts, CPU priority, cache misses
        Mitigation: Use high interrupt priority, minimize concurrent interrupts

CPU Overhead Estimation

Resolution and Limits

Maximum frequency: Limited by interrupt service time

• Practical limit: ~100 kHz (with 1:1 prescaler @ 60 MHz)
• Recommended range: 1 Hz - 50 kHz for stable operation
• For higher frequencies: Use MCHP_OC_HW or MCHP_PWM instead

Troubleshooting

Common Issues

Output Frequency Incorrect

• Timer prescaler: Verify automatic prescaler calculation
• Period calculation: Check FCY (instruction frequency) setting
• Timer overflow: Period value must fit in 16-bit PR register (0-65535)
• Mode confusion: Toggle mode frequency = 1/(2 × toggle_period)

Timing Jitter or Instability

• Interrupt conflicts: Check for higher-priority interrupts delaying service
• CPU load: Reduce background task complexity
• Timer sharing: Ensure timer not used by multiple peripherals
• Cache effects: Code located in slow memory (PIC32)

No Output Signal

• Pin configuration: Verify GPIO pin is available and not used elsewhere
• Timer allocation: Check MCHP_Fun.TimerConfig() succeeded
• Interrupt enable: Verify timer interrupt is enabled in IEC register
• Model execution: Ensure Simulink model is running (External Mode or deployed)

Performance Optimization

Reducing Interrupt Overhead

// Optimize ISR for minimal latency
void __attribute__((__interrupt__, no_auto_psv)) _T2Interrupt(void)
    __attribute__((section(".critical_code")));  // Place in fast RAM

// Use inline assembly for time-critical sections (dsPIC)
void __attribute__((__interrupt__, no_auto_psv)) _T2Interrupt(void)

### Best Practices

- **Use toggle mode (32)** when possible - simplest and fastest
- **Minimize ISR complexity** - only update timer and output pin
- **Pre-calculate values** - avoid math in interrupt handlers
- **Choose appropriate prescaler** - balance resolution vs overflow risk
- **Consider hardware alternatives** - use OC_HW if CPU overhead is concern

## Related Blocks

- [**MCHP_OC_HW**](output_compare_hw) - Hardware output compare (lower CPU overhead)
- [**MCHP_TIMER_Config**](../timers/timer_config) - Timer resource management
- [**MCHP_IC**](input_capture) - Measure external pulse timing
- [**MCHP_PWM**](../pwm_io/pwm) - Dedicated PWM peripheral
- [**MCHP_Digital_Output**](../digital_io/digital_output) - Basic GPIO output control

## See Also

### Application Notes

- [AN1156](https://www.microchip.com/AN1156)
- [AN580](https://www.microchip.com/AN580)