Reblogged from RoboSlam:

• 
• 

RoboSlam starts with an introduction to the overall robot-building process and then delves into assembling the electronic components (i.e., building the circuitry).  The photos below track the progress of several groups of participants in the "Engineering Your Future" event held the week of May 13-17 at DIT.

These photos were all taken by DIT's current Fulbright Scholar in Engineering Education, Dr.

Read more… 31 more words

This program is a simple PWM example which moves a servo motor to one of two possible angles (0 degrees or 90 degrees) depending on the state of a digital input pin (RC4, pin 6). The PWM output signal is produced on pin 5 (CCP1).

I’m using the internal RC oscillator. This has a default Fosc of 1MHz, but in order to achieve a PWM period of 20ms (for the servo), I had to slow the clock down to 500kHz, which gives an instruction cycle of 8us.

//
// PIC18F14K50 servo PWM example program
// Written by Ted Burke (http://batchloaf.com)
// Last updated 22-4-2013
//
// To compile with XC8:
//     xc8 --chip=18F14K50 main.c
//
 
#include <xc.h>
 
#pragma config FOSC=IRC,MCLRE=OFF,WDTEN=0,LVP=OFF,BOREN=OFF
 
int main(void)
{
	// Set clock frequency to 500kHz, therefore Tcy = 8us
	OSCCONbits.IRCF = 0b010;
	
	// Set up PWM
	CCP1CON = 0b00001100;   // Enable PWM on CCP1
	TRISC = 0b11011111;		// Make CCP1 an output
	T2CON = 0b00000110;     // Enable TMR2 with prescaler = 16
	PR2 = 155;	// PWM period = (PR2+1) * prescaler * Tcy = 19.968ms
	CCPR1L = 8;	// pulse width = CCPR1L * prescaler * Tcy = 1.024ms
	
	while(1)
	{
		if (PORTCbits.RC4) CCPR1L = 12;	// 1.536ms pulses, i.e. 90 degrees
		else CCPR1L = 8;				// 1.024ms pulses, i.e. 0 degrees
	}
	
	return 0;
}

I don’t have an actual PIC18F14K50 to try my program on, so instead I ran it on the simulator in MPLAB v8.50. I captured the simulated PWM output using MPLAB’s logic analyzer tool, as shown below.

The blue waveform is the PWM output on CCP1 (pin 5). The red vertical lines are “cursors” provided in the logic analyzer for measuring the time difference between two points on the waveform. I positioned them to measure the period of the PWM waveform, which is 2511 instruction cycles. Since the clock oscillator frequency F_osc is set to 500kHz, the clock cycle T_osc is 2us. The PIC18F14K50 performs one machine instruction every 4 clock cycles, so the instruction cycle T_cy is 8us. So the PWM period is:

This LCD module uses the Hitachi interface, which has 4-bit and 8-bit operating modes. Here, the 4-bit mode is used, which means that each byte transmitted from the dsPIC to the LCD module is split into two 4-bit nibbles which are transmitted one after the other. The advantage of 4-bit mode is that less microcontroller pins are required – 7 digital outputs in total: 3 control lines and 4 data lines. (Actually, strictly speaking, you could get away with only 6 lines.)

The circuit diagram is shown below. Note that the 5 connections to the PICkit 2 USB programmer are not shown. (Link to editable SVG version of this image, created using Inkscape.)

The 7 connections between the dsPIC’s digital outputs and the LCD module are:

The LCD module I’m using is shown below (front and back views of the same device). The 6-pin header at one end of the breadboard is the connector for the PICkit 2 USB programmer.

This is the complete breadboard circuit including the dsPIC and LCD module (two views of the same circuit):

I was surprised to discover that 16×1 LCD modules of this type (1 line with 16 characters of text) are typically structured as if they had 2 lines of 8 characters. The first 8 characters are “line 1″ and the second 8 characters are “line 2″. As a result, in the program below, half of the single line of text to be displayed is written to “line 1″ and half is written to “line 2″.

This is the C code for the dsPIC program:

//
// LCD display program for dsPIC30F4011
// Written by Ted Burke - Last updated 16-4-2013
//

#include <xc.h>
#include <libpic30.h>

