PIC32 Pulse timing in hardware.

[waltr]

Discussion of PIC coding started in JLKing's Bi-polar detector thread here:
https://www.geotech1.com/forums/show...-and-Front-End

I am moving continued discussion to this thread so we don't fill King's thread.

The PIC32MX and EZ series have a peripheral called 'Output compare'. What these can do is generate a "generate continuous output pulses onOCx pin".

This is perfect for controlling a PI (pulse inductor) TX using only one OC and with additional OC timing and outputs do Sample pulsing, RX clamping, Bipolar TX pulses, etc. The resolution of the pulses generated is only dependent of the PBCLK which clocks a hardware timer (TMRx). Typical PBCLKs are 1/2 of system clock which is 40 or 50MHz for PIC32MX and up to 200MHz for PIC32MZ EF. This means with the MZ pulse time resolution is 10nsec but only 40nsec in MX.

In addition each OCx can produce and interrupt. The ISR can then take action at precise times (plus ISR latency).

For a PI detector this OCx ISR can start another Timer that triggers ADC sample/convert.
These PICs also have a DMA engine that can be triggered from ADC interrupt flag.
The combination can then be setup so TX pulse then RX ADC sampling can be all in hardware.

I will post code sections as examples on how to setup and code.

Please ask questions and post code example you come up with.

[waltr]

Here is code that sets up 9 OC modules to do the timing required for JLKing's Bi-polar PI.

#include <sys/attribs.h>
#include "oc.h"

void OC_Initialize (void)
{
    // ON = 1 enabled  
    // SIDL = 0 disabled
    // OC32 = 0 16-bit Mode;  
    // OCTSEL = 0 Timerx -> TMR2      
    // OCM = 101 Initialize OCx pin low; generate continuous output pulses on OCx pin
    // OCxCON = 1000 0000 0000 0101 = 0x8005
    // Based on PBCLK = 100 MHz
     
    // OCxR =  Rising edge
    // OCxRS = Falling edge
    // OC interrupts on Falling edge or OCxRS match
    
    // OC1 init - TX1   R@10us--F@260us: 250us pulse
    OC1R    = 0x01F4;      // 500
    OC1RS   = 0x32C8;     // 13000
    OC1CON  = 0x8005;    // 1000 0000 0000 0101
//    CFGCON<16> = 0  
 
    // OC2 init - TX2   R@510us--F@760us: 250us pulse
    OC2R    = 0x639C;        // 25500
    OC2RS   = 0x9470;       // 38000
    OC2CON  = 0x8005;      // 1000 0000 0000 0101  
    
    // OC3 init - TX_B1     [email protected]@14.42us: 4.41us pulse
    OC3R    = 0x01F5;      // 501
    OC3RS   = 0x02D1;     // 721
    OC3CON  = 0x8005;    // 1000 0000 0000 0101
    
    // OC4 init - TX_B2     [email protected]@514.42us: 4.41us pulse
    OC4R    = 0x639D;      // 25501
    OC4RS   = 0x6478;     // 25720
    OC4CON  = 0x8005;    // 1000 0000 0000 0101

    // OC5 init - SW    R@9us--F@509us: 500us pulse
    OC5R    = 0x01C2;      // 450
    OC5RS   = 0x636A;     // 25450
    OC5CON  = 0x8005;    // 1000 0000 0000 0101
    
    // OC6 init - Dp_1  R@[email protected]: 253.87us pulse
    OC6R    = 0x01C2;      // 450
    OC6RS   = 0x3357;     // 13143
    OC6CON  = 0x8005;    // 1000 0000 0000 0101
    
    // OC7 init - Rb_1  R@[email protected]: 254.37us pulse
    OC7R    = 0x01C2;      // 450
    OC7RS   = 0x3370;     // 13168
    OC7CON  = 0x8005;    // 1000 0000 0000 0101
    
    // OC8 init - Dp_2  R@[email protected]: 253.97us pulse
    OC8R    = 0x636B;      // 25451
    OC8RS   = 0x94FF;     // 38143
    OC8CON  = 0x8005;    // 1000 0000 0000 0101
    
    // OC9 init - Rb_2  R@[email protected]: 254.37us pulse
    OC9RS = 0x9518;       // 38424
    OC9R  = 0x636A;        // 25450
    OC9CON = 0x8005;    // 1000 0000 0000 0101
    
    
    // TMR2 init- this drives all OC modules
    // Period = 0.001s; PB Frequency = 100000000 Hz; 
    PR2 = 0xC350;   // 50000 cnts 
    
    // ON=enabled
    // SIDL=disabled
    // TGATE=disabled
    // TCKPS=1:2 pre-scaler
    // T32=16 Bit
    // TCS=PBCLK   
    T2CON = 0x8010;     // 0b 1000 0000 0001 0000

    IFS0CLR= 1 << _IFS0_T2IF_POSITION;
    TMR2 = 0x0000;      // clear
    // All OC outputs are now pulsing
    
//    IEC0SET = _IEC0_OC3IE_MASK;
//    IEC0SET = _IEC0_OC4IE_MASK;
    IEC0CLR = _IEC0_OC3IE_MASK;
    IEC0CLR = _IEC0_OC4IE_MASK;
}

