import utime from machine import Pin, I2C class DFRobot_AS3935: def __init__(self, address, i2c): self.address = address self.i2cbus = i2c def writeByte(self, register, value): try: self.i2cbus.writeto_mem(self.address, register, bytes([value])) return 1 except: return 0 def readData(self, register): self.register = self.i2cbus.readfrom_mem(self.address, register, 1) def manualCal(self, capacitance, location, disturber): self.powerUp() if location == 1: self.setIndoors() else: self.setOutdoors() if disturber == 0: self.disturberDis() else: self.disturberEn() self.setIrqOutputSource(0) utime.sleep(0.5) self.setTuningCaps(capacitance) def setTuningCaps(self, capVal): #Assume only numbers divisible by 8 (because that's all the chip supports) if capVal > 120: #cap_value out of range, assume highest capacitance self.singRegWrite(0x08, 0x0F, 0x0F) #set capacitance bits to maximum else: self.singRegWrite(0x08, 0x0F, capVal >> 3) #set capacitance bits self.singRegRead(0x08) #print('capacitance set to 8x%d'%(self.register[0] & 0x0F)) def powerUp(self): #register 0x00, PWD bit: 0 (clears PWD) self.singRegWrite(0x00, 0x01, 0x00) self.calRCO() #run RCO cal cmd self.singRegWrite(0x08, 0x20, 0x20) #set DISP_SRCO to 1 utime.sleep(0.002) self.singRegWrite(0x08, 0x20, 0x00) #set DISP_SRCO to 0 def powerDown(self): #register 0x00, PWD bit: 0 (sets PWD) self.singRegWrite(0x00, 0x01, 0x01) def calRCO(self): self.writeByte(0x3D, 0x96) utime.sleep(0.002) def setIndoors(self): self.singRegWrite(0x00, 0x3E, 0x24) print("set to indoors model") def setOutdoors(self): self.singRegWrite(0x00, 0x3E, 0x1C) print("set to outdoors model") def disturberDis(self): #register 0x03, PWD bit: 5 (sets MASK_DIST) self.singRegWrite(0x03, 0x20, 0x20) print("disenable disturber detection") def disturberEn(self): #register 0x03, PWD bit: 5 (sets MASK_DIST) self.singRegWrite(0x03, 0x20, 0x00) print("enable disturber detection") def singRegWrite(self, regAdd, dataMask, regData): #start by reading original register data (only modifying what we need to) self.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 newRegData = (self.register[0] & ~dataMask)|(regData & dataMask) #finally, write the data to the register self.writeByte(regAdd, newRegData) #print('wrt: %02x'%newRegData) self.singRegRead(regAdd) #print('Act: %02x'%self.register[0]) def singRegRead(self,regAdd): self.readData(regAdd) def getInterruptSrc(self): #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 utime.sleep(0.03) #wait 3ms before reading (min 2ms per pg 22 of datasheet) self.singRegRead(0x03) #read register, get rid of non-interrupt data intSrc = self.register[0]&0x0F if intSrc == 0x08: return 1 #lightning caused interrupt elif intSrc == 0x04: return 2 #disturber detected elif intSrc == 0x01: return 3 #Noise level too high else: return 0 #interrupt result not expected def reset(self): err = self.writeByte(0x3C, 0x96) utime.sleep(0.002) #wait 2ms to complete return err def setLcoFdiv(self,fdiv): self.singRegWrite(0x03, 0xC0, (fdiv & 0x03) << 6) def setIrqOutputSource(self, 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 irqSelect == 1: self.singRegWrite(0x08, 0xE0, 0x20) #set only TRCO bit elif irqSelect == 2: self.singRegWrite(0x08, 0xE0, 0x40) #set only SRCO bit elif irqSelect == 3: self.singRegWrite(0x08, 0xE0, 0x80) #set only SRCO bit else: self.singRegWrite(0x08, 0xE0, 0x00) #clear IRQ pin display bits def getLightningDistKm(self): self.singRegRead(0x07) #read register, get rid of non-distance data return self.register[0]&0x3F def getStrikeEnergyRaw(self): self.singRegRead(0x06) #MMSB, shift 8 bits left, make room for MSB nrgyRaw = (self.register[0]&0x1F) << 8 self.singRegRead(0x05) #read MSB nrgyRaw |= self.register[0] nrgyRaw <<= 8 #shift 8 bits left, make room for LSB self.singRegRead(0x04) #read LSB, add to others nrgyRaw |= self.register[0] return nrgyRaw/16777 def setMinStrikes(self, 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. if minStrk < 5: self.singRegWrite(0x02, 0x30, 0x00) return 1 elif minStrk < 9: self.singRegWrite(0x02, 0x30, 0x10) return 5 elif minStrk < 16: self.singRegWrite(0x02, 0x30, 0x20) return 9 else: self.singRegWrite(0x02, 0x30, 0x30) return 16 def clearStatistics(self): #clear is accomplished by toggling CL_STAT bit 'high-low-high' (then set low to move on) self.singRegWrite(0x02, 0x40, 0x40) #high self.singRegWrite(0x02, 0x40, 0x00) #low self.singRegWrite(0x02, 0x40, 0x40) #high def getNoiseFloorLv1(self): #NF settings addres 0x01, bits 6:4 #default setting of 010 at startup (datasheet, table 9) self.singRegRead(0x01) #read register 0x01 return (self.register[0] & 0x70) >> 4 #should return value from 0-7, see table 16 for info def setNoiseFloorLv1(self, nfSel): #NF settings addres 0x01, bits 6:4 #default setting of 010 at startup (datasheet, table 9) if nfSel <= 7: #nfSel within expected range self.singRegWrite(0x01, 0x70, (nfSel & 0x07) << 4) else: #out of range, set to default (power-up value 010) self.singRegWrite(0x01, 0x70, 0x20) def getWatchdogThreshold(self): #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 0010 #values should only be between 0x00 and 0x0F (0 and 7) self.singRegRead(0x01) return self.register[0] & 0x0F def setWatchdogThreshold(self, 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 0010 #values should only be between 0x00 and 0x0F (0 and 7) self.singRegWrite(0x01, 0x0F, wdth & 0x0F) def getSpikeRejection(self): #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 #less efficient (see page 20-21, especially Fig 21 of datasheet) #SREJ register: add 0x02, bits 3:0 #default value of 0010 #values should only be between 0x00 and 0x0F (0 and 7) self.singRegRead(0x02) return self.register[0] & 0x0F def setSpikeRejection(self, 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 #less efficient (see page 20-21, especially Fig 21 of datasheet) #WDTH register: add 0x02, bits 3:0 #default value of 0010 #values should only be between 0x00 and 0x0F (0 and 7) self.singRegWrite(0x02, 0x0F, srej & 0x0F) def printAllRegs(self): self.singRegRead(0x00) print("Reg 0x00: %02x"%self.register[0]) self.singRegRead(0x01) print("Reg 0x01: %02x"%self.register[0]) self.singRegRead(0x02) print("Reg 0x02: %02x"%self.register[0]) self.singRegRead(0x03) print("Reg 0x03: %02x"%self.register[0]) self.singRegRead(0x04) print("Reg 0x04: %02x"%self.register[0]) self.singRegRead(0x05) print("Reg 0x05: %02x"%self.register[0]) self.singRegRead(0x06) print("Reg 0x06: %02x"%self.register[0]) self.singRegRead(0x07) print("Reg 0x07: %02x"%self.register[0]) self.singRegRead(0x08) print("Reg 0x08: %02x"%self.register[0]) self.singRegRead(0x3A) print("Reg 0x3A: %02x"%self.register[0]) self.singRegRead(0x3B) print("Reg 0x3B: %02x"%self.register[0])