آموزش راه اندازی ماژول LORA

با نام و یاد خدا یک قسمت دیگه از آموزش هامون رو شروع میکنیم توی این آموزش قصد داریم نحوه ی راه اندازی ماژول LORA-RA02 که یک ماژول LONG RANGE بوده و میتواند دیتا را با فاصله بیشتری به نسبت ماژول های دیگر انتقال دهد. این ماژول از چیپ SX1278 استفاده میکند و در فرکانس 433 مگا هرتز با پهنای باند 7.8 تا 500 کیلو هرتز میتواند کار کند.

در این آموزش یک کتابخانه برای استفاده از ماژول LORA-RA02 برای میکرو های STM32 با توابع HAL ارائه میکنیم و نحوه استفاده از کتابخانه را طی یک مثال اموزش خواهیم داد.

در نرم افزار CUBE پس از انتخاب نوع میکرو باید تنظیمات SPI را انجام داده و پین های کنترلی را کانفیگ نماییم. در این برنامه از یک میکرو STM32F103RCT6 استفاده شده و SPI1 و SPI2 این میکرو را برای ارتباط با ماژول گیرنده و فرستنده در نرم افزار کیوب کانفیگ میکنیم. شما میتوانید از یک SPI استفاده کنید.

پین های NSS و RESET را خروجی و پین DIO0 را ورودی تعریف کنید.

در تصویر بالا تنظیمات SPI را مشاهده میکنید. همانطور که میبینید تنظیمات پیش فرض درست هستند و نیازی به تغییر ندارند اما در صورتی که شما روی برد بورد کار میکنید بهتر است که باورریت را کم قرار دهید (با افزایش PRESCALER) .

سپس میتوانید کد را generate کنید. و حالا بریم سراغ بخش برنامه نویسی

مثال زیر را میتونید به صورت کامل از لینک زیر دانلود کنید

برنامه کامل 👇👇

/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "stm32f1xx_hal.h"
#include "SX1278.h"

SPI_HandleTypeDef hspi1;
SPI_HandleTypeDef hspi2;

/* Private variables ---------------------------------------------------------*/
SX1278_hw_t SX1278_hw_M;
SX1278_t SX1278_M;
SX1278_hw_t SX1278_hw_S;
SX1278_t SX1278_S;
int master;
int ret;

char buffer[64];

int message;
int message_length;

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_SPI1_Init(void);
static void MX_SPI2_Init(void);
int main(void)
{
  HAL_Init();
  SystemClock_Config();
  MX_GPIO_Init();
  MX_SPI1_Init();
  MX_SPI2_Init();
	//initialize LoRa MASTER
	SX1278_hw_M.dio0.port = DIO0_M_GPIO_Port;
	SX1278_hw_M.dio0.pin = DIO0_M_Pin;
	SX1278_hw_M.nss.port = NSS_M_GPIO_Port;
	SX1278_hw_M.nss.pin = NSS_M_Pin;
	SX1278_hw_M.reset.port = RESET_M_GPIO_Port;
	SX1278_hw_M.reset.pin = RESET_M_Pin;
	SX1278_hw_M.spi = &hspi1;

	SX1278_M.hw= &SX1278_hw_M;
	//initialize LoRa SLAVE
	SX1278_hw_S.dio0.port = DIO0_S_GPIO_Port;
	SX1278_hw_S.dio0.pin = DIO0_S_Pin;
	SX1278_hw_S.nss.port = NSS_S_GPIO_Port;
	SX1278_hw_S.nss.pin = NSS_S_Pin;
	SX1278_hw_S.reset.port = RESET_S_GPIO_Port;
	SX1278_hw_S.reset.pin = RESET_S_Pin;
	SX1278_hw_S.spi = &hspi2;

	SX1278_S.hw= &SX1278_hw_S;
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
	SX1278_begin(&SX1278_M, SX1278_433MHZ, SX1278_POWER_17DBM, SX1278_LORA_SF_6,
			SX1278_LORA_BW_500KHZ, 10);
	SX1278_begin(&SX1278_S, SX1278_433MHZ, SX1278_POWER_17DBM, SX1278_LORA_SF_6,
			SX1278_LORA_BW_500KHZ, 10);
	
  ret = SX1278_LoRaEntryTx(&SX1278_M, 16, 2000);
  ret = SX1278_LoRaEntryRx(&SX1278_S, 16, 2000);
	while (1)
  {
			HAL_Delay(50);
			message_length = sprintf(buffer, "Hello %d", message);
			SX1278_transmit(&SX1278_M, (uint8_t *) buffer, message_length,50);
      message += 1;		
  /* USER CODE END WHILE */

  /* USER CODE BEGIN 3 */
			ret = SX1278_LoRaRxPacket(&SX1278_S);
			if (ret > 0) {
			SX1278_read(&SX1278_S, (uint8_t *) buffer, ret);
			}

  }
  /* USER CODE END 3 */

}

void SystemClock_Config(void)
{

  RCC_OscInitTypeDef RCC_OscInitStruct;
  RCC_ClkInitTypeDef RCC_ClkInitStruct;

    /**Initializes the CPU, AHB and APB busses clocks 
    */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    _Error_Handler(__FILE__, __LINE__);
  }

    /**Initializes the CPU, AHB and APB busses clocks 
    */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSE;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0) != HAL_OK)
  {
    _Error_Handler(__FILE__, __LINE__);
  }

    /**Enables the Clock Security System 
    */
  HAL_RCC_EnableCSS();

  HAL_SYSTICK_Config(HAL_RCC_GetHCLKFreq()/1000);

  HAL_SYSTICK_CLKSourceConfig(SYSTICK_CLKSOURCE_HCLK);

  HAL_NVIC_SetPriority(SysTick_IRQn, 0, 0);
}

static void MX_SPI1_Init(void)
{
  hspi1.Instance = SPI1;
  hspi1.Init.Mode = SPI_MODE_MASTER;
  hspi1.Init.Direction = SPI_DIRECTION_2LINES;
  hspi1.Init.DataSize = SPI_DATASIZE_8BIT;
  hspi1.Init.CLKPolarity = SPI_POLARITY_LOW;
  hspi1.Init.CLKPhase = SPI_PHASE_1EDGE;
  hspi1.Init.NSS = SPI_NSS_SOFT;
  hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2;
  hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB;
  hspi1.Init.TIMode = SPI_TIMODE_DISABLE;
  hspi1.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
  hspi1.Init.CRCPolynomial = 10;
  if (HAL_SPI_Init(&hspi1) != HAL_OK)
  {
    _Error_Handler(__FILE__, __LINE__);
  }

}

static void MX_SPI2_Init(void)
{
  hspi2.Instance = SPI2;
  hspi2.Init.Mode = SPI_MODE_MASTER;
  hspi2.Init.Direction = SPI_DIRECTION_2LINES;
  hspi2.Init.DataSize = SPI_DATASIZE_8BIT;
  hspi2.Init.CLKPolarity = SPI_POLARITY_LOW;
  hspi2.Init.CLKPhase = SPI_PHASE_1EDGE;
  hspi2.Init.NSS = SPI_NSS_SOFT;
  hspi2.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2;
  hspi2.Init.FirstBit = SPI_FIRSTBIT_MSB;
  hspi2.Init.TIMode = SPI_TIMODE_DISABLE;
  hspi2.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
  hspi2.Init.CRCPolynomial = 10;
  if (HAL_SPI_Init(&hspi2) != HAL_OK)
  {
    _Error_Handler(__FILE__, __LINE__);
  }

}
static void MX_GPIO_Init(void)
{

  GPIO_InitTypeDef GPIO_InitStruct;

  __HAL_RCC_GPIOD_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();
  __HAL_RCC_GPIOC_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(NSS_M_GPIO_Port, NSS_M_Pin, GPIO_PIN_RESET);

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOC, RESET_M_Pin|RESET_S_Pin, GPIO_PIN_RESET);

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(NSS_S_GPIO_Port, NSS_S_Pin, GPIO_PIN_RESET);

  /*Configure GPIO pin : NSS_M_Pin */
  GPIO_InitStruct.Pin = NSS_M_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(NSS_M_GPIO_Port, &GPIO_InitStruct);

  /*Configure GPIO pins : RESET_M_Pin RESET_S_Pin */
  GPIO_InitStruct.Pin = RESET_M_Pin|RESET_S_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);

  /*Configure GPIO pins : DIO0_M_Pin DIO0_S_Pin */
  GPIO_InitStruct.Pin = DIO0_M_Pin|DIO0_S_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);

  /*Configure GPIO pin : NSS_S_Pin */
  GPIO_InitStruct.Pin = NSS_S_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(NSS_S_GPIO_Port, &GPIO_InitStruct);

}

بخش هایی که در این کد امده که برای راه اندازی و ارسال و دریافت دیتا میباشد رو میتوانید در کد خود کپی نمایید و استفاده کنید.

البته برای تست این برنامه که مقادیر ارسالی و دریافتی را ببینیم انرا دیباگ کردیم . شما میتوانید با تغییر این کد عمل مورد نظر خودتون رو براش تعریف کنید.

منبع پست با کمی تغییرات در مثال عملی