leuart.c File Reference

LEUART (serial communication) functionality required by the RN2483 LoRa modem. More...

#include <stdint.h>
#include <stdbool.h>
#include "em_device.h"
#include "em_chip.h"
#include "em_cmu.h"
#include "em_gpio.h"
#include "em_leuart.h"
#include "em_dma.h"
#include "dmactrl.h"
#include "leuart.h"
#include "delay.h"
#include "pin_mapping.h"
#include "debug_dbprint.h"
#include "util_string.h"
#include "util.h"

Go to the source code of this file.

Macros
#define	DBPRINT_TIMEOUT   0
#define	TIMEOUT_SYNC   80
#define	TIMEOUT_DMA   50000
#define	TIMEOUT_SENDCMD   40000
#define	TIMEOUT_WAITRESPONSE   2000000 /* Depends on spreading factor! */
#define	DMA_CHANNEL_TX   0 /* DMA channel is 0 */
#define	DMA_CHANNEL_RX   1
#define	DMA_CHANNELS   2

Functions
void	Leuart_ClearBuffers (void)
static void	basicTxComplete (unsigned int channel, bool primary, void *user)
static void	basicRxComplete (unsigned int channel, bool primary, void *user)
static bool	Leuart_ResponseAvailable (void)
void	setupDma (void)
static void	sendLeuartData (char *buffer, uint8_t bufferLength)
static void	setupLeuart (void)
void	Leuart_Init (void)
void	Leuart_Reinit (void)
void	Leuart_BreakCondition (void)
void	Leuart_ReadResponse (char *buffer, uint8_t bufferLength)
void	Leuart_SendData (char *buffer, uint8_t bufferLength)
Leuart_Status_t	Leuart_SendCommand (char *cb, uint8_t cbl, volatile bool *wakeUp)
Leuart_Status_t	Leuart_WaitForResponse ()

Variables
static DMA_CB_TypeDef	dmaCallBack [2]
char	receiveBuffer [50]
volatile uint8_t	bufferPointer = 0
volatile bool	receiveComplete = false

Detailed Description

LEUART (serial communication) functionality required by the RN2483 LoRa modem.

Version

2.0

Author

Guus Leenders
Modified by Brecht Van Eeckhoudt

---

Versions

• v1.0: DRAMCO GitHub version (https://github.com/DRAMCO/EFM32-RN2483-LoRa-Node).
• v1.1: Removed rtcdriver functionality (timeouts)
• v1.2: Added (basic) timeout functionality.
• v1.3: Refined timeout functionality and cleaned up unused things in comments.
• v2.0: Updated version number.

Definition in file leuart.c.

Macro Definition Documentation

DBPRINT_TIMEOUT

#define DBPRINT_TIMEOUT   0

Enable (1) or disable (0) printing the timeout counter value using DBPRINT

Definition at line 62 of file leuart.c.

DMA_CHANNEL_RX

#define DMA_CHANNEL_RX   1

Definition at line 72 of file leuart.c.

DMA_CHANNEL_TX

#define DMA_CHANNEL_TX   0 /* DMA channel is 0 */

Definition at line 71 of file leuart.c.

DMA_CHANNELS

#define DMA_CHANNELS   2

Definition at line 73 of file leuart.c.

TIMEOUT_DMA

#define TIMEOUT_DMA   50000

Definition at line 66 of file leuart.c.

TIMEOUT_SENDCMD

#define TIMEOUT_SENDCMD   40000

Definition at line 67 of file leuart.c.

TIMEOUT_SYNC

#define TIMEOUT_SYNC   80

Definition at line 65 of file leuart.c.

TIMEOUT_WAITRESPONSE

#define TIMEOUT_WAITRESPONSE   2000000 /* Depends on spreading factor! */

Definition at line 68 of file leuart.c.

Function Documentation

basicRxComplete()

static void basicRxComplete ( unsigned int  channel, bool  primary, void *  user  )

static

Definition at line 103 of file leuart.c.

{
    (void) user;

    /* Refresh DMA basic transaction cycle */
    char c = RN2483_UART->RXDATA;
    if(bufferPointer < RECEIVE_BUFFER_SIZE - 1){
        if(c != '\n'){
            bufferPointer++;
            DMA_ActivateBasic(DMA_CHANNEL_RX,
                                  primary,
                                  false,
                                  &receiveBuffer[bufferPointer],
                                  NULL,
                                  0);
        }
        else{
            receiveComplete = true;
            receiveBuffer[bufferPointer+1] = '\0';
        }
    }
}

basicTxComplete()

static void basicTxComplete ( unsigned int  channel, bool  primary, void *  user  )

static

Definition at line 90 of file leuart.c.

{
    (void) user;
    /* Refresh DMA basic transaction cycle */
    DMA_ActivateBasic(DMA_CHANNEL_RX,
                    primary,
                    false,
                    (void *)&receiveBuffer[0],
                    (void *)&RN2483_UART->RXDATA,
                    0);
    bufferPointer = 0;
}

Leuart_BreakCondition()

void Leuart_BreakCondition

(

void

)

Definition at line 342 of file leuart.c.

{
    GPIO_PinModeSet(RN2483_TX_PORT, RN2483_TX_PIN, gpioModePushPull, 1);
    delay(40);
    GPIO_PinModeSet(RN2483_TX_PORT, RN2483_TX_PIN, gpioModePushPull, 0);
    delay(20);
    GPIO_PinOutSet(RN2483_TX_PORT, RN2483_TX_PIN);
}

Leuart_ClearBuffers()

void Leuart_ClearBuffers

(

void

)

Definition at line 83 of file leuart.c.

{
    memset(receiveBuffer, '\0', RECEIVE_BUFFER_SIZE);
    receiveComplete = false;
}

Leuart_Init()

void Leuart_Init

(

void

)

Definition at line 306 of file leuart.c.

{
    // TODO: Lines below might fix some sleep functionality...
    //CMU_ClockEnable(cmuClock_CORELE, true);
    //CMU_ClockEnable(cmuClock_DMA, true);
    //CMU_ClockEnable(cmuClock_LEUART0, true);

    setupDma();
    Leuart_BreakCondition();
    setupLeuart();

    /* Auto baud setting */
    char b[] = "U";
    sendLeuartData(b, 1);
    delay(500);
}

Leuart_ReadResponse()

void Leuart_ReadResponse	(	char *	buffer,
		uint8_t	bufferLength
	)

Definition at line 351 of file leuart.c.

{
    sprintf(buffer, "%s", receiveBuffer);
    receiveComplete = false;
    bufferPointer = 0;
}

Leuart_Reinit()

void Leuart_Reinit

(

void

)

Definition at line 323 of file leuart.c.

{
    // TODO: Lines below might fix some sleep functionality...
    //CMU_ClockEnable(cmuClock_CORELE, true);
    //CMU_ClockEnable(cmuClock_DMA, true);
    //CMU_ClockEnable(cmuClock_LEUART0, true);

    LEUART_Reset(RN2483_UART);
    Leuart_BreakCondition();
    setupLeuart();

    /* Auto baud setting */
    char b[] = "U";
    sendLeuartData(b, 1);
    Leuart_WaitForResponse();
    delay(20);
    Leuart_WaitForResponse();
}

Leuart_ResponseAvailable()

static bool Leuart_ResponseAvailable ( void  )

static

Definition at line 126 of file leuart.c.

                                          {
    return (receiveComplete);
}

Leuart_SendCommand()

Leuart_Status_t Leuart_SendCommand	(	char *	cb,
		uint8_t	cbl,
		volatile bool *	wakeUp
	)

Send a command string over the LEUART. "wakeUp" IS NOT USED

Definition at line 392 of file leuart.c.

{
    /* Timeout counter */
    uint32_t counter = 0;

    /* Send data over LEUART */
    sendLeuartData(cb, cbl);

    /* Wait for response */
    while ((counter < TIMEOUT_SENDCMD) && !Leuart_ResponseAvailable()) counter++;

    /* Exit the function if the maximum waiting time was reached */
    if (counter == TIMEOUT_SENDCMD)
    {

#if DEBUG_DBPRINT == 1 /* DEBUG_DBPRINT */
        dbcrit("Waiting time for response reached! (Leuart_SendCommand)");
#endif /* DEBUG_DBPRINT */

        error(54);

        return (TX_TIMEOUT);
    }
#if DBPRINT_TIMEOUT == 1 /* DBPRINT_TIMEOUT */
    else
    {

#if DEBUG_DBPRINT == 1 /* DEBUG_DBPRINT */
        dbwarnInt("Leuart_SendCommand (", counter, ")");
#endif /* DEBUG_DBPRINT */

    }
#endif /* DBPRINT_TIMEOUT */

    return (DATA_SENT);
}

Leuart_SendData()

void Leuart_SendData	(	char *	buffer,
		uint8_t	bufferLength
	)

Definition at line 358 of file leuart.c.

{
    /* Timeout counter */
    uint32_t counter = 0;

    /* Send data over LEUART */
    sendLeuartData(buffer, bufferLength);

    /* Wait for response */
    while ((counter < TIMEOUT_WAITRESPONSE) && !Leuart_ResponseAvailable()) counter++;

    /* Exit the function if the maximum waiting time was reached */
    if (counter == TIMEOUT_WAITRESPONSE)
    {

#if DEBUG_DBPRINT == 1 /* DEBUG_DBPRINT */
        dbcrit("Waiting time for response reached! (Leuart_SendData)");
#endif /* DEBUG_DBPRINT */

        error(53);
    }
    else
    {

#if DEBUG_DBPRINT == 1 /* DEBUG_DBPRINT */
        dbwarnInt("Leuart_SendData (", counter, ")");
#endif /* DEBUG_DBPRINT */

    }

    receiveComplete = true;
}

Leuart_WaitForResponse()

Leuart_Status_t Leuart_WaitForResponse

(

)

Definition at line 430 of file leuart.c.

{
    /* Timeout counter */
    uint32_t counter = 0;

    /* Activate DMA */
    DMA_ActivateBasic(  DMA_CHANNEL_RX,
                        true,
                        false,
                        (void *)&receiveBuffer[0],
                        (void *)&RN2483_UART->RXDATA,
                        0);

    /* Wait for response */
    while ((counter < TIMEOUT_WAITRESPONSE) && !Leuart_ResponseAvailable()) counter++;

    /* Exit the function if the maximum waiting time was reached */
    if (counter == TIMEOUT_WAITRESPONSE)
    {

#if DEBUG_DBPRINT == 1 /* DEBUG_DBPRINT */
        dbcrit("Waiting time for response reached! (Leuart_WaitForResponse)");
#endif /* DEBUG_DBPRINT */

        error(55);

        return (RX_TIMEOUT);
    }
#if DBPRINT_TIMEOUT == 1 /* DBPRINT_TIMEOUT */
    else
    {

#if DEBUG_DBPRINT == 1 /* DEBUG_DBPRINT */
        dbwarnInt("Leuart_WaitForResponse (", counter, ")");
#endif /* DEBUG_DBPRINT */

    }
#endif /* DBPRINT_TIMEOUT */

    return (DATA_RECEIVED);
}

sendLeuartData()

static void sendLeuartData ( char *  buffer, uint8_t  bufferLength  )

static

Definition at line 199 of file leuart.c.

{
    /* Timeout counter */
    uint32_t counter = 0;

    /* Wait for sync */
    while ((counter < TIMEOUT_SYNC) && RN2483_UART->SYNCBUSY) counter++;

    /* Exit the function if the maximum waiting time was reached */
    if (counter == TIMEOUT_SYNC)
    {

#if DEBUG_DBPRINT == 1 /* DEBUG_DBPRINT */
        dbcrit("Waiting time for sync reached! (sendLeuartData)");
#endif  /* DEBUG_DBPRINT */

        error(51);
    }
#if DBPRINT_TIMEOUT == 1 /* DBPRINT_TIMEOUT */
    else
    {

#if DEBUG_DBPRINT == 1 /* DEBUG_DBPRINT */
        dbwarnInt("sendLeuartData SYNC (", counter, ")");
#endif /* DEBUG_DBPRINT */

    }
#endif /* DBPRINT_TIMEOUT */

    DMA_ActivateBasic(DMA_CHANNEL_TX,
                      true,
                      false,
                      (void *)&RN2483_UART->TXDATA,
                      buffer,
                      (unsigned int)(bufferLength - 1));

    /* Reset timeout counter */
    counter = 0;

    /* Wait in EM1 for DMA channel enable */
    while ((counter < TIMEOUT_DMA) && DMA_ChannelEnabled(DMA_CHANNEL_TX)) counter++;

    /* Exit the function if the maximum waiting time was reached */
    if (counter == TIMEOUT_DMA)
    {

#if DEBUG_DBPRINT == 1 /* DEBUG_DBPRINT */
        dbcrit("Waiting time for DMA channel enable reached! (sendLeuartData)");
#endif /* DEBUG_DBPRINT */

        error(52);
    }
#if DBPRINT_TIMEOUT == 1 /* DBPRINT_TIMEOUT */
    else
    {

#if DEBUG_DBPRINT == 1 /* DEBUG_DBPRINT */
        dbwarnInt("sendLeuartData DMA (", counter, ")");
#endif /* DEBUG_DBPRINT */

    }
#endif /* DBPRINT_TIMEOUT */

}

setupDma()

void setupDma

(

void

)

Definition at line 130 of file leuart.c.

                   {
    /* DMA configuration structs */
    DMA_Init_TypeDef       dmaInit;
    DMA_CfgChannel_TypeDef rxChnlCfg;
    DMA_CfgChannel_TypeDef txChnlCfg;
    DMA_CfgDescr_TypeDef   rxDescrCfg;
    DMA_CfgDescr_TypeDef   txDescrCfg;

    /* Initializing the DMA */
    dmaInit.hprot        = 0;
    dmaInit.controlBlock = dmaControlBlock;
    DMA_Init(&dmaInit);

    /* RX DMA setup*/
    /* Set the interrupt callback routine */
    dmaCallBack[DMA_CHANNEL_RX].cbFunc = basicRxComplete;
    /* Callback doesn't need userpointer */
    dmaCallBack[DMA_CHANNEL_RX].userPtr = NULL;

    /* Setting up channel for TX*/
    rxChnlCfg.highPri   = false; /* Can't use with peripherals */
    rxChnlCfg.enableInt = true;  /* Enabling interrupt to refresh DMA cycle*/
    /*Setting up DMA transfer trigger request*/
    rxChnlCfg.select = DMAREQ_LEUART0_RXDATAV; /* DMAREQ_LEUART0_RXDATAV; */
    /* Setting up callback function to refresh descriptors*/
    rxChnlCfg.cb     = &(dmaCallBack[DMA_CHANNEL_RX]);
    DMA_CfgChannel(DMA_CHANNEL_RX, &rxChnlCfg);

    /* Setting up channel descriptor */
    /* Destination is buffer, increment ourselves */
    rxDescrCfg.dstInc = dmaDataIncNone;
    /* Source is LEUART_RX register and transfers 8 bits each time */
    rxDescrCfg.srcInc = dmaDataIncNone;
    rxDescrCfg.size   = dmaDataSize1;
    /* Default setting of DMA arbitration*/
    rxDescrCfg.arbRate = dmaArbitrate1;
    rxDescrCfg.hprot   = 0;
    /* Configure primary descriptor */
    DMA_CfgDescr(DMA_CHANNEL_RX, true, &rxDescrCfg);
    DMA_CfgDescr(DMA_CHANNEL_RX, false, &rxDescrCfg);

    /* TX DMA setup*/
    /* Set the interrupt callback routine */
    dmaCallBack[DMA_CHANNEL_TX].cbFunc = basicTxComplete;
    /* Callback doesn't need userpointer */
    dmaCallBack[DMA_CHANNEL_TX].userPtr = NULL;

    /* Setting up channel for TX*/
    txChnlCfg.highPri   = false; /* Can't use with peripherals */
    txChnlCfg.enableInt = true;  /* Enabling interrupt to refresh DMA cycle*/
    /*Setting up DMA transfer trigger request*/
    txChnlCfg.select = DMAREQ_LEUART0_TXBL; /* DMAREQ_LEUART0_RXDATAV; */
    /* Setting up callback function to refresh descriptors*/
    txChnlCfg.cb     = &(dmaCallBack[DMA_CHANNEL_TX]);
    DMA_CfgChannel(DMA_CHANNEL_TX, &txChnlCfg);

    /* Setting up channel descriptor */
    /* Destination is LEUART_Tx register and doesn't move */
    txDescrCfg.dstInc = dmaDataIncNone;
    /* Source is LEUART_TX register and transfers 8 bits each time */
    txDescrCfg.srcInc = dmaDataInc1;
    txDescrCfg.size   = dmaDataSize1;
    /* Default setting of DMA arbitration*/
    txDescrCfg.arbRate = dmaArbitrate1;
    txDescrCfg.hprot   = 0;
    /* Configure primary descriptor */
    DMA_CfgDescr(DMA_CHANNEL_TX, true, &txDescrCfg);
}

setupLeuart()

static void setupLeuart ( void  )

static

Definition at line 264 of file leuart.c.

{
    /* Enable peripheral clocks */
    CMU_ClockEnable(cmuClock_HFPER, true);
    /* Configure GPIO pins */
    CMU_ClockEnable(cmuClock_GPIO, true);
    /* To avoid false start, configure output as high */
    GPIO_PinModeSet(RN2483_TX_PORT, RN2483_TX_PIN, gpioModePushPull, 1);
    GPIO_PinModeSet(RN2483_RX_PORT, RN2483_RX_PIN, gpioModeInput, 0);

    LEUART_Init_TypeDef init = LEUART_INIT_DEFAULT; /* Default config is fine */
    init.baudrate = 4800;

    /* Enable CORE LE clock in order to access LE modules */
    CMU_ClockEnable(cmuClock_CORELE, true);

    /* Select LFRCO for LEUARTs (and wait for it to stabilize) */
    CMU_ClockSelectSet(cmuClock_LFB, cmuSelect_LFXO);
    CMU_ClockEnable(cmuClock_LEUART0, true);

    /* Do not prescale clock */
    CMU_ClockDivSet(cmuClock_LEUART0, cmuClkDiv_1);

    /* Configure LEUART */
    init.enable = leuartDisable;

    LEUART_Init(RN2483_UART, &init);

    /* Enable pins at default location */
    RN2483_UART->ROUTE = LEUART_ROUTE_RXPEN | LEUART_ROUTE_TXPEN | RN2483_UART_LOC;

    /* Set RXDMAWU to wake up the DMA controller in EM2 */
    LEUART_RxDmaInEM2Enable(RN2483_UART, true);

    /* Clear previous RX interrupts */
    LEUART_IntClear(RN2483_UART, LEUART_IF_RXDATAV);
    NVIC_ClearPendingIRQ(LEUART0_IRQn);

    /* Finally enable it */
    LEUART_Enable(RN2483_UART, leuartEnable);
}

Variable Documentation

bufferPointer

volatile uint8_t bufferPointer = 0

Definition at line 79 of file leuart.c.

dmaCallBack

DMA_CB_TypeDef dmaCallBack[2]

static

Definition at line 77 of file leuart.c.

receiveBuffer

char receiveBuffer[50]

Definition at line 78 of file leuart.c.

receiveComplete

volatile bool receiveComplete = false

Definition at line 80 of file leuart.c.