Refactor things around to make it easier to add a reader mode with code reuse

armsrc/legicrf.c

@@ -15,6 +15,30 @@ static struct legic_frame {
 	int bits;
 	uint16_t data;
 } current_frame;
+AT91PS_TC timer;
+
+static void setup_timer(void)
+{
+	/* Set up Timer 1 to use for measuring time between pulses. Since we're bit-banging
+	 * this it won't be terribly accurate but should be good enough.
+	 */
+	AT91C_BASE_PMC->PMC_PCER = (1 << AT91C_ID_TC1);
+	timer = AT91C_BASE_TC1;
+	timer->TC_CCR = AT91C_TC_CLKDIS;
+	timer->TC_CMR = TC_CMR_TCCLKS_TIMER_CLOCK3;
+	timer->TC_CCR = AT91C_TC_CLKEN | AT91C_TC_SWTRG;
+
+/* At TIMER_CLOCK3 (MCK/32) */
+#define	RWD_TIME_1 150     /* RWD_TIME_PAUSE off, 80us on = 100us */
+#define RWD_TIME_0 90      /* RWD_TIME_PAUSE off, 40us on = 60us */
+#define RWD_TIME_PAUSE 30  /* 20us */
+#define RWD_TIME_FUZZ 20   /* rather generous 13us, since the peak detector + hysteresis fuzz quite a bit */
+#define TAG_TIME_BIT 150   /* 100us for every bit */
+#define TAG_TIME_WAIT 490  /* time from RWD frame end to tag frame start, experimentally determined */
+
+}
+
+#define FUZZ_EQUAL(value, target, fuzz) ((value) > ((target)-(fuzz)) && (value) < ((target)+(fuzz)))
 
 static const struct legic_frame queries[] = {
 		{7, 0x55}, /* 1010 101 */
@@ -24,7 +48,10 @@ static const struct legic_frame responses[] = {
 		{6, 0x3b}, /* 1101 11 */
 };
 
-static void frame_send(uint16_t response, int bits)
+/* Send a frame in tag mode, the FPGA must have been set up by
+ * LegicRfSimulate
+ */
+static void frame_send_tag(uint16_t response, int bits)
 {
 #if 0
 	/* Use the SSC to send a response. 8-bit transfers, LSBit first, 100us per bit */
@@ -35,24 +62,25 @@ static void frame_send(uint16_t response, int bits)
 	AT91C_BASE_PIOA->PIO_PER = GPIO_SSC_DOUT;
 	
 	/* Wait for the frame start */
-	while(AT91C_BASE_TC1->TC_CV < 490) ;
+	while(timer->TC_CV < TAG_TIME_WAIT) ;
 	
 	int i;
 	for(i=0; i<bits; i++) {
-		int nextbit = AT91C_BASE_TC1->TC_CV + 150;
+		int nextbit = timer->TC_CV + TAG_TIME_BIT;
 		int bit = response & 1;
 		response = response >> 1;
 		if(bit) 
 			AT91C_BASE_PIOA->PIO_SODR = GPIO_SSC_DOUT;
 		else
 			AT91C_BASE_PIOA->PIO_CODR = GPIO_SSC_DOUT;
-		while(AT91C_BASE_TC1->TC_CV < nextbit) ;
+		while(timer->TC_CV < nextbit) ;
 	}
 	AT91C_BASE_PIOA->PIO_CODR = GPIO_SSC_DOUT;
 #endif
 }
 
-static void frame_respond(struct legic_frame const * const f)
+/* Figure out a response to a frame in tag mode */
+static void frame_respond_tag(struct legic_frame const * const f)
 {
 	LED_D_ON();
 	int i, r_size;
@@ -67,7 +95,7 @@ static void frame_respond(struct legic_frame const * const f)
 	}
 	
 	if(r_size != 0) {
-		frame_send(r_data, r_size);
+		frame_send_tag(r_data, r_size);
 		LED_A_ON();
 	} else {
 		LED_A_OFF();
@@ -89,14 +117,15 @@ static int frame_is_empty(struct legic_frame const * const f)
 	return( f->bits <= 4 );
 }
 
-static void frame_handle(struct legic_frame const * const f)
+/* Handle (whether to respond) a frame in tag mode */
+static void frame_handle_tag(struct legic_frame const * const f)
 {
 	if(f->bits == 6) {
 		/* Short path */
 		return;
 	}
 	if( !frame_is_empty(f) ) {
-		frame_respond(f);
+		frame_respond_tag(f);
 	}
 }
 
@@ -106,10 +135,16 @@ static void frame_clean(struct legic_frame * const f)
 	f->bits = 0;
 }
 