// Start TX, S1 & S2 pulses from OC
void Start_pulses (void)
{
    T2CONSET = _T2CON_ON_MASK;          // start TMR2 & OC timing
    IFS0CLR = _IFS0_OC1IF_MASK;         // clear OC1 interrupt flag
    IEC0SET = _IEC0_OC1IE_MASK;         // enable OC1 interrupt
}

void Sample_pulses_on (void)
{
    OC2CONSET = _OC2CON_ON_MASK;  // OC module ON
    OC1CONSET = _OC1CON_ON_MASK;
    OC4CONSET = _OC4CON_ON_MASK;
}
void Sample_pulses_off (void)
{
    OC2CONCLR = _OC2CON_ON_MASK;  // OC module OFF
    OC1CONCLR = _OC1CON_ON_MASK;
    OC4CONCLR = _OC4CON_ON_MASK;
}

void en_OC1_int(void)
{
    IEC0SET = _IEC0_OC1IE_MASK;   // enable OC1 interrupt
}
void dis_OC1_int(void)
{
    IEC0CLR = _IEC0_OC1IE_MASK;   // disable OC1 interrupt
}

// OCxR =  Rising edge
// OCxRS = Falling edge
// OC interrupts on Falling edge or OCxRS match
//
// OC1 = TX1 pulse
// on falling edge start ADC conversions
void __attribute__((no_fpu)) __ISR(_OUTPUT_COMPARE_1_VECTOR, ipl5AUTO) _IntOC1(void)
{
    LATKINV = 0x0010;                   // K4 Ard_D2_T
    IFS0CLR = _IFS0_OC1IF_MASK;
    // Start the ADC
    IFS0bits.T3IF  = 0;
    TMR3 = 0;                           // reset TMR3 counts
    T3CONSET = _T3CON_ON_MASK;          // start timer to trigger ADC
}

[eclipse]

Finally I got this one sorted.

Tried doing this with Harmony, and Harmony3 it just bring me a huge headache.
Best stay away from it and code without Harmony.

Now It's working stable (Before this I tried this get done in the software - the best resolution is ~2.5uS and quite unstable if I try to add more things like reading pots; doing adc/pwm).
These PICs are not too bad if you don't push them too hard and know what to do (which in most cases I don't haha).

[KingJL]

Finally I got this one sorted.

Tried doing this with Harmony, and Harmony3 it just bring me a huge headache.
Best stay away from it and code without Harmony.

Now It's working stable (Before this I tried this get done in the software - the best resolution is ~2.5uS and quite unstable if I try to add more things like reading pots; doing adc/pwm).
These PICs are not too bad if you don't push them too hard and know what to do (which in most cases I don't haha).

Nice work!

I finally have the household move behind me and now am in the process of setting up my workspace/workbench. Setting up a permanent USB scope,pattern generator for my work bench using Raspberry PI 4 and Digilent Analog Discovery 2 (should receive the AD2 Friday). Should be able to get back to testing/tweaking the Bipolar PI sometime in the next week.

Again nice work!

[eclipse]

I used this blog for more information on PIC32MZ. It's great.

Give it a try for pulse generation using OC: https://www.aidanmocke.com/blog/2018/11/16/pwm/
Advanced topics like DMA, etc:
https://www.aidanmocke.com/blog/2019/01/08/DMA-Intro/
https://www.aidanmocke.com/blog/2019/01/07/DMA/

