MÓDULOS E KITS LoRa/LoRaWAN, LoRa MESH - PRIMEIROS PASSOS: julho 2024

quarta-feira, 31 de julho de 2024

homolog

# Script to install and run EThingz Qualification Application
$msi_name = 'python-2.7.18.amd64.msi'
$msi_exec = 'C:\Windows\System32\msiexec.exe'
$python_installer = 'https://www.python.org/ftp/python/2.7.18/python-2.7.18.amd64.msi'
$python_path = 'C:\Python27\python.exe'
$virtualenv_path = 'C:\Python27\Scripts\virtualenv.exe'
$activate = 'C:\Python27\Lib\site-packages\virtualenv\activation\powershell\activate.ps1'
$env:PYTHONIOENCODING = "UTF-8"

if (-not (Test-Path $python_path)) {
    Write-Host "python not found. Download." -ForegroundColor red
    if (-not (Test-Path $msi_name)) {
        Invoke-WebRequest $python_installer -OutFile $msi_name
    }
    Write-Host "Install." -ForegroundColor Yellow

    if (-not (Test-Path $msi_name)) {
        Write-Host "Download failed."
        exit
    }
    if (-not (Test-Path $msi_exec)) {
        Write-Host "Missing msiexec"
        exit
    }
    # Run install
    Start-Process -FilePath $msi_exec -ArgumentList "/package python-2.7.18.amd64.msi /quiet" -Wait
    
    Remove-Item -Path $msi_name
}
else {
    Write-Host "python found" -ForegroundColor green
}

if (-not (Test-Path $virtualenv_path)) {
    Write-Host "virtualenv module not found. Install." -ForegroundColor Yellow
    Start-Process -FilePath $python_path -ArgumentList "-m pip install virtualenv" -Wait -NoNewWindow
}
else {
    Write-Host "virtualenv module found." -ForegroundColor green

}

if (-not (Test-Path $activate)) {
    Start-Process -FilePath $python_path -ArgumentList "-m virtualenv .virtualenv" -Wait -NoNewWindow
}

& $activate

Start-Process -FilePath 'pip' -ArgumentList "install -r requirements.txt" -Wait -NoNewWindow
 

& deactivate

segunda-feira, 15 de julho de 2024

PROGRAMANDO WISOL LSM110A ( LoRaWAN CLASS A - OTAA) COM STM32DUINO LoRaWAN E ACESSANDO LoRaWAN - EVERYNET - ASSYNC

Baseado no canais de uplink, downlink, dwell, etc

LA915 · Everynet Network Server Máscara de canais (Join, Uplink, Downlink)

Foram alterados os arquivos RegionAU915.h e RegionAU915.c para serem compatíveis somente com EVERYNET.

Entre em contato para testes.

LORAMAC VERSION 1.0.3

O objetivo deste BLOG é demonstrar como é possível programar o módulo WISOL LSM110A via Arduino Framework (STMDUINO32 com LoRaWAN) e assim utilizá-lo como OPENCPU.

Será publicada uma sequência de bytes {0xde, 0xad, 0xbe, 0xef} a cada 20 segundos na rede LoRaWAN EVERYNET (CLASS A, OTAA).

LSM110A Starter KIT

Módulo

O LSM110A é um módulo de última geração que integra o STMicroelectronics STM32WL. É muito menos consumo atual para o dispositivo IoT para estender a vida útil da bateria. E, também suporta ambas as tecnologias – Sigfox e LoRa – com o próprio módulo LSM110A.

Você pode trocar Sigfox ou LoRa com ele para que você também possa reduzir o custo. É altamente otimizado para solução de IoT (Alto Consumo de Energia, Baixo Custo)

BREAKOUT para testes

Esquema Elétrico - últimas correções

PLACA MONTADA

CONEXÃO COM ST-LINK V2 E UART

ATENÇÃO: PARA UTILIZAR SERVIÇOS DA EVERYNET, CONTATE E PEÇA OS BROKERS.

A American Tower é uma multi nacional presente em mais de 16 países, com de 160.000 sites no mundo onde ela aluga espaço para as operadoras colocarem suas torres celulares e rádios. No Brasil ela possui mais de 19.000 sites, tendo uma ampla presença geográfica. Ela decidiu de forma pioneira no Brasil lançar uma rede LoRaWAN junto com a EveryNet, de forma a permitir o avanço do IoT.

O cliente que tem um produto que siga o padrão LoRaWAN pode contratar o serviço de dados da American Tower / EveyNet de forma a se preocupar somente com seus devices e aplicação, sem ter que se focar na infra-estrutura e gateways.

OTAA

• Vantagem: a rede gera e envia as chaves de criptografia; isto torna mais seguro. Devido ao maior nível de segurança, o OTAA é o método mais utilizado em IoT / LoRaWAN.

• AppEUI: Este é um identificador de aplicativo exclusivo usado para agrupar objetos. este

endereço, 64 bits, é usado para classificar os dispositivos periféricos por aplicação. Essa configuração pode seja ajustado.

