-- PIC18Fxx2 RAM management with Pointers. -- Using JAL (jal.sf.net) language. -- -- Copyright (C) 2005 Javier Martinez -- -- This library is free software; you can redistribute it and/or -- modify it under the terms of the GNU Lesser General Public -- License as published by the Free Software Foundation; either -- version 2.1 of the License, or (at your option) any later version. -- -- This library is distributed in the hope that it will be useful, -- but WITHOUT ANY WARRANTY; without even the implied warranty of -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -- Lesser General Public License for more details. -- -- You should have received a copy of the GNU Lesser General Public -- License along with this library; if not, write to the Free Software -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -- -- Javier Martinez, 17 March 2005 -- japus11 (at) gmail (dot) com -- -- -------------------------------------------------------------- -- Pointers definition -- include ./javi_lib/pointers_storage -- -------------------------------------------------------------- -- Exported functions -- -- By default, unless notification, FSR0 is used. -- -- LoadPointer_0 ( pointer:offset ) -- Pointer:Offset -> FSR0 -- LoadPointer_1 ( pointer:offset ) -- Pointer:Offset -> FSR1 -- LoadPointer_2 ( pointer:offset ) -- Pointer:Offset -> FSR2 -- -- SetPointer ( pointer , addrH:addrL ) -- Pointer <- ADDRESS -- SetPointerRel ( pointer1 , pointer0 , offset ) -- Pointer1 <- Pointer0 + Offset -- (FSR0 & FSR1) -- -- GetPointer ( pointer , addrH:addrL ) -- Pointer -> ADDRESS -- MemCpy ( pointer0 , Pointer1 , size ) -- [Pointer0] <- [Pointer1] -- ("size" times) (FSR0 & FSR1) -- MemCopyEx ( pointer0:Offset , -- Pointer1:Offset , size ) -- [Pointer0] <- [Pointer1] -- ("size" times) (FSR0 & FSR1) -- -- MemSet ( pointer , Data , size ) -- [Pointer] <- Data -- ("size" times) -- -- MemSetEx ( pointer:Offset , Data , size ) -- [Pointer] <- Data -- ("size" times) -- -- MemComp ( pointer0 , Pointer1 , size ) -- If [Pointer0] == [Pointer1] then TRUE -- ("size" times) (FSR0 & FSR1) -- MemCompEx ( pointer0:Offset , -- Pointer1:Offset , size ) -- If [Pointer0] == [Pointer1] then TRUE -- ("size" times) (FSR0 & FSR1) -- -- MemComp16 ( pointer0 , DataH:DataL ) -- If [Pointer0] == DataH:DataL then TRUE -- MemComp16Ex ( pointer0:Offset , DataH:DataL ) -- If [Pointer0] == DataH:DataL then TRUE -- -- MemSwp ( pointer0 , Pointer1 , size ) -- [Pointer0] <=> [Pointer1] -- ("size" times) (FSR0 & FSR1) -- MemSwpEx ( pointer0:Offset , Pointer1:Offset , size ) -- [Pointer0] <=> [Pointer1] -- ("size" times) (FSR0 & FSR1) -- -- MemRd ( pointer ) -- Return [Pointer] -- MemRdEx ( pointer:Offset ) -- Return [Pointer] -- -- MemWr ( pointer , Data) -- [Pointer] <- Data -- MemWrEx ( pointer:Offset , Data) -- [Pointer] <- Data -- -- ntohs ( pointer ) -- Convert NET to HOST 16bit order of [Pointer] -- ntohsEx ( pointer:Offset ) -- Convert NET to HOST 16bit order of [Pointer] -- htons ( pointer ) -- Convert HOST to NET 16bit order of [Pointer] -- htonsEx ( pointer:Offset ) -- Convert HOST to NET 16bit order of [Pointer] -- ntohl ( pointer ) -- Convert NET to HOST 32bit order of [Pointer] -- ntohlEx ( pointer:Offset ) -- Convert NET to HOST 32bit order of [Pointer] -- htonl ( pointer ) -- Convert HOST to NET 32bit order of [Pointer] -- htonlEx ( pointer:Offset ) -- Convert HOST to NET 32bit order of [Pointer] -- -- MemNext { type_byte variable } -- byte <- [{old} Pointer] <- byte -- LoadPointer_0 Make FSR0 to point to a specific address -- While calling LoadPointer_0, Offset0 can be omited (default = 0) -- procedure LoadPointer_0 ( byte in Pointer0 , byte in Offset0 = 0x00 ) is var byte hp01 , hp00 FSR0H = Pointers_Bank FSR0L = Pointer0 -- Pointer address hp00 = postinc0 hp01 = indf0 -- get the real address FSR0L = hp00 FSR0H = hp01 assembler -- Add Offset movf Offset0,w Addwf FSR0L,f btfsc status_c incf FSR0H,f end assembler -- now FSR0 points to desired address. end procedure -- LoadPointer_1 Make FSR1 to point to a specific address -- While calling LoadPointer_1, Offset1 can be omited (default = 0) -- procedure LoadPointer_1 ( byte in Pointer1 , byte in Offset1 = 0x00 ) is var byte hp11 , hp10 FSR1H = Pointers_Bank FSR1L = Pointer1 -- Pointer address hp10 = postinc1 hp11 = indf1 -- get the real address FSR1L = hp10 FSR1H = hp11 assembler -- Add Offset movf Offset1,w Addwf FSR1L,f btfsc status_c incf FSR1H,f end assembler -- now FSR1 points to desired address. end procedure -- LoadPointer_2 Make FSR2 to point to a specific address -- While calling LoadPointer_2, Offset2 can be omited (default = 0) -- procedure LoadPointer_2 ( byte in Pointer2 , byte in Offset2 = 0x00 ) is var byte hp21 , hp20 FSR2H = Pointers_Bank FSR2L = Pointer2 -- Pointer address hp20 = postinc2 hp21 = indf2 -- get the real address FSR2L = hp20 FSR2H = hp21 assembler -- Add Offset movf Offset2,w Addwf FSR2L,f btfsc status_c incf FSR2H,f end assembler -- now FSR2 points to desired address. end procedure -- SetPointer Store an "Address" in "Pointer". -- procedure SetPointer ( byte in SPointer , byte in Saddr_H , byte in Saddr_L ) is FSR0H = Pointers_Bank FSR0L = SPointer -- Pointer address postinc0 = Saddr_L indf0 = Saddr_H -- Set the real address end procedure -- SetPointerRel Store "Pointer0+Offset" in "Pointer1". -- procedure SetPointerRel ( byte in SRDPointer , byte in SRSPointer , byte in Offset ) is FSR1H = Pointers_Bank FSR1L = SRDPointer -- Dest. Pointer address FSR0H = Pointers_Bank FSR0L = SRSPointer -- Source Pointer address assembler movf Offset,w addwf postinc0,w movwf postinc1 movlw 0x00 addwfc indf0,w movwf indf1 end assembler end procedure -- GetPointer Get "Address" stored by "Pointer". -- procedure GetPointer ( byte in GPointer , byte out Gaddr_H , byte out Gaddr_L ) is FSR0H = Pointers_Bank FSR0L = GPointer -- Pointer address Gaddr_L = postinc0 Gaddr_H = indf0 -- Get the real address end procedure -- MemCpy Copy "size" bytes from "Pointer1" to "Pointer0" -- procedure MemCpy ( byte in MC_Pointer0 , byte in MC_Pointer1 , byte in MC_size ) is LoadPointer_0 ( MC_Pointer0 ) LoadPointer_1 ( MC_Pointer1 ) for MC_size loop postinc0 = postinc1 end loop end procedure -- MemCpyEx Copy "size" bytes from "Pointer1:Offset" to "Pointer0:Offset" -- procedure MemCpyEx ( byte in MCE_Pointer0 , byte in MCE_Offset0 , byte in MCE_Pointer1 , byte in MCE_Offset1 , byte in MCE_size ) is LoadPointer_0 ( MCE_Pointer0 , MCE_Offset0 ) LoadPointer_1 ( MCE_Pointer1 , MCE_Offset1 ) for MCE_size loop postinc0 = postinc1 end loop end procedure -- MemSet Fill "size" bytes from "Pointer" with "Data" -- procedure MemSet ( byte in MS_Pointer , byte in MS_data , byte in MS_size ) is LoadPointer_0 ( MS_Pointer ) for MS_size loop postinc0 = MS_data end loop end procedure -- MemSetEx Fill "size" bytes from "Pointer:Offset" with "Data" -- procedure MemSetEx ( byte in MSE_Pointer , byte in MSE_Offset , byte in MSE_data , byte in MSE_size ) is LoadPointer_0 ( MSE_Pointer , MSE_Offset ) for MSE_size loop postinc0 = MSE_data end loop end procedure -- MemComp Compare "size" bytes between "Pointer0" and "Pointer1". -- Return TRUE if equal, FALSE if not. -- function MemComp ( byte in MCP_Pointer0 , byte in MCP_Pointer1 , byte in MCP_size ) return bit is LoadPointer_0 ( MCP_Pointer0 ) LoadPointer_1 ( MCP_Pointer1 ) for MCP_size loop if postinc0 != postinc1 then Return False end if end loop return True end function -- MemCompEx Compare "size" bytes between "Pointer0:Offset" and "Pointer1:Offset". -- Return TRUE if equal, FALSE if not. -- function MemCompEx ( byte in MCPE_Pointer0 , byte in MCPE_Offset0 , byte in MCPE_Pointer1 , byte in MCPE_Offset1 , byte in MCPE_size ) return bit is LoadPointer_0 ( MCPE_Pointer0 , MCPE_Offset0 ) LoadPointer_1 ( MCPE_Pointer1 , MCPE_Offset1 ) for MCPE_size loop if postinc0 != postinc1 then Return False end if end loop return True end function -- MemComp16 Compare type_word vs "Pointer0". -- Return TRUE if equal, FALSE if not. -- function MemComp16 ( byte in MC16_Pointer0 , byte in MC16_dataH , byte in MC16_dataL ) return bit is var bit MC16_result LoadPointer_0 ( MC16_Pointer0 ) -- Start at LSB assembler local MC16_FALSE , MC16_TRUE , MC16_END movf MC16_dataL, w cpfseq postinc0 bra MC16_FALSE movf MC16_dataH, w cpfseq postinc0 bra MC16_FALSE MC16_TRUE: bsf MC16_result bra MC16_END MC16_FALSE: bcf MC16_result MC16_END: end assembler return MC16_result end function -- MemComp16Ex Compare type_word vs "Pointer0:Offset". -- Return TRUE if equal, FALSE if not. -- function MemComp16Ex ( byte in MC16E_Pointer0 , byte in MC16E_Offset0 , byte in MC16E_dataH , byte in MC16E_dataL ) return bit is var bit MC16E_result LoadPointer_0 ( MC16E_Pointer0 , MC16E_Offset0 ) assembler local MC16E_FALSE , MC16E_TRUE , MC16E_END movf MC16E_dataL, w cpfseq postinc0 bra MC16E_FALSE movf MC16E_dataH, w cpfseq postinc0 bra MC16E_FALSE MC16E_TRUE: bsf MC16E_result bra MC16E_END MC16E_FALSE: bcf MC16E_result MC16E_END: end assembler return MC16E_result end function -- MemSwp Swap "size" bytes between "Pointer0" and "Pointer1". -- procedure MemSwp ( byte in MSW_Pointer0 , byte in MSW_Pointer1 , byte in MSW_size ) is var byte MSW_temp LoadPointer_0 ( MSW_Pointer0 ) LoadPointer_1 ( MSW_Pointer1 ) for MSW_size loop assembler movf indf0, w movwf MSW_temp movf indf1, w movwf postinc0 movf MSW_temp, w movwf postinc1 end assembler end loop end procedure -- MemSwpEx Swap "size" bytes between "Pointer0:Offset" and "Pointer1:Offset". -- procedure MemSwpEx ( byte in MSWE_Pointer0 , byte in MSWE_Offset0 , byte in MSWE_Pointer1 , byte in MSWE_Offset1 , byte in MSWE_size ) is var byte MSWE_temp LoadPointer_0 ( MSWE_Pointer0 , MSWE_Offset0 ) LoadPointer_1 ( MSWE_Pointer1 , MSWE_Offset1 ) for MSWE_size loop assembler movf indf0, w movwf MSWE_temp movf indf1, w movwf postinc0 movf MSWE_temp, w movwf postinc1 end assembler end loop end procedure -- MemRd Read byte from "Pointer" -- Function MemRd ( byte in MRD_Pointer ) return byte is LoadPointer_0 ( MRD_Pointer ) Return postinc0 end Function -- MemRdEx Read byte from "Pointer:Offset" -- Function MemRdEx ( byte in MRDE_Pointer , byte in MRDE_Offset ) return byte is LoadPointer_0 ( MRDE_Pointer , MRDE_Offset ) Return postinc0 end Function -- MemWr Write "Data" byte to "Pointer" -- procedure MemWr ( byte in MWR_Pointer , byte in MWR_Data ) is LoadPointer_0 ( MWR_Pointer ) postinc0 = MWR_Data end procedure -- MemWrEx Write "Data" byte to "Pointer:Offset" -- procedure MemWrEx ( byte in MWRE_Pointer , byte in MWRE_Offset , byte in MWRE_Data ) is LoadPointer_0 ( MWRE_Pointer , MWRE_Offset ) postinc0 = MWRE_Data end procedure -- ntohs Convert NET byte order of "Pointer" to HOST byte order (16bit) -- procedure ntohs ( byte in ntohs_Pointer ) is begin var byte ntohs_tempbyte LoadPointer_0 ( ntohs_Pointer ) -- Start at LSB (HOST LSB) LoadPointer_1 ( ntohs_Pointer ) -- Start at LSB ntohs_tempbyte = postinc0 -- Temp <- LSB postinc1 = postinc0 -- MSB to LSB postinc1 = ntohs_tempbyte -- MSB <- Temp end procedure -- ntohsEx Convert NET byte order of "Pointer:Offset" to HOST byte order (16bit) -- procedure ntohsEx ( byte in ntohs_Pointer , byte in ntohs_Offset ) is begin var byte ntohsEx_tempbyte LoadPointer_0 ( ntohs_Pointer , ntohs_Offset ) -- Start at LSB LoadPointer_1 ( ntohs_Pointer , ntohs_Offset ) -- Start at LSB ntohsEx_tempbyte = postinc0 -- Temp <- LSB postinc1 = postinc0 -- MSB to LSB postinc1 = ntohsEx_tempbyte -- MSB <- Temp end procedure -- htons Convert HOST byte order of "Pointer" to NET byte order (16bit) -- procedure htons ( byte in htons_Pointer ) is begin ntohs ( htons_Pointer ) end procedure -- htonsEx Convert HOST byte order of "Pointer:Offset" to NET byte order (16bit) -- procedure htonsEx ( byte in htons_Pointer , byte in htons_Offset ) is begin ntohsEx ( htons_Pointer , htons_Offset ) end procedure -- ntohl Convert NET byte order of "Pointer" to HOST byte order (32bit) -- procedure ntohl ( byte in ntohl_Pointer ) is begin var byte ntohl_tempbyte0 , ntohl_tempbyte1 , ntohl_tempbyte2 LoadPointer_0 ( ntohl_Pointer ) -- Start at LSB LoadPointer_1 ( ntohl_Pointer ) -- Start at LSB ntohl_tempbyte0 = postinc0 -- Temp <- B0 (LSB) ntohl_tempbyte1 = postinc0 -- Temp <- B0 ntohl_tempbyte2 = postinc0 -- Temp <- B2 postinc1 = postinc0 -- MSB (B3) to B0 (LSB) postinc1 = ntohl_tempbyte2 -- B2 <- Temp postinc1 = ntohl_tempbyte1 -- B2 <- Temp postinc1 = ntohl_tempbyte0 -- B2 <- Temp end procedure -- ntohlEx Convert NET byte order of "Pointer:Offset" to HOST byte order (32bit) -- procedure ntohlEx ( byte in ntohlEx_Pointer , byte in ntohlEx_Offset ) is begin var byte ntohlEx_tempbyte0 , ntohlEx_tempbyte1 , ntohlEx_tempbyte2 LoadPointer_0 ( ntohlEx_Pointer , ntohlEx_Offset ) -- Start at LSB LoadPointer_1 ( ntohlEx_Pointer , ntohlEx_Offset ) -- Start at LSB ntohlEx_tempbyte0 = postinc0 -- Temp <- B0 (LSB) ntohlEx_tempbyte1 = postinc0 -- Temp <- B0 ntohlEx_tempbyte2 = postinc0 -- Temp <- B2 postinc1 = postinc0 -- MSB (B3) to B0 (LSB) postinc1 = ntohlEx_tempbyte2 -- B2 <- Temp postinc1 = ntohlEx_tempbyte1 -- B2 <- Temp postinc1 = ntohlEx_tempbyte0 -- B2 <- Temp end procedure -- htonl Convert HOST byte order of "Pointer" to NET byte order (32bit) -- procedure htonl ( byte in htonl_Pointer ) is begin ntohl ( htonl_Pointer ) end procedure -- htonlEx Convert HOST byte order of "Pointer:Offset" to NET byte order (32bit) -- procedure htonlEx ( byte in htonl_Pointer , byte in htonl_Offset ) is begin ntohlEx ( htonl_Pointer , htonl_Offset ) end procedure -- MemNext Type_byte variable for use in loops. -- Use it after setting FSR0, like in LoadPointer_0 | MemRd | MemRdEx | MemWr | MemWrEx -- WARNING !! Since FSRx is not checked ... USE IT AT YOUR OWN RISK -- var byte MemNext at postinc0 var byte MemNext0 at postinc0 var byte MemNext1 at postinc1 var byte MemNext2 at postinc2