The owner hates Harmony which is also a big plus.

[waltr]

I also do not like Harmony. Tried following harmony examples and could not figure out what is being done.
Those aidanmocke links are pretty good introduction.

The OC example is what my code above does.

Been working on doing a VLF detector with a PIC32MZ. I am creating Sine wave output using a lookup table of values that is DMA'ed to the OC module. This produces a variable duty cycle output that then goes through a 4-pole Sallen-Key low pass filter. Get real nice and clean sine.
Also playing with multi-frequency sine. Same method, lookup table DMA to OC.
Here is the OC code:

#include <sys/attribs.h>
#include "oc.h"
#include "DSP_math.h"
#include "Cur20_globals.h"



// sine tables    
short sine_3khz[SINE_TABLE_N] = {   //32x1=32 3125Hz
    500, 589, 676, 755, 825, 882, 924, 951, 960, 951, 924, 882, 825, 755, 676, 589, 
    500, 410, 323, 244, 174, 117, 75, 48, 40, 48, 75, 117, 174, 244, 323, 410
};

short sine_6khz[SINE_TABLE_N] = {   //16*2=32 6250Hz
    500, 676, 825, 924, 960, 924, 825, 676, 500, 323, 174, 75, 40, 75, 174, 323,
    500, 676, 825, 924, 960, 924, 825, 676, 500, 323, 174, 75, 40, 75, 174, 323
};

short sine_9khz[SINE_TABLE_N] = {   //10.66*3=32 9375Hz
    512, 767, 936, 963, 837, 601, 335, 129, 52, 129, 335, 601,
    837, 963, 936, 767, 512, 256, 87, 60, 186, 422, 688, 894,
    972, 894, 688, 422, 186, 60, 87, 256
};

short sine_12khz[SINE_TABLE_N] = {  // 8x4=32 12500Hz
    500, 825, 960, 825, 500, 174, 40, 174,
    500, 825, 960, 825, 500, 174, 40, 174,
    500, 825, 960, 825, 500, 174, 40, 174,
    500, 825, 960, 825, 500, 174, 40, 174
};

// mix 3125 * 6250: products -> 3125 & 9375
short sine_3_6khz[SINE_TABLE_N] = {
    312, 463, 626, 768, 864, 887, 833, 713, 548, 373, 224, 128, 94, 117, 178, 251,
    312, 340, 330, 290, 231, 171, 123, 91, 77, 70, 66, 61, 60, 72, 112, 191, 
};

// mix 3125 * 9375: products -> 6250 & 1250
short sine_3_9khz[SINE_TABLE_N] = {
    312, 511, 694, 789, 751, 587, 364, 174, 101, 174, 364, 587,
    751, 789, 694, 511, 312, 158, 79, 65, 85, 104, 110, 104,
    101, 104, 110, 104, 85, 65, 79, 158
};

// mix 3125 * 1250: products -> 9375 & 15625
short sine_3_12khz[SINE_TABLE_N] = {
    312, 553, 719, 692, 479, 216, 99, 229, 548, 856, 960, 798, 479, 193, 86, 162,
    312, 403, 376, 264, 145, 74, 55, 61, 77, 100, 135, 158, 145, 98, 67, 128
};

volatile int sine_cnt;
volatile short* sine_table;

void OC_Initialize (void)
{
    // ON = 1 enabled  
    // SIDL = 0 disabled
    // OC32 = 0 16-bit Mode;  
    // OCTSEL = 0 Timerx -> TMR2      
    // OCM = 101 Initialize OCx pin low; generate continuous output pulses on OCx pin
    // OCxCON = 1000 0000 0000 0101 = 0x8005
    // Based on PBCLK = 100 MHz
     
    // OCxR =  Rising edge
    // OCxRS = Falling edge
    // OC interrupts on Falling edge or OCxRS match
    
    // OC1 init - TX sine
    OC1R    = 0x0190;      //
    OC1RS   = 0x02;     //
    OC1CON  = 0x8005;    // 1000 0000 0000 0101
//    CFGCON<16> = 0  
 
    // TMR2 init- this drives all OC modules
    // PB Frequency = 100000000 Hz; 
//    PR2 = 1024;   // Period = 10.24us;  
    PR2 = 1000;   // Period = 10.00us; 
    
    // ON=enabled
    // SIDL=disabled
    // TGATE=disabled
    // TCKPS=1:1 pre-scaler
    // T32=16 Bit
    // TCS=PBCLK   
    T2CON = 0x0000;     // 0b 0000 0000 0000 0000

    sine_cnt = 0;
    
    IFS0CLR= 1 << _IFS0_T2IF_POSITION;  // clean interrup flag
    TMR2 = 0x0000;      // clear
}

