#include <gtk/gtk.

h>

static GtkWidget *window = NULL;
static GtkWidget *da;
static GdkColor color;
static GtkWidget *frame;

/* Expose callback for the drawing area
*/
static gboolean
expose_event_callback (GtkWidget *widget,
GdkEventExpose *event,
gpointer data)
{
GdkWindow *window = gtk_widget_get_window (widget);

if (window)
{
GtkStyle *style;
cairo_t *cr;

style = gtk_widget_get_style (widget);

cr = gdk_cairo_create (window);

gdk_cairo_set_source_color (cr, &style->bg[GTK_STATE_NORMAL]);
gdk_cairo_rectangle (cr, &event->area);
cairo_fill (cr);

cairo_destroy (cr);
}

return TRUE;
}

static void
change_color_callback (GtkWidget *button,
gpointer data)
{
GtkWidget *dialog;
GtkColorSelection *colorsel;
gint response;

dialog = gtk_color_selection_dialog_new ("Changing color");

gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (window));

colorsel =
GTK_COLOR_SELECTION (gtk_color_selection_dialog_get_color_selection
(GTK_COLOR_SELECTION_DIALOG (dialog)));

gtk_color_selection_set_previous_color (colorsel, &color);
gtk_color_selection_set_current_color (colorsel, &color);
gtk_color_selection_set_has_palette (colorsel, TRUE);

response = gtk_dialog_run (GTK_DIALOG (dialog));

if (response == GTK_RESPONSE_OK)
{
gtk_color_selection_get_current_color (colorsel,
&color);

gtk_widget_modify_bg (da, GTK_STATE_NORMAL, &color);
}

gtk_widget_destroy (dialog);
}

GtkWidget *
do_colorsel (GtkWidget *do_widget)
{
GtkWidget *vbox;
GtkWidget *button;
GtkWidget *alignment;

if (!window)
{
color.red = 0;
color.blue = 65535;
color.green = 0;

window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (do_widget));
gtk_window_set_title (GTK_WINDOW (window), "Color Selection");

g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);

gtk_container_set_border_width (GTK_CONTAINER (window), 8);

vbox = gtk_vbox_new (FALSE, 8);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 8);
gtk_container_add (GTK_CONTAINER (window), vbox);

/*
* Create the color swatch area
*/


frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0);

da = gtk_drawing_area_new ();

g_signal_connect (da, "expose_event",
G_CALLBACK (expose_event_callback), NULL);

/* set a minimum size */
gtk_widget_set_size_request (da, 200, 200);
/* set the color */
gtk_widget_modify_bg (da, GTK_STATE_NORMAL, &color);

gtk_container_add (GTK_CONTAINER (frame), da);

alignment = gtk_alignment_new (1.0, 0.5, 0.0, 0.0);

button = gtk_button_new_with_mnemonic ("_Change the above color");
gtk_container_add (GTK_CONTAINER (alignment), button);

gtk_box_pack_start (GTK_BOX (vbox), alignment, FALSE, FALSE, 0);

g_signal_connect (button, "clicked",
G_CALLBACK (change_color_callback), NULL);
}

if (!gtk_widget_get_visible (window))
{
gtk_widget_show_all (window);
}
else
{
gtk_widget_destroy (window);
window = NULL;
}

return window;
}


Stepper Motor Controller
Back to Top
/////////////////////////////////////////////////////////////////////////
//// EX_STEP.C ////
//// ////
//// This program interfaces to a stepper motor. The program will ////
//// use the RS-232 interface to either control the motor with a ////
//// analog input, a switch input or by RS-232 command. ////
//// ////
//// Configure the CCS prototype card as follows: ////
//// Connect stepper motor to pins 47-50 (B0-B3) ////
//// Conenct 40 to 54 (pushbutton) ////
//// Connect 9 to 15 (pot) ////
//// See additional connections below. ////
/////////////////////////////////////////////////////////////////////////
//// (C) Copyright 1996,2001 Custom Computer Services ////
//// This source code may only be used by licensed users of the CCS ////
//// C compiler. This source code may only be distributed to other ////
//// licensed users of the CCS C compiler. No other use, ////
//// reproduction or distribution is permitted without written ////
//// permission. Derivative programs created using this software ////
//// in object code form are not restricted in any way. ////
/////////////////////////////////////////////////////////////////////////

