CaryCoders / AS3935

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Dependents:   zeus

Fork of AS3935 by valentin spanu

AS3935.cpp@15:afbf7ba667e7, 2015-12-14 (annotated)

Committer:
cmkachur
Date:
Mon Dec 14 22:18:11 2015 +0000
Revision:
15:afbf7ba667e7
Parent:
12:ac6ba62a31c6 
Read energy registers per the data sheet.

Who changed what in which revision?

UserRevisionLine numberNew contents of line
casper 0:346c723cac97 1 /*
casper 0:346c723cac97 2 AS3935.cpp - AS3935 Franklin Lightning Sensor™ IC by AMS library
casper 0:346c723cac97 3 Copyright (c) 2012 Raivis Rengelis (raivis [at] rrkb.lv). All rights reserved.
casper 0:346c723cac97 4 Porté sur MBED par Valentin, version I2C
casper 0:346c723cac97 5
casper 0:346c723cac97 6 This library is free software; you can redistribute it and/or
casper 0:346c723cac97 7 modify it under the terms of the GNU Lesser General Public
casper 0:346c723cac97 8 License as published by the Free Software Foundation; either
casper 0:346c723cac97 9 version 3 of the License, or (at your option) any later version.
casper 0:346c723cac97 10
casper 0:346c723cac97 11 This library is distributed in the hope that it will be useful,
casper 0:346c723cac97 12 but WITHOUT ANY WARRANTY; without even the implied warranty of
casper 0:346c723cac97 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
casper 0:346c723cac97 14 Lesser General Public License for more details.
casper 0:346c723cac97 15
casper 0:346c723cac97 16 You should have received a copy of the GNU Lesser General Public
casper 0:346c723cac97 17 License along with this library; if not, write to the Free Software
casper 0:346c723cac97 18 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
casper 0:346c723cac97 19 */
casper 0:346c723cac97 20
ftagius 1:f2d9ed33c276 21 #include "AS3935.h"
ftagius 1:f2d9ed33c276 22 #include "pinmap.h"
casper 0:346c723cac97 23
cmkachur 7:0d2586164d5b 24 unsigned long sgIntrPulseCount = 0;
cmkachur 7:0d2586164d5b 25
cmkachur 7:0d2586164d5b 26
ftagius 3:c536a9aa2a1c 27 AS3935::AS3935(PinName mosi, PinName miso, PinName sclk, PinName cs, const char* name, int hz) : m_Spi(mosi, miso, sclk), m_Cs(cs, 1), m_FREQ(hz)
ftagius 1:f2d9ed33c276 28 {
ftagius 1:f2d9ed33c276 29
ftagius 1:f2d9ed33c276 30 //Enable the internal pull-up resistor on MISO
ftagius 1:f2d9ed33c276 31 pin_mode(miso, PullUp);
ftagius 1:f2d9ed33c276 32
ftagius 1:f2d9ed33c276 33 //Configure the SPI bus
ftagius 1:f2d9ed33c276 34 m_Spi.format(8, 1);
ftagius 3:c536a9aa2a1c 35 printf("spi bus frequency set to %d hz\r\n",hz);
ftagius 3:c536a9aa2a1c 36 m_Spi.frequency(hz);
ftagius 3:c536a9aa2a1c 37
ftagius 1:f2d9ed33c276 38 }
ftagius 1:f2d9ed33c276 39
ftagius 1:f2d9ed33c276 40 char AS3935::_SPITransfer2(char high, char low)
ftagius 1:f2d9ed33c276 41 {
ftagius 1:f2d9ed33c276 42 m_Cs = 0;
ftagius 1:f2d9ed33c276 43 m_Spi.write(high);
ftagius 1:f2d9ed33c276 44 char regval = m_Spi.write(low);
ftagius 1:f2d9ed33c276 45 m_Cs = 1;
ftagius 1:f2d9ed33c276 46 return regval;
ftagius 1:f2d9ed33c276 47 }
ftagius 1:f2d9ed33c276 48
casper 0:346c723cac97 49 char AS3935::_rawRegisterRead(char reg)
casper 0:346c723cac97 50 {
ftagius 1:f2d9ed33c276 51 return _SPITransfer2((reg & 0x3F) | 0x40, 0);
casper 0:346c723cac97 52 }
casper 0:346c723cac97 53
ftagius 1:f2d9ed33c276 54
casper 0:346c723cac97 55 char AS3935::_ffsz(char mask)
casper 0:346c723cac97 56 {
casper 0:346c723cac97 57 char i = 0;
ftagius 2:3b3b435ca8d9 58
casper 0:346c723cac97 59 while(!(mask & 1)) {
ftagius 2:3b3b435ca8d9 60 mask >>= 1;
casper 0:346c723cac97 61 i++;
casper 0:346c723cac97 62 }
ftagius 2:3b3b435ca8d9 63
casper 0:346c723cac97 64 return i;
casper 0:346c723cac97 65 }
casper 0:346c723cac97 66
casper 0:346c723cac97 67 void AS3935::registerWrite(char reg, char mask, char data)
casper 0:346c723cac97 68 {
ftagius 1:f2d9ed33c276 69
casper 0:346c723cac97 70 char regval;
casper 0:346c723cac97 71 regval = _rawRegisterRead(reg);
casper 0:346c723cac97 72 regval &= ~(mask);
ftagius 2:3b3b435ca8d9 73 regval |= (data << (_ffsz(mask)));
ftagius 1:f2d9ed33c276 74 m_Cs = 0;
ftagius 1:f2d9ed33c276 75 m_Spi.write(reg);
ftagius 1:f2d9ed33c276 76 m_Spi.write(regval);
ftagius 5:28311803e23d 77 //printf("raw transfer for reg %x is 0x%02x\r\n", reg, regval);
ftagius 1:f2d9ed33c276 78 m_Cs = 1;
ftagius 1:f2d9ed33c276 79 wait_ms(2);
casper 0:346c723cac97 80 }
casper 0:346c723cac97 81
casper 0:346c723cac97 82 char AS3935::registerRead(char reg, char mask)
ftagius 1:f2d9ed33c276 83 {
casper 0:346c723cac97 84 char regval;
casper 0:346c723cac97 85 regval = _rawRegisterRead(reg);
ftagius 1:f2d9ed33c276 86 // printf("raw regval is 0x%02x\r\n", regval);
casper 0:346c723cac97 87 regval = regval & mask;
ftagius 1:f2d9ed33c276 88 regval >>= (_ffsz(mask));
casper 0:346c723cac97 89 return regval;
casper 0:346c723cac97 90 }
cmkachur 11:ee2e7a573227 91
ftagius 4:ab1f1b65468b 92 void AS3935::presetDefault()
ftagius 4:ab1f1b65468b 93 {
ftagius 4:ab1f1b65468b 94 m_Cs = 0;
ftagius 4:ab1f1b65468b 95 m_Spi.write(0x3C);
ftagius 4:ab1f1b65468b 96 m_Spi.write(0x96);
ftagius 4:ab1f1b65468b 97 m_Cs = 1;
ftagius 4:ab1f1b65468b 98 wait_ms(2);
ftagius 4:ab1f1b65468b 99 }
ftagius 4:ab1f1b65468b 100
ftagius 4:ab1f1b65468b 101 void AS3935::init()
ftagius 4:ab1f1b65468b 102 {
ftagius 4:ab1f1b65468b 103 presetDefault();
ftagius 4:ab1f1b65468b 104 registerWrite(AS3935_WDTH, 0x04); // set WDTH level to 4
ftagius 4:ab1f1b65468b 105 }
ftagius 4:ab1f1b65468b 106
casper 0:346c723cac97 107 void AS3935::powerDown()
ftagius 1:f2d9ed33c276 108 {
casper 0:346c723cac97 109 registerWrite(AS3935_PWD,1);
ftagius 1:f2d9ed33c276 110 }
casper 0:346c723cac97 111
ftagius 5:28311803e23d 112
cmkachur 11:ee2e7a573227 113
casper 0:346c723cac97 114 int AS3935::interruptSource()
ftagius 2:3b3b435ca8d9 115 {
casper 0:346c723cac97 116 return registerRead(AS3935_INT);
ftagius 2:3b3b435ca8d9 117 }
casper 0:346c723cac97 118
casper 0:346c723cac97 119 void AS3935::disableDisturbers()
ftagius 2:3b3b435ca8d9 120 {
casper 0:346c723cac97 121 registerWrite(AS3935_MASK_DIST,1);
ftagius 2:3b3b435ca8d9 122 }
casper 0:346c723cac97 123
casper 0:346c723cac97 124 void AS3935::enableDisturbers()
ftagius 2:3b3b435ca8d9 125 {
casper 0:346c723cac97 126 registerWrite(AS3935_MASK_DIST,0);
ftagius 2:3b3b435ca8d9 127 }
casper 0:346c723cac97 128
casper 0:346c723cac97 129 int AS3935::getMinimumLightnings()
ftagius 2:3b3b435ca8d9 130 {
casper 0:346c723cac97 131 return registerRead(AS3935_MIN_NUM_LIGH);
ftagius 2:3b3b435ca8d9 132 }
casper 0:346c723cac97 133
casper 0:346c723cac97 134 int AS3935::setMinimumLightnings(int minlightning)
ftagius 2:3b3b435ca8d9 135 {
casper 0:346c723cac97 136 registerWrite(AS3935_MIN_NUM_LIGH,minlightning);
casper 0:346c723cac97 137 return getMinimumLightnings();
ftagius 2:3b3b435ca8d9 138 }
casper 0:346c723cac97 139
casper 0:346c723cac97 140 int AS3935::lightningDistanceKm()
ftagius 2:3b3b435ca8d9 141 {
casper 0:346c723cac97 142 return registerRead(AS3935_DISTANCE);
ftagius 2:3b3b435ca8d9 143 }
casper 0:346c723cac97 144
casper 0:346c723cac97 145 void AS3935::setIndoors()
ftagius 2:3b3b435ca8d9 146 {
casper 0:346c723cac97 147 registerWrite(AS3935_AFE_GB,AS3935_AFE_INDOOR);
ftagius 2:3b3b435ca8d9 148 }
casper 0:346c723cac97 149
ftagius 6:c9b9e7d3bced 150 int AS3935::getGain()
ftagius 6:c9b9e7d3bced 151 {
ftagius 6:c9b9e7d3bced 152 return registerRead(AS3935_AFE_GB);
ftagius 6:c9b9e7d3bced 153 }
ftagius 6:c9b9e7d3bced 154
casper 0:346c723cac97 155 void AS3935::setOutdoors()
ftagius 2:3b3b435ca8d9 156 {
casper 0:346c723cac97 157 registerWrite(AS3935_AFE_GB,AS3935_AFE_OUTDOOR);
ftagius 2:3b3b435ca8d9 158 }
casper 0:346c723cac97 159
casper 0:346c723cac97 160 int AS3935::getNoiseFloor()
ftagius 2:3b3b435ca8d9 161 {
casper 0:346c723cac97 162 return registerRead(AS3935_NF_LEV);
ftagius 2:3b3b435ca8d9 163 }
casper 0:346c723cac97 164
casper 0:346c723cac97 165 int AS3935::setNoiseFloor(int noisefloor)
ftagius 2:3b3b435ca8d9 166 {
casper 0:346c723cac97 167 registerWrite(AS3935_NF_LEV,noisefloor);
casper 0:346c723cac97 168 return getNoiseFloor();
ftagius 2:3b3b435ca8d9 169 }
casper 0:346c723cac97 170
casper 0:346c723cac97 171 int AS3935::getSpikeRejection()
ftagius 2:3b3b435ca8d9 172 {
casper 0:346c723cac97 173 return registerRead(AS3935_SREJ);
ftagius 2:3b3b435ca8d9 174 }
casper 0:346c723cac97 175
casper 0:346c723cac97 176 int AS3935::setSpikeRejection(int srej)
ftagius 2:3b3b435ca8d9 177 {
casper 0:346c723cac97 178 registerWrite(AS3935_SREJ, srej);
casper 0:346c723cac97 179 return getSpikeRejection();
ftagius 2:3b3b435ca8d9 180 }
casper 0:346c723cac97 181
casper 0:346c723cac97 182 int AS3935::getWatchdogThreshold()
ftagius 2:3b3b435ca8d9 183 {
casper 0:346c723cac97 184 return registerRead(AS3935_WDTH);
ftagius 2:3b3b435ca8d9 185 }
casper 0:346c723cac97 186
casper 0:346c723cac97 187 int AS3935::setWatchdogThreshold(int wdth)
ftagius 2:3b3b435ca8d9 188 {
casper 0:346c723cac97 189 registerWrite(AS3935_WDTH,wdth);
casper 0:346c723cac97 190 return getWatchdogThreshold();
ftagius 2:3b3b435ca8d9 191 }
casper 0:346c723cac97 192
casper 0:346c723cac97 193 int AS3935::getTuneCap()
ftagius 2:3b3b435ca8d9 194 {
casper 0:346c723cac97 195 return registerRead(AS3935_TUN_CAP);
ftagius 2:3b3b435ca8d9 196 }
casper 0:346c723cac97 197
casper 0:346c723cac97 198 int AS3935::setTuneCap(int cap)
ftagius 2:3b3b435ca8d9 199 {
casper 0:346c723cac97 200 registerWrite(AS3935_TUN_CAP,cap);
ftagius 2:3b3b435ca8d9 201 return getTuneCap();
ftagius 2:3b3b435ca8d9 202 }
casper 0:346c723cac97 203
casper 0:346c723cac97 204 void AS3935::clearStats()
ftagius 2:3b3b435ca8d9 205 {
casper 0:346c723cac97 206 registerWrite(AS3935_CL_STAT,1);
casper 0:346c723cac97 207 registerWrite(AS3935_CL_STAT,0);
casper 0:346c723cac97 208 registerWrite(AS3935_CL_STAT,1);
ftagius 3:c536a9aa2a1c 209 }
cmkachur 9:19a323b1c508 210
cmkachur 9:19a323b1c508 211 static void intrPulseCntr(void) {sgIntrPulseCount++;}
ftagius 3:c536a9aa2a1c 212
cmkachur 9:19a323b1c508 213 int AS3935::calibrateRCOs (InterruptIn &intrIn)
ftagius 3:c536a9aa2a1c 214 {
ftagius 3:c536a9aa2a1c 215 int rc;
ftagius 3:c536a9aa2a1c 216 uint8_t trco;
ftagius 3:c536a9aa2a1c 217 uint8_t srco;
cmkachur 9:19a323b1c508 218 Timer pulseTimer;
cmkachur 9:19a323b1c508 219 int timeNow;
cmkachur 9:19a323b1c508 220 unsigned long measFreq;
cmkachur 9:19a323b1c508 221
cmkachur 9:19a323b1c508 222 intrIn.rise(intrPulseCntr);
cmkachur 9:19a323b1c508 223
cmkachur 9:19a323b1c508 224 _SPITransfer2(0x3D, 0x96); // send command to calibrate the internal RC oscillators
cmkachur 12:ac6ba62a31c6 225 registerWrite(AS3935_DISP_TRCO, 1); // put TRCO on the IRQ line for measurement
cmkachur 9:19a323b1c508 226 wait_ms(20); // wait for the chip to output the frequency, ususally ~2 ms
ftagius 5:28311803e23d 227
cmkachur 9:19a323b1c508 228 pulseTimer.reset();
cmkachur 9:19a323b1c508 229 pulseTimer.start();
cmkachur 9:19a323b1c508 230 sgIntrPulseCount = 0; // reset the interrupt counter which serves as our frequency\pulse counter
cmkachur 9:19a323b1c508 231
cmkachur 9:19a323b1c508 232 timeNow = 0;
cmkachur 9:19a323b1c508 233 while (timeNow < 500) // wait for 0.5 seconds
cmkachur 9:19a323b1c508 234 {
cmkachur 9:19a323b1c508 235 timeNow = pulseTimer.read_ms();
cmkachur 9:19a323b1c508 236 }
cmkachur 12:ac6ba62a31c6 237
cmkachur 12:ac6ba62a31c6 238 registerWrite(AS3935_DISP_TRCO, 0); // stop the output of the frequncy on IRQ line
cmkachur 9:19a323b1c508 239 measFreq = sgIntrPulseCount << 1; // calculate the measure frequency based upon period of capture and freq scaler
cmkachur 9:19a323b1c508 240
cmkachur 9:19a323b1c508 241 printf("timer RCO: %ld Hz\n\r", measFreq);
cmkachur 9:19a323b1c508 242
cmkachur 12:ac6ba62a31c6 243 trco=registerRead(0x3A, 0x80); // Read out Calibration of TRCO done
cmkachur 12:ac6ba62a31c6 244 srco=registerRead(0x3B, 0x80); // Readout Calibration of SRCO done
ftagius 3:c536a9aa2a1c 245 if(trco != 0x00 && srco != 0x00)
ftagius 3:c536a9aa2a1c 246 {
ftagius 3:c536a9aa2a1c 247 rc = 1;
ftagius 3:c536a9aa2a1c 248 printf("cal is done\r\n");
ftagius 3:c536a9aa2a1c 249 }
ftagius 3:c536a9aa2a1c 250 else
ftagius 3:c536a9aa2a1c 251 {
ftagius 3:c536a9aa2a1c 252 printf("cal is not done\r\n");
ftagius 3:c536a9aa2a1c 253 rc = 0;
ftagius 3:c536a9aa2a1c 254 }
ftagius 3:c536a9aa2a1c 255
ftagius 3:c536a9aa2a1c 256 return rc;
ftagius 3:c536a9aa2a1c 257 }
cmkachur 7:0d2586164d5b 258
cmkachur 7:0d2586164d5b 259
cmkachur 7:0d2586164d5b 260 unsigned long AS3935::tuneAntenna(InterruptIn &intrIn)
cmkachur 7:0d2586164d5b 261 {
cmkachur 7:0d2586164d5b 262 #define ANTENA_RES_FREQ (unsigned long)500000
cmkachur 7:0d2586164d5b 263 Timer pulseTimer;
cmkachur 7:0d2586164d5b 264 int timeNow;
cmkachur 7:0d2586164d5b 265 unsigned long measFreq;
cmkachur 7:0d2586164d5b 266 unsigned long measFreqBest = 0;
cmkachur 7:0d2586164d5b 267 unsigned char tunCapCnt = 0;
cmkachur 7:0d2586164d5b 268 unsigned char tunCapBest = 0;
cmkachur 7:0d2586164d5b 269 unsigned long minError = ANTENA_RES_FREQ;
cmkachur 7:0d2586164d5b 270 unsigned long error;
cmkachur 7:0d2586164d5b 271
cmkachur 7:0d2586164d5b 272 intrIn.rise(intrPulseCntr);
cmkachur 9:19a323b1c508 273 _SPITransfer2(3, 0x80); // set frequency division to 64
cmkachur 7:0d2586164d5b 274
cmkachur 7:0d2586164d5b 275 for (tunCapCnt = 0; tunCapCnt < 16; ++tunCapCnt) // loop for all possible values of the tuning capacitor
cmkachur 7:0d2586164d5b 276 {
cmkachur 7:0d2586164d5b 277 _SPITransfer2(8, 0x80+tunCapCnt); // set the tuning cap and have the frequency output to the IRQ line
cmkachur 7:0d2586164d5b 278 wait_ms(20); // wait for the chip to output the frequency, ususally ~2 ms
cmkachur 7:0d2586164d5b 279
cmkachur 7:0d2586164d5b 280 pulseTimer.reset();
cmkachur 7:0d2586164d5b 281 pulseTimer.start();
cmkachur 7:0d2586164d5b 282 sgIntrPulseCount = 0; // reset the interrupt counter which serves as our frequency\pulse counter
cmkachur 7:0d2586164d5b 283
cmkachur 7:0d2586164d5b 284 timeNow = 0;
cmkachur 7:0d2586164d5b 285 while (timeNow < 500) // wait for 0.5 seconds
cmkachur 7:0d2586164d5b 286 {
cmkachur 7:0d2586164d5b 287 timeNow = pulseTimer.read_ms();
cmkachur 7:0d2586164d5b 288 }
cmkachur 12:ac6ba62a31c6 289
cmkachur 7:0d2586164d5b 290 _SPITransfer2(8, 0x00); // stop the output of the frequncy on IRQ line
cmkachur 7:0d2586164d5b 291
cmkachur 7:0d2586164d5b 292 measFreq = sgIntrPulseCount << 7; // calulate the measure frequency based upon period of capture and freq scaler
cmkachur 7:0d2586164d5b 293
cmkachur 7:0d2586164d5b 294 if (measFreq < ANTENA_RES_FREQ) // calculate error between actual and desired frequency
cmkachur 7:0d2586164d5b 295 error = ANTENA_RES_FREQ - measFreq;
cmkachur 7:0d2586164d5b 296 else
cmkachur 7:0d2586164d5b 297 error = measFreq - ANTENA_RES_FREQ;
cmkachur 7:0d2586164d5b 298
cmkachur 7:0d2586164d5b 299 if (error < minError) // update the best capacitor tuning so far
cmkachur 7:0d2586164d5b 300 {
cmkachur 7:0d2586164d5b 301 tunCapBest = tunCapCnt;
cmkachur 7:0d2586164d5b 302 minError = error;
cmkachur 7:0d2586164d5b 303 measFreqBest = measFreq;
cmkachur 7:0d2586164d5b 304 }
cmkachur 7:0d2586164d5b 305
cmkachur 7:0d2586164d5b 306 printf("sgIntrCount[%ld] measFreq[%ld] timeNow[%ld] tunCapBest[%d]\n\r", sgIntrPulseCount, measFreq, timeNow, tunCapBest);
cmkachur 7:0d2586164d5b 307 }
cmkachur 7:0d2586164d5b 308 setTuneCap(tunCapBest); // 500kHz); // set the best capacitor tuning that was found
cmkachur 7:0d2586164d5b 309 return measFreqBest;
cmkachur 7:0d2586164d5b 310 }
cmkachur 7:0d2586164d5b 311
cmkachur 15:afbf7ba667e7 312
cmkachur 15:afbf7ba667e7 313 void AS3935::_rawRegisterRead(unsigned char reg, unsigned char mask, unsigned char *rxBuff, unsigned char numBytes)
cmkachur 15:afbf7ba667e7 314 {
cmkachur 15:afbf7ba667e7 315 mask = mask; // unused
cmkachur 15:afbf7ba667e7 316
cmkachur 15:afbf7ba667e7 317 m_Cs = 0;
cmkachur 15:afbf7ba667e7 318 m_Spi.write((reg & 0x3F) | 0x40);
cmkachur 15:afbf7ba667e7 319
cmkachur 15:afbf7ba667e7 320 for (unsigned char idx = 0; idx < numBytes; ++idx)
cmkachur 15:afbf7ba667e7 321 {
cmkachur 15:afbf7ba667e7 322 rxBuff[idx] = m_Spi.write(0);
cmkachur 15:afbf7ba667e7 323 }
cmkachur 15:afbf7ba667e7 324 m_Cs = 1;
cmkachur 15:afbf7ba667e7 325 }
cmkachur 15:afbf7ba667e7 326
cmkachur 10:bf33e2946bab 327 unsigned long AS3935::getEnergy(void)
cmkachur 10:bf33e2946bab 328 {
cmkachur 10:bf33e2946bab 329 unsigned long retVal;
cmkachur 10:bf33e2946bab 330 unsigned char rxBuff[3];
cmkachur 10:bf33e2946bab 331
cmkachur 15:afbf7ba667e7 332 #if 0
cmkachur 10:bf33e2946bab 333 rxBuff[0] = registerRead(AS3935_S_LIG_L);
cmkachur 10:bf33e2946bab 334 rxBuff[1] = registerRead(AS3935_S_LIG_M);
cmkachur 10:bf33e2946bab 335 rxBuff[2] = registerRead(AS3935_S_LIG_MM);
cmkachur 15:afbf7ba667e7 336 #else
cmkachur 15:afbf7ba667e7 337 _rawRegisterRead(AS3935_S_LIG_L, rxBuff, 3);
cmkachur 15:afbf7ba667e7 338 #endif
cmkachur 10:bf33e2946bab 339
cmkachur 10:bf33e2946bab 340 retVal = ((unsigned long)rxBuff[2] << 16) | ((unsigned long)rxBuff[1] << 8) | (unsigned long)rxBuff[0];
cmkachur 15:afbf7ba667e7 341 retVal &= 0x001fffff;
cmkachur 10:bf33e2946bab 342 return retVal;
cmkachur 10:bf33e2946bab 343 }
cmkachur 11:ee2e7a573227 344
cmkachur 11:ee2e7a573227 345 bool AS3935::getConfigRegisters(unsigned char *pBuff, unsigned char buffLen)
cmkachur 11:ee2e7a573227 346 {
cmkachur 11:ee2e7a573227 347 unsigned char cnt = 0;
cmkachur 11:ee2e7a573227 348
cmkachur 11:ee2e7a573227 349 if (NULL == pBuff)
cmkachur 11:ee2e7a573227 350 return false;
cmkachur 11:ee2e7a573227 351
cmkachur 11:ee2e7a573227 352 for (cnt = 0; cnt < buffLen && cnt < MAX_CONFIG_REGS; ++cnt)
cmkachur 11:ee2e7a573227 353 {
cmkachur 11:ee2e7a573227 354 pBuff[cnt] = _rawRegisterRead(cnt);
cmkachur 11:ee2e7a573227 355 }
cmkachur 11:ee2e7a573227 356 return true;
cmkachur 11:ee2e7a573227 357 }
cmkachur 11:ee2e7a573227 358
cmkachur 11:ee2e7a573227 359
cmkachur 11:ee2e7a573227 360