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:
Thu Jun 18 15:47:39 2015 +0000
Revision:
9:19a323b1c508
Parent:
8:60e1b6b39e1c
Child:
10:bf33e2946bab
Update calibrate RCO method. Measure the TRC oscillator.

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