• DevEUI: Este identificador, configurado de fábrica, torna cada objeto único. Em princípio, esta

configuração não pode ser ajustada.

• AppKey: esta é uma chave secreta compartilhada entre o dispositivo periférico e a rede. É usado para determinar as chaves da sessão. Essa configuração pode ser ajustada.

Concentre-se na OTAA

O Servido de Rede é o componente de software encarregado de estabelecer uma conexão com os objetos e gerenciando o núcleo da rede. Durante a conexão OTAA, e supondo que o dispositivo esteja autorizado a conectar-se a rede, a rede troca chaves de criptografia específicas da sessão com o núcleo da rede. O Servidor de Rede então aloca informações específicas para a sessão e as envia para o aparelho periférico:

• DevAddr: Endereço lógico (equivalente a um endereço IP) que será usado para todos comunicação subseqüente.

• NetSKey (chave de sessão de rede): chave de criptografia entre o objeto e o operador usado para transmissões e para validar a integridade das mensagens.

• AppSKey (chave de sessão do aplicativo): chave de criptografia entre o objeto e operador (através da aplicação) utilizado para as transmissões e para validar a integridade das mensagens

1.1 Entrando na EveryNet

Passo 1: Cadastre-se uma conta de usuário no servidor EveryNet, em https://ns.atc.everynet.io

1.2 Adicionar um dispositivo EndDevice LoRaWan

Esta seção mostra como adicionar um dispositivo EndDevice LoRaWAN à rede LoRaWAN e ver os dados pelo web site da EveryNet. Usamos o LSM110A como um dispositivo de referência - a configuração para outros dispositivos LoRaWAN será semelhante.

Passo 1: Criar uma definição de dispositivos no EveryNet

Três códigos são necessários para definir o dispositivo no EveryNet:

Device EUI - código de identificação único para um dispositivo em particular.
Application EUI - código de identificação para um aplicativo definido no Everynet.
Application key - Chave exclusiva para proteger as comunicações com um dispositivo em particular.

Para o servidor EveryNet, você pode usar os códigos estabelecidos por você ou criados pelo servidor.

Pressione o sinal de + para abrir a tela abaixo e adicionar device!

Mude para Activation para OTAA e Encryption para NS

LA915-928

Dicas

Device EUI – deixe o sistema gerar

Application EUI – deixe o sistema gerar

Application key – deixe o sistema gerar

Nota-se que há uma APP EUI já criado por EveryNet, mas esta não é a definida no dispositivo. Para adicionar o APP EUI do dispositivo LSM110A, utilize comandos AT.

Introduzir os códigos ApplicationEUI e ApplicationKey obtidos do site da EveryNet e SET para cada um.

Passo 2: Ligar dispositivo LSM110A e vai juntar-se automaticamente a rede EveryNet.

Depois de ingressar com sucesso, ele vai começar a fazer upload de mensagens para a EveryNet. Selecione a guia Dados e você vai ver os dados que aparecem no painel.

Note que isso pode levar algum tempo para que os dados do dispositivo para aparecer no visor EveryNet.

Dados são mostrados no final da página

Configuração no Servidor final.

Não esquecer de especificar "LoRaWAN protocol version" que você está utilizando em seu EndDevice (LoRaWAN protocol version)

ARDUINO

O que é Arduino? Se você sabe pouco sobre Arduino, por favor dê uma olhada abaixo:

https://www.arduino.cc/

Você conhece Arduino. Instale o IDE primeiro:
https://www.arduino.cc/en/Main/Software

LSM110A e Arduino (STM32DUINO)

LSM110A é baseado em STM32WL55. No Arduino STM32 existe este core.

Como instalar Arduino STM32? adicionar em Arquivo-->Preferências-->URLs adicionais

https://github.com/stm32duino/BoardManagerFiles/raw/main/package_stmicroelectronics_index.json

BSP

2.4.0 (última versão na presente data)

LIB STM32LoRaWAN

No github

stm32duino/STM32LoRaWAN (github.com)

Baixe em formato ZIP

Adicione ao Arduino IDE:

Pronto

Altere Placa para STM32WL series

Modelo Generic WLE5CCUX

Baseado no canais de uplink, downlink, dwell, etc

LA915 · Everynet Network Server Máscara de canais (Join, Uplink, Downlink)

Foram alterados os arquivos RegionAU915.h e RegionAU915.c para serem compatíveis somente com EVERYNET.

Altere em radio_board_if.c

C:\Users\Usuario\Documents\Arduino\libraries\STM32LoRaWAN-main\src\BSP

// Supported TX modes (LP/HP or both)
#if !defined(LORAWAN_TX_CONFIG)
  #define LORAWAN_TX_CONFIG RBI_CONF_RFO_HP
  //MIGUEL#define LORAWAN_TX_CONFIG RBI_CONF_RFO_LP_HP
#endif

#if !defined(LORAWAN_RFSWITCH_PINS)
  #define LORAWAN_RFSWITCH_PINS PB12,PC13
  #define LORAWAN_RFSWITCH_PIN_COUNT 2
  #define LORAWAN_RFSWITCH_OFF_VALUES LOW,LOW
  #define LORAWAN_RFSWITCH_RX_VALUES HIGH,LOW
  #define LORAWAN_RFSWITCH_RFO_LP_VALUES HIGH,HIGH
  #define LORAWAN_RFSWITCH_RFO_HP_VALUES HIGH,HIGH
#endif

Ok, o ambiente de desenvolvimento está pronto. Abra o ScheduleAsync.ino e configure 3 parâmetros para LoRaWAN_OTAA os quais deve ser obtidos no servidor EVERYNET.

bool connected = modem.joinOTAA(/* AppEui */ "0000000000000099", /* AppKey */ "FF9F138B40180AA45D6846E0A0146954", /* DevEui */ "0080E115051FD80A");

Neste exemplo, será transmitido para LoRaWAN (EVERYNET) os dados

Segue código final (alterado)

/**
 * This is a more complex asynchronous sketch that shows how the
 * asynchronous code could be used in a sketch that uses a scheduler of
 * some sort to decide what code to run when.
 *
 * This sketch defines its own very, very simple scheduler that is not
 * suggested to be used directly, but just serves to show how a sketch
 * that uses some scheduling mechanism can be used with the
 * asynchronous STM32LoRaWAN API and the MaintainNeeded callback.
 *
 * The behavior of the sketch is simple, it just blinks a LED
 * (asynchronously) and at the same time joins the network and transmit
 * a packet periodically.
 *
 * Revised BSD License - https://spdx.org/licenses/BSD-3-Clause.html
 */
#include <STM32LoRaWAN.h>
#include <IWatchdog.h>

STM32LoRaWAN modem;

char STAT[128];

/*********************************************************************
 * This part of the sketch defines a very simple scheduler and defines
 * two tasks that handle the actual work.
 *********************************************************************/
struct Task {
  unsigned long time; /* When to run, 0 == never */
  void (*callback)();
};

enum Tasks {
  BLINK_TASK,
  LORA_WORK_TASK,
  LORA_MAINTAIN_TASK,
  NUM_TASKS,
};

void do_blink();
void do_lora_maintain();
void do_lora_work();
void maintain_needed_callback();

Task tasks[NUM_TASKS] = {
  [BLINK_TASK] = {0, do_blink},
  [LORA_WORK_TASK] = {0, do_lora_work},
  [LORA_MAINTAIN_TASK] = {0, do_lora_maintain},
};


void run_scheduler()
{
  // Super-simple scheduler that just checks all tasks and runs
  // any that are due.
  for (size_t i = 0; i < NUM_TASKS; ++i) {
    if (tasks[i].time != 0 && (int)(millis() - tasks[i].time) >= 0) {
      tasks[i].time = 0;
      tasks[i].callback();
    }
  }
}

/*********************************************************************
 * This part of the sketch defines the blink task, which just toggles
 * a LED whenever it is called.
 * And this is the entry points of the sketch.
 *********************************************************************/
static const unsigned long BLINK_TASK_TIME = 1000; /* ms */

void do_blink()
{
  digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));
  tasks[BLINK_TASK].time = millis() + BLINK_TASK_TIME;
}

/*********************************************************************
 * This part of the sketch defines the lora work task, which initiates
 * new work and the lora_done() function that processes the results.
 *********************************************************************/

static const unsigned long TX_INTERVAL = 10000; /* ms */
static const unsigned long RETRY_JOIN_INTERVAL = 5000; /* ms */

enum LoraState {
  IDLE,
  JOINING,
  TRANSMITTING,
};
LoraState lora_state;

void start_join()
{
  // Configure join method by (un)commenting the right method
  // call, and fill in credentials in that method call.
  modem.setAppEui("534ae9677ffc1c41");
  modem.setAppKey("708ce3cfacf88f24eb88da478ce56fca");
  modem.setDevEui("0080e115051fcc25");
  modem.joinOTAAAsync();
  //modem.setDevAddr("00000000");
  //modem.setNwkSKey("00000000000000000000000000000000");
  //modem.setAppSKey("00000000000000000000000000000000");
  //modem.joinABP();

  lora_state = JOINING;
}

void send_packet()
{
  uint8_t payload[] = {0xde, 0xad, 0xbe, 0xef};
  modem.setPort(1);
  modem.setADR(true);
  modem.beginPacket();
  modem.write(payload, sizeof(payload));
  if (modem.endPacketAsync(true) == sizeof(payload)) {
    Serial.println("Queued packet");
  } else {
    Serial.println("Failed to queue packet");
  }
  lora_state = TRANSMITTING;
}

void process_rx()
{
  if (modem.available()) {
    Serial.print("Received packet on port ");
    Serial.print(modem.getDownlinkPort());
    Serial.print(":");
    while (modem.available()) {
      uint8_t b = modem.read();
      Serial.print(" ");
      Serial.print(b >> 4, HEX);
      Serial.print(b & 0xF, HEX);
    }
    Serial.println();
  }
}

void do_lora_work()
{
  // Time to start new work
  if (!modem.connected()) {
    start_join();
  } else {
    send_packet();
  }
}

void lora_done()
{
  // If, after calling maintain() the library is no longer
  // busy, then the asynchronous operation has completed,
  // so check its results.
  String STAT_R = String(STAT);
  //Serial.println("++++++++++++++++++++++++++++++++++++++++");
  //Serial.println(STAT_R);
  //Serial.println("++++++++++++++++++++++++++++++++++++++++");
  if (lora_state == TRANSMITTING) {
    if (STAT_R == "LORAMAC_EVENT_INFO_STATUS_OK")
       Serial.println("Sent packet");
    else
       Serial.println("Fail sent packet");    
    // Done transmitting
    process_rx();
    lora_state = IDLE;
    // Schedule transmission of next packet
    tasks[LORA_WORK_TASK].time = millis() + TX_INTERVAL;
  } else if (lora_state == JOINING) {
    if (modem.connected()) {
      Serial.println("Joined");
      send_packet();
    } else {
      Serial.println("Join failed");
      lora_state = IDLE;
      tasks[LORA_WORK_TASK].time = millis() + RETRY_JOIN_INTERVAL;
    }
  }
}

/*********************************************************************
 * This part of the sketch defines the lora maintain task, which calls
 * maintain() to let the lora library do any background work that it
 * needs to do. It is called whenever request by the callback.
 *********************************************************************/

void do_lora_maintain()
{
  modem.maintain();

  // If, after calling maintain() the library is no longer
  // busy, then the asynchronous operation has completed,
  // so check its results.
  if (!modem.busy()) {
    lora_done();
  }
}

void maintain_needed_callback()
{
  // This is called from interrupt context, so this must *not*
  // call maintain() directly and return as fast as possible.
  // So just schedule the maintain task to run ASAP.
  tasks[LORA_MAINTAIN_TASK].time = millis();
}

/*********************************************************************
 * And this is the entry points of the sketch.
 *********************************************************************/

void setup()
{
  Serial.begin(115200);
  Serial.println("Start");
  modem.begin(AU915);
  modem.setPort(1);
  modem.setADR(true);
  modem.power(14);
      //wdt
  IWatchdog.begin(32000000);
  modem.setMaintainNeededCallback(maintain_needed_callback);

  //pinMode(LED_BUILTIN, OUTPUT);

  //do_blink();
  do_lora_work();
}

void loop()
{
  run_scheduler();
     //WDT WAKE UP
  IWatchdog.reload();
}

Alterado também STM32LoRaWAN.cpp

extern char STAT[128];

void STM32LoRaWAN::MacMcpsConfirm(McpsConfirm_t* c) {

// Called after an Mcps request (data TX) when the stack becomes idle again (so after RX windows)

strcpy(STAT, toString(c->Status));

core_debug(

"McpsConfirm: req=%s, status=%s, datarate=%u, power=%d, ack=%u, %s=%u, airtime=%u, upcnt=%u, channel=%u\r\n",

toString(c->McpsRequest), toString(c->Status), c->Datarate, c->TxPower,

c->AckReceived,

#if (defined( LORAMAC_VERSION ) && ( LORAMAC_VERSION == 0x01000300 ))

"retries", c->NbRetries,

#elif (defined( LORAMAC_VERSION ) && ( LORAMAC_VERSION == 0x01000400 ))

"trans", c->NbTrans,

#endif /* LORAMAC_VERSION */

(unsigned)c->TxTimeOnAir, (unsigned)c->UpLinkCounter, (unsigned)c->Channel);

instance->last_tx_acked = c->AckReceived;

instance->fcnt_up = c->UpLinkCounter;

}

Montagem

Compilando

Gravador

"Instale" o STM32 Cube Programmer, o Arduino (STM32 PACKAGE) irá reconhecê-lo e então utilizá-lo para programar o LSM110A. O Kit LSM110A possui um "gravador" ST-LINK embarcado.

Neste blog foi utilizado o BREAKOUT e um ST-LINK-V2.

st-link v2 - Bing images

Uma vez gravado o Software, o LSM110A fará o JOIN na LoRaWAN enviará o pacote a cada 10 segundos.

UPLINK message

PA2 - TXD / PA3- RXD

DOWNLINK message

Fontes:

STM32 Cube Programmer - Aticleworld

DevEUI, AppEUI (JoinEUI) and AppKey (centennialsoftwaresolutions.com)

Assync OTA · Issue #14 · stm32duino/STM32LoRaWAN (github.com)

https://lom204-cli-wisol.blogspot.com/2024/06/lsm110a-au915-la915.html

STM32LoRaWAN: STM32LoRaWAN Class Reference (stm32duino.github.io)

Microsoft PowerPoint - Conversion Level II LPWAN (1) V2 (ntu.edu.tw)

Dúvidas

FORUM

Sobre a SMARTCORE

A SmartCore fornece módulos para comunicação wireless, biometria, conectividade, rastreamento e automação.

Nosso portfólio inclui modem 2G/3G/4G/NB-IoT/Cat.M, satelital, módulos WiFi, Bluetooth, GNSS / GPS, Sigfox, LoRa, leitor de cartão, leitor QR code, mecanismo de impressão, mini-board PC, antena, pigtail, LCD, bateria, repetidor GPS e sensores.

Mais detalhes em www.smartcore.com.br

terça-feira, 9 de julho de 2024

LSM110A - LoRaWAN - Compilando APP (LORA_ENDDEVICE) - bare metal - WISOL - EVERYNET - LA915

Baseado no canais de uplink, downlink, dwell, etc

LA915 · Everynet Network Server Máscara de canais (Join, Uplink, Downlink)

Foram alterados os arquivos RegionCommon.h, RegionAU915.h e RegionAU915.c para serem compatíveis com EVERYNET.

Em RegionCommon.h

/*!

* Receive delay of 1 second.

#define REGION_COMMON_DEFAULT_RECEIVE_DELAY1 5000

/*!

* Receive delay of 2 seconds.

#define REGION_COMMON_DEFAULT_RECEIVE_DELAY2 ( REGION_COMMON_DEFAULT_RECEIVE_DELAY1 + 1000 )

/*!

* Join accept delay of 5 seconds.

#define REGION_COMMON_DEFAULT_JOIN_ACCEPT_DELAY1 5000

/*!

* Join accept delay of 6 seconds.

#define REGION_COMMON_DEFAULT_JOIN_ACCEPT_DELAY2 ( REGION_COMMON_DEFAULT_JOIN_ACCEPT_DELAY1 + 1000 )

/*!
 * \file      RegionAU915.h
 *
 * \brief     Region definition for AU915
 *
 * \copyright Revised BSD License, see section \ref LICENSE.
 *
 * \code
 *                ______                              _
 *               / _____)             _              | |
 *              ( (____  _____ ____ _| |_ _____  ____| |__
 *               \____ \| ___ |    (_   _) ___ |/ ___)  _ \
 *               _____) ) ____| | | || |_| ____( (___| | | |
 *              (______/|_____)_|_|_| \__)_____)\____)_| |_|
 *              (C)2013-2017 Semtech
 *
 *               ___ _____ _   ___ _  _____ ___  ___  ___ ___
 *              / __|_   _/_\ / __| |/ / __/ _ \| _ \/ __| __|
 *              \__ \ | |/ _ \ (__| ' <| _| (_) |   / (__| _|
 *              |___/ |_/_/ \_\___|_|\_\_| \___/|_|_\\___|___|
 *              embedded.connectivity.solutions===============
 *
 * \endcode
 *
 * \author    Miguel Luis ( Semtech )
 *
 * \author    Gregory Cristian ( Semtech )
 *
 * \author    Daniel Jaeckle ( STACKFORCE )
 *
 * \author    Johannes Bruder ( STACKFORCE )
 *
 * \defgroup  REGIONAU915 Region AU915
 *            Implementation according to LoRaWAN Specification v1.0.2.
 * \{
 */
#ifndef __REGION_AU915_H__
#define __REGION_AU915_H__

#include "region/Region.h"


#define AU915_PING_SLOT_CHANNEL_FREQ 923300000

/*!
 * LoRaMac maximum number of channels
 */
#define AU915_MAX_NB_CHANNELS                       72

/*!
 * Minimal datarate that can be used by the node
 */
#define AU915_TX_MIN_DATARATE                       DR_0

/*!
 * Maximal datarate that can be used by the node
 */
#define AU915_TX_MAX_DATARATE                       DR_5

/*!
 * Minimal datarate that can be used by the node
 */
#define AU915_RX_MIN_DATARATE                       DR_8

/*!
 * Maximal datarate that can be used by the node
 */
#define AU915_RX_MAX_DATARATE                       DR_13

/*!
 * Default datarate used by the node
 */
#define AU915_DEFAULT_DATARATE                      DR_0

/*!
 * The minimum datarate which is used when the
 * dwell time is limited.
 */
#define AU915_DWELL_LIMIT_DATARATE                  DR_2

/*!
 * Minimal Rx1 receive datarate offset
 */
#define AU915_MIN_RX1_DR_OFFSET                     0

/*!
 * Maximal Rx1 receive datarate offset
 */
#define AU915_MAX_RX1_DR_OFFSET                     3

/*!
 * Default Rx1 receive datarate offset
 */
#define AU915_DEFAULT_RX1_DR_OFFSET                 0

/*!
 * Minimal Tx output power that can be used by the node
 */
#define AU915_MIN_TX_POWER                          TX_POWER_10

/*!
 * Maximal Tx output power that can be used by the node
 */
#define AU915_MAX_TX_POWER                          TX_POWER_0

/*!
 * Default Tx output power used by the node
 */
#define AU915_DEFAULT_TX_POWER                      TX_POWER_5

/*!
 * Default uplink dwell time configuration
 */
#define AU915_DEFAULT_UPLINK_DWELL_TIME             0

/*!
 * Default downlink dwell time configuration
 */
#define AU915_DEFAULT_DOWNLINK_DWELL_TIME           0

/*!
 * Default Max EIRP
 */
#define AU915_DEFAULT_MAX_EIRP                      30.0f

/*!
 * Default antenna gain
 */
#define AU915_DEFAULT_ANTENNA_GAIN                  0.0f

/*!
 * ADR Ack limit
 */
#define AU915_ADR_ACK_LIMIT                         64

/*!
 * ADR Ack delay
 */
#define AU915_ADR_ACK_DELAY                         32

/*!
 * Enabled or disabled the duty cycle
 */
#define AU915_DUTY_CYCLE_ENABLED                    0

/*!
 * Maximum RX window duration
 */
#define AU915_MAX_RX_WINDOW                         1000

/*!
 * Receive delay 1
 */
#define AU915_RECEIVE_DELAY1                        5000

/*!
 * Receive delay 2
 */
#define AU915_RECEIVE_DELAY2                        6000

/*!
 * Join accept delay 1
 */
#define AU915_JOIN_ACCEPT_DELAY1                    5000

/*!
 * Join accept delay 2
 */
#define AU915_JOIN_ACCEPT_DELAY2                    6000

/*!
 * Maximum frame counter gap
 */
#define AU915_MAX_FCNT_GAP                          16384

/*!
 * Ack timeout
 */
#define AU915_ACKTIMEOUT                            2000

/*!
 * Random ack timeout limits
 */
#define AU915_ACK_TIMEOUT_RND                       1000

/*!
 * Second reception window channel frequency definition.
 */
#define AU915_RX_WND_2_FREQ                         923300000

/*!
 * Second reception window channel datarate definition.
 */
#define AU915_RX_WND_2_DR                           DR_8

/*
 * CLASS B
 */
/*!
 * Beacon frequency
 */
#define AU915_BEACON_CHANNEL_FREQ                   923300000

/*!
 * Beacon frequency channel stepwidth
 */
#define AU915_BEACON_CHANNEL_STEPWIDTH              600000

/*!
 * Number of possible beacon channels
 */
#define AU915_BEACON_NB_CHANNELS                    8

/*!
 * Payload size of a beacon frame
 */
#define AU915_BEACON_SIZE                           19

/*!
 * Size of RFU 1 field
 */
#define AU915_RFU1_SIZE                             3

/*!
 * Size of RFU 2 field
 */
#define AU915_RFU2_SIZE                             1

/*!
 * Datarate of the beacon channel
 */
#define AU915_BEACON_CHANNEL_DR                     DR_10

/*!
 * Bandwith of the beacon channel
 */
#define AU915_BEACON_CHANNEL_BW                     2

/*!
 * Ping slot channel datarate
 */
#define AU915_PING_SLOT_CHANNEL_DR                  DR_10

/*!
 * LoRaMac maximum number of bands
 */
#define AU915_MAX_NB_BANDS                          1

/*!
 * Band 0 definition
 * { DutyCycle, TxMaxPower, LastJoinTxDoneTime, LastTxDoneTime, TimeOff }
 */
#define AU915_BAND0                                 { 1, AU915_MAX_TX_POWER, 0, 0, 0 } //  100.0 %

/*!
 * Defines the first channel for RX window 1 for US band
 */
#define AU915_FIRST_RX1_CHANNEL                     ( (uint32_t) 923300000 )

/*!
 * Defines the last channel for RX window 1 for US band
 */
#define AU915_LAST_RX1_CHANNEL                      ( (uint32_t) 927500000 )

/*!
 * Defines the step width of the channels for RX window 1
 */
#define AU915_STEPWIDTH_RX1_CHANNEL                 ( (uint32_t) 600000 )

/*!
 * Data rates table definition
 */
static const uint8_t DataratesAU915[]  = { 12, 11, 10, 9, 8, 7, 8, 0, 12, 11, 10, 9, 8, 7, 0, 0 };

/*!
 * Bandwidths table definition in Hz
 */
static const uint32_t BandwidthsAU915[] = { 125000, 125000, 125000, 125000, 125000, 125000, 500000, 0, 500000, 500000, 500000, 500000, 500000, 500000, 0, 0 };

/*!
 * Up/Down link data rates offset definition
 */
static const int8_t DatarateOffsetsAU915[7][6] =
{
    { DR_8 , DR_8 , DR_8 , DR_8 , DR_8 , DR_8  }, // DR_0
    { DR_9 , DR_8 , DR_8 , DR_8 , DR_8 , DR_8  }, // DR_1
    { DR_10, DR_9 , DR_8 , DR_8 , DR_8 , DR_8  }, // DR_2
    { DR_11, DR_10, DR_9 , DR_8 , DR_8 , DR_8  }, // DR_3
    { DR_12, DR_11, DR_10, DR_9 , DR_8 , DR_8  }, // DR_4
    { DR_13, DR_12, DR_11, DR_10, DR_9 , DR_8  }, // DR_5
    { DR_13, DR_13, DR_12, DR_11, DR_10, DR_9  }, // DR_6
};

/*!
 * Maximum payload with respect to the datarate index. Cannot operate with repeater.
 * The table is valid for the dwell time configuration of 0 for uplinks.
 */
static const uint8_t MaxPayloadOfDatarateDwell0AU915[] = { 51, 51, 51, 115, 242, 242, 242, 0, 53, 129, 242, 242, 242, 242, 0, 0 };

/*!
 * Maximum payload with respect to the datarate index. Can operate with repeater.
 * The table is valid for the dwell time configuration of 0 for uplinks. The table provides
 * repeater support.
 */
static const uint8_t MaxPayloadOfDatarateRepeaterDwell0AU915[] = { 51, 51, 51, 115, 222, 222, 222, 0, 33, 109, 222, 222, 222, 222, 0, 0 };

/*!
 * Maximum payload with respect to the datarate index. Cannot operate with repeater.
 * The table is valid for the dwell time configuration of 1 for uplinks.
 */
static const uint8_t MaxPayloadOfDatarateDwell1AU915[] = { 0, 0, 11, 53, 125, 242, 242, 0, 53, 129, 129, 242, 242, 242, 242 };

/*!
 * Maximum payload with respect to the datarate index. Can operate with repeater.
 * The table is valid for the dwell time configuration of 1 for uplinks. The table provides
 * repeater support.
 */
static const uint8_t MaxPayloadOfDatarateRepeaterDwell1AU915[] = { 0, 0, 11, 53, 125, 242, 242, 0, 33, 119, 129, 242, 242, 242, 242 };

/*!
 * \brief The function gets a value of a specific phy attribute.
 *
 * \param [IN] getPhy Pointer to the function parameters.
 *
 * \retval Returns a structure containing the PHY parameter.
 */
PhyParam_t RegionAU915GetPhyParam( GetPhyParams_t* getPhy );

/*!
 * \brief Updates the last TX done parameters of the current channel.
 *
 * \param [IN] txDone Pointer to the function parameters.
 */
void RegionAU915SetBandTxDone( SetBandTxDoneParams_t* txDone );

/*!
 * \brief Initializes the channels masks and the channels.
 *
 * \param [IN] type Sets the initialization type.
 */
void RegionAU915InitDefaults( InitDefaultsParams_t* params );

/*!
 * \brief Returns a pointer to the internal context and its size.
 *
 * \param [OUT] params Pointer to the function parameters.
 *
 * \retval      Points to a structure where the module store its non-volatile context.
 */
void* RegionAU915GetNvmCtx( GetPhyParams_t* params );

/*!
 * \brief Verifies a parameter.
 *
 * \param [IN] verify Pointer to the function parameters.
 *
 * \param [IN] type Sets the initialization type.
 *
 * \retval Returns true, if the parameter is valid.
 */
bool RegionAU915Verify( VerifyParams_t* verify, PhyAttribute_t phyAttribute );

/*!
 * \brief The function parses the input buffer and sets up the channels of the
 *        CF list.
 *
 * \param [IN] applyCFList Pointer to the function parameters.
 */
void RegionAU915ApplyCFList( ApplyCFListParams_t* applyCFList );

/*!
 * \brief Sets a channels mask.
 *
 * \param [IN] chanMaskSet Pointer to the function parameters.
 *
 * \retval Returns true, if the channels mask could be set.
 */
bool RegionAU915ChanMaskSet( ChanMaskSetParams_t* chanMaskSet );

/*!
 * Computes the Rx window timeout and offset.
 *
 * \param [IN] datarate     Rx window datarate index to be used
 *
 * \param [IN] minRxSymbols Minimum required number of symbols to detect an Rx frame.
 *
 * \param [IN] rxError      System maximum timing error of the receiver. In milliseconds
 *                          The receiver will turn on in a [-rxError : +rxError] ms
 *                          interval around RxOffset
 *
 * \param [OUT]rxConfigParams Returns updated WindowTimeout and WindowOffset fields.
 */
void RegionAU915ComputeRxWindowParameters( int8_t datarate, uint8_t minRxSymbols, uint32_t rxError, RxConfigParams_t *rxConfigParams );

/*!
 * \brief Configuration of the RX windows.
 *
 * \param [IN] rxConfig Pointer to the function parameters.
 *
 * \param [OUT] datarate The datarate index which was set.
 *
 * \retval Returns true, if the configuration was applied successfully.
 */
bool RegionAU915RxConfig( RxConfigParams_t* rxConfig, int8_t* datarate );

/*!
 * \brief TX configuration.
 *
 * \param [IN] txConfig Pointer to the function parameters.
 *
 * \param [OUT] txPower The tx power index which was set.
 *
 * \param [OUT] txTimeOnAir The time-on-air of the frame.
 *
 * \retval Returns true, if the configuration was applied successfully.
 */
bool RegionAU915TxConfig( TxConfigParams_t* txConfig, int8_t* txPower, TimerTime_t* txTimeOnAir );

/*!
 * \brief The function processes a Link ADR Request.
 *
 * \param [IN] linkAdrReq Pointer to the function parameters.
 *
 * \retval Returns the status of the operation, according to the LoRaMAC specification.
 */
uint8_t RegionAU915LinkAdrReq( LinkAdrReqParams_t* linkAdrReq, int8_t* drOut, int8_t* txPowOut, uint8_t* nbRepOut, uint8_t* nbBytesParsed );

/*!
 * \brief The function processes a RX Parameter Setup Request.
 *
 * \param [IN] rxParamSetupReq Pointer to the function parameters.
 *
 * \retval Returns the status of the operation, according to the LoRaMAC specification.
 */
uint8_t RegionAU915RxParamSetupReq( RxParamSetupReqParams_t* rxParamSetupReq );

/*!
 * \brief The function processes a Channel Request.
 *
 * \param [IN] newChannelReq Pointer to the function parameters.
 *
 * \retval Returns the status of the operation, according to the LoRaMAC specification.
 */
uint8_t RegionAU915NewChannelReq( NewChannelReqParams_t* newChannelReq );

/*!
 * \brief The function processes a TX ParamSetup Request.
 *
 * \param [IN] txParamSetupReq Pointer to the function parameters.
 *
 * \retval Returns the status of the operation, according to the LoRaMAC specification.
 *         Returns -1, if the functionality is not implemented. In this case, the end node
 *         shall not process the command.
 */
int8_t RegionAU915TxParamSetupReq( TxParamSetupReqParams_t* txParamSetupReq );

/*!
 * \brief The function processes a DlChannel Request.
 *
 * \param [IN] dlChannelReq Pointer to the function parameters.
 *
 * \retval Returns the status of the operation, according to the LoRaMAC specification.
 */
uint8_t RegionAU915DlChannelReq( DlChannelReqParams_t* dlChannelReq );

/*!
 * \brief Alternates the datarate of the channel for the join request.
 *
 * \param [IN] currentDr Current datarate.
 *
 * \retval Datarate to apply.
 */
int8_t RegionAU915AlternateDr( int8_t currentDr, AlternateDrType_t type );

/*!
 * \brief Calculates the back-off time.
 *
 * \param [IN] calcBackOff Pointer to the function parameters.
 */

//void RegionAU915CalcBackOff( CalcBackOffParams_t* calcBackOff );

/*!
 * \brief Searches and set the next random available channel
 *
 * \param [OUT] channel Next channel to use for TX.
 *
 * \param [OUT] time Time to wait for the next transmission according to the duty
 *              cycle.
 *
 * \param [OUT] aggregatedTimeOff Updates the aggregated time off.
 *
 * \retval Function status [1: OK, 0: Unable to find a channel on the current datarate]
 */
LoRaMacStatus_t RegionAU915NextChannel( NextChanParams_t* nextChanParams, uint8_t* channel, TimerTime_t* time, TimerTime_t* aggregatedTimeOff );

/*!
 * \brief Adds a channel.
 *
 * \param [IN] channelAdd Pointer to the function parameters.
 *
 * \retval Status of the operation.
 */
LoRaMacStatus_t RegionAU915ChannelAdd( ChannelAddParams_t* channelAdd );

/*!
 * \brief Removes a channel.
 *
 * \param [IN] channelRemove Pointer to the function parameters.
 *
 * \retval Returns true, if the channel was removed successfully.
 */
bool RegionAU915ChannelsRemove( ChannelRemoveParams_t* channelRemove  );

/*!
 * \brief Sets the radio into continuous wave mode.
 *
 * \param [IN] continuousWave Pointer to the function parameters.
 */
//////void RegionAU915SetContinuousWave( ContinuousWaveParams_t* continuousWave );

/*!
 * \brief Computes new datarate according to the given offset
 *
 * \param [IN] downlinkDwellTime Downlink dwell time configuration. 0: No limit, 1: 400ms
 *
 * \param [IN] dr Current datarate
 *
 * \param [IN] drOffset Offset to be applied
 *
 * \retval newDr Computed datarate.
 */
uint8_t RegionAU915ApplyDrOffset( uint8_t downlinkDwellTime, int8_t dr, int8_t drOffset );

/*!
 * \brief Sets the radio into beacon reception mode
 *
 * \param [IN] rxBeaconSetup Pointer to the function parameters
 */
 void RegionAU915RxBeaconSetup( RxBeaconSetup_t* rxBeaconSetup, uint8_t* outDr );

/*! \} defgroup REGIONAU915 */

#endif // __REGION_AU915_H__

Mais informações »