pulseIn: simplify ASM function, remove switch

Martino Facchin · Martino Facchin · commit 150d430a85b6 · 2015-01-20T02:55:16.000Z
diff --git a/hardware/arduino/avr/cores/arduino/wiring_private.h b/hardware/arduino/avr/cores/arduino/wiring_private.h
@@ -43,15 +43,7 @@ extern "C"{
 #define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit))
 #endif
 
-uint32_t countPulseASM_B(const uint8_t bit, uint8_t state, uint32_t maxloops);
-uint32_t countPulseASM_C(const uint8_t bit, uint8_t state, uint32_t maxloops);
-uint32_t countPulseASM_D(const uint8_t bit, uint8_t state, uint32_t maxloops);
-
-#if defined(__AVR_ATmega1280__)||defined(__AVR_ATmega2560__)
-uint32_t countPulseASM_E(const uint8_t bit, uint8_t state, uint32_t maxloops);
-uint32_t countPulseASM_F(const uint8_t bit, uint8_t state, uint32_t maxloops);
-uint32_t countPulseASM_G(const uint8_t bit, uint8_t state, uint32_t maxloops);
-#endif
+uint32_t countPulseASM(uint8_t bit, uint8_t state, uint32_t maxloops, volatile uint8_t* port);
 
 #define EXTERNAL_INT_0 0
 #define EXTERNAL_INT_1 1
diff --git a/hardware/arduino/avr/cores/arduino/wiring_pulse.S b/hardware/arduino/avr/cores/arduino/wiring_pulse.S
@@ -22,102 +22,47 @@
 
 #include <avr/io.h>
 
-#if 0	// commented version, unusable for macro expansion
+.section .text
+
+.global countPulseASM
 
-// bit is r25-24, state is r23-r22, timeout is r21-r18
+// bit is r25-24, state is r23-r22, timeout is r21-r18, *port is r17-r16
 // these register do not need to be restored
-// save r24 and r22 to r16,r17 for further use
+// save r24 and r22 to r14,r15 for further use
 // r25-r22 are used to store width and must be restored
 
-#define countPulseASM_gen(X)  								 \
-countPulseASM_##X:										$	 \
-push r17			; 	save r17-r15					$	 \
-push r16												$	 \
-push r15												$	 \
-mov r16, r24		; set r16 to r24 and r17 to r22     $    \
-mov r17, r22		; r17 is now state                  $    \
-mov r25,r1       	; zero r25-r22                      $    \
-mov r24,r1												$	 \
-mov r23,r1                                              $    \
-mov r22,r1                                              $    \
-loop_##X:            ; start loop                       $    \
-subi r22, 255        ; increment width                  $    \
-sbci r23, 255                                           $    \
-sbci r24, 255                                           $    \
-sbci r25, 255                                           $    \
-cp r22, r18          ; compare width with timeout       $    \
-cpc r23, r19                                            $    \
-cpc r24, r20                                            $    \
-cpc r25, r21                                            $    \
-breq return_zero_##X  ; if equal, return 0              $    \
-in r26, PIN##X - 0x20 ; save port state to unused r26   $    \
-eor r26, r17     	  ; xor with state                  $    \
-and r26, r16          ; and with bit                    $    \
-cpi r26, 0            ; compare with zero               $    \
-breq loop_##X         ; if equal, continue looping      $    \
-rjmp exit_##X                                           $    \
-return_zero_##X:                                        $    \
-mov r22,r1            ; return 0 - timeout reached      $    \
-mov r23,r1                                              $    \
-mov r24,r1                                              $    \
-mov r25,r1												$	 \
-exit_##X:                                               $    \
-pop r17													$    \
-pop r16													$    \
-pop r15													$    \
-ret
-
-#endif
-
-#define countPulseASM_gen(X)	.global countPulseASM_##X	$\
-countPulseASM_##X:	$\
-push r17				$\
-push r16				$\
-push r15				$\
-mov r16, r24			$\
-mov r17, r22			$\
-mov r25, r1				$\
-mov r24, r1				$\
-mov r23, r1				$\
-mov r22, r1				$\
-loop_##X:				$\
-subi r22, 255			$\
-sbci r23, 255			$\
-sbci r24, 255			$\
-sbci r25, 255			$\
-cp r22, r18				$\
-cpc r23, r19			$\
-cpc r24, r20			$\
-cpc r25, r21			$\
-breq return_zero_##X	$\
-in r26, PIN##X - 0x20	$\
-eor r26, r17			$\
-and r26, r16			$\
-cpi r26, 0				$\
-breq loop_##X			$\
-rjmp exit_##X			$\
-return_zero_##X:		$\
-mov r22, r1				$\
-mov r23, r1				$\
-mov r24, r1				$\
-mov r25, r1				$\
-exit_##X:				$\
-pop r17					$\
-pop r16					$\
-pop r15					$\
+countPulseASM:
+push r14			; save r14-r15
+push r15
+mov r14, r24		; set r14 to r24 and r15 to r22
+mov r15, r22		; r15 is now state
+mov r25,r1			; zero r25-r22
+mov r24,r1
+mov r23,r1
+mov r22,r1
+loop:				; start loop
+subi r22, 255		; increment width
+sbci r23, 255
+sbci r24, 255
+sbci r25, 255
+cp r22, r18			; compare width with timeout
+cpc r23, r19
+cpc r24, r20
+cpc r25, r21
+breq return_zero	; if equal, return 0
+movw r30, r16		; save port state to unused r26
+ld r26, Z
+eor r26, r15		; xor with state
+and r26, r14		; and with bit
+cpi r26, 0
+breq loop			; if equal, continue looping
+rjmp exit
+return_zero:
+mov r22,r1          ; return 0 - timeout reached
+mov r23,r1
+mov r24,r1
+mov r25,r1
+exit:
+pop r14
+pop r15
 ret
-
-.section .text
-
-countPulseASM_gen(B)
-countPulseASM_gen(C)
-countPulseASM_gen(D)
-
-
-#if defined(__AVR_ATmega1280__)||defined(__AVR_ATmega2560__)
-
-countPulseASM_gen(E)
-countPulseASM_gen(F)
-countPulseASM_gen(G)
-
-#endif
diff --git a/hardware/arduino/avr/cores/arduino/wiring_pulse.c b/hardware/arduino/avr/cores/arduino/wiring_pulse.c
@@ -25,21 +25,6 @@
 #include "wiring_private.h"
 #include "pins_arduino.h"
 
-//include PORT as the ones defined in Arduino.h
-#define PA 1
-#define PB 2
-#define PC 3
-#define PD 4
-#define PE 5
-#define PF 6
-#define PG 7
-#define PH 8
-#define PJ 10
-#define PK 11
-#define PL 12
-
-uint32_t (*countPulseASM)(const uint8_t bit, uint8_t state, uint32_t maxloops);
-
 /* Measures the length (in microseconds) of a pulse on the pin; state is HIGH
  * or LOW, the type of pulse to measure.  Works on pulses from 2-3 microseconds
  * to 3 minutes in length, but must be called at least a few dozen microseconds
@@ -57,38 +42,10 @@ unsigned long pulseIn(uint8_t pin, uint8_t state, unsigned long timeout)
 	uint8_t stateMask = (state ? bit : 0);
 	unsigned long width = 0; // keep initialization out of time critical area
 
-	switch (port) {
-		case PB:
-			//portB
-			countPulseASM = &countPulseASM_B;
-			break;
-		case PC:
-			//portC
-			countPulseASM = &countPulseASM_C;
-			break;
-		case PD:
-			//portD
-			countPulseASM = &countPulseASM_D;
-			break;
-#if defined(__AVR_ATmega1280__)||defined(__AVR_ATmega2560__)
-		case PE:
-			//portE
-			countPulseASM = &countPulseASM_E;
-		case PF:
-			//portF
-			countPulseASM = &countPulseASM_F;
-		case PG:
-			//portG
-			countPulseASM = &countPulseASM_G;
-#endif
-		default:
-			return 0;
-	}
-
 	// convert the timeout from microseconds to a number of times through
-	// the initial loop; it takes 11 clock cycles per iteration.
+	// the initial loop; it takes approximately 24 clock cycles per iteration. (compiler dependant)
 	unsigned long numloops = 0;
-	unsigned long maxloops = microsecondsToClockCycles(timeout)/15;
+	unsigned long maxloops = microsecondsToClockCycles(timeout)/24;
 	
 	// wait for any previous pulse to end
 	while ((*portInputRegister(port) & bit) == stateMask)
@@ -100,8 +57,8 @@ unsigned long pulseIn(uint8_t pin, uint8_t state, unsigned long timeout)
 		if (numloops++ == maxloops)
 			return 0;
 
-	width = countPulseASM(bit, stateMask, (maxloops - numloops));
-	return clockCyclesToMicroseconds(width * 15 + 30);
+	width = countPulseASM(bit, stateMask, (maxloops - numloops), portInputRegister(port));
+	return clockCyclesToMicroseconds(width * 17 + 32);
 }
 
 /* Measures the length (in microseconds) of a pulse on the pin; state is HIGH