void start_OC_TMR2( void)
{
    T2CONSET = 0x8000;
}
void stop_OC_TMR2( void) 
{
    T2CONCLR = 0x8000;
}

Here is the DMA code for OC:

/* Turns on the DMA controller in the PIC */
void initDMA_global(void)
{
    DMACON = 0x0000;                    // clear all
    DMACONbits.ON = 1;                  // enable the DMA controller
    DCH0CONbits.CHPRI = 3;              // Channel 0 (ADC) priority (highest). 
                                        // channel off, priority 3, no chaining
    DCH1CONbits.CHPRI = 3;
    DCH0ECON = 0x0000;                  // clear all
    DCH1ECON = 0x0000;
} 

// This is the DMA1 setup for Memory -> OC1 sine generation
void initDMA1( short* sine_table)
{
    Ard_D2_T;
    DCH1CONCLR = _DCH1CON_CHEN_MASK;    // ensure DMA 1 is disabled to setup 
    while (DCH1CONbits.CHBUSY);         // wait for DMA = !busy
    IEC4CLR = _IEC4_DMA1IE_MASK;        // disable Interrupt
    IFS4CLR = _IFS4_DMA1IF_MASK;        // Clear flag
    DCH1ECON = 0x0000;
    
    
    // 7 = INTERRUPT NUMBER of _OUTPUT_COMPARE_1_VECTOR
    DCH1ECONbits.CHSIRQ = _OUTPUT_COMPARE_1_VECTOR;
    DCH1ECONSET = _DCH1ECON_SIRQEN_MASK;        // Channel Start IRQ Enable bit
 
    DCH1SSA = KVA_TO_PA((void*)sine_table);    // transfer source physical address
    DCH1DSA = KVA_TO_PA((void*)&OC1R);          // transfer destination physical address
    
    // move 16 bit data from Memory to OC1R
    // Source Size
    DCH1SSIZ = 2*SINE_TABLE_N;      // number of bytes to send to OC1R
    // Destination Size
    DCH1DSIZ = 2;       // Number of bytes to the destination
    // Cell Size
    DCH1CSIZ = 2;       // Cell Size of how many bytes to transfer per interrupt Event
 
    DCH1INT &= ~(0x00FF00FF);             // Clear flags in DMA controller channel 0
    DCH1INTSET = _DCH1INT_CHBCIE_MASK;    // Interrupt on block transfer complete
    DCH1INTSET = _DCH1INT_CHERIE_MASK;    // Interrupt on address errors
    DCH1INTSET = _DCH1INT_CHTAIE_MASK;    // Interrupt on transfer abort
//    DCH1INTSET = _DCH1INT_CHDDIE_MASK;      // dest done interrupt enable
    DCH1CONbits.CHAEN = 1;                  // Auto-enable keeps channel active ??
    DCH1CONbits.CHEN = 1;
    
    // Interrupt Priority moved to interrupt_manager.c
//    IPC33bits.DMA1IP = 7;
//    IPC33bits.DMA1IS = 3;

    IFS4CLR = _IFS4_DMA1IF_MASK;        // Clear DMA1 interrupt flag
    IEC4SET = _IEC4_DMA1IE_MASK;        // enable DMA1 interrupt
    DMACONbits.ON = 1; 
}

