UART over radio на PlutoSDR: от serial monitor до неполноценного терминала Raspberry Pi

В этой статье рассматривается процесс создания кастомной no-OS прошивки для клона PlutoSDR, которая позволит принимать UART данные и передавать их по радио, а на другой стороне — принимать данные из радиоканала и выводить их через UART.

Я не эксперт в области программирования ad9361. Это та область, которую я хочу изучить. Я пытаюсь разобраться в основах и мне проще учиться, когда я вижу, как это работает. Вот почему я это делаю. Не потому, что я уже всё знаю об ad9361. И если вы тоже чему‑то научитесь, прочитав мою статью, это будет здорово. Но пожалуйста, не полагайтесь на мои статьи, чтобы понять теорию. Есть множество отличных книг и других источников по этой теме, где вы сможете найти более подробную информацию. Я надеюсь, что благодаря этой статье вы научитесь применять некоторые базовые принципы программирования ad936x в реальных системах. Если вы заметите ошибку или что‑то, что можно улучшить, пожалуйста, напишите мне в комментариях или личных сообщениях. Тогда мы сможем учиться вместе, и, возможно, я смогу исправить это и показать в новых статьях.

Чтобы принимать данные по UART можно воспользоваться прерываниями. Первым делом инициализируем контроллер прерываний

int Init_GIC(void)
{
	XScuGic_Config *p_GICConfig = NULL;

	int status;
	p_GICConfig = XScuGic_LookupConfig(XPAR_PS7_SCUGIC_0_DEVICE_ID);
	if (p_GICConfig == NULL)
	{
		status = XST_FAILURE;
		return status;
	}

	status = XScuGic_CfgInitialize(p_xInterruptController, p_GICConfig, p_GICConfig->CpuBaseAddress);

	status = XScuGic_SelfTest(p_xInterruptController);
	if (status != XST_SUCCESS)
	{
		xil_printf("GIC config init failed \r\n");
		return XST_FAILURE;
	}

 	Xil_ExceptionInit();

 	Xil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_IRQ_INT,(Xil_ExceptionHandler)XScuGic_InterruptHandler,p_xInterruptController);
	return XST_SUCCESS;
}

После выполнения этой функции система будет готова принимать прерывания. Потом инициализируем UART-контроллер

int Init_Uart(void)
{
	XUartPs_Config *p_UartConfig = NULL;

	int status;
	u32 IntrMask;

	p_UartConfig = XUartPs_LookupConfig(XPAR_PS7_UART_1_DEVICE_ID);

	if (p_UartConfig == NULL)
	{
		status = XST_FAILURE;
		return status;
	}
	status = XUartPs_CfgInitialize(p_Uart, p_UartConfig, p_UartConfig->BaseAddress);
	if (status != XST_SUCCESS)
	{
		xil_printf("Uart config init failed \r\n");
		return XST_FAILURE;
	}
	status = XUartPs_SelfTest(p_Uart);
	if (status != XST_SUCCESS)
	{
		return status;
	}

	IntrMask = XUARTPS_IXR_RXOVR | XUARTPS_IXR_RXFULL | XUARTPS_IXR_OVER;

	if (p_Uart->Platform == XPLAT_ZYNQ_ULTRA_MP)
	{
		IntrMask |= XUARTPS_IXR_RBRK;
	}

	XUartPs_SetInterruptMask(p_Uart, IntrMask);

	// Set FIFO threshold.
	XUartPs_SetFifoThreshold(p_Uart, 1);

	/* Set the UART in Normal Mode */
	XUartPs_SetOperMode(p_Uart, XUARTPS_OPER_MODE_NORMAL);

	return XST_SUCCESS;

}

Понадобится обработчик прерываний UART (Uart_ISR) и функция подключения UART к системе прерываний (addUartToInterruptSystem).

void Uart_ISR(void *call_back_ref,u32 Event, unsigned int EventData)
{
	if (Event == XUARTPS_EVENT_RECV_DATA)
	{
		
		XUartPs_Recv(p_Uart, (ReceiveBuffer+ReceiveBufferPtr), 1); //read the data  available in UART receive buffer

		if(ReceiveBuffer[ReceiveBufferPtr] == '\n')
		{
			ReceiveBufferPtr = 0;
			UartRecvIntrFlag = 1;
		}
		else if(++ReceiveBufferPtr == 64)
		{
			ReceiveBufferPtr = 0;
		}
	}

}

