SX Microcontroller Math Method

Increment / Decrement

Best 16 bit

Translated and optimized for the Scenix SX by James Newton. Bug fix by Ted Inoue.

From Scott Dattalo

Please read the entire page before you use this code!

;inc
	dec	high	;ERROR! Read below..
	incsz	low
	 inc	high	;ERROR! Read below..


A downcounting version;
;dec
	test	low
	snz
	 dec	high
	dec	low

Comments:

James Newton responds: "I have no idea how I managed to screw that up when I translated it from the original for the PIC at http://www.piclist.com/techref/microchip/math/incdec/best16.htm which matches your code. Must have been a moment of brain drain.

Yes, almost all of the code has been tested. But the human mind is not immune from error. That is part of the point of this Massmind web site. We can all share and help each other catch our errors. I wonder how many people have used that bad code, found the error and corrected it without using the form at the bottom of this page to post a correction or even a warning. Thank you very much for takeing the time to contribute the corrected code.
 

• I put [the corrected] code into my code and proceeded to have <really> weird results. After much F'ing around, I discovered that the code on the page is STILL BROKEN. This is what is on the page:

  ;inc
      dec high
      incsz low
      inc high
  

  However, the first and last lines should have the opposite operations applied. In other words, it should look like this:

  ;inc
      inc high
      incsz low
      dec high
  

  It's really frustrating to find a page that talks about a piece of broken code that was fixed but which still has the bug in it. Furthermore, while we're on this page, how about commenting the code so it teaches beginners better? I suggest the following verbosity:

  ; HOW THIS FUNCTION WORKS:
  ; A 16 bit variable is stored as two bytes in memory.  In this case
  ; they are called "high" (for the high byte of the 16 bit word) and
  ; "low" for the low byte.
  
  ; In a 16 bit increment, we want to increment the low byte every time,
  ; but ONLY increment the high byte when the low wraps around from 255
  ; back to 0.  This function works by ALWAYS incrementing the high byte,
  ; followed by incrementing the low byte.  Normally, the next instruction
  ; then decrements the high byte back to where it was originally.  However,
  ; when the low byte wraps to zero, it sets the "zero" flag, and the instruction
  ; to "fix" the high byte is skipped.  Since the first instruction already incremented
  ; the high byte, it is at the correct value, and the entire 16 bit word is correct.
  
  ;inc
      inc high    ;Assume the low byte will wrap back to 0
      incsz low     ;Increment the low byte?   Did it wrap?
      dec high    ;No, so fix the high byte value
  
  ; The 16 bite decrement also needs to affect the high byte ONLY when the low
  ; byte wraps from 0 to 255.  In this case, we check if the low byte is already
  ; at 0.  If it is, then we decrement the high byte, followed by the decrementing the
  ; low byte.  If the low byte is at any value other than zero, we simply decrement
  ; the low byte.
  
  ;dec
      test low    ; Is the low byte at zero?
      snz            ;If not, skip the next instruction
      dec high    ; Low byte is zero, so dec the high byte
      dec low    ; We always dec the low byte
  

  At the very least, I suggest leaving the code comments I added so that programmers can read the intent of the code instead of playing human assembler.

  James Newton responds: "Again, thank you for taking the time to share your version. I would like to note that the version you found and realized was incorrect is the original version and NOT the version that Ted fixed. I've added a comment to the original code so that future users will be less likely to miss this. I do NOT want to correct the original error as I think this serves as a good example of both the strengths and weakness of open source and code shareing."

  .