slowly completing MDC1200 (TX and RX)

Makefile

@@ -18,6 +18,7 @@ ENABLE_AIRCOPY                   := 1
 ENABLE_AIRCOPY_REMEMBER_FREQ     := 1
 ENABLE_AIRCOPY_RX_REBOOT         := 0
 # FM Radio 4.2 kB
+#ENABLE_FMRADIO_76_90             := 0
 ENABLE_FMRADIO_68_108            := 0
 ENABLE_FMRADIO_76_108            := 0
 ENABLE_FMRADIO_875_108           := 1
@@ -129,7 +130,7 @@ ifeq ($(ENABLE_UART),1)
 	OBJS += driver/aes.o
 endif
 OBJS += driver/backlight.o
-ifeq ($(filter $(ENABLE_FMRADIO_68_108) $(ENABLE_FMRADIO_76_108) $(ENABLE_FMRADIO_875_108), 1), 1)
+ifeq ($(filter $(ENABLE_FMRADIO_76_90) $(ENABLE_FMRADIO_76_108) $(ENABLE_FMRADIO_875_108) $(ENABLE_FMRADIO_875_108), 1), 1)
 	OBJS += driver/bk1080.o
 endif
 OBJS += driver/bk4819.o
@@ -158,7 +159,7 @@ ifeq ($(ENABLE_AIRCOPY),1)
 endif
 OBJS += app/app.o
 OBJS += app/dtmf.o
-ifeq ($(filter $(ENABLE_FMRADIO_68_108) $(ENABLE_FMRADIO_76_108) $(ENABLE_FMRADIO_875_108), 1), 1)
+ifeq ($(filter $(ENABLE_FMRADIO_76_90) $(ENABLE_FMRADIO_76_108) $(ENABLE_FMRADIO_875_108) $(ENABLE_FMRADIO_875_108), 1), 1)
 	OBJS += app/fm.o
 endif
 OBJS += app/generic.o
@@ -194,7 +195,7 @@ ifeq ($(ENABLE_AIRCOPY),1)
 	OBJS += ui/aircopy.o
 endif
 OBJS += ui/battery.o
-ifeq ($(filter $(ENABLE_FMRADIO_68_108) $(ENABLE_FMRADIO_76_108) $(ENABLE_FMRADIO_875_108), 1), 1)
+ifeq ($(filter $(ENABLE_FMRADIO_76_90) $(ENABLE_FMRADIO_76_108) $(ENABLE_FMRADIO_875_108) $(ENABLE_FMRADIO_875_108), 1), 1)
 	OBJS += ui/fmradio.o
 endif
 OBJS += ui/helper.o
@@ -284,6 +285,9 @@ endif
 ifeq ($(ENABLE_AIRCOPY_RX_REBOOT),1)
 	CFLAGS += -DENABLE_AIRCOPY_RX_REBOOT
 endif
+ifeq ($(ENABLE_FMRADIO_76_90),1)
+	CFLAGS += -DENABLE_FMRADIO_76_90
+endif
 ifeq ($(ENABLE_FMRADIO_68_108),1)
 	CFLAGS += -DENABLE_FMRADIO_68_108
 endif

README.md

@@ -45,6 +45,7 @@ ENABLE_UART_DEBUG                := 0       just for code debugging, it sends de
 ENABLE_AIRCOPY                   := 1       clone radio-to-radio via RF
 ENABLE_AIRCOPY_REMEMBER_FREQ     := 1       remember the aircopy frequency
 ENABLE_AIRCOPY_RX_REBOOT         := 0       auto reboot on an aircopy successful RX completion
+#ENABLE_FMRADIO_76_90            := 0       not yet implemented
 ENABLE_FMRADIO_68_108            := 0       enable FM radio 68MHz ~ 108MHz
 ENABLE_FMRADIO_76_108            := 0       enable FM radio 76MHz ~ 108MHz
 ENABLE_FMRADIO_875_108           := 1       enable FM radio 87.5MHz ~ 108MHz

bitmaps.c

@@ -373,22 +373,44 @@ const uint8_t BITMAP_VFO_NOT_DEFAULT[8] =
 	__extension__ 0b00001000
 };
 
-const uint8_t BITMAP_SCANLIST1[6] =
+#if 0
-{	// 'I' symbol
+	const uint8_t BITMAP_SCANLIST1[6] =
-	__extension__ 0b00000000,
+	{	// 'I' symbol
-	__extension__ 0b00010001,
+		__extension__ 0b00000000,
-	__extension__ 0b00011111,
+		__extension__ 0b00100001,
-	__extension__ 0b00010001,
+		__extension__ 0b00111111,
-	__extension__ 0b00000000,
+		__extension__ 0b00100001,
-	__extension__ 0b00000000
+		__extension__ 0b00000000,
-};
+		__extension__ 0b00000000
+	};
 
