Fixed TX and RX. There is currently a bug as the SPI comms is shared between two tasks, SPI will fail due to two taskes accessing the SPI device

main/board.c

@@ -68,7 +68,7 @@ void board_init(void)
 	// setup debugging IO
 	gpio_config_t debug_pin_config =
 	{
-			.pin_bit_mask = (uint64_t) (BIT64(DEBUG_0)|BIT64(DEBUG_1)),
+			.pin_bit_mask = (uint64_t) (BIT64(DEBUG_0)|BIT64(DEBUG_1)|BIT64(DEBUG_2)|BIT64(DEBUG_3)),
 			.mode = GPIO_MODE_OUTPUT,
 			.pull_up_en = GPIO_PULLUP_DISABLE,
 			.pull_down_en = GPIO_PULLDOWN_DISABLE,

main/board.h

@@ -56,6 +56,8 @@
 
 #define DEBUG_0 			16
 #define DEBUG_1				4
+#define DEBUG_2				32
+#define DEBUG_3				33
 
 void enable_red_led(void);
 void enable_green_led(void);

main/bt_spp.c

@@ -40,6 +40,8 @@ void esp_set_rx_cb(void (*rx_cb)(uint8_t *p, uint16_t p_len) )
 	receive_cb = rx_cb;
 }
 
+uint32_t handle = 0;
+
 // SPP Callback
 static void esp_spp_cb(esp_spp_cb_event_t event, esp_spp_cb_param_t *param)
 {
@@ -65,7 +67,8 @@ static void esp_spp_cb(esp_spp_cb_event_t event, esp_spp_cb_param_t *param)
 		break;
 	case ESP_SPP_CL_INIT_EVT:
 		// called when SPP client initiated a connection
-		ESP_LOGI(SPP_TAG, "ESP_SPP_CL_INIT_EVT");
+		ESP_LOGI(SPP_TAG, "ESP_SPP_CL_INIT_EVT handle=%d", param->open.handle);
+		handle = param->open.handle;
 		break;
 	case ESP_SPP_DATA_IND_EVT:
 		// called when SPP connection receives data
@@ -146,6 +149,11 @@ void esp_bt_gap_cb(esp_bt_gap_cb_event_t event, esp_bt_gap_cb_param_t *param)
 }
 
 
+void bt_spp_tx(uint8_t *buf, uint32_t len)
+{
+	esp_spp_write(handle, len, buf);
+}
+
 void bt_spp_init(void)
 {
     // Bluetooth Controller Initialization

main/cc1200.c

@@ -243,7 +243,7 @@ rf_status_t IRAM_ATTR cc1200_spi_strobe(uint8_t cmd)
 			.command_bits = 0,
 			.address_bits = 0
 	};
-	ret = spi_device_polling_transmit(spi, (spi_transaction_t*)&rx_trans_ext); // switched to spi poll as test
+	ret = spi_device_polling_transmit(spi, (spi_transaction_t*)&rx_trans_ext);
 	ESP_ERROR_CHECK(ret);
 	return (temp & 0xF0);
 }
@@ -380,15 +380,29 @@ static void IRAM_ATTR LUT_lookup(void)
         phase -= (float)LUT_SIZE;
 }
 
-static void IRAM_ATTR cc1200_aprs_tx_isr(void* arg)
+void IRAM_ATTR cc1200_aprs_tx_isr(void* para)
 {
+    GPIO.out_w1ts = (1 << DEBUG_0);
+
+	int timer_idx = (int) para;
+
+    /* Clear the interrupt
+         and update the alarm time for the timer with without reload */
+    TIMERG0.int_clr_timers.t1 = 1;
+
+    // after the alarm has been triggered
+    //  we need enable it again, so it is triggered the next time
+    TIMERG0.hw_timer[1].config.alarm_en = TIMER_ALARM_EN;
+
     cc1200_spi_write_byte(CC120X_CFM_TX_DATA_IN, LUT[phase_i]);
 
     sample_count++;
     new_sample = 1;
 
 	toggle = toggle ^ 1;
-	gpio_set_level(DEBUG_1, toggle);
+
+	GPIO.out_w1tc = (1 << DEBUG_0);
+
 }
 
 void cc1200_lut_init(void)