int addUartToInterruptSystem(void)
{
	int status;

		status = XScuGic_Connect(p_xInterruptController,XPAR_PS7_UART_1_INTR,(Xil_ExceptionHandler)XUartPs_InterruptHandler ,(void *) p_Uart); //
		if (status != XST_SUCCESS)
		{
			return XST_FAILURE;
		}
		XScuGic_SetPriorityTriggerType(p_xInterruptController,XPAR_PS7_UART_1_INTR,UART_INTR_PRI,UART_INTR_TRIG);
		XUartPs_SetHandler(p_Uart, (XUartPs_Handler)Uart_ISR, p_xInterruptController);
		XScuGic_Enable(p_xInterruptController, XPAR_PS7_UART_1_INTR);
		return status;
}

Эти функции необходимо вызвать и включить прерывания

void init_sec_stage(){
	/* Initialize SCUGIC */
	if( Init_GIC() == XST_SUCCESS)
	{
		xil_printf("\nSCUGIC initialized \r\n");
	}

	/* Initialize UART1 */
	if(Init_Uart() == XST_SUCCESS)
	{
		xil_printf("Uart initialized \r\n");
	}

	/* Add UART1 to interrupt system */
	if (addUartToInterruptSystem() == XST_SUCCESS)
	{
		xil_printf("Uart added to interrupt system \r\n");
	}

	/* Enable interrupts */
	xil_printf("Enabling interrupts \r\n");
	Xil_ExceptionEnable();

	xil_printf("Entering main loop \r\n");
}

После этого необходима функция для работы с UART, например, такая

void uart_control(struct ad9361_rf_phy *ad9361_phy, uint8_t *UartRecvIntrFlag, 
	uint8_t *ReceiveBuffer, uint8_t *SendBuffer, XUartPs *p_Uart, bool *flagTx,
	unsigned char *payload, uint16_t *num_pack
){
	
	if(*UartRecvIntrFlag)
	{
		(*UartRecvIntrFlag) = 0;
		//----------------------------------------------------------
		for(uint8_t i = 0;i < 64;++i){
			printf("%c", (char*)ReceiveBuffer[i]);
			if((char*)ReceiveBuffer[i]=='\n'){
				break;
			}
		}
		//----------------------------------------------------------
	}
}

Весь этот исходный код можно добавить к коду, который использовался в статье «Как инициализировать ad9361». Тогда можно отправлять в Serial Monitor данные и они будут выводиться на экран.

На видео видно, что после загрузки можно вводить данные в Serial Monitor, но важно заканчивать их символом ‘\n‘. Именно этого ожидает обработчик прерывания, чтобы взвести флаг, который перехватывается в UART функции.

Подводя промежуточный итог, имеется функционал, который позволяет принимать и обрабатывать данные, поступающие через UART.

Чтобы передать данные через радиоканал и принять на другой плате, можно воспользоваться исходным кодом из статьи про алгоритм обхода в ширину. Для формирования пакета данных, готового к передаче по радио снова воспользуемся библиотекой Liquid-DSP. В UART функции скопируем поступившие данные в payload и взведём флаг для передачи данных по радио.

void uart_control(struct ad9361_rf_phy *ad9361_phy, uint8_t *UartRecvIntrFlag, 
	uint8_t *ReceiveBuffer, uint8_t *SendBuffer, XUartPs *p_Uart, bool *flagTx,
	unsigned char *payload, uint16_t *num_pack
){
	
	if(*UartRecvIntrFlag)
	{
		(*UartRecvIntrFlag) = 0;
		//----------------------------------------------------------
		
		uint8_t len = 0;
		for(uint8_t i = 0;i < 64;++i){
			if((char*)ReceiveBuffer[i]=='\n'){
				len = i;
				break;
			}
		}
		
		// printf("debug: %d\n", len); // strlen((char*)ReceiveBuffer)
		if(len<60)
			memcpy(payload+3, ReceiveBuffer, len+1); // +1 для копирования в payload \n // strlen((char*)ReceiveBuffer)
		payload[0]=len; // strlen((char*)ReceiveBuffer);
		payload[1]= (*num_pack >> 8); // byteHigh // младшие байты отсекутся при сдвиге
		payload[2]= (*num_pack)++ & 0xff; // byteLow  // берём маской младший байт, 0xff == 0b11111111
		*flagTx=true;
		//----------------------------------------------------------
	}
}

В бесконечном цикле отслеживается состояние переменной flagTx. Когда она принимает значение 1, то выполняется framegen64_execute(fg, header, payload, buf) для формирования фрейма. Затем находится максимальная амплитуда (подробнее про это в статье про ретрансляцию под заголовком Передача и приём фрейма — прим. автора), вычисляется коэффициент нормализации, преобразуются данные, это загружается через DMA. Включается передатчик и фрейм 100 раз уходит в эфир. После этого SDR переводится в режим приёма.

if(flagTx){
    flagTx =false;
    
    // execute generator and assemble the frame
    framegen64_execute(fg, header, payload, buf);

    // 1. Находим максимальную амплитуду
    float max_amp = 0.0f;
    for (i = 0; i < buf_len; i++) {
        float amp = cabsf(buf[i]);
        if (amp > max_amp) max_amp = amp;
    }
    
    // 2. Вычисляем коэффициент нормализации
    float normalize_gain = 0.9f / max_amp;

    // преобразуем данные
    for (i = 0; i < buf_len; i++) {

        // Масштабируем и квантуем
        // int16_t i_val = (int16_t)(crealf(buf[i]) * 32767.0f);
        // int16_t q_val = (int16_t)(cimagf(buf[i]) * 32767.0f);
        
        float i_norm = crealf(buf[i]) * normalize_gain;
        float q_norm = cimagf(buf[i]) * normalize_gain;

        int16_t i_val = (int16_t)(i_norm * 32767.0f);
        int16_t q_val = (int16_t)(q_norm * 32767.0f);

        // Проверка переполнения
        if (i_val > 32767 || i_val < -32768) {
            printf("WARNING: i_val overflow at %d: %d\n", i, i_val);
        }
        if (q_val > 32767 || q_val < -32768) {
            printf("WARNING: q_val overflow at %d: %d\n", i, q_val);
        }

        // Упаковываем в uint32_t
        frame_buffer[i] = ((uint32_t)(q_val & 0xFFFF) << 16) | (uint32_t)(i_val & 0xFFFF);
    }

    axi_dac_load_custom_data(ad9361_phy->tx_dac, frame_buffer, FRAME_LEN, (uintptr_t)dac_buffer);

#if 1
    ad9361_set_en_state_machine_mode(ad9361_phy, ENSM_MODE_TX);
    // ad9361_get_en_state_machine_mode(ad9361_phy, &ensm_mode);
    // printf("SPI control - TX: %s\n", ensm_mode == ENSM_MODE_TX ? "OK" : "Error");
    no_os_mdelay(1);
#endif	
    uint16_t count_tx = 100;
    while(count_tx--){ // count_tx--
        Xil_DCacheFlush();

        /* Transfer the data. */
        axi_dmac_transfer_start(tx_dmac, &transfer);

        /* Flush cache data. */
        // Xil_DCacheInvalidateRange((uintptr_t)dac_buffer,sizeof(sine_lut_iq));
        Xil_DCacheInvalidateRange((uintptr_t)dac_buffer, transfer.size);

    }
#if 1		
    ad9361_set_en_state_machine_mode(ad9361_phy, ENSM_MODE_ALERT);
    no_os_mdelay(1);
#endif
#if 1
    ad9361_set_en_state_machine_mode(ad9361_phy, ENSM_MODE_RX);
    no_os_mdelay(1);
#endif
}

Семплы принимаются, конвертируются для обработки в liquid-dsp и выполняется framesync64_execute(fs, rx1_samples, (ADC_BUFFER_SAMPLES * ADC_CHANNELS)/2).

/* Read the data from the ADC DMA. */
axi_dmac_transfer_start(rx_dmac, &read_transfer);

/* Wait until transfer finishes */
status = axi_dmac_transfer_wait_completion(rx_dmac, 500);
if(status < 0)
    return status;

Xil_DCacheInvalidateRange((uintptr_t)adc_buffer, sizeof(adc_buffer));

convert_adc_buffer(adc_buffer, rx1_samples, (ADC_BUFFER_SAMPLES * ADC_CHANNELS));

// execute synchronizer and receive the entire frame at once
framesync64_execute(fs, rx1_samples, (ADC_BUFFER_SAMPLES * ADC_CHANNELS)/2); 
// делю на 2, потому что не привожу данные с второго канала ацп к float

Если в принятых семплах обнаруживаются фреймы, то срабатывает callback, в котором можно вывести данные на экран.

