lora-aprs/LoRa_APRS_iGate
1
0
Fork 0
mirror of https://github.com/lora-aprs/LoRa_APRS_iGate.git synced 2025-12-06 07:42:00 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #136 from lora-aprs/set_lna_max

Browse source 
set LNA to max
This commit is contained in:
Peter Buchegger 2021-12-20 11:30:54 +01:00 committed by GitHub
parent e4ac459810 f9935bfbef
commit 72fe5527f5
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
1 changed files with 96 additions and 138 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

178
lib/LoRa/LoRa.cpp
View file

@ -68,20 +68,12 @@
#define ISR_PREFIX #define ISR_PREFIX
#endif #endif
LoRaClass::LoRaClass() : LoRaClass::LoRaClass() : _spiSettings(LORA_DEFAULT_SPI_FREQUENCY, MSBFIRST, SPI_MODE0), _spi(&LORA_DEFAULT_SPI), _ss(LORA_DEFAULT_SS_PIN), _reset(LORA_DEFAULT_RESET_PIN), _dio0(LORA_DEFAULT_DIO0_PIN), _frequency(0), _packetIndex(0), _implicitHeaderMode(0) {
_spiSettings(LORA_DEFAULT_SPI_FREQUENCY, MSBFIRST, SPI_MODE0),
_spi(&LORA_DEFAULT_SPI),
_ss(LORA_DEFAULT_SS_PIN), _reset(LORA_DEFAULT_RESET_PIN), _dio0(LORA_DEFAULT_DIO0_PIN),
_frequency(0),
_packetIndex(0),
_implicitHeaderMode(0)
{
// overide Stream timeout value // overide Stream timeout value
setTimeout(0); setTimeout(0);
} }
int LoRaClass::begin(long frequency) int LoRaClass::begin(long frequency) {
{
#if defined(ARDUINO_SAMD_MKRWAN1300) || defined(ARDUINO_SAMD_MKRWAN1310) #if defined(ARDUINO_SAMD_MKRWAN1300) || defined(ARDUINO_SAMD_MKRWAN1310)
pinMode(LORA_IRQ_DUMB, OUTPUT); pinMode(LORA_IRQ_DUMB, OUTPUT);
digitalWrite(LORA_IRQ_DUMB, LOW); digitalWrite(LORA_IRQ_DUMB, LOW);
@ -134,7 +126,7 @@ int LoRaClass::begin(long frequency)
writeRegister(REG_FIFO_RX_BASE_ADDR, 0); writeRegister(REG_FIFO_RX_BASE_ADDR, 0);
// set LNA boost // set LNA boost
writeRegister(REG_LNA, readRegister(REG_LNA) | 0x03); writeRegister(REG_LNA, readRegister(REG_LNA) | 0x01);
// set auto AGC // set auto AGC
writeRegister(REG_MODEM_CONFIG_3, 0x04); writeRegister(REG_MODEM_CONFIG_3, 0x04);
@ -148,8 +140,7 @@ int LoRaClass::begin(long frequency)
return 1; return 1;
} }
void LoRaClass::end() void LoRaClass::end() {
{
// put in sleep mode // put in sleep mode
sleep(); sleep();
@ -157,8 +148,7 @@ void LoRaClass::end()
_spi->end(); _spi->end();
} }
int LoRaClass::beginPacket(int implicitHeader) int LoRaClass::beginPacket(int implicitHeader) {
{
if (isTransmitting()) { if (isTransmitting()) {
return 0; return 0;
} }
@ -179,8 +169,7 @@ int LoRaClass::beginPacket(int implicitHeader)
return 1; return 1;
} }
int LoRaClass::endPacket(bool async) int LoRaClass::endPacket(bool async) {
{
// put in TX mode // put in TX mode
writeRegister(REG_OP_MODE, MODE_LONG_RANGE_MODE | MODE_TX); writeRegister(REG_OP_MODE, MODE_LONG_RANGE_MODE | MODE_TX);
@ -197,8 +186,7 @@ int LoRaClass::endPacket(bool async)
return 1; return 1;
} }
bool LoRaClass::isTransmitting() bool LoRaClass::isTransmitting() {
{
if ((readRegister(REG_OP_MODE) & MODE_TX) == MODE_TX) { if ((readRegister(REG_OP_MODE) & MODE_TX) == MODE_TX) {
return true; return true;
} }
@ -211,8 +199,7 @@ bool LoRaClass::isTransmitting()
return false; return false;
} }
int LoRaClass::parsePacket(int size) int LoRaClass::parsePacket(int size) {
{
int packetLength = 0; int packetLength = 0;
int irqFlags = readRegister(REG_IRQ_FLAGS); int irqFlags = readRegister(REG_IRQ_FLAGS);
@ -256,18 +243,15 @@ int LoRaClass::parsePacket(int size)
return packetLength; return packetLength;
} }
int LoRaClass::packetRssi() int LoRaClass::packetRssi() {
{
return (readRegister(REG_PKT_RSSI_VALUE) - (_frequency < RF_MID_BAND_THRESHOLD ? RSSI_OFFSET_LF_PORT : RSSI_OFFSET_HF_PORT)); return (readRegister(REG_PKT_RSSI_VALUE) - (_frequency < RF_MID_BAND_THRESHOLD ? RSSI_OFFSET_LF_PORT : RSSI_OFFSET_HF_PORT));
} }
float LoRaClass::packetSnr() float LoRaClass::packetSnr() {
{
return ((int8_t)readRegister(REG_PKT_SNR_VALUE)) * 0.25; return ((int8_t)readRegister(REG_PKT_SNR_VALUE)) * 0.25;
} }
long LoRaClass::packetFrequencyError() long LoRaClass::packetFrequencyError() {
{
int32_t freqError = 0; int32_t freqError = 0;
freqError = static_cast<int32_t>(readRegister(REG_FREQ_ERROR_MSB) & B111); freqError = static_cast<int32_t>(readRegister(REG_FREQ_ERROR_MSB) & B111);
freqError <<= 8L; freqError <<= 8L;
@ -285,18 +269,15 @@ long LoRaClass::packetFrequencyError()
return static_cast<long>(fError); return static_cast<long>(fError);
} }
int LoRaClass::rssi() int LoRaClass::rssi() {
{
return (readRegister(REG_RSSI_VALUE) - (_frequency < RF_MID_BAND_THRESHOLD ? RSSI_OFFSET_LF_PORT : RSSI_OFFSET_HF_PORT)); return (readRegister(REG_RSSI_VALUE) - (_frequency < RF_MID_BAND_THRESHOLD ? RSSI_OFFSET_LF_PORT : RSSI_OFFSET_HF_PORT));
} }
size_t LoRaClass::write(uint8_t byte) size_t LoRaClass::write(uint8_t byte) {
{
return write(&byte, sizeof(byte)); return write(&byte, sizeof(byte));
} }
size_t LoRaClass::write(const uint8_t *buffer, size_t size) size_t LoRaClass::write(const uint8_t *buffer, size_t size) {
{
int currentLength = readRegister(REG_PAYLOAD_LENGTH); int currentLength = readRegister(REG_PAYLOAD_LENGTH);
// check size // check size
@ -315,13 +296,11 @@ size_t LoRaClass::write(const uint8_t *buffer, size_t size)
return size; return size;
} }
int LoRaClass::available() int LoRaClass::available() {
{
return (readRegister(REG_RX_NB_BYTES) - _packetIndex); return (readRegister(REG_RX_NB_BYTES) - _packetIndex);
} }
int LoRaClass::read() int LoRaClass::read() {
{
if (!available()) { if (!available()) {
return -1; return -1;
} }
@ -331,8 +310,7 @@ int LoRaClass::read()
return readRegister(REG_FIFO); return readRegister(REG_FIFO);
} }
int LoRaClass::peek() int LoRaClass::peek() {
{
if (!available()) { if (!available()) {
return -1; return -1;
} }
@ -349,12 +327,10 @@ int LoRaClass::peek()
return b; return b;
} }
void LoRaClass::flush() void LoRaClass::flush() {
{
} }
void LoRaClass::receive(int size) void LoRaClass::receive(int size) {
{
writeRegister(REG_DIO_MAPPING_1, 0x00); // DIO0 => RXDONE writeRegister(REG_DIO_MAPPING_1, 0x00); // DIO0 => RXDONE
@ -369,18 +345,15 @@ void LoRaClass::receive(int size)
writeRegister(REG_OP_MODE, MODE_LONG_RANGE_MODE | MODE_RX_CONTINUOUS); writeRegister(REG_OP_MODE, MODE_LONG_RANGE_MODE | MODE_RX_CONTINUOUS);
} }
void LoRaClass::idle() void LoRaClass::idle() {
{
writeRegister(REG_OP_MODE, MODE_LONG_RANGE_MODE | MODE_STDBY); writeRegister(REG_OP_MODE, MODE_LONG_RANGE_MODE | MODE_STDBY);
} }
void LoRaClass::sleep() void LoRaClass::sleep() {
{
writeRegister(REG_OP_MODE, MODE_LONG_RANGE_MODE | MODE_SLEEP); writeRegister(REG_OP_MODE, MODE_LONG_RANGE_MODE | MODE_SLEEP);
} }
void LoRaClass::setTxPower(int level, int outputPin) void LoRaClass::setTxPower(int level, int outputPin) {
{
if (PA_OUTPUT_RFO_PIN == outputPin) { if (PA_OUTPUT_RFO_PIN == outputPin) {
// RFO // RFO
if (level < 0) { if (level < 0) {
@ -416,8 +389,7 @@ void LoRaClass::setTxPower(int level, int outputPin)
} }
} }
void LoRaClass::setFrequency(long frequency) void LoRaClass::setFrequency(long frequency) {
{
_frequency = frequency; _frequency = frequency;
uint64_t frf = ((uint64_t)frequency << 19) / 32000000; uint64_t frf = ((uint64_t)frequency << 19) / 32000000;
@ -427,13 +399,11 @@ void LoRaClass::setFrequency(long frequency)
writeRegister(REG_FRF_LSB, (uint8_t)(frf >> 0)); writeRegister(REG_FRF_LSB, (uint8_t)(frf >> 0));
} }
int LoRaClass::getSpreadingFactor() int LoRaClass::getSpreadingFactor() {
{
return readRegister(REG_MODEM_CONFIG_2) >> 4; return readRegister(REG_MODEM_CONFIG_2) >> 4;
} }
void LoRaClass::setSpreadingFactor(int sf) void LoRaClass::setSpreadingFactor(int sf) {
{
if (sf < 6) { if (sf < 6) {
sf = 6; sf = 6;
} else if (sf > 12) { } else if (sf > 12) {
@ -452,28 +422,36 @@ void LoRaClass::setSpreadingFactor(int sf)
setLdoFlag(); setLdoFlag();
} }
long LoRaClass::getSignalBandwidth() long LoRaClass::getSignalBandwidth() {
{
byte bw = (readRegister(REG_MODEM_CONFIG_1) >> 4); byte bw = (readRegister(REG_MODEM_CONFIG_1) >> 4);
switch (bw) { switch (bw) {
case 0: return 7.8E3; case 0:
case 1: return 10.4E3; return 7.8E3;
case 2: return 15.6E3; case 1:
case 3: return 20.8E3; return 10.4E3;
case 4: return 31.25E3; case 2:
case 5: return 41.7E3; return 15.6E3;
case 6: return 62.5E3; case 3:
case 7: return 125E3; return 20.8E3;
case 8: return 250E3; case 4:
case 9: return 500E3; return 31.25E3;
case 5:
return 41.7E3;
case 6:
return 62.5E3;
case 7:
return 125E3;
case 8:
return 250E3;
case 9:
return 500E3;
} }
return -1; return -1;
} }
void LoRaClass::setSignalBandwidth(long sbw) void LoRaClass::setSignalBandwidth(long sbw) {
{
int bw; int bw;
if (sbw <= 7.8E3) { if (sbw <= 7.8E3) {
@ -502,8 +480,7 @@ void LoRaClass::setSignalBandwidth(long sbw)
setLdoFlag(); setLdoFlag();
} }
void LoRaClass::setLdoFlag() void LoRaClass::setLdoFlag() {
{
// Section 4.1.1.5 // Section 4.1.1.5
long symbolDuration = 1000 / (getSignalBandwidth() / (1L << getSpreadingFactor())); long symbolDuration = 1000 / (getSignalBandwidth() / (1L << getSpreadingFactor()));
@ -515,8 +492,7 @@ void LoRaClass::setLdoFlag()
writeRegister(REG_MODEM_CONFIG_3, config3); writeRegister(REG_MODEM_CONFIG_3, config3);
} }
void LoRaClass::setCodingRate4(int denominator) void LoRaClass::setCodingRate4(int denominator) {
{
if (denominator < 5) { if (denominator < 5) {
denominator = 5; denominator = 5;
} else if (denominator > 8) { } else if (denominator > 8) {
@ -528,41 +504,34 @@ void LoRaClass::setCodingRate4(int denominator)
writeRegister(REG_MODEM_CONFIG_1, (readRegister(REG_MODEM_CONFIG_1) & 0xf1) | (cr << 1)); writeRegister(REG_MODEM_CONFIG_1, (readRegister(REG_MODEM_CONFIG_1) & 0xf1) | (cr << 1));
} }
void LoRaClass::setPreambleLength(long length) void LoRaClass::setPreambleLength(long length) {
{
writeRegister(REG_PREAMBLE_MSB, (uint8_t)(length >> 8)); writeRegister(REG_PREAMBLE_MSB, (uint8_t)(length >> 8));
writeRegister(REG_PREAMBLE_LSB, (uint8_t)(length >> 0)); writeRegister(REG_PREAMBLE_LSB, (uint8_t)(length >> 0));
} }
void LoRaClass::setSyncWord(int sw) void LoRaClass::setSyncWord(int sw) {
{
writeRegister(REG_SYNC_WORD, sw); writeRegister(REG_SYNC_WORD, sw);
} }
void LoRaClass::enableCrc() void LoRaClass::enableCrc() {
{
writeRegister(REG_MODEM_CONFIG_2, readRegister(REG_MODEM_CONFIG_2) | 0x04); writeRegister(REG_MODEM_CONFIG_2, readRegister(REG_MODEM_CONFIG_2) | 0x04);
} }
void LoRaClass::disableCrc() void LoRaClass::disableCrc() {
{
writeRegister(REG_MODEM_CONFIG_2, readRegister(REG_MODEM_CONFIG_2) & 0xfb); writeRegister(REG_MODEM_CONFIG_2, readRegister(REG_MODEM_CONFIG_2) & 0xfb);
} }
void LoRaClass::enableInvertIQ() void LoRaClass::enableInvertIQ() {
{
writeRegister(REG_INVERTIQ, 0x66); writeRegister(REG_INVERTIQ, 0x66);
writeRegister(REG_INVERTIQ2, 0x19); writeRegister(REG_INVERTIQ2, 0x19);
} }
void LoRaClass::disableInvertIQ() void LoRaClass::disableInvertIQ() {
{
writeRegister(REG_INVERTIQ, 0x27); writeRegister(REG_INVERTIQ, 0x27);
writeRegister(REG_INVERTIQ2, 0x1d); writeRegister(REG_INVERTIQ2, 0x1d);
} }
void LoRaClass::setOCP(uint8_t mA) void LoRaClass::setOCP(uint8_t mA) {
{
uint8_t ocpTrim = 27; uint8_t ocpTrim = 27;
if (mA <= 120) { if (mA <= 120) {
@ -574,8 +543,7 @@ void LoRaClass::setOCP(uint8_t mA)
writeRegister(REG_OCP, 0x20 | (0x1F & ocpTrim)); writeRegister(REG_OCP, 0x20 | (0x1F & ocpTrim));
} }
void LoRaClass::setGain(uint8_t gain) void LoRaClass::setGain(uint8_t gain) {
{
// check allowed range // check allowed range
if (gain > 6) { if (gain > 6) {
gain = 6; gain = 6;
@ -593,37 +561,32 @@ void LoRaClass::setGain(uint8_t gain)
writeRegister(REG_MODEM_CONFIG_3, 0x00); writeRegister(REG_MODEM_CONFIG_3, 0x00);
// clear Gain and set LNA boost // clear Gain and set LNA boost
writeRegister(REG_LNA, 0x03); writeRegister(REG_LNA, 0x01);
// set gain // set gain
writeRegister(REG_LNA, readRegister(REG_LNA) | (gain << 5)); writeRegister(REG_LNA, readRegister(REG_LNA) | (gain << 5));
} }
} }
byte LoRaClass::random() byte LoRaClass::random() {
{
return readRegister(REG_RSSI_WIDEBAND); return readRegister(REG_RSSI_WIDEBAND);
} }
void LoRaClass::setPins(int ss, int reset, int dio0) void LoRaClass::setPins(int ss, int reset, int dio0) {
{
_ss = ss; _ss = ss;
_reset = reset; _reset = reset;
_dio0 = dio0; _dio0 = dio0;
} }
void LoRaClass::setSPI(SPIClass& spi) void LoRaClass::setSPI(SPIClass &spi) {
{
_spi = &spi; _spi = &spi;
} }
void LoRaClass::setSPIFrequency(uint32_t frequency) void LoRaClass::setSPIFrequency(uint32_t frequency) {
{
_spiSettings = SPISettings(frequency, MSBFIRST, SPI_MODE0); _spiSettings = SPISettings(frequency, MSBFIRST, SPI_MODE0);
} }
void LoRaClass::dumpRegisters(Stream& out) void LoRaClass::dumpRegisters(Stream &out) {
{
for (int i = 0; i < 128; i++) { for (int i = 0; i < 128; i++) {
out.print("0x"); out.print("0x");
out.print(i, HEX); out.print(i, HEX);
@ -632,32 +595,27 @@ void LoRaClass::dumpRegisters(Stream& out)
} }
} }
void LoRaClass::explicitHeaderMode() void LoRaClass::explicitHeaderMode() {
{
_implicitHeaderMode = 0; _implicitHeaderMode = 0;
writeRegister(REG_MODEM_CONFIG_1, readRegister(REG_MODEM_CONFIG_1) & 0xfe); writeRegister(REG_MODEM_CONFIG_1, readRegister(REG_MODEM_CONFIG_1) & 0xfe);
} }
void LoRaClass::implicitHeaderMode() void LoRaClass::implicitHeaderMode() {
{
_implicitHeaderMode = 1; _implicitHeaderMode = 1;
writeRegister(REG_MODEM_CONFIG_1, readRegister(REG_MODEM_CONFIG_1) | 0x01); writeRegister(REG_MODEM_CONFIG_1, readRegister(REG_MODEM_CONFIG_1) | 0x01);
} }
uint8_t LoRaClass::readRegister(uint8_t address) uint8_t LoRaClass::readRegister(uint8_t address) {
{
return singleTransfer(address & 0x7f, 0x00); return singleTransfer(address & 0x7f, 0x00);
} }
void LoRaClass::writeRegister(uint8_t address, uint8_t value) void LoRaClass::writeRegister(uint8_t address, uint8_t value) {
{
singleTransfer(address | 0x80, value); singleTransfer(address | 0x80, value);
} }
uint8_t LoRaClass::singleTransfer(uint8_t address, uint8_t value) uint8_t LoRaClass::singleTransfer(uint8_t address, uint8_t value) {
{
uint8_t response; uint8_t response;
digitalWrite(_ss, LOW); digitalWrite(_ss, LOW);