Storing constant data in program memory - Revision history

LIMS: /* Creating a look-up table for the sine function using CONST */

2008-07-06T21:31:00Z

Creating a look-up table for the sine function using CONST

← Older revision		Revision as of 16:31, 6 July 2008
Line 66:		Line 66:

	//To look up sine values from the table, you could use a function like the following:		//To look up sine values from the table, you could use a function like the following:

	//prior to calling the function, make sure that the input, i, is 0<=i<=359. If you don't,		//prior to calling the function, make sure that the input, i, is 0<=i<=359. If you don't,
	//you will index outside of the array and create the infamous, "stray pointer"		//you will index outside of the sineTable[90] array and create the infamous, "stray pointer"

	float sineLookup(unsigned int16 i){		float sineLookup(unsigned int16 i){
	if (i < 90)		if (i < 90)

LIMS: /* Creating a look-up table for the sine function using CONST */

2008-07-06T21:29:20Z

Creating a look-up table for the sine function using CONST

← Older revision		Revision as of 16:29, 6 July 2008
Line 65:		Line 65:
	0.987688,0.990268,0.992546,0.994522,0.996195,0.997564,0.99863,0.999391,0.999848};		0.987688,0.990268,0.992546,0.994522,0.996195,0.997564,0.99863,0.999391,0.999848};

	//To look up sine values from the table, you could use a function like the following:		//To look up sine values from the table, you could use a function like the following:
	//prior to calling the function, make sure that the input, i, is 0<=i<=359. If you don't,		//prior to calling the function, make sure that the input, i, is 0<=i<=359. If you don't,
	//you will index outside of the array and create the infamous, "stray pointer"		//you will index outside of the array and create the infamous, "stray pointer"
	float sineLookup(unsigned int16 i){		float sineLookup(unsigned int16 i){
	if (i < 90)		if (i < 90)
	{return sineTable[i];}		{return sineTable[i];}
Line 77:		Line 77:
	else if (i < 360)		else if (i < 360)
	{return (-1*sineTable[359-i]);}		{return (-1*sineTable[359-i]);}
	}		}

	===Using a Loop to Write Constant Data===		===Using a Loop to Write Constant Data===

LIMS: /* Creating a look-up table for the sine function using CONST */

2008-07-06T21:28:27Z

Creating a look-up table for the sine function using CONST

← Older revision		Revision as of 16:28, 6 July 2008
Line 1:		Line 1:

	== Overview ==		== Overview ==
	The PIC has a relatively large amount of flash program memory (32 Kbytes) but relatively little data memory (1536 bytes of SRAM), as well as a very small amount of EEPROM (256 bytes). For some applications, we want to have lookup tables or calibration data stored on our PIC, but we don't want it hogging data memory. The CCS C Compiler provides a few different ways to use program memory for data, discussed below. We have also provided an example of how to create a look-up table for the sine function to illustrate one of these methods.		The PIC has a relatively large amount of flash program memory (32 Kbytes) but relatively little data memory (1536 bytes of SRAM), as well as a very small amount of EEPROM (256 bytes). For some applications, we want to have lookup tables or calibration data stored on our PIC, but we don't want it hogging data memory. The CCS C Compiler provides a few different ways to use program memory for data, discussed below. We have also provided an example of how to create a look-up table for the sine function to illustrate one of these methods.
Line 66:		Line 65:
	0.987688,0.990268,0.992546,0.994522,0.996195,0.997564,0.99863,0.999391,0.999848};		0.987688,0.990268,0.992546,0.994522,0.996195,0.997564,0.99863,0.999391,0.999848};

	//To look up sine values from the table, you could use a function like the following:		//To look up sine values from the table, you could use a function like the following:
			//prior to calling the function, make sure that the input, i, is 0<=i<=359. If you don't,
⚫	float sineLookup(~~index~~){
			//you will index outside of the array and create the infamous, "stray pointer"
	i = index % 360; //Is there a better way to implement this?
		⚫	float sineLookup(unsigned int16 i){
⚫	if (~~i >= 0 &&~~ i < 90)
	~~return sineTable[i];~~		if (i < 90)
	~~else~~ if (i ~~>= 90 &&~~ i ~~< 180)~~		{return sineTable[i];}
		⚫	else if (i < 180)
⚫	return sineTable[~~179~~-i];
	~~else~~ if (i ~~>= 180 &&~~ i ~~< 270)~~		{return sineTable[179-i];}
			else if (i < 270)
	return -sineTable[180-i];
	~~else~~ if (i ~~>= 270 &&~~ i ~~< 360~~)		{return (-1*sineTable[i-180]);}
			else if (i < 360)
	return -sineTable[359-i];
		⚫	{return (-1*sineTable[359-i]);}
	end
	}		}

	===Using a Loop to Write Constant Data===		===Using a Loop to Write Constant Data===