#include <16c74.h>
#fuses HS,NOWDT,NOPROTECT
#use delay(clock=20000000)
#use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7) // Jumpers: 8 to 11, 7 to 12

#include

#byte port_b = 6

#define FOUR_PHASE TRUE

#ifdef FOUR_PHASE

byte const POSITIONS[4] = {0b0101,
0b1001,
0b1010,
0b0110};
#else
byte const POSITIONS[8] = {0b0101,
0b0001,
0b1001,
0b1000,
0b1010,
0b0010,
0b0110,
0b0100};
#endif


drive_stepper(BYTE speed, char dir, BYTE steps) {
static BYTE stepper_state = 0;
BYTE i;

for(i=0; i<steps; ++i) {
delay_ms(speed);
set_tris_b(0xf0);
port_b = POSITIONS[ stepper_state ];
if(dir!='R')
stepper_state=(stepper_state+1)&(sizeof(POSITIONS)-1);
else
stepper_state=(stepper_state-1)&(sizeof(POSITIONS)-1);
}
}



use_pot() {
BYTE value;

setup_adc(adc_clock_internal);
set_adc_channel( 1 );
printf("rn");

while( TRUE ) {
value=read_adc();
printf("%2Xr",value);
if(value<0x80)
drive_stepper(value,'R',8);
else if(value>0x80)
drive_stepper(128-(value-128),'F',8);
}

}


use_switch(BYTE speed, char dir) {

BYTE steps;

printf("nrSteps per press: ");
steps = gethex();

while(true) {
while(input(PIN_B7)) ;
drive_stepper(speed,dir,steps);
while(!input(PIN_B7)) ;
delay_ms(100);
}
}


main() {

byte speed,steps;
char dir;

setup_port_a(RA0_RA1_ANALOG);

while (TRUE) {
printf("nrSpeed (hex): ");
speed = gethex();

if(speed==0)
use_pot();

printf("nrDirection (F,R): ");
dir=getc()|0x20;
putc(dir);

printf("nrSteps (hex): ");
steps = gethex();

if(steps==0)
use_switch(speed,dir);

drive_stepper(speed,dir,steps);
}

}
Seconds Timer
Back to Top
///////////////////////////////////////////////////////////////////////
//// EX_STWT.C ////
//// ////
//// This program uses the RTCC (timer0) and interrupts to keep a ////
//// real time seconds counter. A simple stop watch function is ////
//// then implemented. ////
//// ////
//// Configure the CCS prototype card as follows: ////
//// Insert jumpers from: 11 to 17 and 12 to 18. ////
///////////////////////////////////////////////////////////////////////
#include<16f877a.h>
#fuses HS,NOLVP,NOWDT,PUT
#use delay(clock=20000000)
#use rs232(baud=9600,xmit=PIN_C6,rcv=PIN_C7)

#define high_start 76
byte seconds, high_count;

#INT_RTCC //Interrupt procedure
clock_isr() { //called every time RTCC
high_count -= 1; //flips from 255 to 0

if(high_count==0) {
++seconds;
high_count=high_start; //Inc SECONDS counter every
} //76 times to keep time
}

void main() { //a simple stopwatch program
byte start, time;

high_count = high_start;
setup_timer_0( RTCC_INTERNAL | RTCC_DIV_256 );
set_timer0(0);
enable_interrupts(INT_RTCC);
enable_interrupts(GLOBAL);

do {
printf("Press any key to begin.nr");
getc();
start = seconds;
printf("Press any key to stop.rn");
getc();
time = seconds - start;
printf("%U seconds.nr", time);
} while (TRUE);
}
Simple A/D
Back to Top
/////////////////////////////////////////////////////////////////////////
//// EX_ADMM.C ////
//// ////
//// This program displays the min and max of 30 A/D samples over ////
//// the RS-232 interface. The process is repeated forever. ////
//// ////
//// Configure the CCS prototype card as follows: ////
//// Insert jumpers from: 11 to 17, 12 to 18 and 9 to 16 ////
//// Use the #9 POT to vary the voltage. ////
/////////////////////////////////////////////////////////////////////////
#include<16f877a.h>
#fuses HS,NOLVP,NOWDT,PUT
#use delay(clock=20000000)
#use rs232(baud=9600,xmit=PIN_C6,rcv=PIN_C7)

void main() {
int i, value, min, max;

printf("Sampling:");

setup_adc_ports( RA0_ANALOG );
setup_adc( ADC_CLOCK_INTERNAL );
set_adc_channel( 0 );

do { //Takes 30 samples from pin A0
min = 255; //and displays the min and max
max = 0; //values for that 100ms period
for(i = 0; i <= 30; ++i) {
delay_ms(100);
value = read_adc();
if(value < min)
min = value;
if(value > max)
max = value;
}
printf("nrMin:%x MAX: %x", min, max);
} while (TRUE);
}
Output Listing
Back to Top
.................... min=255;
008D: MOVLW FF
008E: MOVWF 28
.................... max=0;
008F: CLRF 29
.................... incc=TRUE;
0090: BSF 2B,0
.................... for(i=0;i<=30;++i) {
0091: CLRF 26
0092: MOVLW 1F
0093: SUBWF 26,W
0094: BTFSC 03,0
0095: GOTO 0AC
.................... delay_ms(100);
0096: MOVLW 64
0097: MOVWF 2C
0098: GOTO 02D
.................... value = Read_ADC();
0099: BSF 1F,2
009A: BTFSC 1F,2
009B: GOTO 09A
009C: MOVF 1E,W
009D: MOVWF 27
.................... if(value < min)
009E: MOVF 28,W
009F: SUBWF 27,W
00A0: BTFSC 03,0
00A1: GOTO 0A4
.................... min=value;
00A2: MOVF 27,W
00A3: MOVWF 28
.................... if(value > max)
00A4: MOVF 27,W
00A5: SUBWF 29,W
00A6: BTFSC 03,0
00A7: GOTO 0AA
.................... max=value;
00A8: MOVF 27,W
00A9: MOVWF 29
.................... }
00AA: INCF 26,F

00AB: GOTO 092
.................... if (incc)
00AC: BTFSC 2B,0
.................... counter++;
00AD: INCF 2A,F
Simple Square Wave Generator
Back to Top

/////////////////////////////////////////////////////////////////////////
//// EX_SQW.C ////
//// ////
//// This program displays a message over the RS-232 and waits for ////
//// any keypress to continue. The program will then begin a 1khz ////
//// square wave over I/O pin B4. ////
//// ////
//// Comment out the printf's and getc to eliminate the RS232 and ////
//// just output a square wave. ////
//// ////
//// Change both delay_us to delay_ms to make the frequency 1 hz. ////
//// This will be more visable on a LED. ////
//// ////
//// ////
//// Change the device, clock and RS232 pins for your hardware if ////
//// needed. ////
/////////////////////////////////////////////////////////////////////////

#include <30F2010.h>

//#device ICD=TRUE // For using the debugger, un-comment

#use delay(crystal=20mhz)



// UART1A specifies the alternate UART pins Pin_C13, Pin_C14
// use UART1 to sprcify UART for pins Pin_F3, Pin_F2

#use rs232(baud=9600, UART1A)