@@ -407,35 +421,42 @@ void cc1200_lut_init(void)
 void IRAM_ATTR cc1200_radio_APRSTXPacket(uint8_t  *f, uint16_t f_len, uint8_t tx_delay, uint8_t tx_tail)
 {
 	// acquire SPI bus for fastest possible SPI transactions
-	spi_device_acquire_bus(spi, portMAX_DELAY);
+//	spi_device_acquire_bus(spi, portMAX_DELAY);
 
 	vTaskSuspendAll();
 
 	// setup data rate for CFM TX
-	cc1200_radio_write(APRS_TX_SETTINGS, sizeof(APRS_TX_SETTINGS)/sizeof(cc1200_reg_settings_t));
-	cc1200_radio_frequency(144390000-6000);
+//	cc1200_radio_write(APRS_RX2_SETTINGS, sizeof(APRS_RX2_SETTINGS)/sizeof(cc1200_reg_settings_t));
+//	cc1200_radio_frequency(144390000-6000);
 
 
 	// start CW transmission
-	cc1200_spi_write_byte(CC120X_FIFO, 0x12);
-	while(cc1200_spi_strobe(CC120X_STX) != CC120X_STATE_TX);
-
-	// enable interrupt pin for CC1120 for timing packets
-	gpio_install_isr_service(ESP_INTR_FLAG_IRAM);
-	gpio_isr_handler_add(CC1120_GPIO3, cc1200_aprs_tx_isr, NULL);
-	gpio_set_intr_type(CC1120_GPIO3, GPIO_INTR_POSEDGE);
-	gpio_intr_enable(CC1120_GPIO3);
+//	cc1200_spi_write_byte(CC120X_FIFO, 0x12);
+	uint8_t state = 0x00;
 
+	//while(cc1200_spi_strobe(CC120X_STX) != CC120X_STATE_TX);
+	while(state != CC120X_STATE_TX)
+	{
+		state = cc1200_spi_strobe(CC120X_STX);
+	}
 
+	// enable interrupt pin for CC1120 for timing packets
+//	gpio_install_isr_service(ESP_INTR_FLAG_IRAM);
+//	gpio_isr_handler_add(CC1120_GPIO3, cc1200_aprs_tx_isr, NULL);
+//	gpio_set_intr_type(CC1120_GPIO3, GPIO_INTR_POSEDGE);
+//	gpio_intr_enable(CC1120_GPIO3);
 
+    timer_enable_intr(TIMER_GROUP_0, TIMER_1);
+    timer_set_counter_value(TIMER_GROUP_0, TIMER_1, 0x00000000ULL);
+    timer_start(TIMER_GROUP_0, TIMER_1);
 
 	int16_t i,j;
 	uint16_t p_len = tx_delay * 12;
 	uint16_t t_len = tx_tail * 12 + 1;
 
-    // Start CW transmission
-	cc1200_spi_write_byte(CC120X_FIFO, 0x12);
-	cc1200_spi_strobe(CC120X_STX);
+////    // Start CW transmission
+//	cc1200_spi_write_byte(CC120X_FIFO, 0x12);
+//	cc1200_spi_strobe(CC120X_STX);
 
 	sample_count = 0;
 	new_sample = 0;
@@ -577,12 +598,15 @@ void IRAM_ATTR cc1200_radio_APRSTXPacket(uint8_t  *f, uint16_t f_len, uint8_t tx
 		}
 	}
 
-	gpio_intr_disable(CC1120_GPIO3);
-	gpio_set_intr_type(CC1120_GPIO3, GPIO_INTR_DISABLE);
+//	gpio_intr_disable(CC1120_GPIO3);
+//	gpio_set_intr_type(CC1120_GPIO3, GPIO_INTR_DISABLE);
+    timer_disable_intr(TIMER_GROUP_0, TIMER_1);
+	timer_pause(TIMER_GROUP_0, TIMER_1);
+
 	while(cc1200_spi_strobe(CC120X_SIDLE)!= CC120X_STATE_IDLE);
 	xTaskResumeAll();