// Change the Table used 
void DMA_change_sine( short* sine_table)
{
    DCH1CONCLR = _DCH1CON_CHEN_MASK;    // ensure DMA 1 is disabled to setup 
    while (DCH1CONbits.CHBUSY);         // wait for DMA = !busy
    
    DCH1SSA = KVA_TO_PA((void*)sine_table);    // transfer source physical address
    DCH1CONbits.CHAEN = 1;                  // Auto-enable keeps channel active ??
    DCH1CONbits.CHEN = 1;
}
// ------------------------------------
//   DMA1 INTERRUPT  Memory -> OC cycle done
void __attribute__(( interrupt( ipl7SRS), at_vector(_DMA1_VECTOR),no_fpu)) 
    _IntHandlerSysDmaCh1(void)
{    
    // Channel Block Transfer Complete Interrupt Flag bit
    if (DCH1INTbits.CHBCIF == 1) { 
        Ard_D3_T;               // toggle pin Ard D3 -RJ12
        // sync ADC acquisitions with signal generation phase
        T3CONSET = _T3CON_ON_MASK;      // start ADC timer 
        gen_sig_done = 1;
        
    } else if (DCH1INTbits.CHDDIF == 1) {   // dest done
        UART2_string_Out("dd1");
    } else if (DCH1INTbits.CHERIF == 1) {   // address errors
        UART2_string_Out("ae1");
    } else if (DCH1INTbits.CHTAIF == 1) {   // transfer abort
        UART2_string_Out("ta1");
    } else if (DCH1INTbits.CHSDIF == 1) {   // 
        UART2_string_Out("sd1");
    }
    DCH1INTCLR = 0x000000ff;        // Clear flags in DMA controller channel 0
    IFS4CLR = _IFS4_DMA1IF_MASK;    // Clear interrupt flag
}

Note that in the OC DMA ISR Timer 3 is enabled. T3 runs the ADC conversions and this starts the ADC at the same phase on each Sine wave.

[eclipse]

Adding soft start is easy. I just did it so it must be easy..
Soft start is good to have because you give some time for the capacitors to charge and the whole circuit to stabilize before doing high current pulses:



OC4 is used for example for syncing boost or inverter circuit meanwhile so it's starts right away with circuit turn on.
The rest of the outputs start few seconds after that.

And the better way to do it (with delay_ms()) (updated!):

int main()
{
   //


    OC_init();
    
    Soft_Startup();
    
    while (1)
    {        
    }
}

void Soft_Startup()
{
    delay_ms(500);          // 1/2s
    
    OC6CONbits.ON = 1;        // Turn on Output Compare module 6 (OC6)
    OC7CONbits.ON = 1;        // Turn on Output Compare module 7 (OC7)
    OC8CONbits.ON = 1;        // Turn on Output Compare module 8 (OC8)
    OC5CONbits.ON = 1;        // Turn on Output Compare module 5 (OC5)
    OC9CONbits.ON = 1;        // Turn on Output Compare module 9 (OC9)
    OC1CONbits.ON = 1;        // Turn on Output Compare module 1 (OC1)
    OC2CONbits.ON = 1;        // Turn on Output Compare module 2 (OC2)
    OC3CONbits.ON = 1;        // Turn on Output Compare module 3 (OC3)
}

void delay_us(unsigned int us)
{
    // Convert microseconds us into how many clock ticks it will take
    us *= (SYS_FREQ / 1000000) / 2; // Core Timer updates every 2 ticks
                      
    _CP0_SET_COUNT(0); // Set Core Timer count to 0


    while (us > _CP0_GET_COUNT()); // Wait until Core Timer count reaches the number we calculated earlier
}
void delay_ms(int ms)
{
    delay_us(ms * 1000);
}

[waltr]

Not sure I would call this 'soft start'. What I see is simply a delay before starting the pulsing.

I do this is in 'main' between initializing the various software/hardware modules.
You are correct that one must allow time for power and circuits to stabilize.

Nice delay function using the CP0 timer.

[eclipse]

I've added reading ADC channel for Delay pot. It's a bit unstable I noticed if the potentiometer is half-way rotated between 2 values it glitches(i've limited it 30 steps so I can see
the timing jumping around a little bit better).
Im thinking to add averaging filter - taking 4 values and averaging the result. A buddy that's helping me out suggested trying to implement a digital filter.
What filtering you would suggest, any literature would be helpful or some coding examples?

[waltr]

I've added reading ADC channel for Delay pot. It's a bit unstable I noticed if the potentiometer is half-way rotated between 2 values it glitches(i've limited it 30 steps so I can see
the timing jumping around a little bit better).
Im thinking to add averaging filter - taking 4 values and averaging the result. A buddy that's helping me out suggested trying to implement a digital filter.
What filtering you would suggest, any literature would be helpful or some coding examples?