// Configuration settings
_FOSC(CSW_FSCM_OFF & FRC_PLL16); // Fosc=16x7.5MHz, Fcy=30MHz
_FWDT(WDT_OFF);                  // Watchdog timer off
_FBORPOR(MCLR_DIS);              // Disable reset pin

#define RS_PIN _LATC14
#define RW_PIN _LATC13
#define E_PIN _LATC15

void delay_ms(unsigned int n);
void send_nibble(unsigned char nibble);
void send_command_byte(unsigned char byte);
void send_data_byte(unsigned char byte);

int main()
{
	_TRISD0 = 0; // Make RD0 an output
	
	TRISC = 0; // RC13-15 as digital outputs
	TRISB = 0xFFF0; // RB0-3 as digital outputs
	_PCFG0 = 1; // AN0 is digital
	_PCFG1 = 1; // AN1 is digital
	_PCFG2 = 1; // AN2 is digital
	_PCFG3 = 1; // AN3 is digital

	// Let's just write to the LCD and never read!
	// We'll wait 2ms after every command since we can't
	// check the busy flag.
	RW_PIN = 0;
	RS_PIN = 0;
	E_PIN = 1;
	
	// Initialisation
	delay_ms(16); // must be more than 15ms
	send_nibble(0b0011);
	delay_ms(5); // must be more than 4.1ms
	send_nibble(0b0011);
	delay_ms(1); // must be more than 100us
	send_nibble(0b0011);
	delay_ms(5); // must be more than 4.1ms
	send_nibble(0b0010); // select 4-bit mode
	
	// Display settings
	send_command_byte(0b00101000); // N=0 : 2 lines (half lines!), F=0 : 5x7 font
	send_command_byte(0b00001000); // Display: display off, cursor off, blink off
	send_command_byte(0b00000001); // Clear display
	send_command_byte(0b00000110); // Set entry mode: ID=1, S=0
	send_command_byte(0b00001111); // Display: display on, cursor on, blink on
	
	// Define two 8 character strings
	const char line1[] = " Ted's d";
	const char line2[] = "sPIC30F ";
	
	// Write the two strings to lines 1 and 2
	int n;
	send_command_byte(0x02); // Go to start of line 1
	for (n=0 ; n<8 ; ++n) send_data_byte(line1[n]);
	send_command_byte(0xC0); // Go to start of line 2
	for (n=0 ; n<8 ; ++n) send_data_byte(line2[n]);
	
	// Now just blink LED indefinitely
	while(1)
	{
		_LATD0 = 1 - _LATD0;
		delay_ms(500);
	}
}

// Delay by specified number of milliseconds
void delay_ms(unsigned int n)
{
	while(n--) __delay32(30000);
}

void send_nibble(unsigned char nibble)
{
	// Note: data is latched on falling edge of pin E
	LATB = nibble;
	delay_ms(1);
	E_PIN = 0;
	delay_ms(1);
	E_PIN = 1;
	delay_ms(2); // Enough time even for slowest command
}

// Send a command byte (i.e. with pin RS low)
void send_command_byte(unsigned char byte)
{
	RS_PIN = 0;
	send_nibble(byte >> 4);
	send_nibble(byte & 0xF);
}

// Send a data byte (i.e. with pin RS high)
void send_data_byte(unsigned char byte)
{
	RS_PIN = 1;
	send_nibble(byte >> 4);
	send_nibble(byte & 0xF);
}

I compiled this with Microchip’s XC16 compiler, using the following simple build script.

xc16-gcc main.c -mcpu=30F4011 -Wl,--script=p30F4011.gld
if errorlevel 0 xc16-bin2hex a.out

To use the build script:

1. Create a new folder.
2. Save the C program in that folder as “main.c”.
3. Save the build script in the same folder as “build.bat”.
4. Open a console window and navigate to that folder.
5. Type “build.bat” to compile the program.
6. Use the PICkit 2 application (or another program) to download the compiled program (file “a.hex”) onto the dsPIC.

References

1. Wikipedia article on Hitachi HD44780 LCD controller (contains useful summary of connections and commands)
2. Book: PIC Microcontrollers, Appendix B: Examples (scroll down to the example titled “LCD DISPLAY”)
3. HD44780 LCD controller datasheet, containing all the gory details (courtesy of Sparkfun who sell lots of LCD modules)

