Hi R,
Hi N and R,
Ian, if the chip has PPS then you can use 1 CCP module and switch it's output to the relevant pin.
Hi All,
program, which simulates ok.
I did a similar thing a long time ago but had to write the port value on interrupt which caused jitter (1/2 cycles). With PPS, accuracy could be cycle perfect and any jitter eliminated.
/*
* File: servo_pwm_test.c
* Author: Robert
*
* Created on 08 May 2022, 20:40
*/
#include <16F18446.h>
#DEVICE PIC16F18446 ICD=1
#USE DELAY(internal=32MHz)
#USE FAST_IO(A)
#USE FAST_IO(B)
#USE FAST_IO(C)
#include <stdio.h>
#include <stdlib.h>
unsigned int16 ticks; // Counter for use in clock interrupt
int1 flag_20mS;
int8 index;
unsigned int16 servo_times[8];
unsigned int16 time_now;
unsigned int16 time_set;
unsigned int8 shift_reg;
//
// This is only used to set the flag to restart a new cycle every so often.
//
#INT_TIMER1
void t1_interrupt_routine(void) {
//
// Approx. 60Hz
//
ticks = ticks + 1;
// Trigger new cycle every other tick,
// to get greater than 20mS sequence interval.
if(ticks > 1) {
ticks = 0;
flag_20mS = 1;
}
}
#INT_CCP1
void ccp1_interrupt_routine(void) {
//
// This is executed at each new compare
//
// Get the timer present count for reference
time_now = get_timer1();
if(index < 8) { // All servos already done?
// No, do next servo
// Increment index for next servo time value
index = index + 1;
shift_reg <<= 1; // Shift the bit left one place.
// shift_reg = shift_reg + shift reg would do the same.
output_c(shift_reg); // Write the shift register bits to the port
time_set = time_now + servo_times[index]; // And set the duration for this output
CCP_1 = time_set; // Write the compare time to CCP 1 register.
}
else {
output_c(0); // Turn off all servo bits.
// And do nothing with timing - the interrupt would be
// triggered again after a full counter cycle, in ~15mS
// Which again will just clear the outputs, unless a new
// sequence has been started by the 20mS flag.
}
}
/*
*
*/
int main(int argc, char** argv) {
set_tris_c(0); // Port C all outputs
setup_adc(ADC_OFF);
// OSC = 32 MHz.
// Timer source: Internal = osc / 4; 8 MHz.
// T1 = A 16 bit timer used as the timebase
// Divide by 8 prescale = 1MHz input clock
// With 16 bit count, overflow will occur approx. every 16mS, 60Hz.
setup_timer_1(T1_INTERNAL | T1_DIV_BY_8);
// Without an output pin defined, just an interrupt from CCP
setup_ccp1(CCP_COMPARE_TOGGLE);
//
// With this timing, 1mS = 1000 counts;
// servo 1mS to 2mS = 1000 to 2000,
// with 1500 as mid point.
//
//
//
// For demonstration, I'm setting the servo times
// to various fixed values.
//
// Set them from your program as needed.
//
servo_times[0] = 1500; // Port bit 0, Mid position
servo_times[1] = 1100; // Port bit 1, Near min position
servo_times[2] = 1900; // Port bit 2, Near max position
servo_times[3] = 1300; // Port bit 3, Under mid position
servo_times[4] = 1700; // Port bit 4, Over mid position
servo_times[5] = 1200; // Port bit 5, etc
servo_times[6] = 1800; // Port bit 6
servo_times[7] = 1400; // Port bit 7
// And enable the interrupts for the hardware used
enable_interrupts(GLOBAL);
enable_interrupts(INT_TIMER1);
enable_interrupts(INT_CCP1);
// Main loop
for(;;) {
if(flag_20mS == 1) {
// Set up new cycle
index = 0;
shift_reg = 1; // Set a bit that will be at port bit 0.
time_now = get_timer1(); // Get the timer present count
output_c(shift_reg); // Write the shift register bits to the port
time_set = time_now + servo_times[index]; // And set the first duration
CCP_1 = time_set; // Write the compare time to CCP 1 register.
// Reset the new cycle flag after it has been seen.
flag_20mS = 0;
}
//
// Rest of the program here onwards.
// No delay or wait loops!
//
}
return (0);
}Hi Ian,
/*
* File: servo_pwm_test_v2.c
* Author: Robert Jenkins
*
* Created on 09 May 2022, 09:45
*
*
* Better optimised version, more consistent output timing and
* no timer interrupt or anything needed in main program section,
* beyond the initialisations.
*
* The main program loop can have delays or wait loops,
* as long as interrupts are never blocked.
*
*/
#include <16F18446.h>
#DEVICE PIC16F18446 ICD=1
#USE DELAY(internal=32MHz)
#USE FAST_IO(A)
#USE FAST_IO(B)
#USE FAST_IO(C)
int8 index;
unsigned int16 servo_times[8];
unsigned int16 time_now;
unsigned int16 time_set;
unsigned int8 shift_reg;
#INT_CCP1
void ccp1_interrupt_routine(void) {
//
// This is executed at each new compare
//
shift_reg <<= 1; // Shift the bit left one place.
// shift_reg = shift_reg + shift reg would do the same.
output_c(shift_reg); // Write the shift register bits to the port
// Increment index for next servo time value
index = index + 1;
if(index < 8) { // All servos already done?
// No, do next servo
// Set the duration for this output, as a new offset
// from the last compare time.
time_set = time_set + servo_times[index];
CCP_1 = time_set; // Write the compare time to CCP 1 register.
}
else {
// No output needed as the port is already updated.
// output_c(0); // Turn off all servo bits.
// Add a fixed time increment for delays before
// restarting the sequence.
time_set = time_set + 1500; // add 1.5mS for the next interrupt
// Update CCP
CCP_1 = time_set;
if(index > 15) {
// 15 * average 1.5mS = 22.5mS, a reasonable frame repeat time
// Set up for a new sequence
index = 0;
shift_reg = 1; // Set a bit that will be at port bit 0.
time_now = get_timer1(); // Get the timer present count
time_set = time_now + servo_times[index]; // And set the first duration
output_c(shift_reg); // Write the shift register bits to the port
CCP_1 = time_set; // Write the compare time to CCP 1 register.
}
}
}
/*
*
*/
int main(int argc, char** argv) {
set_tris_c(0); // Port C all outputs
setup_adc(ADC_OFF);
// OSC = 32 MHz.
// Timer source: Internal = osc / 4; 8 MHz.
// T1 = A 16 bit timer used as the timebase
// Divide by 8 prescale = 1MHz input clock
// With 16 bit count, overflow will occur approx. every 16mS, 60Hz.
setup_timer_1(T1_INTERNAL | T1_DIV_BY_8);
// Without an output pin defined, just an interrupt from CCP
setup_ccp1(CCP_COMPARE_TOGGLE);
//
// With this timing, 1mS = 1000 counts;
// servo 1mS to 2mS = 1000 to 2000,
// with 1500 as mid point.
//
//
//
// For demonstration, I'm setting the servo times
// to various fixed values.
//
// Set them from your program as needed.
//
servo_times[0] = 1500; // Port bit 0, Mid position
servo_times[1] = 1100; // Port bit 1, Near min position
servo_times[2] = 1900; // Port bit 2, Near max position
servo_times[3] = 1300; // Port bit 3, Under mid position
servo_times[4] = 1700; // Port bit 4, Over mid position
servo_times[5] = 1200; // Port bit 5, etc
servo_times[6] = 1800; // Port bit 6
servo_times[7] = 1400; // Port bit 7
// And enable the interrupts for the hardware used
// Timer 1 is free running after initialisation & only used as
// the reference for CCP1, so no time interrupt required.
enable_interrupts(GLOBAL);
enable_interrupts(INT_CCP1);
// Main loop
for(;;) {
//
// Nothing needed here for servos, it's all in the CCP interrupt.
//
// Rest of the program here onwards.
//
}
return (0);
}Hi R,
Hi I,
Though so..
I don't have any of those, but it has the same 16 bit timer1 and CCP1 references timer1 for the compare time, just like the 16F446 I used for my test setup, so it should be able to work just the same on that device.
timer1 is set up to run with a 1MHz clock, so giving 1uS steps to the servo output pulse durations.
Hi R,
