;====================================================================================== ; Very high speed DUAL 4X-resolution quadrature encoder routine. ; ; This module defines a routine that will allow a 20MHz PIC16xxx to encode two ; simultaneous quadrature encoders. Transitions on both edges of both signals ; from each encoder are processed to provide 4x resolution. ; ; (c) 2003 - Robert V. Ammerman ; RAm Systems ; rammerman@adelphia.net (as of 21-Apr-2003) ; via the PICLIST (www.piclist.com) ; ; This code may be freely used in any application, commercial or otherwise, with the following ; provisos: ; ; 1. The above copyright notice and these conditions remain intact within the source code. ; 2. Robert V. Ammerman, RAm Systems, the PICLIST and PICLIST.COM have no responsibility ; for this code working in your application, or any consequences of it not working. ; 3. This code is provided without any form of warranty whatsoever. ; 4. You must make a diligent effort to contact Robert V. Ammerman via email or the ; PICLIST to inform him, in general terms, about how you are using this code (he ; is curious!) ; ; PERFORMANCE: Unlike many quadrature decoding schemes, this code does not depend on ; interrupts from edges of the input signals. Rather, it periodically checks the ; inputs to see what changes have occured. It can be driven either from a timer ; interrupt, or simply by being called from a non-interrupt-driven loop. ; ; In the non-interrupt-driven case, each call of the encoder polling routine uses ; a maximum of 22 instruction cycles, including the call and return. It uses as few ; as 12 cycles if no inputs have changed. ; ; A reasonable computation for the maximum edge rate at which this routine ; can work is: ; ; 22 instructions per poll ; x 1.5 (to allow for 'distortion' in the encoder waveforms) ; x 1.5 (to give the 'application' code at least 1/3 of the total CPU time). ; ------- ; = 50 instructions per edge ; ; At a 20Mhz clock rate, or 5Mhz instruction rate, this gives a maximum edge rate ; of 100,000 edges per second or 25,000 full encoder cycles per second. ; ; Note that at the rate given above, an application has to limit itself to ; no more than 11 instruction times between calls on the ENCPOLL macro to ; meet the 1.5 factor in the above comptution. Changing that factor, for example, ; to 2.0 would allow 22 application instructions per poll at a maximum edge rate ; of about 67,000 per second. A factor of 3.0 would allow 44 application instructions ; per poll at a maximum edge rate of about 50,000 per second. ; ; When interrupt driven, a number of cycles will be used to enter and exit the ; interrupt routine, which will reduce the maximum possible edge rate. ; ; Note that if any interrupts are enabled, then the worst case ISR time has to ; be added to the clocks per edge. This is true even if the encoder is using ; the polling mode. ; ; This code is provided in ABSOLUTE mode to avoid the complexity of defining and ; distributing a linker control file with it (sorry Olin). ; ; NOTE: The sample application code that is included herein is not complete. Appropriate ; initialize code needs to be added. ; list p=16F628,r=DEC,x=OFF include "p16F628.inc" ;============================================================== org 0x000 goto initialize ;============================================================== ; Where to put the lookup table enc_lookup_table = 0x100 ;============================================================== ; Variables used by the encoder cblock 0x20 enc1_count:2 ; current count for encoder 1 enc2_count:2 ; current count for encoder 2 enc1_faults ; number of faults seen on encoder 1 enc2_faults ; number of faults seen on encoder 2 enc_inputs ; most recent (old,new) input input pair endc ;============================================================== ; Routine to poll the encoder. This code assumes that the encoder ; inputs are connected to pins RA3..RA0, and that PCLATH is ; always set to HIGH(enc_lookup_table) POLL_ENCODER: movlw 0x0F ;[3] andwf enc_inputs,F ;[4] swapf enc_inputs,F ;[5] andwf PORTA,W ;[6] iorwf enc_inputs,W ;[7] movwf enc_inputs ;[8] movwf PCL ;[9-10] ;============================================================== ; Define a macro to poll the encoders ; Min time (including call and return) = 12 instructions ; Max time (including call and return) = 22 instructions POLLENC macro call POLL_ENCODER ;[1-2] endm ;============================================================== ; Define the four possible actions for an encoder A_NOP = 0 ; do nothing (neither input changed) A_INC = 1 ; increment count A_DEC = 2 ; decrement count A_FLT = 3 ; fault condition (both inputs changed) ;============================================================== ; Macro to generate the label for an action routine A_LABEL macro m1,m2 ACT_#v((m1<<2)|m2): endm ;============================================================== ; Macros to perform the actions for the two encoders. To store ; a larger count than 16 bits these routines would have to be ; changed. INC1 macro incf enc1_count+1,f ;[1] assume carry incfsz enc1_count,f ;[2] bump low bits decf enc1_count+1,f ;[3] no carry actually happened endm INC2 macro incf enc2_count+1,f ;[1] assume carry incfsz enc2_count,f ;[2] bump low bits decf enc2_count+1,f ;[3] no carry actually happened endm DEC1 macro movf enc1_count,f ;[1] check for zero skpnz ;[2] decf enc1_count+1,f ;[3] decrement msbits decf enc1_count,f ;[4] decrement lsbits endm DEC2 macro movf enc2_count,f ;[1] check for zero skpnz ;[2] decf enc2_count+1,f ;[3] decrement msbits decf enc2_count,f ;[4] decrement lsbits endm FLT1 macro incf enc1_faults,f ;[1] endm FLT2 macro incf enc2_faults,f ;[1] endm ;============================================================== ; Define the routines that implement the actions. A_LABEL A_INC,A_NOP INC1 ;[13-15] fall thru return ;[13-14] or [16-17] A_LABEL A_INC,A_INC INC1 ;[13-15] fall thru A_LABEL A_NOP,A_INC INC2 ;[13-15] or [16-18] return ;[16-17] or [19-20] A_LABEL A_INC,A_DEC INC1 ;[13-15] fall thru A_LABEL A_NOP,A_DEC DEC2 ;[13-16] or [16-19] return ;[17-18] or [20-21] A_LABEL A_INC,A_FLT INC1 ;[13-15] fall thru A_LABEL A_NOP,A_FLT FLT2 ;[13] or [16] return ;[14-15] or [17-18] A_LABEL A_DEC,A_INC INC2 ;[13-15] fall thru A_LABEL A_DEC,A_NOP DEC1 ;[13-16] or [16-19] return ;[17-18] or [20-21] A_LABEL A_DEC,A_DEC DEC1 ;[13-16] DEC2 ;[17-20] return ;[21-22] A_LABEL A_DEC,A_FLT DEC1 ;[13-16] FLT2 ;[17] return ;[18-19] A_LABEL A_FLT,A_INC INC2 ;[13-15] fall thru A_LABEL A_FLT,A_NOP FLT1 ;[13] or [16] return ;[14-15] or [17-18] A_LABEL A_FLT,A_DEC FLT1 ;[13] DEC2 ;[14-17] return ;[18-19] A_LABEL A_FLT,A_FLT FLT1 ;[13] FLT2 ;[14] return ;[15-16] ;============================================================== ;============================================================== ;============================================================== ;============================================================== ; START OF SAMPLE APPLICATION CODE ; ; This dummy application shows how the PIC could be polled ; via UART to supply the current input values. ; ; Note: the numbers in [] identify the number of instructions ; between polls. To support a 100,000 edge per second rate ; this must be kept at 11 or below. As you can see, it really ; isn't too difficult. cblock send_save ; saved MSBits of current count value being sent xmit_hold ; byte held while waiting for TX to be ready endc initialize: ; -- perform initialization of UART, ports, etc -- mainloop: POLLENC btfss RCSTA,OERR ;[1] do we have an overrun? goto no_error ;[2-3] bcf RCSTA,CREN ;[3] disable nop ;[4] bsf RCSTA,CREN ;[5] and reenable to correct overrun no_error: POLLENC btfss PIR1,RCIF ;[1] do we have a character? goto mainloop ;[2-3] no movf RCREG,W ;[3] get character xorlw 'P' ;[4] is it the poll command? skpz ;[5] goto mainloop ;[6-7] no POLLENC movf enc1_count+1,W ;[1] save MSBits of counter movwf send_save ;[2] ...so we get a consistent view movf enc1_count,W ;[3] send ls byte firs call xmit_byte ;[4-5] send it off movf send_save,W ;[3] now the ms byte call xmit_byte ;[4-5] movf enc1_faults,W ;[3] and the number of faults call xmit_byte ;[4-5] movf enc2_count+1,W ;[3] save MSBits of counter movwf send_save ;[4] ...so we get a consistent view movf enc2_count,W ;[5] send ls byte first call xmit_byte ;[6-7] movf send_save,W ;[3] now the ms byte call xmit_byte ;[4-5] movf enc2_faults,W ;[3] and the number of faults call xmit_byte ;[4-5] goto mainloop ;[3-4] ; -- send the byte in W to the UART. xmit_byte: movwf xmit_hold ;[8] remember it xmit_loop: POLLENC btfss PIR1,TXIF ;[1] goto xmit_loop ;[2-3] movf xmit_hold,W ;[4] movwf TXREG ;[5] POLLENC return ;[1-2] ; END OF SAMPLE APPLICATION CODE ;============================================================== ;============================================================== ;============================================================== ;============================================================== ;============================================================== ; Macro to encode an old and new state to determine what ; action to perform for a single encoder SENCODE macro result,old,new ; no change if old == new result = A_NOP exitm endif ; fault condition (both bits changed) if old == (new ^ B'11') result = A_FLT exitm endif ; increment is: 00->01->11->10->00 ; decrement is: 00->10->11->01->00 local x x = (old << 2) | new if x == B'0001' || x == B'0111' || x == B'1110' || x == B'1000' result = A_INC ; it is an increment else result = A_DEC ; it must be a decrement endif endm ;============================================================== ; Macro to encode the old and new states for both encoders ; to determine the action routine to be executed. SACTIONS macro old,new local m1,m2,action ; figure out the action for the first encoder SENCODE m1,((old >> 2)&B'11'),((new >> 2)&B'11') ; figure out the action for the second encoder SENCODE m2,(old&B'11'),(new&B'11') ; combine the two action = (m1<<2)|m2 ; no sense generating a goto instruction to a return. just generate ; the return instead if action == 0 LIST X=ON return ;[11-12] LIST X=OFF else LIST X=ON goto ACT_#v(action) ;[11-12] LIST X=OFF endif endm ;============================================================== ; Define a 256 instruction table that is indexed by the ; concatenation of the old and new state bits to determine the ; actions to be taken. It is interesting to note that each ; possible action routine is used exactly 16 times by this code ; Now build the lookup table. It consumes 0x100 locations starting ; at 'enc_lookup_table' org enc_lookup_table while $ < enc_lookup_table + 0x100 SACTIONS (($>>4)&B'1111'),($&B'1111') endw enc
.