| |
| 
|
|
The PIC16F877 or PIC16F876 microcontrollers have very limited amounts of memory and several types of memory. These limited resources has to be carefully used. This chapter describes the types of memory and how they may be used by PicPuter program.
$00 - $1F internal Microchip system registers . $20 - $3F PicPuter implementation registers. $40 - $6F lower byte of 16 bit variables . $70 - $7F PicPuter implementation registers. $80 - $9F internal Microchip system registers . $A0 - $BF PicPuter implementation registers. $C0 - $EF upper byte of 16 bit variables . $F0 - $FF Accesses $70 - $7F. $100 -$10F Internal Microchip system registers. $110 -$15F Basic Stack. $160 -$16F UART Output Fifo. $170 -$17F Accesses $70 - $7F. $180 -$18F Internal Microchip system registers. $190 -$1DF Input Buffer. $1E0 -$1EF LCD Output Fifo. $1F0 -$1FF Accesses $70 - $7F. Whenever you access a registers or variables you are accessing SRAM. Some SRAM locations, $00-$1F $80-$9F, are implemented by PIC hardware to do special functions, these are called registers in PicPuter nomenclature. These locations control various features PIC16F877 chip. They are all accessible by the name given to them in the microchip reference manual and are treated as an unsigned 8 bit value. Other locations access general purpose 8 bit and 16 bit storage, These are used for variables storage as well as the various buffers and implementation variables used by the kernel. If you 'PRINT A' you are printing the value at location 65 (and 65+128 for the upper 8 bits of the 16 bit value) which happens to be the ascii code for 'A'. You can also access memory as an array , a command like command like 'PRINT A[1]' will print the value at location 65+1 or 'B'.
$0000 - $00FF PicPuter kernel. $0100 - $01FF Fail-safe Boot-loader. $0200 - $05?? PicPuter kernel. $05?? - $07FF PicPuter string constants. $0800 - $0FFF PicPuter kernel. $1000 - $1FFF Basic Program Storage. The 8192 words (14 bit) of flash memory is also inside the chip. The lower half, $0000-$0FFF, is used to store the PicPuter Program, and the upper half, $1000-$1FFF. stores basic or assembler programs. PicPuter stores basic bottom up (starting at $1FFF and less) while the assembly runs top down. The makes it easy to divide memory between assembly and basic. The lower half is normally protected to prevent a rampant program from overwriting the PicPuter kernel, but if bit 15 of the CONFIGURATOR register is set, you may modify the kernel with the handy built-in assembler . Only memory locations $0000 and $0100-$01FF can not be modified, these locations contain the fail-safe bootloader , just incase you make your PicPuter non-bootable. Unregistered users may only modify locations $1E00 - $1EFF, but it is cheap and easy to register .
The EEPROM memory is not used very much by PicPuter and there is no easy way for a user to access it. It contains a few strings to reduce the size of kernel, and the user license key. A full featured version of PicPuter is available. After which a small PicPuter program is sent to you that rewrites the EEPROM. The EEPROM stores the user name address as well as other parts required to validate the key. This key will unlock all future versions up to Version 2.5. Altering the contents of the eeprom will cause PicPuter not to boot.
PicPuter features many different addressing modes and most commands allow you to use any type of addressing. This makes PicPuter BASIC a very flexible and rich language. There are two types of memory that a PicPuter BASIC can access, sram or flash . The major types of addressing are directly, indirectly, arrays, linear interpolated tables.
To access the internal sram directly simply use the name of the registers or variables . There are 26 general purpose variables A-Z and are treated 16 bit signed values. examples: A,B,C...Z registers are treated as an 8 bit unsigned values. variables can be a 16 bit signed value or an 8 bit unsigned value. examples: A, B, CONFIGURATOR, EVENTS, ADC0, ADC7, USAGE, RND The upper 8 bits of any 16bit variables may be accessed by including the suffix 'h'. It is then interpreted as an 8 bit unsigned value. examples: Ah, Bh, ADC0h, RNDh
flash memory is accessed by preceding the variable with an '@' or an '*'. When a variable is preceded with an amberstand its contents is treated as the flash ram address. So if A=$600 then @A or *A would access the flash location at $600. This location can also be accessed by the constant expression *$600. examples: *10, *$A, *A, *Ah, *RND flash memory is only 14 bits wide. The 14 bit value may be either zero filled or sign extended when loaded into a 16 bit variables . The behavior is dependent upon the CONFIGURATOR Sign Extend bit. The upper two bits are always dropped on write. Since flash memory can wear out, care should be taken not to write a single location too many times. Reads do not wear out the flash.
Most variables can be used in an Array. Arrays allow you access a group of related data using an index. The index may be a constant , variable, or register. The expression A[1] would access B, A[2] access C. examples: A[1], A[B], A[ADC0h], A[RND], SEC[Ah] You can also use arrays to access flash ram. When accessing flash, the index of the array is added to the address. If a=$600 then the expression *A[2] would access the flash location $602. examples: *A[0], *A[1] *A[B], *A[Bh], *Ah[RNDh], *RND[RND]
Fixed point interpolated tables are new for version 1.8,. A variable may be preceded with a period '.' inside of an array subscript. This causes the variable to be treated as an 8.8 fixed point index into the table. The upper eight bits are the index for the array. The lower eight bits represent the fractional portion. A simple linear interpolation method is used that effectively draws a straight line between the two array points to interpolate the addition 255 virtual array locations. This allows picputer to use tables that approximate the value of various math functions such as SIN() COS(), or the calibrate ADC0 value to a real temperature value. The state of the CONFIGURATOR SIGN_EXTEND bit determine the sign extension characteristics of the read. Example: C = @A[.B] c = *(A+(B>>8)) + ( (((*(A+(B>>8)+1) - *(A+(B>>8))) *(B&255))>>8) ) |
3.01 : SRAM : 512 Bytes