//
// dsPIC30F4011 program to record bytes received via UART 2
// and then print the byte values and text string via UART 1
//
// Written by Ted Burke - last updated 16-4-2013
//

#include <xc.h>
#include <stdio.h>
 
// Configuration settings
_FOSC(CSW_FSCM_OFF & FRC_PLL16); // Fosc=16x7.5MHz, i.e. 30 MIPS
_FWDT(WDT_OFF);                  // Watchdog timer off
_FBORPOR(MCLR_DIS);              // Disable reset pin

// Function prototype for Timer 1 interrupt service routine
void __attribute__((__interrupt__, __auto_psv__)) _T1Interrupt(void);

int n = 0;
unsigned char buf[100];

int main(void)
{
	// Setup UART 1
	U1BRG = 48;            // 38400 baud @ 30 MIPS
	U1MODEbits.UARTEN = 1; // Enable UART
	
	// Setup UART 2
	U2BRG = 48;            // 38400 baud @ 30 MIPS
	U2MODEbits.UARTEN = 1; // Enable UART

	// Configure Timer 1
	// TMR1 is set to zero whenever a byte is received
	// or whenever the buffer is empty. Whenever TMR1
	// reaches PR1, the Timer 1 ISR prints whatever
	// bytes are in the buffer. This creates a timeout,
	// such that when bytes are received, they are stored
	// in the buffer, but when no bytes are received for
	// 100ms, the buffer data is printed.
	PR1 = 46875;          // Set the Timer 1 period to 100ms
	TMR1 = 0;             // Reset Timer 1 counter
	IEC0bits.T1IE = 1;    // Enable Timer 1 interrupt
	T1CONbits.TCKPS = 2;  // Prescaler (0=1:1, 1=1:8, 2=1:64, 3=1:256)
	T1CONbits.TON = 1;    // Turn on Timer 1

	_TRISD0 = 0; // Make RD0 a digital output

	while(1)
	{
		// Don't let TMR1 increase unless bytes are in buffer
		if (n == 0) TMR1 = 0;

		// Check if any characters were received via UART
		if (U2STAbits.URXDA == 1)
		{
			// Store received byte and increment byte counter
			buf[n++] = U2RXREG;
			TMR1 = 0;
		}
	}

	return 0;
}

// Timer 1 interrupt service routine prints the buffer contents.
// This runs when there are bytes stored in the buffer, but none
// have been received for 100ms.
void __attribute__((__interrupt__, __auto_psv__)) _T1Interrupt(void)
{
	int m;

	// Clear Timer 1 interrupt flag
	IFS0bits.T1IF = 0;

	// Print bytes as numbers in hex format
	for (m=0 ; m<n ; ++m) printf("%02x ", buf[m]);

	// Print the same bytes again as a text string
	buf[n] = '\0';
	printf("\n%s\n", buf);

	// Reset the buffer byte count
	n = 0;
}

I compiled the program above with Microchip’s XC16 C compiler using the following simple build script.

xc16-gcc main.c -mcpu=30F4011 -Wl,--script=p30F4011.gld
if errorlevel 0 xc16-bin2hex a.out

To use the build script, just create a new folder, save the C program above in the folder as “main.c”, save the build script above as “build.bat” in the same folder, and then open a command window and type “build.bat”.

Example

The following screenshot shows SerialSend running twice in a command window. The serial device used (COM22) is a USB-to-serial converter which is connected to the Tx and Rx pins of UART 2 on the dsPIC.

The following screenshot shows the UART tool window in the PICkit 2 software application. The PICkit 2 hardware is connected to the Tx and Rx pins of UART 1. The byte sequences sent in the previous screenshot have been received by the dsPIC on UART 2 and, after a 100ms timeout, printed out via UART 1 and displayed in the UART tool.

NB The PIC18F4620 provides 10-bit resolution in setting the PWM pulse width. However, to keep things simple, I’m disregarding the 2 least significant bits, which reside in a different register to the 8 most significant bits. Unless you really need the extra resolution, I recommend ignoring the 2 least significant bits and treating both the PWM period and pulse width as 8-bit values. Because I’m making this simplification, the calculations I present below are a bit simpler than those described in the PIC18F4620 datasheet.

Setting the PWM period and duty cycle

In this example, the clock oscillator frequency of the 18F4620 is left at the default value of Fosc = 1MHz. The oscillator period is therefore Tosc = 1us.

The PIC18F4620 performs one machine code instruction every four clock cycles, so the instruction cycle in this example is Tcy = 4us. This is an important figure because Tcy is really the fundamental unit of time when measuring time in PIC programs.

The period of the PWM waveform is determined by the value written to a special function register called PR2 (short for Period Register for Timer 2). The formula for calculating PWM period is:

PWM period = (PR2+1) * Timer 2 prescaler value * Tcy

In this example, PR2 = 249, the Timer 2 prescaler = 1 and Tcy = 4us. Therefore,

PWM period = 250 * 1 * 4us = 1ms

The pulse width of the PWM waveform is determined by the value written to a special function register called CCPR1L (short for Capture/Compare/PWM channel 1 Register, low byte). The formula for calculating PWM pulse width is:

PWM pulse width = CCPR1L * Timer 2 presacler value * Tcy

Initially, CCPR1L = 125, the Timer 2 prescaler = 1 and Tcy = 4us. Initially therefore,

PWM period = 125 * 1 * 4us = 0.5ms

The values of PR2 and CCPR1L can be changed at any time, which will change the period or pulse width of the waveform. In this example, the period is constant at 1ms, giving a frequency of 1kHz. However, the value of CCPR1L changes every half a seconds, causing the duty cycle of the waveform to cycle through the values 50%, 10%, 0% repeatedly.

C code and build script

This is the full C code for the XC8 compiler.

//
// PIC18F4620 1kHz PWM example program
// Written by Ted Burke (http://batchloaf.com)
// Last updated 4-4-2013
//
// To compile with XC8:
//     xc8 --chip=18F4620 main.c
//

#include <xc.h>

#pragma config OSC=INTIO67,MCLRE=OFF,WDT=OFF,LVP=OFF,BOREN=OFF

int main(void)
{
	// Set up PWM (see section 15.4 of the PIC18F4620 datasheet)
	CCP1CON = 0b00001100;   // Enable PWM on CCP1
	TRISC = 0b11111001;     // Make pin 17 (RC1/CCP2) an output
	T2CON = 0b00000100;     // Enable TMR2 with prescaler = 1
	PR2 = 249;   // PWM period = (PR2+1) * prescaler * Tcy = 1ms
	CCPR1L = 25; // pulse width = CCPR1L * prescaler * Tcy = 100us
	
	while(1)
	{
		// 50% duty cycle for 500ms
		CCPR1L = 125;
		_delay(125000);
		
		// 10% duty cycle for 500ms
		CCPR1L = 25;
		_delay(125000);
		
		// 0% duty cycle for 500ms
		CCPR1L = 0;
		_delay(125000);
	}
}

I don’t use MPLAB; I just write my C code in a text editor, compile it with XC8 in a command window, then use the PICkit 2 application to transfer the hex file to the PIC. The build script I use (which contains just one command) is shown below. I save the C code as “main.c” and the build script in the same folder as “build.bat”.

xc8 --chip=18F4620 main.c

Here’s how it looked when I compiled the program on my laptop:

Measuring the waveform period and pulse width

I used the PICkit2 Logic Analyzer to take the following snapshot of the waveform when the duty cycle was 50% (when CCPR1L = 125). The signal was connected to channel 3 of the logic analyzer (pin 6 of the PICkit 2):

Here, the logic analyzer cursors are measuring the period of the waveform:

Here, the logic analyzer cursors are measuring the pulse width of the waveform:

Finally, here’s the waveform when the duty cycle is set to 10% (i.e. when CCPR1L = 25):

As a starting point, I’ve written the following C program to sketch out the basic calculation in a Windows console app before I even think about doing it on the dsPIC. This seems to be working, so I guess the next step is to stick it onto the dsPIC and see how it runs. However, that requires some careful thought on account of the size of the look-up table and the limited RAM on the dsPIC30F4011, which is the microcontroller I usually use.

I’ll post again once I’ve made a bit of progress on the dsPIC implementation.

// 
// 2-D linear interpolation experiment
// Written by Ted Burke
// last updated 11-3-2013
//
// To compile: gcc interpolation.c -o interpolation.exe
// To run: interpolation.exe
//

#include <stdio.h>