// user-defined static callback function
static int mycallback(unsigned char *  _header,
                      int              _header_valid,
                      unsigned char *  _payload,
                      unsigned int     _payload_len,
                      int              _payload_valid,
                      framesyncstats_s _stats,
                      void *           _userdata)
{
    if(_header_valid){
	#if 1
		uint16_t val = (((uint16_t)_payload[1]) << 8) | _payload[2];
		if(old_num_pac!=val){
			old_num_pac = val;
			for(unsigned int i = 3; i < _payload[0]+3; i++) { // смещение на единицу для того чтобы выводить только полезную нагрузку и пропускать 1 байт, в котором количество
				printf("%c", _payload[i]);
			}
			printf("\n");
		}
	#endif	
		// type-cast, de-reference, and increment frame counter
		unsigned int * counter = (unsigned int *) _userdata;
		(*counter)++;
	
	}

    return 0;
}

В эфир уходит 100 фреймов, чтобы гарантированно принять хотя бы один валидный фрейм, но иногда может быть принято больше одного фрейма. Происходит дублирование. Для защиты в каждое сообщение помимо длины, 2 байта отведены для нумерации сообщений. То есть в каждом из 100 дубликатов будет один и тот же номер. Поэтому на приёмной стороне очень просто дедуплицировать сообщения путём сравнения переменных.

К одному хосту подключены два PlutoSDR. На видео загружается прошивка в первую плату (на 31 секунде — прим. автора), затем во вторую (на 1:13 - прим. автора). Затем на 1:21 видно, как в UART первой платы отправляется “test“ и это сообщение появляется во втором serial monitor. А когда на 1:30 во вторую плату отправляется несколько раз “test“, то ничего не происходит, потому что строка не заканчивается символом ‘\n‘. Когда на 1:46 serial monitor настраивается на Line ending = LF, то сообщения из UART второй платы по радиоканалу попадают в первую плату. Потом отправляются короткие и длинные сообщения с обеих плат.

Подводя итоги, получилось реализовать приёмопередатчик на основе ad9361 и zynq-7000, который позволяет передавать всё, что приходит по UART, принимать данные из радиоканала и выводить на экран. Количество передаваемых байтов пока что ограничено только возможностями liquid-sdr, а они сравнительно огромные.

Честно говоря, хотелось управлять таким образом raspberry pi zero через uart. Но пока не получается.

На видео терминал подключён через ssh к raspberry pi zero. На raspberry pi запускается agetty, и в serial monitor на ноутбуке видно приглашение ввести логин и пароль. После авторизации можно работать через uart.

Так почему бы не включить место usb-to-com трансиверы с кастомной прошивкой?

На видео видно, что сначала оба приёмопередатчика подключены к одному хосту и тестируется связь. После этого один и приёмопередатчиков переключается в raspberry pi zero и в терминале RPI на 51 секунде запускается aggtty. Вместо длинного приглашения приходит только один символ ‘\n‘ на 52 секунде. Хорошо, видимо, не всё дошло. На 58 секунде вводится логин — в ответ что-то приходит, но только до символа ‘\n‘. На 1-02 вводится пароль — в ответ даже что-то приходит, но явно меньше чем надо. Дальнейшие попытки ввести команду “pwd“ остаются безуспешными. И лишь только на 1-28 приходит какое-то невнятное сообщение “Passwerrypi login: test“. Дальнейшие команды также безуспешны.

Так что же произошло? Agetty отправляет в UART по одному байту. Без какого-либо символа конца строки. Zynq-7000 настроен на приём символа ‘\n‘ как сигнала об окончании приёма данных по UART и их дальнейшей обработки. Плюс ко всему, буфер сделан лишь на 64 байта, а agetty отправляет гораздо больше. Почему через радиоканал было вообще что-то видно? Если проанализировать данные, которые приходят по UART, то там есть символы перехода на новую строку. Именно на это и реагирует zynq-7000 и отправляет данные, которые успел накопить к этому моменту, но это абсолютно не работает. Так что же делать? Как решение в лоб напрашивается писать очень хитрый обработчик UART под zynq-7000, но это неверно с точки зрения архитектуры в целом хоть это и может сработать. Гораздо корректнее будет разделить транспортный уровень радиоканала и уровень формирования данных agetty. Скорее всего, надо попробовать заставить работать agetty не с физическим /dev/ttyUSB0, а с виртуальным pty (на самом деле существует mingetty, которая уже из коробки работает с pty — прим. автора). А вот данные из pty выдёргивать простой программой на python3, например. Эта программа и будет формировать пачки байтов, которые корректно могут быть приняты по uart на zyqn-7000 и переданы по радио. Но это только один из путей, а как сделали бы вы?