File content as of revision 3:c536a9aa2a1c:

/*
AS3935.cpp - AS3935 Franklin Lightning Sensor™ IC by AMS library
Copyright (c) 2012 Raivis Rengelis (raivis [at] rrkb.lv). All rights reserved.
Porté sur MBED par Valentin, version I2C

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 3 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/

#include "AS3935.h"
#include "pinmap.h"

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)
{
 
    //Enable the internal pull-up resistor on MISO
    pin_mode(miso, PullUp);

    //Configure the SPI bus
    m_Spi.format(8, 1);
    printf("spi bus frequency set to %d hz\r\n",hz);
    m_Spi.frequency(hz);
  
}
 
char AS3935::_SPITransfer2(char high, char low)
{
    m_Cs = 0;
    m_Spi.write(high);
    char regval = m_Spi.write(low);
    m_Cs = 1;
    return regval;  
}

char AS3935::_rawRegisterRead(char reg)
{
    return _SPITransfer2((reg & 0x3F) | 0x40, 0);
}


char AS3935::_ffsz(char mask)
{
    char i = 0;
       
    while(!(mask & 1)) {
           mask >>= 1;
          i++;
    }
 
    return i;
}

void AS3935::registerWrite(char reg, char mask, char data)
{
   
    char regval;
    regval = _rawRegisterRead(reg);
    regval &= ~(mask);
    regval |= (data << (_ffsz(mask)));
    m_Cs = 0;
    m_Spi.write(reg);
    m_Spi.write(regval);
    //printf("raw transfer for reg %x is 0x%02x\r\n", high, regval);
    m_Cs = 1;
    wait_ms(2);
}

char AS3935::registerRead(char reg, char mask)
{
    char regval;
    regval = _rawRegisterRead(reg);
    // printf("raw regval is 0x%02x\r\n", regval);
    regval = regval & mask;
    regval >>= (_ffsz(mask));
    return regval;
}

void AS3935::reset()
 {
    m_Cs = 0;
    m_Spi.write(0x3D);
    m_Spi.write(0x96);
    m_Cs = 1;
    wait_ms(2);
} 

void AS3935::powerDown()
{
    registerWrite(AS3935_PWD,1);
}

void AS3935::powerUp()
{
 
    registerWrite(AS3935_PWD,0);
    m_Cs = 0;
    m_Spi.write(0x3D);
    m_Spi.write(0x96);
    m_Cs = 1;
    wait_ms(3);
    registerWrite(AS3935_DISP_TRCO,1);
    wait_ms(2);
    registerWrite(AS3935_DISP_TRCO,0);
}

int AS3935::interruptSource()
{
    return registerRead(AS3935_INT);
}

void AS3935::disableDisturbers()
{
    registerWrite(AS3935_MASK_DIST,1);
}

void AS3935::enableDisturbers()
{
    registerWrite(AS3935_MASK_DIST,0);
} 

int AS3935::getMinimumLightnings()
{
    return registerRead(AS3935_MIN_NUM_LIGH);
}

int AS3935::setMinimumLightnings(int minlightning)
{
    registerWrite(AS3935_MIN_NUM_LIGH,minlightning);
    return getMinimumLightnings();
}

int AS3935::lightningDistanceKm()
{
    return registerRead(AS3935_DISTANCE);
}

void AS3935::setIndoors()
{
    registerWrite(AS3935_AFE_GB,AS3935_AFE_INDOOR);
}

void AS3935::setOutdoors()
{
    registerWrite(AS3935_AFE_GB,AS3935_AFE_OUTDOOR);
}

int AS3935::getNoiseFloor()
{
    return registerRead(AS3935_NF_LEV);
}

int AS3935::setNoiseFloor(int noisefloor)
{
    registerWrite(AS3935_NF_LEV,noisefloor);
    return getNoiseFloor();
}

int AS3935::getSpikeRejection()
{
    return registerRead(AS3935_SREJ);
}

int AS3935::setSpikeRejection(int srej)
{
    registerWrite(AS3935_SREJ, srej);
    return getSpikeRejection();
}

int AS3935::getWatchdogThreshold()
{
    return registerRead(AS3935_WDTH);
}

int AS3935::setWatchdogThreshold(int wdth)
{
    registerWrite(AS3935_WDTH,wdth);
    return getWatchdogThreshold();
}

int AS3935::getTuneCap()
{
    return registerRead(AS3935_TUN_CAP);    
}
        
int AS3935::setTuneCap(int cap)
{
    registerWrite(AS3935_TUN_CAP,cap);
    return getTuneCap();   
}

void AS3935::clearStats()
{
    registerWrite(AS3935_CL_STAT,1);
    registerWrite(AS3935_CL_STAT,0);
    registerWrite(AS3935_CL_STAT,1);
}

int AS3935::calibrateRCOs (void)
{
    int rc;
    uint8_t trco;
    uint8_t srco;
    m_Cs = 0;
    m_Spi.write(0x3D);        // Direct Command Calibrate RCO
    m_Spi.write(0x96);
    m_Cs = 1;
    wait_ms(1);                          // wait 1ms
    registerWrite(0x08, 0x40, 0x40);    // ERRATA: after power down mode
    wait_ms(2);                                   // wait 1ms
    registerWrite(0x08, 0x40, 0x00);    // ERRATA: after power down mode
    trco=registerRead(0x3A, 0x80);        // Read out Calibration of TRCO done
    srco=registerRead(0x3B, 0x80);        // Readout Calibration of SRCO done
    if(trco != 0x00 && srco != 0x00)
    {
        rc = 1;
        printf("cal is done\r\n");
    }
    else
    {
        printf("cal is not done\r\n");
        rc = 0;
    }

    return rc;
}