-	spi_device_release_bus(spi);
-	gpio_uninstall_isr_service();
+//	spi_device_release_bus(spi);
+//	gpio_uninstall_isr_service();
 }
 
 extern SemaphoreHandle_t xRadioRXISRSemaphore;
@@ -612,12 +636,12 @@ static void IRAM_ATTR cc1200_aprs_rx_isr(void* arg)
 void IRAM_ATTR cc1200_radio_start_APRSRX(void)
 {
 	// acquire SPI bus for fastest possible SPI transactions
-	spi_device_acquire_bus(spi, portMAX_DELAY);
+	//spi_device_acquire_bus(spi, portMAX_DELAY);
 
 
 	// start RX transmission
-	cc1200_radio_write(APRS_RX2_SETTINGS, sizeof(APRS_RX2_SETTINGS)/sizeof(cc1200_reg_settings_t));
-	cc1200_radio_frequency(144390000-6000);
+//	cc1200_radio_write(APRS_RX2_SETTINGS, sizeof(APRS_RX2_SETTINGS)/sizeof(cc1200_reg_settings_t));
+//	cc1200_radio_frequency(144390000-6000);
 
 	// enable ISR for CC1120 for timing packets
 //	gpio_install_isr_service(ESP_INTR_FLAG_IRAM);
@@ -625,7 +649,8 @@ void IRAM_ATTR cc1200_radio_start_APRSRX(void)
 //	gpio_set_intr_type(CC1120_GPIO2, GPIO_INTR_POSEDGE);
 //	gpio_intr_enable(CC1120_GPIO2);
 
-	while(cc1200_spi_strobe(CC120X_SRX) != CC120X_STATE_RX);
+	while(cc1200_spi_strobe(CC120X_SRX) != CC120X_STATE_RX)
+		vTaskDelay(2/portTICK_PERIOD_MS);
 }
 
 void cc1200_radio_stop_APRSRX(void)
@@ -635,16 +660,21 @@ void cc1200_radio_stop_APRSRX(void)
 //	gpio_set_intr_type(CC1120_GPIO2, GPIO_INTR_DISABLE);
 //	gpio_uninstall_isr_service();
 
-	while(cc1200_spi_strobe(CC120X_SIDLE) != CC120X_STATE_IDLE);
-	spi_device_release_bus(spi);
+	//spi_device_release_bus(spi);
+	vTaskDelay(2/portTICK_PERIOD_MS);
+	while(cc1200_spi_strobe(CC120X_SIDLE) != CC120X_STATE_IDLE)
+		vTaskDelay(2/portTICK_PERIOD_MS);
 }
 
 void cc1200_radio_init(const cc1200_reg_settings_t* rf_settings, uint8_t len)
 {
+
 	cc1200_gpio_init();
 	cc1200_spi_init();
 	cc1200_lut_init();
 
+	spi_device_acquire_bus(spi, portMAX_DELAY);
+
 	cc1200_radio_reset();	gpio_set_level(CC1120_RESET, 1);
 
 	//uint8_t data;

main/cc1200.h

@@ -294,6 +294,7 @@ void cc1200_radio_start_APRSRX(void);
 void cc1200_radio_stop_APRSRX(void);
 uint8_t cc1200_radio_read_RSSI(void);
 uint8_t cc1200_radio_read_CFM(void);
+void IRAM_ATTR cc1200_aprs_tx_isr(void* para);
 
 
 #endif// CC120X_SPI_H

main/cc1200_protocol.h

@@ -177,7 +177,8 @@ static const cc1200_reg_settings_t APRS_RX2_SETTINGS[]=
   {CC120X_IOCFG2,            0x08},
   {CC120X_IOCFG0,            0x09},
   {CC120X_SYNC_CFG1,         0x3F},
-  {CC120X_MODCFG_DEV_E,      0x01},
+  {CC120X_DEVIATION_M,		 0x9D},
+  {CC120X_MODCFG_DEV_E,      0x00},
   {CC120X_DCFILT_CFG,        0x5D},
   {CC120X_PREAMBLE_CFG1,     0x00},
   {CC120X_PREAMBLE_CFG0,     0x8A},
@@ -197,7 +198,7 @@ static const cc1200_reg_settings_t APRS_RX2_SETTINGS[]=
   {CC120X_FS_CFG,            0x1B},
   {CC120X_PKT_CFG2,          0x03},
   {CC120X_PKT_CFG1,          0x00},
-  {CC120X_PKT_CFG0,          0x20},
+  {CC120X_PKT_CFG0,          0x28},
   {CC120X_PA_CFG1,           0x3F},
   {CC120X_PKT_LEN,           0xFF},
   {CC120X_IF_MIX_CFG,        0x1C},
@@ -244,13 +245,14 @@ static const cc1200_reg_settings_t APRS_TX2_SETTINGS[]=
   {CC120X_IOCFG2,            0x08},
   {CC120X_IOCFG0,            0x09},
   {CC120X_SYNC_CFG1,         0x0B},
+  {CC120X_DEVIATION_M,		 0x06},
   {CC120X_MODCFG_DEV_E,      0x01},
   {CC120X_DCFILT_CFG,        0x5D},
   {CC120X_PREAMBLE_CFG1,     0x00},
   {CC120X_PREAMBLE_CFG0,     0x8A},
   {CC120X_IQIC,              0xCB},
   {CC120X_CHAN_BW,           0x9C},
-  {CC120X_MDMCFG1,           0x06},
+  {CC120X_MDMCFG1,           0x00},
   {CC120X_MDMCFG0,           0x45},
   {CC120X_SYMBOL_RATE2,      0x3F},
   {CC120X_SYMBOL_RATE1,      0x75},

main/kiss.c

@@ -19,6 +19,7 @@
 buffer_handle_t buffer_handle;
 tnc_settings_t tnc_settings;
 
+
 void kiss_clear_buffer(void)
 {
 	ESP_LOGD(TNC_TAG, "TNC buffer cleared.");

main/main.c

@@ -50,7 +50,7 @@ SemaphoreHandle_t xRadioTXSemaphore;
 
 extern int8_t EXTERNAL_DATA;
 
-#define WINDOW_SIZE 6
+#define WINDOW_SIZE 7
 #define SAMPLEFREQUENCY 6000
 
 int window[WINDOW_SIZE];
@@ -115,7 +115,7 @@ int window_get_size(void)
 void IRAM_ATTR rx_timer_isr(void *para)
 {
 
-    GPIO.out_w1ts = (1 << DEBUG_0);
+    //GPIO.out_w1ts = (1 << DEBUG_0);
 
 	int timer_idx = (int) para;
 
@@ -135,7 +135,7 @@ void IRAM_ATTR rx_timer_isr(void *para)
 		portYIELD_FROM_ISR( );
 	}
 
-	GPIO.out_w1tc = (1 << DEBUG_0);
+	//GPIO.out_w1tc = (1 << DEBUG_0);
 
 }
 
@@ -144,8 +144,49 @@ void TX_Task(void *pvParameters)
 {
 	size_t p_size;
 
+    // Setup Timer for TX Task
+	timer_config_t config;
+    config.divider = 2;
+    config.counter_dir = TIMER_COUNT_UP;
+    config.counter_en = TIMER_PAUSE;
+    config.alarm_en = TIMER_ALARM_EN;
+    config.intr_type = TIMER_INTR_LEVEL;
+    config.auto_reload = TIMER_AUTORELOAD_EN;
+    timer_init(TIMER_GROUP_0, TIMER_1, &config);
+    timer_set_counter_value(TIMER_GROUP_0, TIMER_1, 0x00000000ULL);
+    timer_set_alarm_value(TIMER_GROUP_0, TIMER_1, 3030);
+    timer_isr_register(TIMER_GROUP_0, TIMER_1, cc1200_aprs_tx_isr,
+    		(void *) TIMER_1, ESP_INTR_FLAG_IRAM, NULL);
+
+	// Setup Sampling Timer for RX Task
+	timer_config_t rx_config;
+	rx_config.divider = 2;
+	rx_config.counter_dir = TIMER_COUNT_UP;
+	rx_config.counter_en = TIMER_PAUSE;
+	rx_config.alarm_en = TIMER_ALARM_EN;
+	rx_config.intr_type = TIMER_INTR_LEVEL;
+	rx_config.auto_reload = TIMER_AUTORELOAD_EN;
+    timer_init(TIMER_GROUP_0, TIMER_0, &rx_config);
+    timer_set_counter_value(TIMER_GROUP_0, TIMER_0, 0x00000000ULL);
+    timer_set_alarm_value(TIMER_GROUP_0, TIMER_0, 6666);
+    timer_isr_register(TIMER_GROUP_0, TIMER_0, rx_timer_isr,
+    		(void *) TIMER_0, ESP_INTR_FLAG_IRAM, NULL);
+
+	// Initialize Radio
+	cc1200_radio_init(APRS_RX2_SETTINGS, sizeof(APRS_RX2_SETTINGS)/sizeof(cc1200_reg_settings_t));
+	cc1200_radio_frequency(144390000);
+
+
 	while(1)
 	{
+		// setup LEDs for RX mode
+		disable_red_led();
+		enable_green_led();
+		cc1200_radio_start_APRSRX();
+	    timer_enable_intr(TIMER_GROUP_0, TIMER_0);
+	    timer_set_counter_value(TIMER_GROUP_0, TIMER_0, 0x00000000ULL);
+	    timer_start(TIMER_GROUP_0, TIMER_0);
+
 
 		// block until packet is in queue
 		uint8_t *p = (uint8_t *)xRingbufferReceive(radio_tx_buf, &p_size, portMAX_DELAY);
@@ -155,26 +196,18 @@ void TX_Task(void *pvParameters)
 		{
 
 			// disable RX mode
-			timer_pause(TIMER_GROUP_0, TIMER_0);
 		    timer_disable_intr(TIMER_GROUP_0, TIMER_0);
+			timer_pause(TIMER_GROUP_0, TIMER_0);
 			cc1200_radio_stop_APRSRX();
 
 			// setup LEDs for TX mode
 			enable_red_led();
 			disable_green_led();
 
-			cc1200_radio_APRSTXPacket(p, p_size, 2, 0);
+			cc1200_radio_APRSTXPacket(p, p_size, 4, 1);
 
 			vRingbufferReturnItem(radio_tx_buf, (void *)p);
 
-			// setup LEDs for RX mode
-			disable_red_led();
-			enable_green_led();
-
-			cc1200_radio_start_APRSRX();
-		    timer_enable_intr(TIMER_GROUP_0, TIMER_0);
-		    timer_set_counter_value(TIMER_GROUP_0, TIMER_0, 0x00000000ULL);
-		    timer_start(TIMER_GROUP_0, TIMER_0);
 		}
 	}
 }
@@ -198,6 +231,7 @@ void RX_Task(void *pvParameters)
 	double E_s1=0, E_s2=0;
 	uint8_t raw_bit=0, previous_raw_bit=0;
 	int32_t d_pll=0, dpll_error=0, err_div=2;
+	int lpf_input = 0;
 	int lpf_output = 0;
 
 	aprs_decoder_init();
@@ -206,40 +240,36 @@ void RX_Task(void *pvParameters)
 	// Sampling Semaphore
 	xRadioRXISRSemaphore = xSemaphoreCreateBinary();
 
-	// setup LEDs for RX mode
-	enable_green_led();
-	disable_red_led();
-
-	cc1200_radio_start_APRSRX();
-    timer_enable_intr(TIMER_GROUP_0, TIMER_0);
-    timer_set_counter_value(TIMER_GROUP_0, TIMER_0, 0x00000000ULL);
-    timer_start(TIMER_GROUP_0, TIMER_0);
-
-
 	while(1)
 	{
 		if( xSemaphoreTake(xRadioRXISRSemaphore, portMAX_DELAY) == pdTRUE)
 		{
 
-			enable_debug_IO(DEBUG_0);
+			//enable_debug_IO(DEBUG_0);
 			EXTERNAL_DATA = (int)cc1200_radio_read_CFM();
-			disable_debug_IO(DEBUG_0);
-			enable_debug_IO(DEBUG_0);
-			lpf_output += (50000 * (((int)EXTERNAL_DATA) - lpf_output)) / 100000;
+			//disable_debug_IO(DEBUG_0);
+			//enable_debug_IO(DEBUG_0);
+			//lpf_output += (50000 * (((int)EXTERNAL_DATA) - lpf_output)) / 100000;
 			window_add((int) EXTERNAL_DATA);
 			E_s1 = goertzelFilter(window, 1200, WINDOW_SIZE);
 			E_s2 = goertzelFilter(window, 2200, WINDOW_SIZE);
+
 			if (E_s1 > E_s2)
 			{
 				raw_bit = 1;
+				enable_debug_IO(DEBUG_2);
+				enable_debug_IO(DEBUG_0);
+
 			}
 			else
 			{
 				raw_bit = 0;
+				disable_debug_IO(DEBUG_2);
+				disable_debug_IO(DEBUG_0);
 			}
 
-			disable_debug_IO(DEBUG_0);
-			enable_debug_IO(DEBUG_0);
+			//disable_debug_IO(DEBUG_0);
+			//enable_debug_IO(DEBUG_0);
 			// DPLL for sampling
 			if (raw_bit != previous_raw_bit)
 			{
@@ -258,11 +288,11 @@ void RX_Task(void *pvParameters)
 
 			d_pll += D_PLL_INC;
 
-			disable_debug_IO(DEBUG_0);
-			enable_debug_IO(DEBUG_0);
+			disable_debug_IO(DEBUG_3);
 			if (d_pll >= D_PLL_MAX)
 			{
 				// set clock debug I/O high
+				enable_debug_IO(DEBUG_3);
 
 				// feed bit to aprs decoder algorithm
 				switch(aprs_decoder_feed_bit(raw_bit))
@@ -271,7 +301,8 @@ void RX_Task(void *pvParameters)
 						break;
 					case FRAME_DECODED:
 						ESP_LOGI("APRS RX", "AX.25 Frame Received");
-						ESP_LOG_BUFFER_HEXDUMP("APRS RX", aprs_buf, 100, ESP_LOG_INFO);
+						// send via KISS TNC to over BLE SPP
+						//ESP_LOG_BUFFER_HEXDUMP("APRS RX", aprs_buf, 100, ESP_LOG_INFO);
 						break;
 					case ERROR_FCS_MISMATCH:
 						ESP_LOGV("APRS RX", "AX.25 FCS Error\n");
@@ -288,7 +319,7 @@ void RX_Task(void *pvParameters)
 				// set clock debug I/O low
 			}
 			previous_raw_bit = raw_bit;
-			disable_debug_IO(DEBUG_0);
+			//disable_debug_IO(DEBUG_0);
 		}
 	}
 }
@@ -300,24 +331,6 @@ void radio_init()
 	xRadioRXSemaphore = xSemaphoreCreateBinary();
 	xRadioTXSemaphore = xSemaphoreCreateBinary();
 
-	// Initialize Radio
-	cc1200_radio_init(APRS_RX2_SETTINGS, sizeof(APRS_RX2_SETTINGS)/sizeof(cc1200_reg_settings_t));
-	cc1200_radio_frequency(144390000-6000);
-
-	// Setup Sampling Timer
-	timer_config_t config;
-    config.divider = 2;
-    config.counter_dir = TIMER_COUNT_UP;
-    config.counter_en = TIMER_PAUSE;
-    config.alarm_en = TIMER_ALARM_EN;
-    config.intr_type = TIMER_INTR_LEVEL;
-    config.auto_reload = TIMER_AUTORELOAD_EN;
-    timer_init(TIMER_GROUP_0, TIMER_0, &config);
-    timer_set_counter_value(TIMER_GROUP_0, TIMER_0, 0x00000000ULL);
-    timer_set_alarm_value(TIMER_GROUP_0, TIMER_0, 6666);
-    timer_isr_register(TIMER_GROUP_0, TIMER_0, rx_timer_isr,
-    		(void *) TIMER_0, ESP_INTR_FLAG_IRAM, NULL);
-
 	xTaskCreatePinnedToCore(TX_Task, "TX Task", 1024*4, 0, 2, NULL, 1);
 	xTaskCreatePinnedToCore(RX_Task, "RX Task", 1024*4, 0, 1, NULL, 1);