-const uint8_t BITMAP_SCANLIST2[6] =
+	const uint8_t BITMAP_SCANLIST2[6] =
-{	// 'II' symbol
+	{	// 'II' symbol
-	__extension__ 0b00000000,
+		__extension__ 0b00100001,
-	__extension__ 0b00010001,
+		__extension__ 0b00111111,
-	__extension__ 0b00011111,
+		__extension__ 0b00100001,
-	__extension__ 0b00010001,
+		__extension__ 0b00100001,
-	__extension__ 0b00011111,
+		__extension__ 0b00111111,
-	__extension__ 0b00010001
+		__extension__ 0b00100001
-};
+	};
+#else
+	const uint8_t BITMAP_SCANLIST1[6] =
+	{	// 'I' symbol
+		__extension__ 0b00000000,
+		__extension__ 0b00111110,
+		__extension__ 0b01111111,
+		__extension__ 0b01111111,
+		__extension__ 0b00111110,
+		__extension__ 0b00000000
+	};
+
+	const uint8_t BITMAP_SCANLIST2[6] =
+	{	// 'II' symbol
+		__extension__ 0b00000000,
+		__extension__ 0b00000000,
+		__extension__ 0b00110110,
+		__extension__ 0b01110111,
+		__extension__ 0b01110111,
+		__extension__ 0b00110110
+	};
+#endif

mdc1200.c

@@ -132,14 +132,125 @@ uint16_t reverse_bits(const uint16_t bits_in, const unsigned int num_bits)
 
 #define FEC_K   7
 
