CCS C - Revision history

LIMS at 23:43, 26 December 2007

2007-12-26T23:43:58Z

← Older revision		Revision as of 18:43, 26 December 2007
Line 14:		Line 14:
	*Interrupts		*Interrupts
	*Include libraries		*Include libraries

			[[Image:refman.gif\|right]]


	The CCS <i>C Compiler Reference Manual</i> is awful, even as user manuals go. When reading the function descriptions, it helps to look at the relevant section of the hardware datasheet for the PIC chip itself, and try to figure out what the reference manual is talking about.		The CCS <i>C Compiler Reference Manual</i> is awful, even as user manuals go. When reading the function descriptions, it helps to look at the relevant section of the hardware datasheet for the PIC chip itself, and try to figure out what the reference manual is talking about.

LIMS at 23:41, 26 December 2007

2007-12-26T23:41:32Z

← Older revision		Revision as of 18:41, 26 December 2007
Line 18:		Line 18:

	[http://129.105.69.13/datasheets/Microcontrollers/PIC18F4520.pdf Local copy of the PIC 18F4520 datasheet (6MB)]		[http://129.105.69.13/datasheets/Microcontrollers/PIC18F4520.pdf Local copy of the PIC 18F4520 datasheet (6MB)]



	<b>CCS C compared to vanilla C</b>		<b>CCS C compared to vanilla C</b>

LIMS at 23:41, 26 December 2007

2007-12-26T23:41:22Z

← Older revision		Revision as of 18:41, 26 December 2007
Line 15:		Line 15:
	*Include libraries		*Include libraries

	The CCS <i>C Compiler Reference Manual</i> is ~~quite~~ awful, even as user manuals go. When reading the function descriptions, it helps to look at the relevant section of the hardware datasheet for the PIC chip itself, and try to figure out what the reference manual is talking about.		The CCS <i>C Compiler Reference Manual</i> is awful, even as user manuals go. When reading the function descriptions, it helps to look at the relevant section of the hardware datasheet for the PIC chip itself, and try to figure out what the reference manual is talking about.

	[http://129.105.69.13/datasheets/Microcontrollers/PIC18F4520.pdf Local copy of the PIC 18F4520 datasheet (6MB)]		[http://129.105.69.13/datasheets/Microcontrollers/PIC18F4520.pdf Local copy of the PIC 18F4520 datasheet (6MB)]

			<b>CCS C compared to vanilla C</b>

	CCS's PIC C is a pretty standard C with a few notable exceptions:		CCS's PIC C is a pretty standard C with a few notable exceptions:

LIMS at 23:39, 26 December 2007

2007-12-26T23:39:42Z

← Older revision		Revision as of 18:39, 26 December 2007
Line 1:		Line 1:
			[[Image:nigel.jpg\|right]]
	Read the PIC C intro by Nigel Gardner. It's short and also makes a good refresher for C programming. CCS's PIC C is a pretty standard C with a few notable exceptions:

			Read the small book that comes with the compiler & ICD device: <i>PICmicro MCU C, An Introduction to Programming the Microchip PIC in CCS C</i> by Nigel Gardner. It's short and makes a good refresher for C programming.

			Chapter 9 has some i/o specifics. Such information is on these wiki pages too, but another rendition can be useful.
			*Inputs and Outputs
			*Mixing C and Assembler
			*Bit manipulation
			*Timers
			*A/D Conversion
			*Data Communication: RS232, I2C, SPI
			*Pulse width modulation (PWM)
			*LCD display driving
			*Interrupts
			*Include libraries

			The CCS <i>C Compiler Reference Manual</i> is quite awful, even as user manuals go. When reading the function descriptions, it helps to look at the relevant section of the hardware datasheet for the PIC chip itself, and try to figure out what the reference manual is talking about.

			[http://129.105.69.13/datasheets/Microcontrollers/PIC18F4520.pdf Local copy of the PIC 18F4520 datasheet (6MB)]

			CCS's PIC C is a pretty standard C with a few notable exceptions:

	*You have to be very explicit about the size and type of variables. The PIC has limited memory for variables (1536 bytes). Its instruction set natively handles operations only for 8-bit integers, and all the rest is done in software. So think carefully about which variables need which data type. Adding two floats takes 150 times longer than adding two int8s.		*You have to be very explicit about the size and type of variables. The PIC has limited memory for variables (1536 bytes). Its instruction set natively handles operations only for 8-bit integers, and all the rest is done in software. So think carefully about which variables need which data type. Adding two floats takes 150 times longer than adding two int8s.

LIMS at 03:03, 26 December 2007

2007-12-26T03:03:38Z

← Older revision		Revision as of 22:03, 25 December 2007
Line 17:		Line 17:
	*Watch out for type conversion. When in doubt force the conversion the way you expect it to be. An expression is fully evaluated before being type converted for assignment. For instance if (int8) value = 100, then <b>bignumber = value << 3 </b> will be wrong; what you probably want is <b> bignumber = (int16) value << 3 </b>		*Watch out for type conversion. When in doubt force the conversion the way you expect it to be. An expression is fully evaluated before being type converted for assignment. For instance if (int8) value = 100, then <b>bignumber = value << 3 </b> will be wrong; what you probably want is <b> bignumber = (int16) value << 3 </b>

	*It's also useful to be able to select (mask) one or more bits from an int, using the bitwise operators & (logical and), \| (logical or), and ! (invert). Make order of evaluation unambiguous with parentheses.		*It's also useful to be able to select (mask) one or more bits from an int, using the bitwise operators & (logical and), \| (logical or), and ! (invert). Make order of evaluation unambiguous with parentheses. Example: if msecs is an int32 that is incremented by a 1KHz interrupt routine, then <b>(msecs & 255)</b> will be 0 every 256 milliseconds.

	Example: if msecs is an int32 that is incremented by a 1KHz interrupt routine, then <b>(msecs & 255)</b> will be 0 every 256 milliseconds.

	*Because float operations are so slow it's often better to use fixed point arithmetic; e.g. a continuous value between 0 and 1 can be represented as an int16 between 0 and 1000.		*Because float operations are so slow it's often better to use fixed point arithmetic; e.g. a continuous value between 0 and 1 can be represented as an int16 between 0 and 1000.

LIMS at 03:03, 26 December 2007

2007-12-26T03:03:23Z

← Older revision		Revision as of 22:03, 25 December 2007
Line 19:		Line 19:
	*It's also useful to be able to select (mask) one or more bits from an int, using the bitwise operators & (logical and), \| (logical or), and ! (invert). Make order of evaluation unambiguous with parentheses.		*It's also useful to be able to select (mask) one or more bits from an int, using the bitwise operators & (logical and), \| (logical or), and ! (invert). Make order of evaluation unambiguous with parentheses.

	Example: if msecs is an int32 that is incremented by a 1KHz interrupt routine, then (msecs & 255) will be 0 every 256 milliseconds.		Example: if msecs is an int32 that is incremented by a 1KHz interrupt routine, then <b>(msecs & 255)</b> will be 0 every 256 milliseconds.

	*Because float operations are so slow it's often better to use fixed point arithmetic; e.g. a continuous value between 0 and 1 can be represented as an int16 between 0 and 1000.		*Because float operations are so slow it's often better to use fixed point arithmetic; e.g. a continuous value between 0 and 1 can be represented as an int16 between 0 and 1000.

LIMS at 03:02, 26 December 2007

2007-12-26T03:02:54Z

← Older revision		Revision as of 22:02, 25 December 2007
Line 11:		Line 11:
	*Any of the int types (except int1) can be signed; by default they are unsigned (positive only.) Operations on signed ints are just as fast as on default (unsigned) ints. (check this)		*Any of the int types (except int1) can be signed; by default they are unsigned (positive only.) Operations on signed ints are just as fast as on default (unsigned) ints. (check this)

	*Ideally most of your variables will be defined like ~~this~~		*Ideally most of your variables will be defined like <b> int8 myvariable; </b> or <b> signed int8 myvariable; </b>

		⚫	*Addition and subtraction are much faster than multiplication and division. When multiplying or dividing an int8, int16, or int32 by a power of two, use the left-shift and right shift operators, e.g. <b> result = bignumber>>3; // divide by 8; right-shift by 3 bits </b>
	int8 myvariable; // or...
	signed int8 myvariable;

⚫	*Addition and subtraction are much faster than multiplication and division. When multiplying or dividing an int8, int16, or int32 by a power of two, use the left-shift and right shift operators:

	result = bignumber>>3; // divide by 8; right-shift by 3 bits

	*Watch out for type conversion. When in doubt force the conversion the way you expect it to be. An expression is fully evaluated before being type converted for assignment. For instance if (int8) value = 100, then <b>bignumber = value << 3 </b> will be wrong; what you probably want is <b> bignumber = (int16) value << 3 </b>		*Watch out for type conversion. When in doubt force the conversion the way you expect it to be. An expression is fully evaluated before being type converted for assignment. For instance if (int8) value = 100, then <b>bignumber = value << 3 </b> will be wrong; what you probably want is <b> bignumber = (int16) value << 3 </b>

LIMS at 03:01, 26 December 2007

2007-12-26T03:01:48Z

← Older revision		Revision as of 22:01, 25 December 2007
Line 20:		Line 20:
	result = bignumber>>3; // divide by 8; right-shift by 3 bits		result = bignumber>>3; // divide by 8; right-shift by 3 bits

	*Watch out for type conversion. When in doubt force the conversion the way you expect it to be. An expression is fully evaluated before being type converted for assignment. For instance if (int8) value = 100		*Watch out for type conversion. When in doubt force the conversion the way you expect it to be. An expression is fully evaluated before being type converted for assignment. For instance if (int8) value = 100, then <b>bignumber = value << 3 </b> will be wrong; what you probably want is <b> bignumber = (int16) value << 3 </b>

	bignumber = value << 3

	will be wrong; what you want is

	bignumber = (int16) value << 3

	*It's also useful to be able to select (mask) one or more bits from an int, using the bitwise operators & (logical and), \| (logical or), and ! (invert). Make order of evaluation unambiguous with parentheses.		*It's also useful to be able to select (mask) one or more bits from an int, using the bitwise operators & (logical and), \| (logical or), and ! (invert). Make order of evaluation unambiguous with parentheses.

LIMS at 03:00, 26 December 2007

2007-12-26T03:00:28Z

← Older revision		Revision as of 22:00, 25 December 2007
Line 13:		Line 13:
	*Ideally most of your variables will be defined like this		*Ideally most of your variables will be defined like this

	int8 myvariable;		int8 myvariable; // or...

	or

	signed int8 myvariable;		signed int8 myvariable;

Line 33:		Line 30:
	*It's also useful to be able to select (mask) one or more bits from an int, using the bitwise operators & (logical and), \| (logical or), and ! (invert). Make order of evaluation unambiguous with parentheses.		*It's also useful to be able to select (mask) one or more bits from an int, using the bitwise operators & (logical and), \| (logical or), and ! (invert). Make order of evaluation unambiguous with parentheses.

	Example: if msecs is an int32 that is incremented by a 1KHz interrupt routine, then (msecs & 255) will be 0 every 256 milliseconds.		Example: if msecs is an int32 that is incremented by a 1KHz interrupt routine, then (msecs & 255) will be 0 every 256 milliseconds.

	*Because float operations are so slow it's often better to use fixed point arithmetic; e.g. a continuous value between 0 and 1 can be represented as an int16 between 0 and 1000.		*Because float operations are so slow it's often better to use fixed point arithmetic; e.g. a continuous value between 0 and 1 can be represented as an int16 between 0 and 1000.

LIMS at 02:59, 26 December 2007

2007-12-26T02:59:49Z

← Older revision		Revision as of 21:59, 25 December 2007
Line 1:		Line 1:
	Read the PIC C intro by Nigel Gardner. It's short and also makes a good refresher for C programming.		Read the PIC C intro by Nigel Gardner. It's short and also makes a good refresher for C programming. CCS's PIC C is a pretty standard C with a few notable exceptions:

	CCS's PIC C is a pretty standard C with a few notable exceptions:

	*You have to be very explicit about the size and type of variables. The PIC has limited memory for variables (1536 bytes). Its instruction set natively handles operations only for 8-bit integers, and all the rest is done in software. So think carefully about which variables need which data type. Adding two floats takes 150 times longer than adding two int8s.		*You have to be very explicit about the size and type of variables. The PIC has limited memory for variables (1536 bytes). Its instruction set natively handles operations only for 8-bit integers, and all the rest is done in software. So think carefully about which variables need which data type. Adding two floats takes 150 times longer than adding two int8s.
Line 15:		Line 13:
	*Ideally most of your variables will be defined like this		*Ideally most of your variables will be defined like this

	int8 myvariable;		int8 myvariable;

	or		or

	signed int8 myvariable;		signed int8 myvariable;

	*Addition and subtraction are much faster than multiplication and division. When multiplying or dividing an int8, int16, or int32 by a power of two, use the left-shift and right shift operators:		*Addition and subtraction are much faster than multiplication and division. When multiplying or dividing an int8, int16, or int32 by a power of two, use the left-shift and right shift operators:

	result = bignumber>>3; // divide by 8; right-shift by 3 bits		result = bignumber>>3; // divide by 8; right-shift by 3 bits

	*Watch out for type conversion. When in doubt force the conversion the way you expect it to be. An expression is fully evaluated before being type converted for assignment. For instance if (int8) value = 100		*Watch out for type conversion. When in doubt force the conversion the way you expect it to be. An expression is fully evaluated before being type converted for assignment. For instance if (int8) value = 100

	bignumber = value << 3		bignumber = value << 3

	will be wrong; what you want is		will be wrong; what you want is

	bignumber = (int16) value << 3		bignumber = (int16) value << 3

	*It's also useful to be able to select (mask) one or more bits from an int, using the bitwise operators & (logical and), \| (logical or), and ! (invert). Make order of evaluation unambiguous with parentheses.		*It's also useful to be able to select (mask) one or more bits from an int, using the bitwise operators & (logical and), \| (logical or), and ! (invert). Make order of evaluation unambiguous with parentheses.

	Example: if msecs is an int32 that is incremented by a 1KHz interrupt routine, then (msecs & 255) will be 0 every 256 milliseconds.		Example: if msecs is an int32 that is incremented by a 1KHz interrupt routine, then (msecs & 255) will be 0 every 256 milliseconds.

	*Because float operations are so slow it's often better to use fixed point arithmetic; e.g. a continuous value between 0 and 1 can be represented as an int16 between 0 and 1000.		*Because float operations are so slow it's often better to use fixed point arithmetic; e.g. a continuous value between 0 and 1 can be represented as an int16 between 0 and 1000.