-static void emit(int bit)
+enum emit_mode { 
+	EMIT_RWD, /* Emit in tag simulation mode, e.g. the source is the RWD */
+	EMIT_TAG  /* Emit in reader simulation mode, e.g. the source is the TAG */
+}; 
+static void emit(enum emit_mode mode, int bit)
 {
 	if(bit == -1) {
-		frame_handle(&current_frame);
+		if(mode == EMIT_RWD) {
+			frame_handle_tag(&current_frame);
+		}
 		frame_clean(&current_frame);
 	} else if(bit == 0) {
 		frame_append_bit(&current_frame, 0);
@@ -138,56 +173,46 @@ void LegicRfSimulate(void)
 	AT91C_BASE_PIOA->PIO_ODR = GPIO_SSC_DIN;
 	AT91C_BASE_PIOA->PIO_PER = GPIO_SSC_DIN;
 	
-	/* Set up Timer 1 to use for measuring time between pulses. Since we're bit-banging
+	setup_timer();
-	 * this it won't be terribly accurate but should be good enough.
-	 */
-	AT91C_BASE_PMC->PMC_PCER = (1 << AT91C_ID_TC1);
-	AT91C_BASE_TC1->TC_CCR = AT91C_TC_CLKDIS;
-	AT91C_BASE_TC1->TC_CMR = TC_CMR_TCCLKS_TIMER_CLOCK3;
-	AT91C_BASE_TC1->TC_CCR = AT91C_TC_CLKEN | AT91C_TC_SWTRG;
-	int old_level = 0;
-
-/* At TIMER_CLOCK3 (MCK/32) */
-#define	BIT_TIME_1 150
-#define BIT_TIME_0 90
-#define BIT_TIME_FUZZ 20
 	
+	int old_level = 0;
 	int active = 0;
+	
 	while(!BUTTON_PRESS()) {
 		int level = !!(AT91C_BASE_PIOA->PIO_PDSR & GPIO_SSC_DIN);
-		int time = AT91C_BASE_TC1->TC_CV;
+		int time = timer->TC_CV;
 		
 		if(level != old_level) {
 			if(level == 1) {
-				AT91C_BASE_TC1->TC_CCR = AT91C_TC_CLKEN | AT91C_TC_SWTRG;
+				timer->TC_CCR = AT91C_TC_CLKEN | AT91C_TC_SWTRG;
-				if(time > (BIT_TIME_1-BIT_TIME_FUZZ) && time < (BIT_TIME_1+BIT_TIME_FUZZ)) {
+				if(FUZZ_EQUAL(time, RWD_TIME_1, RWD_TIME_FUZZ)) {
 					/* 1 bit */
-					emit(1);
+					emit(EMIT_RWD, 1);
 					active = 1;
 					LED_B_ON();
-				} else if(time > (BIT_TIME_0-BIT_TIME_FUZZ) && time < (BIT_TIME_0+BIT_TIME_FUZZ)) {
+				} else if(FUZZ_EQUAL(time, RWD_TIME_0, RWD_TIME_FUZZ)) {
 					/* 0 bit */
-					emit(0);
+					emit(EMIT_RWD, 0);
 					active = 1;
 					LED_B_ON();
 				} else if(active) {
 					/* invalid */
-					emit(-1);
+					emit(EMIT_RWD, -1);
 					active = 0;
 					LED_B_OFF();
 				}
 			}
 		}
 		
-		if(time >= (BIT_TIME_1+BIT_TIME_FUZZ) && active) {
+		if(time >= (RWD_TIME_1+RWD_TIME_FUZZ) && active) {
 			/* Frame end */
-			emit(-1);
+			emit(EMIT_RWD, -1);
 			active = 0;
 			LED_B_OFF();
 		}
 		
-		if(time >= (20*BIT_TIME_1) && (AT91C_BASE_TC1->TC_SR & AT91C_TC_CLKSTA)) {
+		if(time >= (20*RWD_TIME_1) && (timer->TC_SR & AT91C_TC_CLKSTA)) {
-			AT91C_BASE_TC1->TC_CCR = AT91C_TC_CLKDIS;
+			timer->TC_CCR = AT91C_TC_CLKDIS;
 		}