Lynch at 22:40, 2 March 2008

2008-03-02T22:40:40Z

← Older revision		Revision as of 17:40, 2 March 2008
Line 1:		Line 1:
	== Original Assignment ==

	Your PIC has a relatively large amount of program memory (32 Kbytes) but relatively little data memory (1536 bytes). For some applications, we want to have lookup tables or calibration data stored on our PIC, but we don't want it hogging data memory. This project is to demonstrate how to write a program that stores constant data in program memory. Test your ability to do this by creating a look-up table for the sin function. This is a 1-d array with integer index corresponding to an angle (e.g., numbers 0 to 89 if the index is in degrees; angles in other quadrants can be determined by simple transformations). Depending on your choice of int8, int16, or float to represent the number, what angle resolution can you use for the index before you reach the limits of program memory?

	See p. 43 of the PIC MCU C Compiler book.

	Finally, give sample code for storing data in the EEPROM, too.

	== Overview ==		== Overview ==

JonathanShih: /* Using a Loop to Write Constant Data */

2008-02-21T01:36:11Z

Using a Loop to Write Constant Data

← Older revision		Revision as of 20:36, 20 February 2008
Line 91:		Line 91:

	The code below creates a list of 100 integers using a loop and writes them to program memory:		The code below creates a list of 100 integers using a loop and writes them to program memory:

	#include <stdlibm.h>		#include <stdlibm.h>
	int * listptr;		int * listptr;
	int i;		int i;
	listptr = calloc(~~100~~, sizeof(int)); //allocates memory space for temporary variable		listptr = calloc(1000, sizeof(int)); //allocates memory space for temporary variable
	for(i=0x1000;i<=~~0x1064~~;i++){		for(i=0x1000;i<=0x13e8;i++){
	listptr[i]=i;		listptr[i]=i;
	write_program_memory(i, listptr[i], 1);}		write_program_memory(i, listptr[i], 1);}
	free(listptr); //deallocates memory used by temporary variable for future use		free(listptr); //deallocates memory used by temporary variable for future use

	The data can be retrieved by		The data can be retrieved by read_program_memory(address, pointer, count) :ex. read_program_memory(0x1000,listptr,1);

	===Memory Management===		===Memory Management===

BrianKephart: More references

2008-02-21T01:26:28Z

More references

← Older revision		Revision as of 20:26, 20 February 2008
Line 140:		Line 140:
	*PIC MCU C Compiler		*PIC MCU C Compiler
	*PICmicro MCU C		*PICmicro MCU C
	http://en.wikipedia.org/wiki/Memory_address		*http://en.wikipedia.org/wiki/Memory_address

JonathanShih: /* References */

2008-02-21T01:24:39Z

References

← Older revision		Revision as of 20:24, 20 February 2008
Line 140:		Line 140:
	*PIC MCU C Compiler		*PIC MCU C Compiler
	*PICmicro MCU C		*PICmicro MCU C
			http://en.wikipedia.org/wiki/Memory_address

JonathanShih: /* Code */

2008-02-21T00:40:27Z

Code

← Older revision		Revision as of 19:40, 20 February 2008
Line 59:		Line 59:

	===Creating a look-up table for the sine function using CONST===		===Creating a look-up table for the sine function using CONST===

⚫	*int8 = 8 bit number (1 byte); range 0 to 255 (2-3 digits)
⚫	*int16 = 16 bit number (2 bytes); range 0 to 65535 (4-5 digits)
⚫	*float = 32 bit number (4 bytes); range -1.5x10^45 to 3.4x10^38 (7-8 digits)

	With values of sine from 0-89°, we can calculate sine values for all 360°. Below is code storing a table of sine values from 0-89° with a angle resolution of 1° and algorithm for calculating sine values for 90-360°.		With values of sine from 0-89°, we can calculate sine values for all 360°. Below is code storing a table of sine values from 0-89° with a angle resolution of 1° and algorithm for calculating sine values for 90-360°.