// This is just a dummy function for testing
double f(double x, double y)
{
	return (0.1*x*x + 0.2*y*y);
}

// M is number of rows, N is number of columns
#define M 61
#define N 20

int main()
{
	// m and n are row and column indices
	int m, n;
	double mf, nf; // fractional parts

	// x, y are the input parameters for the interpolation
	double x, y, x_min=2.0, x_max=18.0, y_min=5.0, y_max=15.0;
	
	// f is the table of function values - i.e. f(x,y)
	// Fill this with calculated values for testing
	double f_vals[M][N];
	for (m=0 ; m<M ; ++m)
	{
		for (n=0 ; n<N ; ++n)
		{
			x = x_min + (x_max - x_min) * (n / (double)(N-1));
			y = y_min + (y_max - y_min) * (m / (double)(M-1));
			f_vals[m][n] = f(x,y);
		}
	}
	
	// fi is interpolated estimate of f(x,y)
	double fi;

	// Ask for an (x,y) point to calculate f at
	printf("Please enter x and y values: ");
	scanf("%lf %lf", &x, &y);
	
	// Find integer and fractional part of column index
	nf = (N-1) * (x - x_min) / (x_max - x_min);
	n = (int)nf;
	nf = nf - n;
	
	// Find integer and fractional part of row index
	mf = (M-1) * (y - y_min) / (y_max - y_min);
	m = (int)mf;
	mf = mf - m;
	
	// Calculate interpolated estimated
	fi = (1-nf)*(1-mf)*f_vals[m][n] + nf*(1-mf)*f_vals[m][n+1]
			+ (1-nf)*mf*f_vals[m+1][n] + nf*mf*f_vals[m+1][n+1];
	
	// Print results
	printf("Actual f(x,y) = %lf\n", f(x,y));
	printf("Estimated f(x,y) = %lf\n", fi);
	
	return 0;
}

Here’s what it looked like when I compiled and ran the above code in a console window:

• Firstly, download the Linux version of XC8 from microchip.com and install it. Accept all default options. When it asks for a registration key, just leave it blank to install the free version.
• Secondly, download the Linux version of the pk2cmd utility that matches your Linux kernel version. You’ll need to scroll down to the “Downloads” section of that page and look for the “Linux & Mac OS X Software” sub-section. The one I downloaded was titled “PK2CMD V1.20 Linux Kernel 2.6 Executable Binary”.

This is a simple C example program to try out the XC8 compiler.

//
// LED blink example for PIC18F4520
// Written by Ted Burke
// Last updated 5-3-2013
//

#include <xc.h>

#pragma config OSC=INTIO67,MCLRE=OFF,WDT=OFF,LVP=OFF,BOREN=OFF

int main(void)
{
	// Make RD0 a digital output
	TRISD = 0b11111110;
	
	// Blink LED on RD0 (pin 19)
	while(1)
	{
		LATDbits.LATD0 = 1 - LATDbits.LATD0;
		_delay(100000);
	}
}

Create a directory for the program and save the above code in it as a file called “main.c”.

I use the simple build script below to compile the program and (assuming it compiles without errors) download the updated hex file onto the PIC. Save the following into the same directory as a file called “build_and_program”.

#!/bin/bash

/mnt/sdb2/microchip/xc8/v1.12/bin/xc8 --chip=18F4520 main.c &&
sudo ./pk2cmd -PPIC18F4520 -F./main.hex -M -T

I installed XC8 in the directory “/mnt/sdb2/microchip/xc8″, so that’s the location specified above. The build script needs to modified according to the actual installation directory on a particular computer. If the installation directory was added to the path, the installation directory may not need to be specified at all.

To make the build script executable, use the following command:

chmod 755 build_and_program

To keep things simple, I create a separate directory for each PIC program and store all of the following files in it:

• main.c – The actual C program (see above).
• build_and_program – The build script (see above).
• pk2cmd – This the command line utility for programming PIC microntrollers using the PICkit 2. It’s a very compact program, so I just place a copy of it in the folder along with each of my programs.
• PK2DeviceFile.dat – This file is required by pk2cmd, so I place a copy of it into the folder with each of my programs.

To run the build script and download the hex file to the PIC, just type the following command:

./build_and_program

Here’s how it looks in my terminal window:

Anyway, I came across another interesting use of it today. Gitshots is something clever that Víctor Martínez created for Mac OS to automatically take a webcam snapshot each time a programmer commits code to a git repository (that’s basically a source code management system). German software engineer Benedikt Eger wanted to do the same thing in Windows, so he came up with an elegant three-line hack (English translation) using CommandCam.

When you write a simple program like CommandCam and send it out into the world, it’s really interesting to hear about the places it ends up!

//
// dsPIC30F4011 phase difference measurement example
//
// Written by Ted Burke
// Last updated 4-3-2013
//
// Measure the phase difference between two 50Hz sine waves.
// The leading sine wave is assumed to be connected to AN0.
// The lagging sine wave is assumed to be connected to AN1.
// Both sine waves are assumed to vary between 0V and 5V.
// The phase difference is measured as the time delay
// between the time each signal crosses a threshold (2.5V).
//

#include <xc.h>
#include <stdio.h>
#include <libpic30.h>

// Configuration settings
_FOSC(CSW_FSCM_OFF & FRC_PLL16); // Fosc=16x7.5MHz, Fcy=30MHz
_FWDT(WDT_OFF);                  // Watchdog timer off
_FBORPOR(MCLR_DIS);              // Disable reset pin

// Function prototype for analog input function
unsigned int read_analog_channel(int channel);

int main()
{
	// Configure AN0-AN8 as analog inputs
	ADCON3bits.ADCS = 15;  // Tad = 266ns, conversion time is 12*Tad
	ADCON1bits.ADON = 1;   // Turn ADC ON
	
	// Setup UART
	U1BRG = 48;            // 38400 baud @ 30 MIPS
	U1MODEbits.UARTEN = 1; // Enable UART

	// Configure Timer 1
	PR1 = 65535;          // Set the Timer 1 period (max 65535)
	TMR1 = 0;             // Reset Timer 1 counter
	T1CONbits.TCKPS = 2;  // Prescaler (0=1:1, 1=1:8, 2=1:64, 3=1:256)
	T1CONbits.TON = 0;    // Disable Timer 1
			
	while(1)
	{
		// Reset timer to zero
		TMR1 = 0;
		
		// Wait until AN0 is below voltage threshold
		while (read_analog_channel(0) >= 512);
		
		// Wait for AN0 to rise above voltage threshold
		while (read_analog_channel(0) < 512);
		
		// Start timer to measure phase difference
		T1CONbits.TON = 1;
		
		// Wait for AN1 to rise above voltage threshold
		while (read_analog_channel(1) < 512);
		
		// Stop timer
		T1CONbits.TON = 0;
		
		// Print time delay. Note 64:1 timer prescaling.
		// Also note that 30000 clock cycles is 1ms at 30 MIPS.
		printf("Phase diff = %4.2f ms\n", 64.0 * TMR1 / 30000.0);
	}
	
	return 0;
}

// This function reads a single sample from the specified
// analog input. It should take less than 5us when the
// microcontroller is running at 30 MIPS.
// The dsPIC30F4011 has a 10-bit ADC, so the value
// returned is between 0 and 1023 inclusive.
unsigned int read_analog_channel(int channel)
{
	ADCHS = channel;          // Select the requested channel
	ADCON1bits.SAMP = 1;      // Start sampling
	__delay32(30);            // 1us delay @ 30 MIPS
	ADCON1bits.SAMP = 0;      // Start Converting
	while (!ADCON1bits.DONE); // Should take 12 * Tad = 3.2us
	return ADCBUF0;
}

I built this program using Microchip’s XC16 C compiler. I don’t use MPLAB, so I used the following build script to invoke the compiler. To use it, save the C code as “main.c” and the build script as “build.bat” in the same folder. Then just open a command window, navigate to that folder and type “build.bat” to compile the program.

xc16-gcc main.c -mcpu=30F4011 -Wl,--script=p30F4011.gld
if errorlevel 0 xc16-bin2hex a.out

The output file is “a.hex”. I use the PICkit 2 software to download the compiled program onto the dsPIC.

Code explanation

There’s not much to it really:

• Lines 29-31 enable 8 analog inputs (although only AN0 and AN1 are actually used).
• Lines 33-35 enable the UART, which is used to transmit the measured phase difference as plain text to be displayed on the PC (as a time in ms).
• Lines 37-41 configure Timer 1 to run with a prescaler value of 64:1. This means that the timer counter TMR1 increments once every 64 instruction cycles. With the dsPIC running at 30 MIPS, that means TMR1 increments once every 2.1333us. This is what determines the time resolution of the phase measurement. TMR1 is a 16-bit register, so its maximum value is 65535, after which is resets to zero. The longest phase difference that can be measured at this prescaler setting is therefore 139.8ms.
• The main loop of the program (lines 43-66) simply measures the time delay beween the voltage on AN0 crossing a threshold (in the positive-going direction) and the voltage on AN1 crossing the same threshold. I have set the threshold to 2.5V. If each sine waves varies between 0V and 5V, this corresponds to the what I would regard as the zero-crossing point in the waveform.
• Each time the phase difference is measured, it is printed to the screen via the UART (line 65). The result is converted from timer ticks into milliseconds using the timer prescaler ratio (64:1) and the number of clock cycles per millisecond (30,000).
• I’m using the PICkit 2 software’s UART tool to display the result (see image below).

Here’s a screenshot of a few phase difference measurements displayed in the PICkit 2 software’s UART tool. Since I don’t have two 50Hz waveforms on hand to test the program, I used an RC circuit and a switch to create a reasonably consistent time difference between two rising voltage signals. Obviously, since 50Hz waveforms have a period of 20ms, actual phase difference measurements will be considerably shorter than these example readings.

The following C program sends a keypress to a specified window that does not need to be in focus. The keystroke to send is specified as the first command line argument. The second command line argument is a “target” word that appears in the title of the target window. The target word can be anything that appears in the title of the taregt window, but it makes sense to pick something that definitely won’t appear in the title of any other windows. The search word is case sensitive and the simulated keystroke is sent to the first matching window.

//
// sendkey.c - Send a key press to a specific window
// Written by Ted Burke
// Last updated 13-2-2013
//
// To compile using gcc:
//
//		gcc -o sendkey.exe sendkey.c
//
// To send the letter 'a' to a WordPad window:
//
//		sendkey.exe a WordPad
//

#define WINVER 0x0500
#include <windows.h>
#include <stdio.h>

int main(int argc, char* argv[])
{
	// Check number of command line arguments
	if (argc < 3)
	{
		fprintf(stderr, "Too few command line arguments\n");
		fprintf(stderr, "Usage: sendkey.exe KEY_TO_SEND");
		fprintf(stderr, " WORD_FROM_TARGET_WINDOW_TITLE\n");
		return 1;
	}
	
	// Get the character to send from the first command
	// line argument
	char char_to_send = toupper(argv[1][0]);
	
	// Get first window on desktop
	HWND firstwindow = FindWindowEx(NULL, NULL, NULL, NULL);
	HWND window = firstwindow;
	TCHAR windowtext[MAX_PATH];
	
	// We need to get the console title in case we
	// accidentally match the search word with it
	// instead of the intended target window.
	TCHAR consoletitle[MAX_PATH];
	GetConsoleTitle(consoletitle, MAX_PATH);
	
	while(1)
	{
		fprintf(stderr, ".");
		
		// Check window title for a match
		GetWindowText(window, windowtext, MAX_PATH);
		if (strstr(windowtext, argv[2]) != NULL &&
			strcmp(windowtext, consoletitle) != 0) break;
		
		// Get next window
		window = FindWindowEx(NULL, window, NULL, NULL);
		if (window == NULL || window == firstwindow)
		{
			fprintf(stderr, "Window not found\n");
			return 1;
		}
	}
	fprintf(stderr, "Window found: %s\n", windowtext);
	
	// Bring specified window into focus
	SetForegroundWindow(window);

	// Create the desired keyboard event
	INPUT ip;
	ip.type = INPUT_KEYBOARD;
	ip.ki.wVk = char_to_send;
	ip.ki.wScan = 0;
	ip.ki.dwFlags = 0;
	ip.ki.time = 0;
	ip.ki.dwExtraInfo = 0;
	
	// Send the keyboard event to the specified window
	SendInput(1, &ip, sizeof(INPUT));
	
	// Exit normally
	return 0;
}

This is what it looked like in the console where I compiled and ran sendkey.exe:

This screenshot shows the WordPad window that received the ‘A’ key press: