diff --git a/DFRobot_AS3935_I2C.cpp b/DFRobot_AS3935_I2C.cpp index e07a2eb..e5c924c 100644 --- a/DFRobot_AS3935_I2C.cpp +++ b/DFRobot_AS3935_I2C.cpp @@ -1,164 +1,164 @@ #include "DFRobot_AS3935_I2c.h" -DF_AS3935_I2C::DF_AS3935_I2C(uint8_t IRQx, uint8_t DEVADDx) +DFRobot_AS3935_I2C::DFRobot_AS3935_I2C(uint8_t irqx, uint8_t devAddx) { - _devadd = DEVADDx; - _irq = IRQx; + devAdd = devAddx; + irq = irqx; // initalize the IRQ pins - pinMode(_irq, INPUT); + pinMode(irq, INPUT); } -void DF_AS3935_I2C::AS3935_SetI2CAddress(uint8_t DEVADDx) +void DFRobot_AS3935_I2C::AS3935SetI2CAddress(uint8_t devAddx) { - if (DEVADDx == AS3935_ADD1) + if (devAddx == AS3935_ADD1) { - _devadd=DEVADDx; + devAdd = devAddx; } - else if (DEVADDx == AS3935_ADD2) + else if (devAddx == AS3935_ADD2) { - _devadd=DEVADDx; + devAdd = devAddx; } else { - _devadd=AS3935_ADD3; + devAdd = AS3935_ADD3; } } -uint8_t DF_AS3935_I2C::_sing_reg_read(uint8_t RegAdd) +uint8_t DFRobot_AS3935_I2C::singRegRead(uint8_t regAdd) { // I2C address Register address num bytes - I2c.read((uint8_t)_devadd, (uint8_t)RegAdd, (uint8_t)0x01); // Use I2C library to read register - uint8_t RegData = I2c.receive(); // receive the I2C data - return RegData; + I2c.read((uint8_t)devAdd, (uint8_t)regAdd, (uint8_t)0x01); // Use I2C library to read register + uint8_t regData = I2c.receive(); // receive the I2C data + return regData; } -void DF_AS3935_I2C::_sing_reg_write(uint8_t RegAdd, uint8_t DataMask, uint8_t RegData) +void DFRobot_AS3935_I2C::singRegWrite(uint8_t regAdd, uint8_t dataMask, uint8_t regData) { // start by reading original register data (only modifying what we need to) - uint8_t OrigRegData = _sing_reg_read(RegAdd); + uint8_t origRegData = singRegRead(regAdd); // calculate new register data... 'delete' old targeted data, replace with new data // note: 'DataMask' must be bits targeted for replacement // add'l note: this function does NOT shift values into the proper place... they need to be there already - uint8_t NewRegData = ((OrigRegData & ~DataMask) | (RegData & DataMask)); + uint8_t newRegData = ((origRegData & ~dataMask) | (regData & dataMask)); // finally, write the data to the register - I2c.write(_devadd, RegAdd, NewRegData); + I2c.write(devAdd, regAdd, newRegData); Serial.print("wrt: "); - Serial.print(NewRegData,HEX); + Serial.print(newRegData,HEX); Serial.print(" Act: "); - Serial.println(_sing_reg_read(RegAdd),HEX); + Serial.println(singRegRead(regAdd),HEX); } -void DF_AS3935_I2C::AS3935_DefInit() +void DFRobot_AS3935_I2C::AS3935DefInit() { - _AS3935_Reset(); // reset registers to default + AS3935Reset(); // reset registers to default } -void DF_AS3935_I2C::_AS3935_Reset() +void DFRobot_AS3935_I2C::AS3935Reset() { // run PRESET_DEFAULT Direct Command to set all registers in default state - I2c.write(_devadd, (uint8_t)0x3C, (uint8_t)0x96); + I2c.write(devAdd, (uint8_t)0x3C, (uint8_t)0x96); delay(2); // wait 2ms to complete } -void DF_AS3935_I2C::_CalRCO() +void DFRobot_AS3935_I2C::calRCO() { // run ALIB_RCO Direct Command to cal internal RCO - I2c.write(_devadd, (uint8_t)0x3D, (uint8_t)0x96); + I2c.write(devAdd, (uint8_t)0x3D, (uint8_t)0x96); delay(2); // wait 2ms to complete } -void DF_AS3935_I2C::AS3935_PowerUp(void) +void DFRobot_AS3935_I2C::AS3935PowerUp(void) { // power-up sequence based on datasheet, pg 23/27 // register 0x00, PWD bit: 0 (clears PWD) - _sing_reg_write(0x00, 0x01, 0x00); - _CalRCO(); // run RCO cal cmd - _sing_reg_write(0x08, 0x20, 0x20); // set DISP_SRCO to 1 + singRegWrite(0x00, 0x01, 0x00); + calRCO(); // run RCO cal cmd + singRegWrite(0x08, 0x20, 0x20); // set DISP_SRCO to 1 delay(2); - _sing_reg_write(0x08, 0x20, 0x00); // set DISP_SRCO to 0 + singRegWrite(0x08, 0x20, 0x00); // set DISP_SRCO to 0 } -void DF_AS3935_I2C::AS3935_PowerDown(void) +void DFRobot_AS3935_I2C::AS3935PowerDown(void) { // register 0x00, PWD bit: 0 (sets PWD) - _sing_reg_write(0x00, 0x01, 0x01); + singRegWrite(0x00, 0x01, 0x01); Serial.println("AS3935 powered down"); } -void DF_AS3935_I2C::AS3935_DisturberEn(void) +void DFRobot_AS3935_I2C::AS3935DisturberEn(void) { // register 0x03, PWD bit: 5 (sets MASK_DIST) - _sing_reg_write(0x03, 0x20, 0x00); + singRegWrite(0x03, 0x20, 0x00); Serial.println("disturber detection enabled"); } -void DF_AS3935_I2C::AS3935_DisturberDis(void) +void DFRobot_AS3935_I2C::AS3935DisturberDis(void) { // register 0x03, PWD bit: 5 (sets MASK_DIST) - _sing_reg_write(0x03, 0x20, 0x20); + singRegWrite(0x03, 0x20, 0x20); } -void DF_AS3935_I2C::AS3935_SetIRQ_Output_Source(uint8_t irq_select) +void DFRobot_AS3935_I2C::AS3935SetIRQOutputSource(uint8_t irqSelect) { // set interrupt source - what to display on IRQ pin // reg 0x08, bits 5 (TRCO), 6 (SRCO), 7 (LCO) // only one should be set at once, I think // 0 = NONE, 1 = TRCO, 2 = SRCO, 3 = LCO - if(1 == irq_select) + if(1 == irqSelect) { - _sing_reg_write(0x08, 0xE0, 0x20); // set only TRCO bit + singRegWrite(0x08, 0xE0, 0x20); // set only TRCO bit } - else if(2 == irq_select) + else if(2 == irqSelect) { - _sing_reg_write(0x08, 0xE0, 0x40); // set only SRCO bit + singRegWrite(0x08, 0xE0, 0x40); // set only SRCO bit } - else if(3 == irq_select) + else if(3 == irqSelect) { - _sing_reg_write(0x08, 0xE0, 0x80); // set only LCO bit + singRegWrite(0x08, 0xE0, 0x80); // set only LCO bit } else // assume 0 { - _sing_reg_write(0x08, 0xE0, 0x00); // clear IRQ pin display bits + singRegWrite(0x08, 0xE0, 0x00); // clear IRQ pin display bits } } -void DF_AS3935_I2C::AS3935_SetTuningCaps(uint8_t cap_val) +void DFRobot_AS3935_I2C::AS3935SetTuningCaps(uint8_t capVal) { // Assume only numbers divisible by 8 (because that's all the chip supports) - if(120 < cap_val) // cap_value out of range, assume highest capacitance + if(120 < capVal) // cap_value out of range, assume highest capacitance { - _sing_reg_write(0x08, 0x0F, 0x0F); // set capacitance bits to maximum + singRegWrite(0x08, 0x0F, 0x0F); // set capacitance bits to maximum } else { - _sing_reg_write(0x08, 0x0F, (cap_val>>3)); // set capacitance bits + singRegWrite(0x08, 0x0F, (capVal >> 3)); // set capacitance bits } Serial.print("capacitance set to 8x"); - Serial.println((_sing_reg_read(0x08) & 0x0F)); + Serial.println((singRegRead(0x08) & 0x0F)); } -uint8_t DF_AS3935_I2C::AS3935_GetInterruptSrc(void) +uint8_t DFRobot_AS3935_I2C::AS3935GetInterruptSrc(void) { // definition of interrupt data on table 18 of datasheet // for this function: // 0 = unknown src, 1 = lightning detected, 2 = disturber, 3 = Noise level too high delay(10); // wait 3ms before reading (min 2ms per pg 22 of datasheet) - uint8_t int_src = (_sing_reg_read(0x03) & 0x0F); // read register, get rid of non-interrupt data - if(0x08 == int_src) + uint8_t intSrc = (singRegRead(0x03) & 0x0F); // read register, get rid of non-interrupt data + if(0x08 == intSrc) { return 1; // lightning caused interrupt } - else if(0x04 == int_src) + else if(0x04 == intSrc) { return 2; // disturber detected } - else if(0x01 == int_src) + else if(0x01 == intSrc) { return 3; // Noise level too high } @@ -166,116 +166,116 @@ uint8_t DF_AS3935_I2C::AS3935_GetInterruptSrc(void) } -uint8_t DF_AS3935_I2C::AS3935_GetLightningDistKm(void) +uint8_t DFRobot_AS3935_I2C::AS3935GetLightningDistKm(void) { - uint8_t strike_dist = (_sing_reg_read(0x07) & 0x3F); // read register, get rid of non-distance data - return strike_dist; + uint8_t strikeDist = (singRegRead(0x07) & 0x3F); // read register, get rid of non-distance data + return strikeDist; } -uint32_t DF_AS3935_I2C::AS3935_GetStrikeEnergyRaw(void) +uint32_t DFRobot_AS3935_I2C::AS3935GetStrikeEnergyRaw(void) { - uint32_t nrgy_raw = ((_sing_reg_read(0x06) & 0x1F) << 8); // MMSB, shift 8 bits left, make room for MSB - nrgy_raw |= _sing_reg_read(0x05); // read MSB - nrgy_raw <<= 8; // shift 8 bits left, make room for LSB - nrgy_raw |= _sing_reg_read(0x04); // read LSB, add to others + uint32_t nrgyRaw = ((singRegRead(0x06) & 0x1F) << 8); // MMSB, shift 8 bits left, make room for MSB + nrgyRaw |= singRegRead(0x05); // read MSB + nrgyRaw <<= 8; // shift 8 bits left, make room for LSB + nrgyRaw |= singRegRead(0x04); // read LSB, add to others - return nrgy_raw/16777; + return nrgyRaw/16777; } -uint8_t DF_AS3935_I2C::AS3935_SetMinStrikes(uint8_t min_strk) +uint8_t DFRobot_AS3935_I2C::AS3935SetMinStrikes(uint8_t minStrk) { // This function sets min strikes to the closest available number, rounding to the floor, // where necessary, then returns the physical value that was set. Options are 1, 5, 9 or 16 strikes. // see pg 22 of the datasheet for more info (#strikes in 17 min) - if(5 > min_strk) + if(5 > minStrk) { - _sing_reg_write(0x02, 0x30, 0x00); + singRegWrite(0x02, 0x30, 0x00); return 1; } - else if(9 > min_strk) + else if(9 > minStrk) { - _sing_reg_write(0x02, 0x30, 0x10); + singRegWrite(0x02, 0x30, 0x10); return 5; } - else if(16 > min_strk) + else if(16 > minStrk) { - _sing_reg_write(0x02, 0x30, 0x20); + singRegWrite(0x02, 0x30, 0x20); return 9; } else { - _sing_reg_write(0x02, 0x30, 0x30); + singRegWrite(0x02, 0x30, 0x30); return 16; } } -void DF_AS3935_I2C::AS3935_SetIndoors(void) +void DFRobot_AS3935_I2C::AS3935SetIndoors(void) { // AFE settings addres 0x00, bits 5:1 (10010, based on datasheet, pg 19, table 15) // this is the default setting at power-up (AS3935 datasheet, table 9) - _sing_reg_write(0x00, 0x3E, 0x24); + singRegWrite(0x00, 0x3E, 0x24); Serial.println("set up for indoor operation"); } -void DF_AS3935_I2C::AS3935_SetOutdoors(void) +void DFRobot_AS3935_I2C::AS3935SetOutdoors(void) { // AFE settings addres 0x00, bits 5:1 (01110, based on datasheet, pg 19, table 15) - _sing_reg_write(0x00, 0x3E, 0x1C); + singRegWrite(0x00, 0x3E, 0x1C); Serial.println("set up for outdoor operation"); } -void DF_AS3935_I2C::AS3935_ClearStatistics(void) +void DFRobot_AS3935_I2C::AS3935ClearStatistics(void) { // clear is accomplished by toggling CL_STAT bit 'high-low-high' (then set low to move on) - _sing_reg_write(0x02, 0x40, 0x40); // high - _sing_reg_write(0x02, 0x40, 0x00); // low - _sing_reg_write(0x02, 0x40, 0x40); // high + singRegWrite(0x02, 0x40, 0x40); // high + singRegWrite(0x02, 0x40, 0x00); // low + singRegWrite(0x02, 0x40, 0x40); // high } -uint8_t DF_AS3935_I2C::AS3935_GetNoiseFloorLvl(void) +uint8_t DFRobot_AS3935_I2C::AS3935GetNoiseFloorLvl(void) { // NF settings addres 0x01, bits 6:4 // default setting of 010 at startup (datasheet, table 9) - uint8_t reg_raw = _sing_reg_read(0x01); // read register 0x01 - return ((reg_raw & 0x70)>>4); // should return value from 0-7, see table 16 for info + uint8_t regRaw = singRegRead(0x01); // read register 0x01 + return ((regRaw & 0x70) >> 4); // should return value from 0-7, see table 16 for info } -void DF_AS3935_I2C::AS3935_SetNoiseFloorLvl(uint8_t nf_sel) +void DFRobot_AS3935_I2C::AS3935SetNoiseFloorLvl(uint8_t nfSel) { // NF settings addres 0x01, bits 6:4 // default setting of 010 at startup (datasheet, table 9) - if(7 >= nf_sel) // nf_sel within expected range + if(7 >= nfSel) // nf_sel within expected range { - _sing_reg_write(0x01, 0x70, ((nf_sel & 0x07)<<4)); + singRegWrite(0x01, 0x70, ((nfSel & 0x07) << 4)); } else { // out of range, set to default (power-up value 010) - _sing_reg_write(0x01, 0x70, 0x20); + singRegWrite(0x01, 0x70, 0x20); } } -uint8_t DF_AS3935_I2C::AS3935_GetWatchdogThreshold(void) +uint8_t DFRobot_AS3935_I2C::AS3935GetWatchdogThreshold(void) { // This function is used to read WDTH. It is used to increase robustness to disturbers, // though will make detection less efficient (see page 19, Fig 20 of datasheet) // WDTH register: add 0x01, bits 3:0 // default value of 0001 // values should only be between 0x00 and 0x0F (0 and 7) - uint8_t reg_raw = _sing_reg_read(0x01); - return (reg_raw & 0x0F); + uint8_t regRaw = singRegRead(0x01); + return (regRaw & 0x0F); } -void DF_AS3935_I2C::AS3935_SetWatchdogThreshold(uint8_t wdth) +void DFRobot_AS3935_I2C::AS3935SetWatchdogThreshold(uint8_t wdth) { // This function is used to modify WDTH. It is used to increase robustness to disturbers, // though will make detection less efficient (see page 19, Fig 20 of datasheet) // WDTH register: add 0x01, bits 3:0 // default value of 0001 // values should only be between 0x00 and 0x0F (0 and 7) - _sing_reg_write(0x01, 0x0F, (wdth & 0x0F)); + singRegWrite(0x01, 0x0F, (wdth & 0x0F)); } -uint8_t DF_AS3935_I2C::AS3935_GetSpikeRejection(void) +uint8_t DFRobot_AS3935_I2C::AS3935GetSpikeRejection(void) { // This function is used to read SREJ (spike rejection). Similar to the Watchdog threshold, // it is used to make the system more robust to disturbers, though will make general detection @@ -283,11 +283,11 @@ uint8_t DF_AS3935_I2C::AS3935_GetSpikeRejection(void) // SREJ register: add 0x02, bits 3:0 // default value of 0010 // values should only be between 0x00 and 0x0F (0 and 7) - uint8_t reg_raw = _sing_reg_read(0x02); - return (reg_raw & 0x0F); + uint8_t regRaw = singRegRead(0x02); + return (regRaw & 0x0F); } -void DF_AS3935_I2C::AS3935_SetSpikeRejection(uint8_t srej) +void DFRobot_AS3935_I2C::AS3935SetSpikeRejection(uint8_t srej) { // This function is used to modify SREJ (spike rejection). Similar to the Watchdog threshold, // it is used to make the system more robust to disturbers, though will make general detection @@ -295,73 +295,73 @@ void DF_AS3935_I2C::AS3935_SetSpikeRejection(uint8_t srej) // WDTH register: add 0x02, bits 3:0 // default value of 0010 // values should only be between 0x00 and 0x0F (0 and 7) - _sing_reg_write(0x02, 0x0F, (srej & 0x0F)); + singRegWrite(0x02, 0x0F, (srej & 0x0F)); } -void DF_AS3935_I2C::AS3935_SetLCO_FDIV(uint8_t fdiv) +void DFRobot_AS3935_I2C::AS3935SetLcoFdiv(uint8_t fdiv) { // This function sets LCO_FDIV register. This is useful in the tuning of the antenna // LCO_FDIV register: add 0x03, bits 7:6 // default value: 00 // set 0, 1, 2 or 3 for ratios of 16, 32, 64 and 128, respectively. // See pg 23, Table 20 for more info. - _sing_reg_write(0x03, 0xC0, ((fdiv & 0x03) << 6)); + singRegWrite(0x03, 0xC0, ((fdiv & 0x03) << 6)); } -void DF_AS3935_I2C::AS3935_PrintAllRegs(void) +void DFRobot_AS3935_I2C::AS3935PrintAllRegs(void) { Serial.print("Reg 0x00: "); - Serial.println(_sing_reg_read(0x00)); + Serial.println(singRegRead(0x00)); Serial.print("Reg 0x01: "); - Serial.println(_sing_reg_read(0x01)); + Serial.println(singRegRead(0x01)); Serial.print("Reg 0x02: "); - Serial.println(_sing_reg_read(0x02)); + Serial.println(singRegRead(0x02)); Serial.print("Reg 0x03: "); - Serial.println(_sing_reg_read(0x03)); + Serial.println(singRegRead(0x03)); Serial.print("Reg 0x04: "); - Serial.println(_sing_reg_read(0x04)); + Serial.println(singRegRead(0x04)); Serial.print("Reg 0x05: "); - Serial.println(_sing_reg_read(0x05)); + Serial.println(singRegRead(0x05)); Serial.print("Reg 0x06: "); - Serial.println(_sing_reg_read(0x06)); + Serial.println(singRegRead(0x06)); Serial.print("Reg 0x07: "); - Serial.println(_sing_reg_read(0x07)); + Serial.println(singRegRead(0x07)); Serial.print("Reg 0x08: "); - Serial.println(_sing_reg_read(0x08)); - uint32_t nrgy_val = AS3935_GetStrikeEnergyRaw(); - Serial.println(nrgy_val); + Serial.println(singRegRead(0x08)); + uint32_t nrgyVal = AS3935GetStrikeEnergyRaw(); + Serial.println(nrgyVal); } -void DF_AS3935_I2C::AS3935_ManualCal(uint8_t capacitance, uint8_t location, uint8_t disturber) +void DFRobot_AS3935_I2C::AS3935ManualCal(uint8_t capacitance, uint8_t location, uint8_t disturber) { // start by powering up - AS3935_PowerUp(); + AS3935PowerUp(); // indoors/outdoors next... if(1 == location) // set outdoors if 1 { - AS3935_SetOutdoors(); + AS3935SetOutdoors(); } else // set indoors if anything but 1 { - AS3935_SetIndoors(); + AS3935SetIndoors(); } // disturber cal if(0 == disturber) // disabled if 0 { - AS3935_DisturberDis(); + AS3935DisturberDis(); } else // enabled if anything but 0 { - AS3935_DisturberEn(); + AS3935DisturberEn(); } - AS3935_SetIRQ_Output_Source(0); + AS3935SetIRQOutputSource(0); delay(500); // capacitance first... directly write value here - AS3935_SetTuningCaps(capacitance); + AS3935SetTuningCaps(capacitance); Serial.println("AS3935 manual cal complete"); } diff --git a/DFRobot_AS3935_I2C.h b/DFRobot_AS3935_I2C.h index 5c2636d..cc7d667 100644 --- a/DFRobot_AS3935_I2C.h +++ b/DFRobot_AS3935_I2C.h @@ -1,5 +1,5 @@ -#ifndef DF_AS3935_I2C_h -#define DF_AS3935_I2C_h +#ifndef DFRobot_AS3935_I2C_h +#define DFRobot_AS3935_I2C_h #include "Arduino.h" #include "avr/pgmspace.h" @@ -12,48 +12,48 @@ #define AS3935_ADD3 0x03 // A0=high, A1=high #define AS3935_ADD2 0x02 // A0=low, A1=high -class DF_AS3935_I2C +class DFRobot_AS3935_I2C { public: - DF_AS3935_I2C(uint8_t IRQx, uint8_t DEVADDx); + DFRobot_AS3935_I2C(uint8_t irqx, uint8_t devAddx); /*! Set i2c address */ - void AS3935_SetI2CAddress(uint8_t DEVADDx); + void AS3935SetI2CAddress(uint8_t devAddx); /*! Manual calibration */ - void AS3935_ManualCal(uint8_t capacitance, uint8_t location, uint8_t disturber); + void AS3935ManualCal(uint8_t capacitance, uint8_t location, uint8_t disturber); /*! reset registers to default */ - void AS3935_DefInit(void); - void AS3935_PowerUp(void); - void AS3935_PowerDown(void); - void AS3935_DisturberEn(void); - void AS3935_DisturberDis(void); - void AS3935_SetIRQ_Output_Source(uint8_t irq_select); - void AS3935_SetTuningCaps(uint8_t cap_val); + void AS3935DefInit(void); + void AS3935PowerUp(void); + void AS3935PowerDown(void); + void AS3935DisturberEn(void); + void AS3935DisturberDis(void); + void AS3935SetIRQOutputSource(uint8_t irqSelect); + void AS3935SetTuningCaps(uint8_t capVal); /*! 0 = unknown src, 1 = lightning detected, 2 = disturber, 3 = Noise level too high */ - uint8_t AS3935_GetInterruptSrc(void); + uint8_t AS3935GetInterruptSrc(void); /*! Get rid of non-distance data */ - uint8_t AS3935_GetLightningDistKm(void); + uint8_t AS3935GetLightningDistKm(void); /*! Get lightning energy intensity */ - uint32_t AS3935_GetStrikeEnergyRaw(void); - uint8_t AS3935_SetMinStrikes(uint8_t min_strk); - void AS3935_ClearStatistics(void); - void AS3935_SetIndoors(void); - void AS3935_SetOutdoors(void); - uint8_t AS3935_GetNoiseFloorLvl(void); - void AS3935_SetNoiseFloorLvl(uint8_t nf_sel); - uint8_t AS3935_GetWatchdogThreshold(void); - void AS3935_SetWatchdogThreshold(uint8_t wdth); - uint8_t AS3935_GetSpikeRejection(void); - void AS3935_SetSpikeRejection(uint8_t srej); - void AS3935_SetLCO_FDIV(uint8_t fdiv); + uint32_t AS3935GetStrikeEnergyRaw(void); + uint8_t AS3935SetMinStrikes(uint8_t minStrk); + void AS3935ClearStatistics(void); + void AS3935SetIndoors(void); + void AS3935SetOutdoors(void); + uint8_t AS3935GetNoiseFloorLvl(void); + void AS3935SetNoiseFloorLvl(uint8_t nfSel); + uint8_t AS3935GetWatchdogThreshold(void); + void AS3935SetWatchdogThreshold(uint8_t wdth); + uint8_t AS3935GetSpikeRejection(void); + void AS3935SetSpikeRejection(uint8_t srej); + void AS3935SetLcoFdiv(uint8_t fdiv); /*! View register data */ - void AS3935_PrintAllRegs(void); + void AS3935PrintAllRegs(void); private: - uint8_t _irq, _si, _devadd; - uint8_t _sing_reg_read(uint8_t RegAdd); - void _sing_reg_write(uint8_t RegAdd, uint8_t DataMask, uint8_t RegData); - void _AS3935_Reset(void); - void _CalRCO(void); + uint8_t irq, devAdd; + uint8_t singRegRead(uint8_t regAdd); + void singRegWrite(uint8_t regAdd, uint8_t dataMask, uint8_t regData); + void AS3935Reset(void); + void calRCO(void); }; #endif diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..8000a6f --- /dev/null +++ b/LICENSE @@ -0,0 +1,504 @@ + GNU LESSER GENERAL PUBLIC LICENSE + Version 2.1, February 1999 + + Copyright (C) 1991, 1999 Free Software Foundation, Inc. + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + +[This is the first released version of the Lesser GPL. It also counts + as the successor of the GNU Library Public License, version 2, hence + the version number 2.1.] + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +Licenses are intended to guarantee your freedom to share and change +free software--to make sure the software is free for all its users. + + This license, the Lesser General Public License, applies to some +specially designated software packages--typically libraries--of the +Free Software Foundation and other authors who decide to use it. You +can use it too, but we suggest you first think carefully about whether +this license or the ordinary General Public License is the better +strategy to use in any particular case, based on the explanations below. + + When we speak of free software, we are referring to freedom of use, +not price. Our General Public Licenses are designed to make sure that +you have the freedom to distribute copies of free software (and charge +for this service if you wish); that you receive source code or can get +it if you want it; that you can change the software and use pieces of +it in new free programs; and that you are informed that you can do +these things. + + To protect your rights, we need to make restrictions that forbid +distributors to deny you these rights or to ask you to surrender these +rights. These restrictions translate to certain responsibilities for +you if you distribute copies of the library or if you modify it. + + For example, if you distribute copies of the library, whether gratis +or for a fee, you must give the recipients all the rights that we gave +you. You must make sure that they, too, receive or can get the source +code. If you link other code with the library, you must provide +complete object files to the recipients, so that they can relink them +with the library after making changes to the library and recompiling +it. And you must show them these terms so they know their rights. + + We protect your rights with a two-step method: (1) we copyright the +library, and (2) we offer you this license, which gives you legal +permission to copy, distribute and/or modify the library. + + To protect each distributor, we want to make it very clear that +there is no warranty for the free library. Also, if the library is +modified by someone else and passed on, the recipients should know +that what they have is not the original version, so that the original +author's reputation will not be affected by problems that might be +introduced by others. + + Finally, software patents pose a constant threat to the existence of +any free program. We wish to make sure that a company cannot +effectively restrict the users of a free program by obtaining a +restrictive license from a patent holder. Therefore, we insist that +any patent license obtained for a version of the library must be +consistent with the full freedom of use specified in this license. + + Most GNU software, including some libraries, is covered by the +ordinary GNU General Public License. This license, the GNU Lesser +General Public License, applies to certain designated libraries, and +is quite different from the ordinary General Public License. We use +this license for certain libraries in order to permit linking those +libraries into non-free programs. + + When a program is linked with a library, whether statically or using +a shared library, the combination of the two is legally speaking a +combined work, a derivative of the original library. The ordinary +General Public License therefore permits such linking only if the +entire combination fits its criteria of freedom. The Lesser General +Public License permits more lax criteria for linking other code with +the library. + + We call this license the "Lesser" General Public License because it +does Less to protect the user's freedom than the ordinary General +Public License. It also provides other free software developers Less +of an advantage over competing non-free programs. These disadvantages +are the reason we use the ordinary General Public License for many +libraries. However, the Lesser license provides advantages in certain +special circumstances. + + For example, on rare occasions, there may be a special need to +encourage the widest possible use of a certain library, so that it becomes +a de-facto standard. To achieve this, non-free programs must be +allowed to use the library. A more frequent case is that a free +library does the same job as widely used non-free libraries. In this +case, there is little to gain by limiting the free library to free +software only, so we use the Lesser General Public License. + + In other cases, permission to use a particular library in non-free +programs enables a greater number of people to use a large body of +free software. For example, permission to use the GNU C Library in +non-free programs enables many more people to use the whole GNU +operating system, as well as its variant, the GNU/Linux operating +system. + + Although the Lesser General Public License is Less protective of the +users' freedom, it does ensure that the user of a program that is +linked with the Library has the freedom and the wherewithal to run +that program using a modified version of the Library. + + The precise terms and conditions for copying, distribution and +modification follow. Pay close attention to the difference between a +"work based on the library" and a "work that uses the library". The +former contains code derived from the library, whereas the latter must +be combined with the library in order to run. + + GNU LESSER GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License Agreement applies to any software library or other +program which contains a notice placed by the copyright holder or +other authorized party saying it may be distributed under the terms of +this Lesser General Public License (also called "this License"). +Each licensee is addressed as "you". + + A "library" means a collection of software functions and/or data +prepared so as to be conveniently linked with application programs +(which use some of those functions and data) to form executables. + + The "Library", below, refers to any such software library or work +which has been distributed under these terms. A "work based on the +Library" means either the Library or any derivative work under +copyright law: that is to say, a work containing the Library or a +portion of it, either verbatim or with modifications and/or translated +straightforwardly into another language. (Hereinafter, translation is +included without limitation in the term "modification".) + + "Source code" for a work means the preferred form of the work for +making modifications to it. For a library, complete source code means +all the source code for all modules it contains, plus any associated +interface definition files, plus the scripts used to control compilation +and installation of the library. + + Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running a program using the Library is not restricted, and output from +such a program is covered only if its contents constitute a work based +on the Library (independent of the use of the Library in a tool for +writing it). Whether that is true depends on what the Library does +and what the program that uses the Library does. + + 1. You may copy and distribute verbatim copies of the Library's +complete source code as you receive it, in any medium, provided that +you conspicuously and appropriately publish on each copy an +appropriate copyright notice and disclaimer of warranty; keep intact +all the notices that refer to this License and to the absence of any +warranty; and distribute a copy of this License along with the +Library. + + You may charge a fee for the physical act of transferring a copy, +and you may at your option offer warranty protection in exchange for a +fee. + + 2. You may modify your copy or copies of the Library or any portion +of it, thus forming a work based on the Library, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) The modified work must itself be a software library. + + b) You must cause the files modified to carry prominent notices + stating that you changed the files and the date of any change. + + c) You must cause the whole of the work to be licensed at no + charge to all third parties under the terms of this License. + + d) If a facility in the modified Library refers to a function or a + table of data to be supplied by an application program that uses + the facility, other than as an argument passed when the facility + is invoked, then you must make a good faith effort to ensure that, + in the event an application does not supply such function or + table, the facility still operates, and performs whatever part of + its purpose remains meaningful. + + (For example, a function in a library to compute square roots has + a purpose that is entirely well-defined independent of the + application. Therefore, Subsection 2d requires that any + application-supplied function or table used by this function must + be optional: if the application does not supply it, the square + root function must still compute square roots.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Library, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Library, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote +it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Library. + +In addition, mere aggregation of another work not based on the Library +with the Library (or with a work based on the Library) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may opt to apply the terms of the ordinary GNU General Public +License instead of this License to a given copy of the Library. To do +this, you must alter all the notices that refer to this License, so +that they refer to the ordinary GNU General Public License, version 2, +instead of to this License. (If a newer version than version 2 of the +ordinary GNU General Public License has appeared, then you can specify +that version instead if you wish.) Do not make any other change in +these notices. + + Once this change is made in a given copy, it is irreversible for +that copy, so the ordinary GNU General Public License applies to all +subsequent copies and derivative works made from that copy. + + This option is useful when you wish to copy part of the code of +the Library into a program that is not a library. + + 4. You may copy and distribute the Library (or a portion or +derivative of it, under Section 2) in object code or executable form +under the terms of Sections 1 and 2 above provided that you accompany +it with the complete corresponding machine-readable source code, which +must be distributed under the terms of Sections 1 and 2 above on a +medium customarily used for software interchange. + + If distribution of object code is made by offering access to copy +from a designated place, then offering equivalent access to copy the +source code from the same place satisfies the requirement to +distribute the source code, even though third parties are not +compelled to copy the source along with the object code. + + 5. A program that contains no derivative of any portion of the +Library, but is designed to work with the Library by being compiled or +linked with it, is called a "work that uses the Library". Such a +work, in isolation, is not a derivative work of the Library, and +therefore falls outside the scope of this License. + + However, linking a "work that uses the Library" with the Library +creates an executable that is a derivative of the Library (because it +contains portions of the Library), rather than a "work that uses the +library". The executable is therefore covered by this License. +Section 6 states terms for distribution of such executables. + + When a "work that uses the Library" uses material from a header file +that is part of the Library, the object code for the work may be a +derivative work of the Library even though the source code is not. +Whether this is true is especially significant if the work can be +linked without the Library, or if the work is itself a library. The +threshold for this to be true is not precisely defined by law. + + If such an object file uses only numerical parameters, data +structure layouts and accessors, and small macros and small inline +functions (ten lines or less in length), then the use of the object +file is unrestricted, regardless of whether it is legally a derivative +work. (Executables containing this object code plus portions of the +Library will still fall under Section 6.) + + Otherwise, if the work is a derivative of the Library, you may +distribute the object code for the work under the terms of Section 6. +Any executables containing that work also fall under Section 6, +whether or not they are linked directly with the Library itself. + + 6. As an exception to the Sections above, you may also combine or +link a "work that uses the Library" with the Library to produce a +work containing portions of the Library, and distribute that work +under terms of your choice, provided that the terms permit +modification of the work for the customer's own use and reverse +engineering for debugging such modifications. + + You must give prominent notice with each copy of the work that the +Library is used in it and that the Library and its use are covered by +this License. You must supply a copy of this License. If the work +during execution displays copyright notices, you must include the +copyright notice for the Library among them, as well as a reference +directing the user to the copy of this License. Also, you must do one +of these things: + + a) Accompany the work with the complete corresponding + machine-readable source code for the Library including whatever + changes were used in the work (which must be distributed under + Sections 1 and 2 above); and, if the work is an executable linked + with the Library, with the complete machine-readable "work that + uses the Library", as object code and/or source code, so that the + user can modify the Library and then relink to produce a modified + executable containing the modified Library. (It is understood + that the user who changes the contents of definitions files in the + Library will not necessarily be able to recompile the application + to use the modified definitions.) + + b) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (1) uses at run time a + copy of the library already present on the user's computer system, + rather than copying library functions into the executable, and (2) + will operate properly with a modified version of the library, if + the user installs one, as long as the modified version is + interface-compatible with the version that the work was made with. + + c) Accompany the work with a written offer, valid for at + least three years, to give the same user the materials + specified in Subsection 6a, above, for a charge no more + than the cost of performing this distribution. + + d) If distribution of the work is made by offering access to copy + from a designated place, offer equivalent access to copy the above + specified materials from the same place. + + e) Verify that the user has already received a copy of these + materials or that you have already sent this user a copy. + + For an executable, the required form of the "work that uses the +Library" must include any data and utility programs needed for +reproducing the executable from it. However, as a special exception, +the materials to be distributed need not include anything that is +normally distributed (in either source or binary form) with the major +components (compiler, kernel, and so on) of the operating system on +which the executable runs, unless that component itself accompanies +the executable. + + It may happen that this requirement contradicts the license +restrictions of other proprietary libraries that do not normally +accompany the operating system. Such a contradiction means you cannot +use both them and the Library together in an executable that you +distribute. + + 7. You may place library facilities that are a work based on the +Library side-by-side in a single library together with other library +facilities not covered by this License, and distribute such a combined +library, provided that the separate distribution of the work based on +the Library and of the other library facilities is otherwise +permitted, and provided that you do these two things: + + a) Accompany the combined library with a copy of the same work + based on the Library, uncombined with any other library + facilities. This must be distributed under the terms of the + Sections above. + + b) Give prominent notice with the combined library of the fact + that part of it is a work based on the Library, and explaining + where to find the accompanying uncombined form of the same work. + + 8. You may not copy, modify, sublicense, link with, or distribute +the Library except as expressly provided under this License. Any +attempt otherwise to copy, modify, sublicense, link with, or +distribute the Library is void, and will automatically terminate your +rights under this License. However, parties who have received copies, +or rights, from you under this License will not have their licenses +terminated so long as such parties remain in full compliance. + + 9. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Library or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Library (or any work based on the +Library), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Library or works based on it. + + 10. Each time you redistribute the Library (or any work based on the +Library), the recipient automatically receives a license from the +original licensor to copy, distribute, link with or modify the Library +subject to these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties with +this License. + + 11. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Library at all. For example, if a patent +license would not permit royalty-free redistribution of the Library by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Library. + +If any portion of this section is held invalid or unenforceable under any +particular circumstance, the balance of the section is intended to apply, +and the section as a whole is intended to apply in other circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 12. If the distribution and/or use of the Library is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Library under this License may add +an explicit geographical distribution limitation excluding those countries, +so that distribution is permitted only in or among countries not thus +excluded. In such case, this License incorporates the limitation as if +written in the body of this License. + + 13. The Free Software Foundation may publish revised and/or new +versions of the Lesser General Public License from time to time. +Such new versions will be similar in spirit to the present version, +but may differ in detail to address new problems or concerns. + +Each version is given a distinguishing version number. If the Library +specifies a version number of this License which applies to it and +"any later version", you have the option of following the terms and +conditions either of that version or of any later version published by +the Free Software Foundation. If the Library does not specify a +license version number, you may choose any version ever published by +the Free Software Foundation. + + 14. If you wish to incorporate parts of the Library into other free +programs whose distribution conditions are incompatible with these, +write to the author to ask for permission. For software which is +copyrighted by the Free Software Foundation, write to the Free +Software Foundation; we sometimes make exceptions for this. Our +decision will be guided by the two goals of preserving the free status +of all derivatives of our free software and of promoting the sharing +and reuse of software generally. + + NO WARRANTY + + 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO +WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. +EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR +OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY +KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE +LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME +THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN +WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY +AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU +FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR +CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE +LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING +RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A +FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF +SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH +DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Libraries + + If you develop a new library, and you want it to be of the greatest +possible use to the public, we recommend making it free software that +everyone can redistribute and change. You can do so by permitting +redistribution under these terms (or, alternatively, under the terms of the +ordinary General Public License). + + To apply these terms, attach the following notices to the library. It is +safest to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least the +"copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + 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 2.1 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 Street, Fifth Floor, Boston, MA 02110-1301 + USA + +Also add information on how to contact you by electronic and paper mail. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the library, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the + library `Frob' (a library for tweaking knobs) written by James Random + Hacker. + + , 1 April 1990 + Ty Coon, President of Vice + +That's all there is to it! diff --git a/Lib_I2C.cpp b/Lib_I2C.cpp index 3465496..31d6ce6 100644 --- a/Lib_I2C.cpp +++ b/Lib_I2C.cpp @@ -555,8 +555,8 @@ uint8_t I2C::read(uint8_t address, uint8_t registerAddress, uint8_t numberBytes, uint8_t I2C::start() { unsigned long startingTime = millis(); - TWCR = (1<= timeOutDelay) @@ -583,8 +583,8 @@ uint8_t I2C::sendAddress(uint8_t i2cAddress) { TWDR = i2cAddress; unsigned long startingTime = millis(); - TWCR = (1<= timeOutDelay) @@ -615,8 +615,8 @@ uint8_t I2C::sendByte(uint8_t i2cData) { TWDR = i2cData; unsigned long startingTime = millis(); - TWCR = (1<= timeOutDelay) @@ -648,14 +648,14 @@ uint8_t I2C::receiveByte(uint8_t ack) unsigned long startingTime = millis(); if(ack) { - TWCR = (1<= timeOutDelay) @@ -704,8 +704,8 @@ uint8_t I2C::receiveByte(uint8_t ack, uint8_t *target) uint8_t I2C::stop() { unsigned long startingTime = millis(); - TWCR = (1<= timeOutDelay) diff --git a/examples/DFRobot_AS3935_lightning_sensor/DFRobot_AS3935_lightning_sensor.ino b/examples/DFRobot_AS3935_lightning_sensor/DFRobot_AS3935_lightning_sensor.ino index 99109df..d373b7e 100644 --- a/examples/DFRobot_AS3935_lightning_sensor/DFRobot_AS3935_lightning_sensor.ino +++ b/examples/DFRobot_AS3935_lightning_sensor/DFRobot_AS3935_lightning_sensor.ino @@ -1,5 +1,5 @@ /*! - file DFRobot_AS3935_lightning_I2c.ino + file DFRobot_AS3935_lightning_sensor.ino SEN0290 Lightning Sensor This sensor can detect lightning and display the distance and intensity of the lightning within 40 km @@ -12,14 +12,14 @@ Copyright [DFRobot](http://www.dfrobot.com), 2018 Copyright GNU Lesser General Public License - version V0.2 - date 2018-10-08 + version V0.3 + date 2018-11-13 */ #include "Lib_I2C.h" #include "DFRobot_AS3935_I2C.h" -volatile int8_t AS3935_ISR_Trig = 0; +volatile int8_t AS3935IsrTrig = 0; #define IRQ_PIN 2 @@ -41,7 +41,7 @@ volatile int8_t AS3935_ISR_Trig = 0; void AS3935_ISR(); -DF_AS3935_I2C lightning0((uint8_t)IRQ_PIN, (uint8_t)AS3935_I2C_ADDR); +DFRobot_AS3935_I2C lightning0((uint8_t)IRQ_PIN, (uint8_t)AS3935_I2C_ADDR); void setup() { @@ -56,9 +56,9 @@ void setup() delay(2); // Set registers to default - lightning0.AS3935_DefInit(); + lightning0.AS3935DefInit(); // Configure sensor - lightning0.AS3935_ManualCal(AS3935_CAPACITANCE, AS3935_MODE, AS3935_DIST); + lightning0.AS3935ManualCal(AS3935_CAPACITANCE, AS3935_MODE, AS3935_DIST); // Enable interrupt (connect IRQ pin IRQ_PIN: 2, default) // Connect the IRQ and GND pin to the oscilloscope. @@ -66,7 +66,7 @@ void setup() // This will dispaly the antenna's resonance frequency/16 on IRQ pin (The resonance frequency will be divided by 16 on this pin) // Tuning AS3935_CAPACITANCE to make the frequency within 500/16 kHz ± 3.5% // lightning0.AS3935_SetLCO_FDIV(0); -// lightning0.AS3935_SetIRQ_Output_Source(3); +// lightning0.AS3935SetIRQOutputSource(3); attachInterrupt(0, AS3935_ISR, RISING); @@ -75,34 +75,34 @@ void setup() void loop() { // It does nothing until an interrupt is detected on the IRQ pin. - while (AS3935_ISR_Trig == 0) {} + while (AS3935IsrTrig == 0) {} delay(5); // Reset interrupt flag - AS3935_ISR_Trig = 0; + AS3935IsrTrig = 0; // Get interrupt source - uint8_t int_src = lightning0.AS3935_GetInterruptSrc(); - if (int_src == 1) + uint8_t intSrc = lightning0.AS3935GetInterruptSrc(); + if (intSrc == 1) { // Get rid of non-distance data - uint8_t lightning_dist_km = lightning0.AS3935_GetLightningDistKm(); + uint8_t lightningDistKm = lightning0.AS3935GetLightningDistKm(); Serial.println("Lightning occurs!"); Serial.print("Distance: "); - Serial.print(lightning_dist_km); + Serial.print(lightningDistKm); Serial.println(" km"); // Get lightning energy intensity - uint32_t lightning_energy_val = lightning0.AS3935_GetStrikeEnergyRaw(); + uint32_t lightningEnergyVal = lightning0.AS3935GetStrikeEnergyRaw(); Serial.print("Intensity: "); - Serial.print(lightning_energy_val); + Serial.print(lightningEnergyVal); Serial.println(""); } - else if (int_src == 2) + else if (intSrc == 2) { Serial.println("Disturber discovered!"); } - else if (int_src == 3) + else if (intSrc == 3) { Serial.println("Noise level too high!"); } @@ -112,6 +112,6 @@ void loop() //IRQ handler for AS3935 interrupts void AS3935_ISR() { - AS3935_ISR_Trig = 1; + AS3935IsrTrig = 1; } diff --git a/keywords.txt b/keywords.txt index 35f937d..6a7dd09 100644 --- a/keywords.txt +++ b/keywords.txt @@ -6,7 +6,7 @@ # Datatypes (KEYWORD1) ####################################### -DF_AS3935_I2C KEYWORD1 +DFRobot_AS3935_I2C KEYWORD1 I2C KEYWORD1 ####################################### @@ -23,33 +23,31 @@ write KEYWORD2 read KEYWORD2 available KEYWORD2 receive KEYWORD2 -AS3935_DefInit KEYWORD2 -AS3935_DefInit KEYWORD2 -_AS3935_Reset KEYWORD2 -_CalRCO KEYWORD2 -AS3935_PowerUp KEYWORD2 -AS3935_PowerDown KEYWORD2 -AS3935_DisturberEn KEYWORD2 -AS3935_DisturberDis KEYWORD2 -AS3935_SetIRQ_Output_Source KEYWORD2 -AS3935_SetTuningCaps KEYWORD2 -AS3935_GetInterruptSrc KEYWORD2 -AS3935_GetLightningDistKm KEYWORD2 -AS3935_SetMinStrikes KEYWORD2 -AS3935_SetIndoors KEYWORD2 -AS3935_SetOutdoors KEYWORD2 -AS3935_ClearStatistics KEYWORD2 -AS3935_GetNoiseFloorLvl KEYWORD2 -AS3935_SetNoiseFloorLvl KEYWORD2 -AS3935_GetWatchdogThreshold KEYWORD2 -AS3935_SetWatchdogThreshold KEYWORD2 -AS3935_GetSpikeRejection KEYWORD2 -AS3935_SetSpikeRejection KEYWORD2 -AS3935_SetLCO_FDIV KEYWORD2 -AS3935_PrintAllRegs KEYWORD2 -AS3935_ManualCal KEYWORD2 -AS3935_SetI2CAddress KEYWORD2 +AS3935SetI2CAddress KEYWORD2 +AS3935ManualCal KEYWORD2 +AS3935DefInit KEYWORD2 +AS3935PowerUp KEYWORD2 +AS3935PowerDown KEYWORD2 +AS3935DisturberEn KEYWORD2 +AS3935DisturberDis KEYWORD2 +AS3935SetIRQOutputSource KEYWORD2 +AS3935SetTuningCaps KEYWORD2 +AS3935GetInterruptSrc KEYWORD2 +AS3935GetLightningDistKm KEYWORD2 +AS3935GetStrikeEnergyRaw KEYWORD2 +AS3935SetMinStrikes KEYWORD2 +AS3935ClearStatistics KEYWORD2 +AS3935SetIndoors KEYWORD2 +AS3935SetOutdoors KEYWORD2 +AS3935GetNoiseFloorLvl KEYWORD2 +AS3935SetNoiseFloorLvl KEYWORD2 +AS3935GetWatchdogThreshold KEYWORD2 +AS3935SetWatchdogThreshold KEYWORD2 +AS3935GetSpikeRejection KEYWORD2 +AS3935SetSpikeRejection KEYWORD2 +AS3935SetLcoFdiv KEYWORD2 +AS3935PrintAllRegs KEYWORD2 ####################################### # Constants (LITERAL1) diff --git a/readme.md b/readme.md index c109263..d0fb724 100644 --- a/readme.md +++ b/readme.md @@ -45,23 +45,22 @@ Download the library ZIP file and unzip it to the Arduino folder of the library. /* * @brief AS3935 object * - * @param IRQx irq pin - * SIx si pin - * DEVADDx i2c address + * @param irqx irq pin + * devAddx i2c address */ -DF_AS3935_I2C(uint8_t IRQx, uint8_t SIx, uint8_t DEVADDx); +DFRobot_AS3935_I2C(uint8_t irqx, uint8_t devAddx); /* * @brief reset registers to default */ -void AS3935_DefInit(void); +void AS3935DefInit(void); /* * @brief set i2c address * - * @param DEVADDx i2c address + * @param devAddx i2c address */ -void AS3935_SetI2CAddress(uint8_t DEVADDx); +void AS3935SetI2CAddress(uint8_t devAddx); /* * @brief manual calibration @@ -70,12 +69,12 @@ void AS3935_SetI2CAddress(uint8_t DEVADDx); * location location * disturber disturber */ -void AS3935_ManualCal(uint8_t capacitance, uint8_t location, uint8_t disturber); +void AS3935ManualCal(uint8_t capacitance, uint8_t location, uint8_t disturber); /* * @brief view register data */ -void AS3935_PrintAllRegs(void); +void AS3935PrintAllRegs(void); /* * @brief get interrupt source @@ -85,21 +84,46 @@ void AS3935_PrintAllRegs(void); * 2 disturber detected * 3 Noise level too high */ -uint8_t AS3935_GetInterruptSrc(void); +uint8_t AS3935GetInterruptSrc(void); /* * @brief get lightning distance * * @return unit kilometer */ -uint8_t AS3935_GetLightningDistKm(void); +uint8_t AS3935GetLightningDistKm(void); /* * @brief get lightning energy intensity * * @return lightning energy intensity(0-1000) */ -uint32_t AS3935_GetStrikeEnergyRaw(void); +uint32_t AS3935GetStrikeEnergyRaw(void); + +/* + * @brief Set to the outdoor model + */ +void AS3935SetOutdoors(void); + +/* + * @brief Set to the indoor model + */ +void AS3935SetIndoors(void); + +/* + * @brief Print all register values + */ +void AS3935PrintAllRegs(void); + +/* + * @brief Disturber detection enabled + */ +void DFRobot_AS3935_I2C::AS3935DisturberEn(void); + +/* + * @brief Disturber detection disenabled + */ +void DFRobot_AS3935_I2C::AS3935DisturberDis(void); ``` @@ -114,4 +138,4 @@ Arduino uno | √ | | | ## Credits -Written by DFRobot, 2018. (Welcome to our [website](https://www.dfrobot.com/)) +Written by DFRobot_JH, 2018. (Welcome to our [website](https://www.dfrobot.com/))