Line 92:		Line 88:

	===Using a Loop to Write Constant Data===		===Using a Loop to Write Constant Data===
			Although we must initialize a constant variable when we declare it, it is possible to use loops to calculate an array, which is then stored into program memory via other means.

			The code below creates a list of 100 integers using a loop and writes them to program memory:
			#include <stdlibm.h>
			int * listptr;
			int i;
			listptr = calloc(100, sizeof(int)); //allocates memory space for temporary variable
			for(i=0x1000;i<=0x1064;i++){
			listptr[i]=i;
			write_program_memory(i, listptr[i], 1);}
			free(listptr); //deallocates memory used by temporary variable for future use

			The data can be retrieved by

	===Memory Management===		===Memory Management===

	~~This~~ table stores values as floats and is 360 bytes in size. Since the PIC has 32 KB of program memory, we could theoretically hold a sine lookup table precise to 0.01125° (32000/360 = 88.8x larger size; 1°/88.8 = 0.01125°).		The above sine table stores values as floats and is 360 bytes in size. Since the PIC has 32 KB of program memory, we could theoretically hold a sine lookup table precise to 0.01125° (32000/360 = 88.8x larger size; 1°/88.8 = 0.01125°).

		⚫	*int8 = 8 bit number (1 byte); range 0 to 255 (2-3 digits)
		⚫	*int16 = 16 bit number (2 bytes); range 0 to 65535 (4-5 digits)
		⚫	*float = 32 bit number (4 bytes); range -1.5x10^45 to 3.4x10^38 (7-8 digits)

	const int8 sineTable[90] = ...		const int8 sineTable[90] = ...

JonathanShih: /* Constant Data */

2008-02-21T00:09:13Z

Constant Data

← Older revision		Revision as of 19:09, 20 February 2008
Line 19:		Line 19:
	const int iCanCount[10] = {1,2,3,4,5,6,7,8,9,10};		const int iCanCount[10] = {1,2,3,4,5,6,7,8,9,10};

	You must initialize the constant variable when you declare it or the compiler will spit out an error at you.		You must initialize the constant variable when you declare it or the compiler will spit out an error at you. This means you cannot use a loop to directly initialize the constant variable (in the case of large arrays). It is also not possible to use a temporary variable to run calculations in a loop before storing in a constant variable because the compiler will not let you declare new variables after running the calculations in the loop.

	It is also not possible to use a temporary variable to run calculations in a loop before storing in a constant variable because the compiler will not let you declare new variables after running the calculations in the loop.

	=== #ROM Directive ===		=== #ROM Directive ===

BrianKephart: Logical vs. physical memory

2008-02-21T00:04:18Z

Logical vs. physical memory

← Older revision		Revision as of 19:04, 20 February 2008
Line 11:		Line 11:

	=== Constant Data ===		=== Constant Data ===
	The CONST qualifier will place variables into program memory. If the keyword CONST is used before the identifier, the identifier is treated as a constant. These constants need to be initialized and cannot be changed at run-time.		The CONST qualifier will place variables into flash program memory. If the keyword CONST is used before the identifier, the identifier is treated as a constant. These constants need to be initialized and cannot be changed at run-time.

	The ROM qualifier puts data in program memory with 3 bytes per instruction space. The address used for ROM data is a true byte address not a physical address. The & operator can be used on ROM variables even though the address is logical not physical.		The ROM qualifier puts data into flash program memory with 3 bytes per instruction space. The address used for ROM data is a true byte address not a physical address. The & operator can be used on ROM variables even though the address is logical not physical. Physical memory space is how the data is laid out on the memory in hardware, and may be spaced apart. This is in contrast to logical, or virtual memory, which is how the software views the memory.

	The syntax is: const ''type'' ''name''[''size''] = {''values''}		The syntax is: const ''type'' ''name''[''size''] = {''values''}
Line 30:		Line 30:
	The following example places the numbers 1, 3, 5, 7, 9 into ROM addresses starting at 0x2000:		The following example places the numbers 1, 3, 5, 7, 9 into ROM addresses starting at 0x2000:

	#rom 0x2000 = {1, 3, 5, 7, 9}		#rom 0x2000 = {1,3,5,7,9}

	You can also put strings into program memory using the #ROM directive:		You can also put strings into program memory using the #ROM directive: