Air724ugLora/drv_periph/sx126x_driver.lua

--- 模块功能：sx126x模块驱动
-- 读取FLASH ID
-- @author openLuat
-- @module spi.testSpiFlash
-- @license MIT
-- @copyright openLuat
-- @release 2018.03.27

module(...,package.seeall)

require"utils"
require"pm"
pm.wake("wake11")
require"pins"
-- require "sx126x_reg"
require "Drv_spi"
require "sx126x_reg"

local SX126x = json.encode(sx126x_reg.SX126x_t)
local SX126xCopy,result,errinfo = json.decode(SX126x)
SX126x = nil
local ImageCalibrated = false

local FREQ_STEP = 0.95367431640625

local RadioPublicNetwork_t = {
    Previous = false,
    Current  = false
}

RadioPublicNetwork = RadioPublicNetwork_t

SX126xResetGPIO = pins.setup(pio.P0_13,0)
OperatingMode = sx126x_reg.RadioStandbyModes_t.STDBY_RC

function gsonLoginfo(data)
    local jsondata = json.encode(data)
    log.info("SX126xSetModulationParams.encode",jsondata)
end

-- 初始化SPI
function SX126xIoInit()
    Drv_spi.SPI_GPIO_Init()
end

-- 复位SX126x
function SX126xReset()
    sys.wait(10) 
    SX126xResetGPIO(0)
    sys.wait(20)
    SX126xResetGPIO(1)
    sys.wait(10) 
end

function SX126xWakeup()
    local command = sx126x_reg.RadioCommands.RADIO_GET_STATUS .. "00"
    local ret = Drv_spi.drv_spi_read_write_byte(command)
    log.info("SX126xWakeup",ret)
end

--命令写入 完成
function SX126xWriteCommand(command,buffer)
    local bufferTotal = ""
    for i, num in ipairs(buffer) do
        bufferTotal = bufferTotal .. num
    end
    Drv_spi.drv_spi_read_write_byte(command .. bufferTotal,0)
    -- 50
    -- sys.wait(20)
    -- Drv_spi.drv_spi_read_write_byte(bufferTotal,0)
    -- local ret = Drv_spi.drv_spi_read_write_byte("1d07400000",1);
    -- log.info("SX126xWriteCommand",Drv_spi.drv_spi_read_write_byte(bufferTotal,1))

end

function SX126xReadCommand(command,size)
    Drv_spi.drv_spi_read_write_byte(command,0)
    for i = 1, size do
        command = command .. "00"
    end
    -- Drv_spi.drv_spi_read_write_byte(command,0)
    log.info("SX126xReadCommand",Drv_spi.drv_spi_read_write_byte(command,size))
end
-- -----------------------------------------------SPI基础读写---------------------------------------------------
-- 读取寄存器 完成
function SX126xReadRegisters(address,size)
    Drv_spi.drv_spi_read_write_byte(sx126x_reg.RadioCommands.RADIO_READ_REGISTER,0)
    sys.wait(20)
    local sendData = address .. "00"
    local receiverDataCount= size

    while size > 0 do
        sendData = sendData .. "00"
        size = size - 1
    end

    local result = Drv_spi.drv_spi_read_write_byte(sendData,receiverDataCount)  --这里乘2的意思是，16进制是两位，但是转成字符串的形式就是4位了。

    log.info("SX126xReadRegisters",result)
    return result
end

--封装后的读寄存器
function SX126xReadRegister(address)
    local ret = SX126xReadRegisters(address,1)
    return ret
end

-- 写入寄存器
function SX126xWriteRegisters(address,buffer)
    local bufferTotal = ""
    Drv_spi.drv_spi_read_write_byte(sx126x_reg.RadioCommands.RADIO_WRITE_REGISTER,0)
    sys.wait(20)
    for i, data in ipairs(buffer) do
        bufferTotal = bufferTotal .. data
    end

    local test = address .. bufferTotal
    log.info("SX126xWriteRegisters",bufferTotal)
    Drv_spi.drv_spi_read_write_byte(test,0);
end

function SX126xWriteRegister(address,value)
    SX126xWriteRegisters( address,value);
end



function SX126xSetStandby(standbyConfig)
    SX126xWriteCommand(sx126x_reg.RadioCommands.RADIO_SET_STANDBY,{standbyConfig})
    -- log.info("SX126xSetStandby_操作模式",standbyConfig)

    if standbyConfig == sx126x_reg.RadioStandbyModes_t.STDBY_RC then
        OperatingMode = sx126x_reg.RadioStandbyModes_t.STDBY_RC
    else
        OperatingMode = sx126x_reg.RadioStandbyModes_t.STDBY_XOSC
    end
end

function SX126xSetRegulatorMode(mode)
    SX126xWriteCommand(sx126x_reg.RadioCommands.RADIO_SET_REGULATORMODE,{mode})
end

function SX126xSetBufferBaseAddress(txBaseAddress, rxBaseAddress)
    local buf = {txBaseAddress,rxBaseAddress}
    SX126xWriteCommand(sx126x_reg.RadioCommands.RADIO_SET_BUFFERBASEADDRESS,buf)
end

function SX126xSetPaConfig(paDutyCycle,hpMax,deviceSel,paLut)
    local buf = {paDutyCycle,hpMax,deviceSel,paLut}
    SX126xWriteCommand(sx126x_reg.RadioCommands.RADIO_SET_PACONFIG,buf)
    log.info("SX126xSetPaConfig",sx126x_reg.RadioCommands.RADIO_SET_PACONFIG)
end

function SX126xSetTxParams(power, rampTime)
    local buf = {power,rampTime}
    SX126xSetPaConfig("04","07","00","01")
    SX126xWriteRegister( sx126x_reg.REG_OCP, {"38"} )
    SX126xWriteCommand(sx126x_reg.RadioCommands.RADIO_SET_TXPARAMS,buf)

end

-- function SX126xSetDioIrqParams2222(timeout, freq, rfChain, power, preambleLen)
--     local buf = {timeout, freq, rfChain, power, preambleLen}
--     SX126xSetTxParams(power, sx126x_reg.RadioRampTimes_t.RADIO_RAMP_40_US)
--     SX126xWriteCommand(sx126x_reg.RadioCommands.RADIO_SET_TX,buf)
-- end


function SX126xSetDioIrqParams(irqMask, dio1Mask, dio2Mask, dio3Mask )
    local buf = {"02","02","02","02","00","00","00","00"}
    -- buf[2] = irqMask
    -- buf[4] = irqMask
    local jsondata = json.encode(buf)
    log.info("SX126xSetModulationParams.encode",jsondata)
    SX126xWriteCommand(sx126x_reg.RadioCommands.RADIO_CFG_DIOIRQ,buf)
end


function SX126xSetStopRxTimerOnPreambleDetect(enable)
    SX126xWriteCommand(sx126x_reg.RadioCommands.RADIO_SET_STOPRXTIMERONPREAMBLE,{enable})
end

function SX126xSetLoRaSymbNumTimeout(SymbNum)
    SX126xWriteCommand(sx126x_reg.RadioCommands.RADIO_SET_LORASYMBTIMEOUT,{SymbNum})
end

function SX126xSetPacketType(packetType)
    PacketType = packetType;
    SX126xWriteCommand( sx126x_reg.RadioCommands.RADIO_SET_PACKETTYPE,{PacketType})
    log.info("PacketType:",PacketType,sx126x_reg.RadioCommands.RADIO_SET_PACKETTYPE)
end

function RadioSetPublicNetwork(enable)
    SX126xSetPacketType(sx126x_reg.RadioPacketTypes_t.PACKET_TYPE_LORA)
    if enable == true then
        SX126xWriteRegister( sx126x_reg.REG_LR_SYNCWORD,{"07"});
        SX126xWriteRegister( sx126x_reg.REG_LR_SYNCWORD_LSB,{"40"});
    else
        SX126xWriteRegister( sx126x_reg.REG_LR_SYNCWORD, {"07"});
        SX126xWriteRegister( sx126x_reg.REG_LR_SYNCWORD_LSB, {"41"} );
    end
end


function RadioSetModem(modem)
    if modem == sx126x_reg.RadioModems_t.MODEM_FSK then
        -- 处理 FSK 调制的逻辑
        -- SX126xSetPacketType(sx126x_reg.RadioPacketTypes_t.PACKET_TYPE_GFSK)
    elseif modem == sx126x_reg.RadioModems_t.MODEM_LORA then
        SX126xSetPacketType(sx126x_reg.RadioPacketTypes_t.PACKET_TYPE_LORA)
        if RadioPublicNetwork.Current ~= RadioPublicNetwork.Previous then
            RadioPublicNetwork.Current = RadioPublicNetwork.Previous
            RadioSetPublicNetwork(RadioPublicNetwork.Current)
        end
    else
        -- 处理未知调制类型的逻辑
        print("错误：未知的调制类型")
    end
end  -- 增加了函数结束标记

function SX126xSetModulationParams(modulationParams)
    buf = {modulationParams.Params.LoRa.SpreadingFactor, 
    modulationParams.Params.LoRa.Bandwidth,
    modulationParams.Params.LoRa.CodingRate, 
    modulationParams.Params.LoRa.LowDatarateOptimize
    }
    local jsondata = json.encode(buf)
    log.info("SX126xSetModulationParams.encode",jsondata)
    SX126xWriteCommand( sx126x_reg.RadioCommands.RADIO_SET_MODULATIONPARAMS,buf);