For simple 'relative' measurements like the Pot position, no need to average. Just take more samples (faster rate) and SUM them.
Now use the SUM (example if 4 measurements of 12-bit ADC value = 0 to (4*4096) or 0 to 16384. If only need 32 steps then right shift the sum 10 bits (steps = sum >> 16; ).
You could do a right shift before summing to keep the SUM value smaller. However, this is a 32bit processor so max native value is very big (+-2147483648 ).
That does depend on what you need to filter to do.
A FIR filter is the easiest to calculate coefficients and code. For sharper cut-offs the number of coefficients and execution time gets large.
An IIR filter has more design-able parameters but difficult to calculate coefficients. Can have sharper cut-cuts for less execution time.

Here are some links I use:

FIR filter design
http://t-filter.engineerjs.com/

coding example:
https://sestevenson.wordpress.com/im...g-in-c-part-1/

For IIR filters I have used the DSP_lib functions (these are written in assembler and use the PIC32's mips DSP instructions).
However, calculating the coefficients is hard and have only gotten 2nd order to work. It does work well and is fast. These DSP_lib function however use Q15 numbers but not hard to convert.
https://reference.digilentinc.com/le...s/unit-7/start

For higher order IIR filters I use code and coefficients from:
http://jaggedplanet.com/iir/iir-explorer.asp


Filter design:
http://www.iowahills.com/

[eclipse]

I'm more towards the averaging technique .

I used this before some time (https://www.geotech1.com/forums/cont...-4-Source-Code) for the PIC32MZ project, harmony based, Im doing a complete rewrite without Harmony and no stress. I may use it again.

tmp += CurrentSample; // tmp is effectively a 12-bit value
sampleCount++;

if(sampleCount == 4) // If we've accumulated 4 samples, then store
{
sampleArray[sampleIndex] = tmp>>2; // Store the current sample - 10 bits
sampleCount = 0;
tmp = 0;

sampleIndex++; // Increment the array pointer
if(sampleIndex == sampleArraySize) // If we're wrapping around...
sampleIndex = 0; // Set the pointer back to the beginning

SampleAve = 0;
for(i = 0; i < sampleArraySize; i++)// Average all the samples
SampleAve += sampleArray[i]; // This is effectively a 15-bit value

SampleAve >>= sampleAveShift; // Divide back down to a 10-bit value

trackArray[trackIndex] = SampleAve; // Store the average - 10 bits

trackIndex++; // Increment the array pointer
if(trackIndex == trackArraySize) // If we're wrapping around...
trackIndex = 0; // Set the pointer back to the beginning

TrackAve = 0;
for(i = 0; i < trackArraySize; i++) // Average all the averages
TrackAve += trackArray[i]; // This is effectively a 16-bit value

TrackAve >>= trackAveShift; // Divide back down to a 10-bit value
}

[Carl-NC]

For simple 'relative' measurements like the Pot position, no need to average. Just take more samples (faster rate) and SUM them.

Waltr: what you describe is averaging. Also a type of FIR filter, specifically a rectangular FIR filter.

Eclipse: it is good practice to put some capacitance on the pot's CT to discourage board noise from coupling into the ADC. As big as you can make it without slowing down the pot response. Usually bit-shifting (looking at, say, just the 5 MSBs) is enough to get stable readings but you can also average (as suggested) or add some hysteresis in code.

[ivconic]

Kalman filter, tried as well?

[Qiaozhi]

If you want to effectively increase the resolution of your ADC, you can use a process called "over-sampling and decimation".
Here is a very good reference document that describes this technique. I've used this in another project and it really works.

[Altra]

If you want to effectively increase the resolution of your ADC, you can use a process called "over-sampling and decimation".
Here is a very good reference document that describes this technique. I've used this in another project and it really works.

I use this method a lot. On a 10bit adc take 16 samples then divide by 4 or shift by 2 you get a smooth 12bit result.

@eclipse If you are only reading pots to control timings and not direct sampling. Try increasing your tad or acquisition time on your adc this will stabilize your readings. Along with the other suggestions.