void main() {

printf("Press any key to beginnr");
getc();
printf("1 khz signal activatednr");

while (TRUE) {
output_high(PIN_B4);
delay_us(500);
output_low(PIN_B4);
delay_us(500);
}
}

Watchdog Timer
Back to Top

/////////////////////////////////////////////////////////////////////////
//// EX_WDT.C ////
//// ////
//// This program demonstartes the watchdog timer. If the user ////
//// does not hit a key in the set amount of time, the processor ////
//// restarts, and tells the user why it restarted. ////
//// ////
//// Jumpers: ////
//// PCH pin C7 to RS232 RX, pin C6 to RS232 TX ////
//// PCD none ////
//// ////
//// This example will work with the PCD compiler. ////
//// The following conditional compilation lines are used to ////
//// include a valid device for each compiler. Change the device, ////
//// clock and RS232 pins for your hardware if needed. ////
/////////////////////////////////////////////////////////////////////////
//// (C) Copyright 1996,2003 Custom Computer Services ////
//// This source code may only be used by licensed users of the CCS ////
//// C compiler. This source code may only be distributed to other ////
//// licensed users of the CCS C compiler. No other use, ////
//// reproduction or distribution is permitted without written ////
//// permission. Derivative programs created using this software ////
//// in object code form are not restricted in any way. ////
/////////////////////////////////////////////////////////////////////////

#ifndef __PCD__
#error This example is only for dsPIC/PIC24 devices
#endif

#include <30F5011.h>
#fuses HS,NOPROTECT,WDT,WPSB1,WPSA512
#use delay(clock=20000000)
#use rs232(baud=9200, UART1)

main() {


switch ( restart_cause() )
{
case RESTART_WATCHDOG:
{
printf("rnRestarted processor because of watchdog timeout!rn");
break;
}
case RESTART_POWER_UP:
{
printf("rnNormal power up!rn");
break;
}
}

setup_wdt(WDT_ON);

while(TRUE)
{
restart_wdt();
printf("Hit any key to avoid a watchdog timeout.rn");
getc();
}
}


A/D Conversion
Back to Top

/////////////////////////////////////////////////////////////////////////
//// EX_ADMM10.C ////
//// ////
//// This program displays the min and max of 30 A/D samples over ////
//// the RS-232 interface. The process is repeated forever. ////
//// ////
//// If required configure the CCS prototype card as follows: ////
//// Insert jumper from output of POT to pin A5 ////
//// Use a 10K POT to vary the voltage. ////
//// ////
//// Jumpers: ////
//// PCM,PCH pin C7 to RS232 RX, pin C6 to RS232 TX ////
//// PCD none ////
//// ////
//// This example will work with the PCM, PCH, and PCD compilers. ////
//// The following conditional compilation lines are used to ////
//// include a valid device for each compiler. Change the device, ////
//// clock and RS232 pins for your hardware if needed. ////
/////////////////////////////////////////////////////////////////////////
//// (C) Copyright 1996,2007 Custom Computer Services ////
//// This source code may only be used by licensed users of the CCS ////
//// C compiler. This source code may only be distributed to other ////
//// licensed users of the CCS C compiler. No other use, ////
//// reproduction or distribution is permitted without written ////
//// permission. Derivative programs created using this software ////
//// in object code form are not restricted in any way. ////
/////////////////////////////////////////////////////////////////////////


#include <30F5011.h>
#fuses HS,NOWDT
#use delay(clock=20000000)
#use rs232(baud=9600, UART1)


void main() {

int i, value, min, max;

printf("Sampling:");

setup_adc_ports( sAN0 );
setup_adc( ADC_CLOCK_INTERNAL );
set_adc_channel( 0 );

do {
min=255;
max=0;
for(i=0; i<=30; ++i) {
delay_ms(100);
value = read_adc();
if(valuemax)
max=value;
}
printf("nrMin: %2X Max: %2Xnr",min,max);
} while (TRUE);
}