end


function SX126xSetPacketParams(packetParams)
    buf = { "00",
            packetParams.Params.LoRa.PreambleLength, 
            packetParams.Params.LoRa.HeaderType, 
            packetParams.Params.LoRa.PayloadLength, 
            packetParams.Params.LoRa.CrcMode, 
            packetParams.Params.LoRa.InvertIQ}
    local jsondata = json.encode(buf)
    log.info("SX126xSetPacketParams.encode",jsondata)
    SX126xWriteCommand(sx126x_reg.RadioCommands.RADIO_SET_PACKETPARAMS,buf);
end

--[[
        modem : sx126x_reg.RadioModems_t.MODEM_LORA
        power : 22 = 16
        fdev  : 0  = 0
        bandwidth : 2
        datarate : 11
        coderate : 1
        preambleLen : 12
        fixLen : false
        crcOn : true
        freqHopOn : false
        hopPeriod : 0
        iqInverted : 0
        timeout : 3000
]]
--                   MODEM_LORA  16    0       1       7      1           12      false    true    false       0        0         3000
function RadioSetTxConfig(modem,power,fdev,bandwidth,datarate,coderate,preambleLen,fixLen,crcOn,freqHopOn,hopPeriod,iqInverted,timeout)
    SX126xSetStopRxTimerOnPreambleDetect("00")  -- = flase
    SX126xSetLoRaSymbNumTimeout("00")
    SX126xCopy.ModulationParams.PacketType = sx126x_reg.RadioPacketTypes_t.PACKET_TYPE_LORA

	SX126xCopy.ModulationParams.Params.LoRa.SpreadingFactor = string.format("%02X", datarate)
	SX126xCopy.ModulationParams.Params.LoRa.Bandwidth =  "05"
	SX126xCopy.ModulationParams.Params.LoRa.CodingRate= coderate

    -- if ( (bandwidth == 0) and ( (datarate == 11) or (datarate == 12) ) ) or ( (bandwidth == 1) and (datarate == 12) ) then
    --     SX126xCopy.ModulationParams.Params.LoRa.LowDatarateOptimize = 0x01
    -- else
    --     SX126xCopy.ModulationParams.Params.LoRa.LowDatarateOptimize = 0x00
    -- end
    SX126xCopy.ModulationParams.Params.LoRa.LowDatarateOptimize = "00"


    
    SX126xCopy.PacketParams.PacketType = sx126x_reg.RadioPacketTypes_t.PACKET_TYPE_LORA

    SX126xCopy.PacketParams.Params.LoRa.PreambleLength = preambleLen

    SX126xCopy.PacketParams.Params.LoRa.HeaderType = fixLen
	SX126xCopy.PacketParams.Params.LoRa.PayloadLength = "FF"
	SX126xCopy.PacketParams.Params.LoRa.CrcMode = crcOn
	SX126xCopy.PacketParams.Params.LoRa.InvertIQ = iqInverted
    -- gsonLoginfo("SX126xCopy",SX126xCopy.PacketParams.Params.LoRa)

    SX126xSetStandby(sx126x_reg.RadioStandbyModes_t.STDBY_RC)
    RadioSetModem(sx126x_reg.RadioModems_t.MODEM_LORA)
    SX126xSetModulationParams(SX126xCopy.ModulationParams)
    SX126xSetPacketParams(SX126xCopy.PacketParams)
    SX126xSetTxParams(power,sx126x_reg.RadioRampTimes_t.RADIO_RAMP_40_US)
end

function SX126xCalibrateImage(freq)
    local calFreq = {}

    if freq > 900000000 then
        calFreq = {"E1", "E9"}
    elseif freq > 850000000 then
        calFreq = {"D7", "D8"}
    elseif freq > 770000000 then
        calFreq = {"C1", "C5"}
    elseif freq > 460000000 then
        calFreq = {"75", "81"}
    elseif freq > 425000000 then
        calFreq = {"6B", "6F"}
    elseif freq >= 210000000 then
        calFreq = {"37", "41"}
    end

    SX126xWriteCommand(sx126x_reg.RadioCommands.RADIO_CALIBRATEIMAGE, calFreq)
end


function SX126xSetRfFrequency(frequency)
    
    local buf = {}
    local freq = 0

    if ImageCalibrated == false then
        SX126xCalibrateImage(frequency)
        ImageCalibrated = true
    end
    -- local FREQ_STEP = 0.95367431640625

    freq = frequency / FREQ_STEP
    
    log.info("freq", freq)
    log.info("freq", string.format("%02X", freq))
    SX126xWriteCommand( sx126x_reg.RadioCommands.RADIO_SET_RFFREQUENCY, {string.format("%02X", freq)});
end

