AS3935.cpp

00001 /*
00002 AS3935.cpp - AS3935 Franklin Lightning Sensor™ IC by AMS library
00003 Copyright (c) 2012 Raivis Rengelis (raivis [at] rrkb.lv). All rights reserved.
00004 Porté sur MBED par Valentin, version I2C
00005 
00006 This library is free software; you can redistribute it and/or
00007 modify it under the terms of the GNU Lesser General Public
00008 License as published by the Free Software Foundation; either
00009 version 3 of the License, or (at your option) any later version.
00010 
00011 This library is distributed in the hope that it will be useful,
00012 but WITHOUT ANY WARRANTY; without even the implied warranty of
00013 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
00014 Lesser General Public License for more details.
00015 
00016 You should have received a copy of the GNU Lesser General Public
00017 License along with this library; if not, write to the Free Software
00018 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
00019 */
00020 
00021 #include "AS3935.hpp"
00022 
00023 AS3935::AS3935(PinName sda, PinName scl, int adresse): i2c(sda, scl), _adress(adresse) {        
00024         
00025         wait_ms(11);
00026     }
00027 
00028     //~AS3935(){
00029         
00030     //}
00031         
00032 char AS3935::_rawRegisterRead(char reg)
00033 {
00034     char data;
00035     i2c.write( _adress, &reg, 1, true);
00036     i2c.read(_adress, &data, 1);
00037     return data;
00038     
00039 }
00040 
00041 char AS3935::_ffsz(char mask)
00042 {
00043     char i = 0;
00044     //char temp;
00045     
00046     while(!(mask & 1)) {
00047        //if (!(mask & 1)) {
00048           mask >>= 1;
00049           i++;
00050        //}
00051     }
00052     //if (mask){
00053       //  for (i = 1; ~mask & 1 ; i++) {
00054         //    mask >>= 1;
00055           //  }
00056        // }
00057     return i;
00058 }
00059 
00060 void AS3935::registerWrite(char reg, char mask, char data)
00061 {
00062     char cmd[2];
00063     char regval;
00064     regval = _rawRegisterRead(reg);
00065     regval &= ~(mask);
00066     //if (mask){
00067         regval |= (data << (_ffsz(mask)));
00068       //  }
00069     //else {
00070       //  regval |= data;
00071        // }
00072     cmd[0] = reg;
00073     cmd[1] = regval;
00074     i2c.write( _adress, cmd, 2);
00075 
00076 }
00077 
00078 char AS3935::registerRead(char reg, char mask)
00079     {
00080     char regval;
00081     regval = _rawRegisterRead(reg);
00082     regval = regval & mask;
00083     //if (mask){
00084         regval >>= (_ffsz(mask));
00085       //  }
00086     return regval;
00087 }
00088 
00089 void AS3935::reset()
00090     {
00091     char cmd[2];
00092     cmd[0] = 0x3C;
00093     cmd[1] = 0x96;
00094     i2c.write( _adress, cmd, 2);
00095     wait_ms(2);
00096     }
00097 
00098 
00099 
00100 void AS3935::powerDown()
00101     {
00102     registerWrite(AS3935_PWD,1);
00103     }
00104 
00105 void AS3935::powerUp()
00106     {
00107     char cmd[2];
00108     cmd[0] = 0x3D;
00109     cmd[1] = 0x96;
00110     registerWrite(AS3935_PWD,0);
00111     i2c.write( _adress, cmd, 2);
00112     wait_ms(3);
00113     registerWrite(AS3935_DISP_TRCO,1);
00114     wait_ms(2);
00115     registerWrite(AS3935_DISP_TRCO,0);
00116     }
00117 
00118 int AS3935::interruptSource()
00119     {
00120     return registerRead(AS3935_INT);
00121     }
00122 
00123 void AS3935::disableDisturbers()
00124     {
00125     registerWrite(AS3935_MASK_DIST,1);
00126     }
00127 
00128 void AS3935::enableDisturbers()
00129     {
00130     registerWrite(AS3935_MASK_DIST,0);
00131     }
00132 
00133 int AS3935::getMinimumLightnings()
00134     {
00135     return registerRead(AS3935_MIN_NUM_LIGH);
00136     }
00137 
00138 int AS3935::setMinimumLightnings(int minlightning)
00139     {
00140     registerWrite(AS3935_MIN_NUM_LIGH,minlightning);
00141     return getMinimumLightnings();
00142     }
00143 
00144 int AS3935::lightningDistanceKm()
00145     {
00146     return registerRead(AS3935_DISTANCE);
00147     }
00148 
00149 void AS3935::setIndoors()
00150     {
00151     registerWrite(AS3935_AFE_GB,AS3935_AFE_INDOOR);
00152     }
00153 
00154 void AS3935::setOutdoors()
00155     {
00156     registerWrite(AS3935_AFE_GB,AS3935_AFE_OUTDOOR);
00157     }
00158 
00159 int AS3935::getNoiseFloor()
00160     {
00161     return registerRead(AS3935_NF_LEV);
00162     }
00163 
00164 int AS3935::setNoiseFloor(int noisefloor)
00165     {
00166     registerWrite(AS3935_NF_LEV,noisefloor);
00167     return getNoiseFloor();
00168     }
00169 
00170 int AS3935::getSpikeRejection()
00171     {
00172     return registerRead(AS3935_SREJ);
00173     }
00174 
00175 int AS3935::setSpikeRejection(int srej)
00176     {
00177     registerWrite(AS3935_SREJ, srej);
00178     return getSpikeRejection();
00179     }
00180 
00181 int AS3935::getWatchdogThreshold()
00182     {
00183     return registerRead(AS3935_WDTH);
00184     }
00185 
00186 int AS3935::setWatchdogThreshold(int wdth)
00187     {
00188     registerWrite(AS3935_WDTH,wdth);
00189     return getWatchdogThreshold();
00190     }
00191 
00192 int AS3935::getTuneCap()
00193     {
00194     return registerRead(AS3935_TUN_CAP);    
00195     }
00196         
00197 int AS3935::setTuneCap(int cap)
00198     {
00199     registerWrite(AS3935_TUN_CAP,cap);
00200     return getTuneCap();    
00201     }
00202 
00203 void AS3935::clearStats()
00204     {
00205     registerWrite(AS3935_CL_STAT,1);
00206     registerWrite(AS3935_CL_STAT,0);
00207     registerWrite(AS3935_CL_STAT,1);
00208     }