+void error_correction(uint8_t *data)
+{
+	int i;
+	uint8_t csr[FEC_K];
+	uint8_t syn = 0;
+//	uint8_t shift_reg = 0;
+
+	syn = 0;
+
+	for (i = 0; i < FEC_K; i++)
+		csr[i] = 0;
+
+	for (i = 0; i < FEC_K; i++)
+	{
+		const uint8_t bi = data[i];
+		int bit_num;
+		for (bit_num = 0; bit_num < 8; bit_num++)
+		{
+			uint8_t b;
+			int k;
+			unsigned int ec = 0;
+
+			#if 0
+				shift_reg = (shift_reg << 1) | ((bi >> bit_num) & 1u);
+				b = ((shift_reg >> 6) ^ (shift_reg >> 5) ^ (shift_reg >> 2) ^ (shift_reg >> 0)) & 1u;
+			#else
+				for (k = FEC_K - 1; k > 0; k--)
+					csr[k] = csr[k - 1];
+				csr[0] = (bi >> bit_num) & 1u;
+				b = (csr[0] + csr[2] + csr[5] + csr[6]) & 1u;
+			#endif
+			syn = (syn << 1) | (((b ^ (data[i + FEC_K] >> bit_num)) & 1u) ? 1u : 0u);
+
+			if (syn & 0x80) ec++;
+			if (syn & 0x20) ec++;
+			if (syn & 0x04) ec++;
+			if (syn & 0x02) ec++;
+
+			if (ec >= 3)
+			{	// correct error
+
+				int fix_i = i;
+				int fix_j = bit_num - 7;
+
+				syn ^= 0xA6;
+
+				if (fix_j < 0)
+				{
+					--fix_i;
+					fix_j += 8;
+				}
+
+				if (fix_i >= 0)
+					data[fix_i] ^= 1u << fix_j;
+			}
+		}
+	}
+}
+
+uint8_t * decode_data(uint8_t *data)
+{
+	uint16_t crc1;
+	uint16_t crc2;
+
+//	(void)data;
+
+	{	// de-interleave
+
+		unsigned int i;
+		unsigned int k;
+		uint8_t deinterleaved[(FEC_K * 2) * 8];
+
+		// de-interleave the received bits
+		for (i = 0, k = 0; i < 16; i++)
+		{
+			unsigned int m;
+			for (m = 0; m < FEC_K; m++)
+			{
+				const unsigned int n = (m * 16) + i;
+				deinterleaved[k++] = (data[n >> 3] >> ((7 - n) & 7u)) & 1u;
+			}
+		}
+
+		// copy the de-interleaved bits to the data buffer
+		for (i = 0; i < (FEC_K * 2); i++)
+		{
+			unsigned int k;
+			uint8_t b = 0;
+			for (k = 0; k < 8; k++)
+				if (deinterleaved[(i * 8) + k])
+					b |= 1u << k;
+			data[i] = b;
+		}
+	}
+
+	error_correction(data);
+
+	crc1 = compute_crc(data, 4);
+	crc2 = (data[5] << 8) | (data[4] << 0);
+
+	if (crc1 != crc2)
+		return NULL;
+	
+	// appears to be a valid packet
+
+
+	
+	// TODO: more stuff
+
+
+
+
+	return NULL;
+}
+
 uint8_t * encode_data(uint8_t *data)
 {
-	unsigned int i;
-
 	// R=1/2 K=7 convolutional coder
 	//
-	// create the FEC bits
-	//
 	// op     0x01
 	// arg    0x80
 	// id     0x1234
@@ -152,27 +263,28 @@ uint8_t * encode_data(uint8_t *data)
 	// 1. reverse the bit order for each byte of the first 7 bytes (to undo the reversal performed for display, above)
 	// 2. feed those bits into a shift register which is preloaded with all zeros
 	// 3. for each bit, calculate the modulo-2 sum: bit(n-0) + bit(n-2) + bit(n-5) + bit(n-6)
-	// 4. then for each byte of resulting output, again reverse those bits to generate the values listed above (for display)
+	// 4. then for each byte of resulting output, again reverse those bits to generate the values shown above
-	//
+
-	{
+	{	// add the FEC bits to the end of the data
+		unsigned int i;
 		uint8_t shift_reg = 0;
 		for (i = 0; i < FEC_K; i++)
 		{
-			unsigned int  bit;
+			unsigned int  bit_num;
 			const uint8_t bi = data[i];
 			uint8_t       bo = 0;
-
+			for (bit_num = 0; bit_num < 8; bit_num++)
-			for (bit = 0; bit < 8; bit++)
 			{
-				shift_reg = (shift_reg << 1) | ((bi >> bit) & 1u);
+				shift_reg = (shift_reg << 1) | ((bi >> bit_num) & 1u);
-				bo |= (((shift_reg >> 6) ^ (shift_reg >> 5) ^ (shift_reg >> 2) ^ (shift_reg >> 0)) & 1u) << bit;
+				bo |= (((shift_reg >> 6) ^ (shift_reg >> 5) ^ (shift_reg >> 2) ^ (shift_reg >> 0)) & 1u) << bit_num;
 			}
-
+			data[FEC_K + i] = bo;
-			data[i + FEC_K] = bo;
 		}
 	}
 
-	{
+	{	// interleave the bits
+
+		unsigned int i;
 		unsigned int k;
 		unsigned int m;
 		uint8_t interleaved[(FEC_K * 2) * 8];
@@ -180,25 +292,25 @@ uint8_t * encode_data(uint8_t *data)
 		// bit interleaver
 		for (i = 0, k = 0, m = 0; i < (FEC_K * 2); i++)
 		{
-			unsigned int bit;
+			unsigned int bit_num;
 			const uint8_t b = data[i];
-			for (bit = 0; bit < 8; bit++)
+			for (bit_num = 0; bit_num < 8; bit_num++)
 			{
-				interleaved[k] = (b >> bit) & 1u;
+				interleaved[k] = (b >> bit_num) & 1u;
 				k += 16;
 				if (k >= sizeof(interleaved))
 					k = ++m;
 			}
 		}
 
-		// copy the interleaved bits to the output buffer
+		// copy the interleaved bits back to the input/output buffer
 		for (i = 0, k = 0; i < (FEC_K * 2); i++)
 		{
-			int bit;
+			int bit_num;
 			uint8_t b = 0;
-			for (bit = 7; bit >= 0; bit--)
+			for (bit_num = 7; bit_num >= 0; bit_num--)
 				if (interleaved[k++])
-					b |= 1u << bit;
+					b |= 1u << bit_num;
 			data[i] = b;
 		}
 	}

misc.c

@@ -346,8 +346,19 @@ void NUMBER_trim_trailing_zeros(char *str)
 {
 	if (str != NULL)
 	{
-		int i = (int)strlen(str) - 1;
+		bool found_dp = false;
-		while (i > 0 && (str[i] == '0' || str[i] == ' ') && str[i - 1] != '.')
+		int i = 0;
-			str[i--] = 0;
+		while (i < 16 && str[i] != 0)
+		{
+			if (str[i] == '.')
+				found_dp = true;
+			i++;
+		}
+		if (found_dp)
+		{
+			i--;
+			while (i > 0 && (str[i] == '0' || str[i] == ' ') && str[i - 1] != '.')
+				str[i--] = 0;
+		}
 	}
 }