function RadioSetChannel(frequency) 
    SX126xSetRfFrequency(frequency)
end

function SX126xWriteBuffer(offset, buffer,size) 
    log.info("SX126xWriteBuffer",offset,buffer,size)
    local sentdata = offset .. buffer
    Drv_spi.drv_spi_read_write_byte(sx126x_reg.RadioCommands.RADIO_WRITE_BUFFER,0)
    Drv_spi.drv_spi_read_write_byte(sentdata,10)

end

function SX126xSetPayload (payload,size)
    log.info("SX126xSetPayload",payload,size)
    SX126xWriteBuffer( "00", payload, size );
end

function SX126xSetTx(timeout) 
    SX126xWriteCommand( sx126x_reg.RadioCommands.RADIO_SET_TX, {timeout});
end


function SX126xSendPayload(payload,size,timeout) 
    log.info("SX126xSendPayload",payload,size,timeout)
    SX126xSetPayload( payload, size );
    SX126xSetTx( timeout );
end

function RadioSend(buffer,size,time_out) 
    log.info("RadioSend",buffer,size,time_out)
    SX126xCopy.PacketParams.Params.LoRa.PayloadLength = size
    SX126xSetPacketParams(SX126xCopy.PacketParams)
    SX126xSendPayload(buffer,size,time_out)
end


-- 初始化SX126x
function SX126xInit()
    SX126xIoInit()
    SX126xReset()
    SX126xWakeup()
    -- local table = {sx126x_reg.RadioStandbyModes_t.STDBY_RC}
    SX126xSetStandby(sx126x_reg.RadioStandbyModes_t.STDBY_RC)
    -- local table1 = {sx126x_reg.RadioStandbyModes_t.USE_DCDC}
    SX126xSetRegulatorMode(sx126x_reg.RadioStandbyModes_t.USE_DCDC)
    SX126xSetBufferBaseAddress("00","00")
    SX126xSetTxParams( "00", sx126x_reg.RadioRampTimes_t.RADIO_RAMP_200_US )
    SX126xSetDioIrqParams( sx126x_reg.RadioIrqMasks_t.IRQ_RADIO_ALL, sx126x_reg.RadioIrqMasks_t.IRQ_RADIO_ALL, sx126x_reg.RadioIrqMasks_t.IRQ_RADIO_NONE, sx126x_reg.RadioIrqMasks_t.IRQ_RADIO_NONE )

    -- -- local table2 = {sx126x_reg.RadioStandbyModes_t.STDBY_RC}
    SX126xSetStandby(sx126x_reg.RadioStandbyModes_t.STDBY_RC)

    sys.wait(2000)
    RadioSetTxConfig(sx126x_reg.RadioModems_t.MODEM_LORA,"16",0,1,7,"01","0c","00","01","00","00","00",3000)

    log.info("RadioSetTxConfig",string.format("%02X", 433000000))
    RadioSetChannel(433000000) 
end

sys.taskInit(function ()
    sys.wait(5000)
    SX126xInit()
    sys.wait(2000)
    while true do
        -- log.info("testSpiFlash.readFlashID",spi.send_recv(spi.SPI_1,s):toHex())--收发读写

        --下面方法和上面的等价
        -- spi.send(spi.SPI_1,string.char(0x1d,0x07,0x40,0x00,0x00,0x00))
        -- sys.wait(5)
        -- log.info("testSpiFlash.readFlashID",spi.recv(spi.SPI_1,8):toHex())--收数据

        -- local ret = Drv_spi.drv_spi_read_write_byte("1D",1)
        -- log.info("testSpiFlash.readFlashID",ret)
        -- sys.wait(20)
        -- local ret = Drv_spi.drv_spi_read_write_byte("07400000",1)
        -- log.info("testSpiFlash.readFlashID",ret)

        -- SX126xWriteCommand("1d",{"0740"})
        -- SX126xWriteRegister("0740",{string.format("%02X", i),string.format("%02X", i+1)})
        -- log.info("计算结果0740寄存器", SX126xReadRegister("0740"))
        -- log.info("计算结果0741寄存器", SX126xReadRegister("0741"))
        -- SX126xWriteCommand("1d",{"07400000"})
    
        -- sys.wait(20)
        log.info("计算结果")
        -- SX126xSetStandby(sx126x_reg.RadioStandbyModes_t.STDBY_RC)
        -- SX126xReadCommand(sx126x_reg.RadioCommands.RADIO_GET_STATUS,1)
        -- sys.wait(20)
        RadioSend("A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5A5","1e","00")
        -- sys.wait(20)
        -- SX126xReadCommand(sx126x_reg.RadioCommands.RADIO_GET_STATUS,1)
        -- SX126xWakeup()
        sys.wait(1000)
    end
    spi.close(spi.SPI_1)
end)