AS3935 Lightning sensor library

Dependents:   zeus

Fork of AS3935 by valentin spanu

include the mbed library with this snippet

#include "mbed.h"
#include "AS3935.h"

 // frdm-kl25z sd card connections for spi1 
 // ------------------------------------------------
 // Header -- kl25z -- SD/MMC          
 // J2-20  -- PTE1  -- MOSI
 // J9-13  -- PTE4  -- CS
 // J2-14  -- GND   -- Vss (GND) 
 // J9-9   -- PTE2  -- SCK
 // J9-11  -- PTE3  -- MISO
 
AS3935 ld(PTE1, PTE3, PTE2, PTE4, "ld", 100000); // MOSI, MISO, SCK, CS, SPI bus freq (hz) 
InterruptIn IntLightning(PTA12); //IRQ AS3935
DigitalOut led1(LED_RED);
Serial pc(USBTX, USBRX);

void DetectLightning()
{
    char OriginInt;
     wait_ms(2); 
    OriginInt = ld.interruptSource();
    if (OriginInt == 1) { //
        pc.printf(" Noise level too high\r\n");
        }
    if (OriginInt == 4) { //
        pc.printf(" Disturber\r\n");
        }
    if (OriginInt == 8) { // detection
        // pc.printf(" Lightning detection\r\n");
        pc.printf(" Lightning detection, distance=%dkm\r\n", ld.lightningDistanceKm());
        ld.clearStats();

        }
}

 
int main() {
    pc.baud(9600);
    pc.printf("\r\nstart lightning detector\r\n");
    
    //initialisations
    ld.reset();
    ld.setTuneCap(5); // 500kHz
    ld.powerUp();
    ld.setIndoors();  
    ld.setMinimumLightnings(1);
    //ld.setSpikeRejection(2);
    ld.setNoiseFloor(2);
    ld.disableDisturbers();
    //ld.enableDisturbers();
    ld.setWatchdogThreshold(2);
    wait_ms(10);
    IntLightning.rise(&DetectLightning);
    int MinBlysk = ld.getMinimumLightnings();
    int Noise = ld.getNoiseFloor();
    int TuneCap = ld.getTuneCap();
    int SpikeRej = ld.getSpikeRejection();
    int WatchDog = ld.getWatchdogThreshold();
     
    pc.printf(" Min wylad: %i", MinBlysk);
    pc.printf("\r\n");
    pc.printf(" Noise: %i", Noise);
    pc.printf("\r\n");
    pc.printf(" Tune CAP: %i", TuneCap);
    pc.printf("\r\n");
    pc.printf(" Spike rej: %i", SpikeRej);
    pc.printf("\r\n");
    pc.printf(" Watchdog: %i", WatchDog);
    pc.printf("\r\n");
    while(1) {
        led1 = ! led1;
        wait(0.2);
     }
    
 
 }
Committer:
cmkachur
Date:
Tue Jun 23 21:01:27 2015 +0000
Revision:
10:bf33e2946bab
Parent:
9:19a323b1c508
Child:
11:ee2e7a573227
Add method for reading energy of lightning strike. Add energy data to the log file. Remove call to powerUp() since this was only setting outdoor mode which was done elsewhere.

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 9:19a323b1c508 91 #if 0
casper 0:346c723cac97 92 void AS3935::reset()
ftagius 1:f2d9ed33c276 93 {
ftagius 1:f2d9ed33c276 94 m_Cs = 0;
ftagius 1:f2d9ed33c276 95 m_Spi.write(0x3D);
ftagius 1:f2d9ed33c276 96 m_Spi.write(0x96);
ftagius 1:f2d9ed33c276 97 m_Cs = 1;
casper 0:346c723cac97 98 wait_ms(2);
ftagius 1:f2d9ed33c276 99 }
cmkachur 9:19a323b1c508 100 #endif
ftagius 4:ab1f1b65468b 101 void AS3935::presetDefault()
ftagius 4:ab1f1b65468b 102 {
ftagius 4:ab1f1b65468b 103 m_Cs = 0;
ftagius 4:ab1f1b65468b 104 m_Spi.write(0x3C);
ftagius 4:ab1f1b65468b 105 m_Spi.write(0x96);
ftagius 4:ab1f1b65468b 106 m_Cs = 1;
ftagius 4:ab1f1b65468b 107 wait_ms(2);
ftagius 4:ab1f1b65468b 108 }
ftagius 4:ab1f1b65468b 109
ftagius 4:ab1f1b65468b 110 void AS3935::init()
ftagius 4:ab1f1b65468b 111 {
ftagius 4:ab1f1b65468b 112 presetDefault();
ftagius 4:ab1f1b65468b 113 registerWrite(AS3935_WDTH, 0x04); // set WDTH level to 4
ftagius 4:ab1f1b65468b 114 }
ftagius 4:ab1f1b65468b 115
casper 0:346c723cac97 116 void AS3935::powerDown()
ftagius 1:f2d9ed33c276 117 {
casper 0:346c723cac97 118 registerWrite(AS3935_PWD,1);
ftagius 1:f2d9ed33c276 119 }
casper 0:346c723cac97 120
cmkachur 10:bf33e2946bab 121 #if 0
casper 0:346c723cac97 122 void AS3935::powerUp()
ftagius 1:f2d9ed33c276 123 {
ftagius 5:28311803e23d 124 #if 0
casper 0:346c723cac97 125 registerWrite(AS3935_PWD,0);
ftagius 5:28311803e23d 126 //printf("wrote power up \r\n");
ftagius 1:f2d9ed33c276 127 m_Cs = 0;
ftagius 1:f2d9ed33c276 128 m_Spi.write(0x3D);
ftagius 1:f2d9ed33c276 129 m_Spi.write(0x96);
ftagius 1:f2d9ed33c276 130 m_Cs = 1;
casper 0:346c723cac97 131 wait_ms(3);
casper 0:346c723cac97 132 registerWrite(AS3935_DISP_TRCO,1);
casper 0:346c723cac97 133 wait_ms(2);
casper 0:346c723cac97 134 registerWrite(AS3935_DISP_TRCO,0);
ftagius 5:28311803e23d 135 #else
ftagius 5:28311803e23d 136 m_Cs = 0;
ftagius 5:28311803e23d 137 m_Spi.write(0x00);
ftagius 5:28311803e23d 138 m_Spi.write(0x1c);
ftagius 5:28311803e23d 139 m_Cs = 1;
ftagius 5:28311803e23d 140 wait_ms(2);
ftagius 6:c9b9e7d3bced 141 #endif
ftagius 5:28311803e23d 142 }
cmkachur 10:bf33e2946bab 143 #endif
ftagius 5:28311803e23d 144
cmkachur 7:0d2586164d5b 145 #if 0
ftagius 5:28311803e23d 146 // replication of the acurite init sequence
ftagius 5:28311803e23d 147 void AS3935::acurite()
ftagius 5:28311803e23d 148 {
ftagius 5:28311803e23d 149 m_Cs = 0;
ftagius 5:28311803e23d 150 m_Spi.write(0x00);
ftagius 5:28311803e23d 151 m_Spi.write(0x1d);
ftagius 5:28311803e23d 152 m_Cs = 1;
ftagius 5:28311803e23d 153 wait_ms(2);
ftagius 5:28311803e23d 154
ftagius 5:28311803e23d 155 m_Cs = 0;
ftagius 5:28311803e23d 156 m_Spi.write(0x3c);
ftagius 5:28311803e23d 157 m_Spi.write(0x96);
ftagius 5:28311803e23d 158 m_Cs = 1;
ftagius 5:28311803e23d 159 wait_ms(2);
ftagius 5:28311803e23d 160
ftagius 5:28311803e23d 161 m_Cs = 0;
ftagius 5:28311803e23d 162 m_Spi.write(0x01);
ftagius 5:28311803e23d 163 m_Spi.write(0x24);
ftagius 5:28311803e23d 164 m_Cs = 1;
ftagius 5:28311803e23d 165 wait_ms(2);
ftagius 5:28311803e23d 166
ftagius 5:28311803e23d 167 m_Cs = 0;
ftagius 5:28311803e23d 168 m_Spi.write(0x03);
ftagius 5:28311803e23d 169 m_Spi.write(0x41);
ftagius 5:28311803e23d 170 m_Cs = 1;
ftagius 5:28311803e23d 171 wait_ms(2);
ftagius 5:28311803e23d 172
ftagius 5:28311803e23d 173 int i;
ftagius 5:28311803e23d 174 for (i=0;i<8; i++)
ftagius 5:28311803e23d 175 {
ftagius 5:28311803e23d 176 m_Cs = 0;
ftagius 5:28311803e23d 177 m_Spi.write(0x08);
ftagius 5:28311803e23d 178 m_Spi.write(0x80+i);
ftagius 5:28311803e23d 179 m_Cs = 1;
ftagius 5:28311803e23d 180 wait_ms(2);
ftagius 5:28311803e23d 181 }
ftagius 5:28311803e23d 182
ftagius 5:28311803e23d 183 m_Cs = 0;
ftagius 5:28311803e23d 184 m_Spi.write(0x08);
ftagius 5:28311803e23d 185 m_Spi.write(0x08);
ftagius 5:28311803e23d 186 m_Cs = 1;
ftagius 5:28311803e23d 187 wait_ms(2);
ftagius 5:28311803e23d 188 m_Cs = 0;
ftagius 5:28311803e23d 189 m_Spi.write(0x00);
ftagius 5:28311803e23d 190 m_Spi.write(0x1c);
ftagius 5:28311803e23d 191 m_Cs = 1;
ftagius 5:28311803e23d 192 wait_ms(2);
ftagius 5:28311803e23d 193
ftagius 5:28311803e23d 194 m_Cs = 0;
ftagius 5:28311803e23d 195 m_Spi.write(0x3d);
ftagius 5:28311803e23d 196 m_Spi.write(0x96);
ftagius 5:28311803e23d 197 m_Cs = 1;
ftagius 5:28311803e23d 198 wait_ms(2);
ftagius 5:28311803e23d 199 m_Cs = 0;
ftagius 5:28311803e23d 200 m_Spi.write(0x08);
ftagius 5:28311803e23d 201 m_Spi.write(0x48);
ftagius 5:28311803e23d 202 m_Cs = 1;
ftagius 5:28311803e23d 203 wait_ms(2);
ftagius 5:28311803e23d 204
ftagius 5:28311803e23d 205 m_Cs = 0;
ftagius 5:28311803e23d 206 m_Spi.write(0x08);
ftagius 5:28311803e23d 207 m_Spi.write(0x8);
ftagius 5:28311803e23d 208 m_Cs = 1;
ftagius 5:28311803e23d 209 wait_ms(2);
ftagius 5:28311803e23d 210
ftagius 5:28311803e23d 211 m_Cs = 0;
ftagius 5:28311803e23d 212 m_Spi.write(0x08);
ftagius 5:28311803e23d 213 m_Spi.write(0x28);
ftagius 5:28311803e23d 214 m_Cs = 1;
ftagius 5:28311803e23d 215 wait_ms(2);
ftagius 5:28311803e23d 216
ftagius 5:28311803e23d 217 m_Cs = 0;
ftagius 5:28311803e23d 218 m_Spi.write(0x08);
ftagius 5:28311803e23d 219 m_Spi.write(0x48);
ftagius 5:28311803e23d 220 m_Cs = 1;
ftagius 5:28311803e23d 221 wait_ms(2);
ftagius 5:28311803e23d 222
ftagius 5:28311803e23d 223 m_Cs = 0;
ftagius 5:28311803e23d 224 m_Spi.write(0x08);
ftagius 5:28311803e23d 225 m_Spi.write(0x8);
ftagius 5:28311803e23d 226 m_Cs = 1;
ftagius 5:28311803e23d 227 wait_ms(2);
ftagius 5:28311803e23d 228
ftagius 5:28311803e23d 229 m_Cs = 0;
ftagius 5:28311803e23d 230 m_Spi.write(0x02);
ftagius 5:28311803e23d 231 m_Spi.write(0x82);
ftagius 5:28311803e23d 232 m_Cs = 1;
ftagius 5:28311803e23d 233 wait_ms(2);
ftagius 5:28311803e23d 234
ftagius 5:28311803e23d 235 m_Cs = 0;
ftagius 5:28311803e23d 236 m_Spi.write(0x01);
ftagius 5:28311803e23d 237 m_Spi.write(0x24);
ftagius 5:28311803e23d 238 m_Cs = 1;
ftagius 5:28311803e23d 239 wait_ms(2);
ftagius 5:28311803e23d 240
ftagius 5:28311803e23d 241 m_Cs = 0;
ftagius 5:28311803e23d 242 m_Spi.write(0x02);
ftagius 5:28311803e23d 243 m_Spi.write(0xc2);
ftagius 5:28311803e23d 244 m_Cs = 1;
ftagius 5:28311803e23d 245 wait_ms(2);
ftagius 5:28311803e23d 246
ftagius 5:28311803e23d 247
ftagius 1:f2d9ed33c276 248 }
cmkachur 7:0d2586164d5b 249 #endif
casper 0:346c723cac97 250 int AS3935::interruptSource()
ftagius 2:3b3b435ca8d9 251 {
casper 0:346c723cac97 252 return registerRead(AS3935_INT);
ftagius 2:3b3b435ca8d9 253 }
casper 0:346c723cac97 254
casper 0:346c723cac97 255 void AS3935::disableDisturbers()
ftagius 2:3b3b435ca8d9 256 {
casper 0:346c723cac97 257 registerWrite(AS3935_MASK_DIST,1);
ftagius 2:3b3b435ca8d9 258 }
casper 0:346c723cac97 259
casper 0:346c723cac97 260 void AS3935::enableDisturbers()
ftagius 2:3b3b435ca8d9 261 {
casper 0:346c723cac97 262 registerWrite(AS3935_MASK_DIST,0);
ftagius 2:3b3b435ca8d9 263 }
casper 0:346c723cac97 264
casper 0:346c723cac97 265 int AS3935::getMinimumLightnings()
ftagius 2:3b3b435ca8d9 266 {
casper 0:346c723cac97 267 return registerRead(AS3935_MIN_NUM_LIGH);
ftagius 2:3b3b435ca8d9 268 }
casper 0:346c723cac97 269
casper 0:346c723cac97 270 int AS3935::setMinimumLightnings(int minlightning)
ftagius 2:3b3b435ca8d9 271 {
casper 0:346c723cac97 272 registerWrite(AS3935_MIN_NUM_LIGH,minlightning);
casper 0:346c723cac97 273 return getMinimumLightnings();
ftagius 2:3b3b435ca8d9 274 }
casper 0:346c723cac97 275
casper 0:346c723cac97 276 int AS3935::lightningDistanceKm()
ftagius 2:3b3b435ca8d9 277 {
casper 0:346c723cac97 278 return registerRead(AS3935_DISTANCE);
ftagius 2:3b3b435ca8d9 279 }
casper 0:346c723cac97 280
casper 0:346c723cac97 281 void AS3935::setIndoors()
ftagius 2:3b3b435ca8d9 282 {
casper 0:346c723cac97 283 registerWrite(AS3935_AFE_GB,AS3935_AFE_INDOOR);
ftagius 2:3b3b435ca8d9 284 }
casper 0:346c723cac97 285
ftagius 6:c9b9e7d3bced 286 int AS3935::getGain()
ftagius 6:c9b9e7d3bced 287 {
ftagius 6:c9b9e7d3bced 288 return registerRead(AS3935_AFE_GB);
ftagius 6:c9b9e7d3bced 289 }
ftagius 6:c9b9e7d3bced 290
casper 0:346c723cac97 291 void AS3935::setOutdoors()
ftagius 2:3b3b435ca8d9 292 {
casper 0:346c723cac97 293 registerWrite(AS3935_AFE_GB,AS3935_AFE_OUTDOOR);
ftagius 2:3b3b435ca8d9 294 }
casper 0:346c723cac97 295
casper 0:346c723cac97 296 int AS3935::getNoiseFloor()
ftagius 2:3b3b435ca8d9 297 {
casper 0:346c723cac97 298 return registerRead(AS3935_NF_LEV);
ftagius 2:3b3b435ca8d9 299 }
casper 0:346c723cac97 300
casper 0:346c723cac97 301 int AS3935::setNoiseFloor(int noisefloor)
ftagius 2:3b3b435ca8d9 302 {
casper 0:346c723cac97 303 registerWrite(AS3935_NF_LEV,noisefloor);
casper 0:346c723cac97 304 return getNoiseFloor();
ftagius 2:3b3b435ca8d9 305 }
casper 0:346c723cac97 306
casper 0:346c723cac97 307 int AS3935::getSpikeRejection()
ftagius 2:3b3b435ca8d9 308 {
casper 0:346c723cac97 309 return registerRead(AS3935_SREJ);
ftagius 2:3b3b435ca8d9 310 }
casper 0:346c723cac97 311
casper 0:346c723cac97 312 int AS3935::setSpikeRejection(int srej)
ftagius 2:3b3b435ca8d9 313 {
casper 0:346c723cac97 314 registerWrite(AS3935_SREJ, srej);
casper 0:346c723cac97 315 return getSpikeRejection();
ftagius 2:3b3b435ca8d9 316 }
casper 0:346c723cac97 317
casper 0:346c723cac97 318 int AS3935::getWatchdogThreshold()
ftagius 2:3b3b435ca8d9 319 {
casper 0:346c723cac97 320 return registerRead(AS3935_WDTH);
ftagius 2:3b3b435ca8d9 321 }
casper 0:346c723cac97 322
casper 0:346c723cac97 323 int AS3935::setWatchdogThreshold(int wdth)
ftagius 2:3b3b435ca8d9 324 {
casper 0:346c723cac97 325 registerWrite(AS3935_WDTH,wdth);
casper 0:346c723cac97 326 return getWatchdogThreshold();
ftagius 2:3b3b435ca8d9 327 }
casper 0:346c723cac97 328
casper 0:346c723cac97 329 int AS3935::getTuneCap()
ftagius 2:3b3b435ca8d9 330 {
casper 0:346c723cac97 331 return registerRead(AS3935_TUN_CAP);
ftagius 2:3b3b435ca8d9 332 }
casper 0:346c723cac97 333
casper 0:346c723cac97 334 int AS3935::setTuneCap(int cap)
ftagius 2:3b3b435ca8d9 335 {
casper 0:346c723cac97 336 registerWrite(AS3935_TUN_CAP,cap);
ftagius 2:3b3b435ca8d9 337 return getTuneCap();
ftagius 2:3b3b435ca8d9 338 }
casper 0:346c723cac97 339
casper 0:346c723cac97 340 void AS3935::clearStats()
ftagius 2:3b3b435ca8d9 341 {
casper 0:346c723cac97 342 registerWrite(AS3935_CL_STAT,1);
casper 0:346c723cac97 343 registerWrite(AS3935_CL_STAT,0);
casper 0:346c723cac97 344 registerWrite(AS3935_CL_STAT,1);
ftagius 3:c536a9aa2a1c 345 }
cmkachur 9:19a323b1c508 346
cmkachur 9:19a323b1c508 347 static void intrPulseCntr(void) {sgIntrPulseCount++;}
ftagius 3:c536a9aa2a1c 348
cmkachur 9:19a323b1c508 349 int AS3935::calibrateRCOs (InterruptIn &intrIn)
ftagius 3:c536a9aa2a1c 350 {
ftagius 3:c536a9aa2a1c 351 int rc;
ftagius 3:c536a9aa2a1c 352 uint8_t trco;
ftagius 3:c536a9aa2a1c 353 uint8_t srco;
cmkachur 9:19a323b1c508 354 Timer pulseTimer;
cmkachur 9:19a323b1c508 355 int timeNow;
cmkachur 9:19a323b1c508 356 unsigned long measFreq;
cmkachur 9:19a323b1c508 357
cmkachur 9:19a323b1c508 358 intrIn.rise(intrPulseCntr);
cmkachur 9:19a323b1c508 359
cmkachur 9:19a323b1c508 360 _SPITransfer2(0x3D, 0x96); // send command to calibrate the internal RC oscillators
cmkachur 9:19a323b1c508 361 _SPITransfer2(8, 0x20); // put TRCO on the IRQ line for measurement
cmkachur 9:19a323b1c508 362 wait_ms(20); // wait for the chip to output the frequency, ususally ~2 ms
ftagius 5:28311803e23d 363
cmkachur 9:19a323b1c508 364 pulseTimer.reset();
cmkachur 9:19a323b1c508 365 pulseTimer.start();
cmkachur 9:19a323b1c508 366 sgIntrPulseCount = 0; // reset the interrupt counter which serves as our frequency\pulse counter
cmkachur 9:19a323b1c508 367
cmkachur 9:19a323b1c508 368 timeNow = 0;
cmkachur 9:19a323b1c508 369 while (timeNow < 500) // wait for 0.5 seconds
cmkachur 9:19a323b1c508 370 {
cmkachur 9:19a323b1c508 371 timeNow = pulseTimer.read_ms();
cmkachur 9:19a323b1c508 372 }
cmkachur 9:19a323b1c508 373 _SPITransfer2(8, 0); // stop the output of the frequncy on IRQ line
cmkachur 9:19a323b1c508 374 measFreq = sgIntrPulseCount << 1; // calculate the measure frequency based upon period of capture and freq scaler
cmkachur 9:19a323b1c508 375
cmkachur 9:19a323b1c508 376 printf("timer RCO: %ld Hz\n\r", measFreq);
cmkachur 9:19a323b1c508 377
cmkachur 9:19a323b1c508 378 trco=registerRead(0x3A, 0x80); // Read out Calibration of TRCO done
cmkachur 9:19a323b1c508 379 srco=registerRead(0x3B, 0x80); // Readout Calibration of SRCO done
ftagius 3:c536a9aa2a1c 380 if(trco != 0x00 && srco != 0x00)
ftagius 3:c536a9aa2a1c 381 {
ftagius 3:c536a9aa2a1c 382 rc = 1;
ftagius 3:c536a9aa2a1c 383 printf("cal is done\r\n");
ftagius 3:c536a9aa2a1c 384 }
ftagius 3:c536a9aa2a1c 385 else
ftagius 3:c536a9aa2a1c 386 {
ftagius 3:c536a9aa2a1c 387 printf("cal is not done\r\n");
ftagius 3:c536a9aa2a1c 388 rc = 0;
ftagius 3:c536a9aa2a1c 389 }
ftagius 3:c536a9aa2a1c 390
ftagius 3:c536a9aa2a1c 391 return rc;
ftagius 3:c536a9aa2a1c 392 }
cmkachur 7:0d2586164d5b 393
cmkachur 7:0d2586164d5b 394
cmkachur 7:0d2586164d5b 395 unsigned long AS3935::tuneAntenna(InterruptIn &intrIn)
cmkachur 7:0d2586164d5b 396 {
cmkachur 7:0d2586164d5b 397 #define ANTENA_RES_FREQ (unsigned long)500000
cmkachur 7:0d2586164d5b 398 Timer pulseTimer;
cmkachur 7:0d2586164d5b 399 int timeNow;
cmkachur 7:0d2586164d5b 400 unsigned long measFreq;
cmkachur 7:0d2586164d5b 401 unsigned long measFreqBest = 0;
cmkachur 7:0d2586164d5b 402 unsigned char tunCapCnt = 0;
cmkachur 7:0d2586164d5b 403 unsigned char tunCapBest = 0;
cmkachur 7:0d2586164d5b 404 unsigned long minError = ANTENA_RES_FREQ;
cmkachur 7:0d2586164d5b 405 unsigned long error;
cmkachur 7:0d2586164d5b 406
cmkachur 7:0d2586164d5b 407 intrIn.rise(intrPulseCntr);
cmkachur 9:19a323b1c508 408 _SPITransfer2(3, 0x80); // set frequency division to 64
cmkachur 7:0d2586164d5b 409
cmkachur 7:0d2586164d5b 410 for (tunCapCnt = 0; tunCapCnt < 16; ++tunCapCnt) // loop for all possible values of the tuning capacitor
cmkachur 7:0d2586164d5b 411 {
cmkachur 7:0d2586164d5b 412 _SPITransfer2(8, 0x80+tunCapCnt); // set the tuning cap and have the frequency output to the IRQ line
cmkachur 7:0d2586164d5b 413 wait_ms(20); // wait for the chip to output the frequency, ususally ~2 ms
cmkachur 7:0d2586164d5b 414
cmkachur 7:0d2586164d5b 415 pulseTimer.reset();
cmkachur 7:0d2586164d5b 416 pulseTimer.start();
cmkachur 7:0d2586164d5b 417 sgIntrPulseCount = 0; // reset the interrupt counter which serves as our frequency\pulse counter
cmkachur 7:0d2586164d5b 418
cmkachur 7:0d2586164d5b 419 timeNow = 0;
cmkachur 7:0d2586164d5b 420 while (timeNow < 500) // wait for 0.5 seconds
cmkachur 7:0d2586164d5b 421 {
cmkachur 7:0d2586164d5b 422 timeNow = pulseTimer.read_ms();
cmkachur 7:0d2586164d5b 423 }
cmkachur 7:0d2586164d5b 424 _SPITransfer2(8, 0x00); // stop the output of the frequncy on IRQ line
cmkachur 7:0d2586164d5b 425
cmkachur 7:0d2586164d5b 426 measFreq = sgIntrPulseCount << 7; // calulate the measure frequency based upon period of capture and freq scaler
cmkachur 7:0d2586164d5b 427
cmkachur 7:0d2586164d5b 428 if (measFreq < ANTENA_RES_FREQ) // calculate error between actual and desired frequency
cmkachur 7:0d2586164d5b 429 error = ANTENA_RES_FREQ - measFreq;
cmkachur 7:0d2586164d5b 430 else
cmkachur 7:0d2586164d5b 431 error = measFreq - ANTENA_RES_FREQ;
cmkachur 7:0d2586164d5b 432
cmkachur 7:0d2586164d5b 433 if (error < minError) // update the best capacitor tuning so far
cmkachur 7:0d2586164d5b 434 {
cmkachur 7:0d2586164d5b 435 tunCapBest = tunCapCnt;
cmkachur 7:0d2586164d5b 436 minError = error;
cmkachur 7:0d2586164d5b 437 measFreqBest = measFreq;
cmkachur 7:0d2586164d5b 438 }
cmkachur 7:0d2586164d5b 439
cmkachur 7:0d2586164d5b 440 printf("sgIntrCount[%ld] measFreq[%ld] timeNow[%ld] tunCapBest[%d]\n\r", sgIntrPulseCount, measFreq, timeNow, tunCapBest);
cmkachur 7:0d2586164d5b 441 }
cmkachur 7:0d2586164d5b 442 setTuneCap(tunCapBest); // 500kHz); // set the best capacitor tuning that was found
cmkachur 7:0d2586164d5b 443 return measFreqBest;
cmkachur 7:0d2586164d5b 444 }
cmkachur 7:0d2586164d5b 445
cmkachur 10:bf33e2946bab 446 unsigned long AS3935::getEnergy(void)
cmkachur 10:bf33e2946bab 447 {
cmkachur 10:bf33e2946bab 448 unsigned long retVal;
cmkachur 10:bf33e2946bab 449 unsigned char rxBuff[3];
cmkachur 10:bf33e2946bab 450
cmkachur 10:bf33e2946bab 451 rxBuff[0] = registerRead(AS3935_S_LIG_L);
cmkachur 10:bf33e2946bab 452 rxBuff[1] = registerRead(AS3935_S_LIG_M);
cmkachur 10:bf33e2946bab 453 rxBuff[2] = registerRead(AS3935_S_LIG_MM);
cmkachur 10:bf33e2946bab 454
cmkachur 10:bf33e2946bab 455 retVal = ((unsigned long)rxBuff[2] << 16) | ((unsigned long)rxBuff[1] << 8) | (unsigned long)rxBuff[0];
cmkachur 10:bf33e2946bab 456 return retVal;
cmkachur 10:bf33e2946bab 457 }