CE-PiicoDev-Buzzer-MicroPython-Module/PiicoDev_Buzzer.py at main · CoreElectronics/CE-PiicoDev-Buzzer-MicroPython-Module · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
from PiicoDev_Unified import *
_baseAddr=0x5C
_DevID=0x51
_regDevID=0x11
_regStatus=0x01
_regFirmMaj=0x02
_regFirmMin=0x03
_regI2cAddr=0x04
_regTone=0x05
_regVolume=0x06
_regLED=0x07
_regSelfTest = 0x09

class PiicoDev_Buzzer(object):
    def tone(self, freq, dur=0):
        _f=int(freq);_d=int(dur)
        f = _f.to_bytes(2,'big')
        d = _d.to_bytes(2,'big')
        try: self.i2c.writeto_mem(self.addr, _regTone, f+d); return 0
        except: print(i2c_err_str.format(self.addr)); return 1

    def noTone(self):
        r=self.tone(0); return r

    def volume(self, vol):
        if self.whoami[0] != 1:
            print("Warning: Volume not implemented on this hardware revision")
            return
        assert vol in [0,1,2],"volume must be 0, 1 or 2"
        try:
            self.i2c.writeto_mem(self.addr, _regVolume, vol.to_bytes(1,'big'))
            sleep_ms(5); return 0
        except: print(i2c_err_str.format(self.addr)); return 1

    def setI2Caddr(self, newAddr):
        x=int(newAddr)
        assert 8 <= x <= 0x77, 'address must be >=0x08 and <=0x77'
        try:
            self.i2c.writeto_mem(self.addr, _regI2cAddr, bytes([x]))
            self.addr = x
            sleep_ms(5)
            return 0
        except: print(i2c_err_str.format(self.addr)); return 1


    def readFirmware(self):
        v=[0,0]
        try:
            v[1]=self.i2c.readfrom_mem(self.addr, _regFirmMaj, 1)
            v[0]=self.i2c.readfrom_mem(self.addr, _regFirmMin, 1)
            return (int.from_bytes(v[1],'big'), int.from_bytes(v[0],'big'))
        except: return(0,0)

    @property
    def whoami(self):
        return self.readFirmware()

    @property
    def self_test(self):
        """Returns the result of the self-test"""
        result = self.i2c.readfrom_mem(self.addr, _regSelfTest, 1)
        return int.from_bytes(result,'big')

    def readStatus(self):
        sts=self.i2c.readfrom_mem(self.addr, _regStatus,1)
        return sts

    def readID(self):
        x=self.i2c.readfrom_mem(self.addr, _regDevID,1)
        return int.from_bytes(x,'big')

    def pwrLED(self, x):
        try: self.i2c.writeto_mem(self.addr, _regLED, bytes([x])); return 0
        except: print(i2c_err_str.format(self.addr)); return 1

    def __init__(self, bus=None, freq=None, sda=None, scl=None, addr=_baseAddr, id=None, volume=2):
        self.i2c = create_unified_i2c(bus=bus, freq=freq, sda=sda, scl=scl)
        a=addr
        if type(id) is list and not all(v == 0 for v in id): # preference using the ID argument. ignore id if all elements zero
            assert max(id) <= 1 and min(id) >= 0 and len(id) is 4, "id must be a list of 1/0, length=4"
            self.addr=8+id[0]+2*id[1]+4*id[2]+8*id[3] # select address from pool
        else: self.addr = addr # accept an integer
        try:
            self.i2c.writeto_mem(self.addr, _regLED, b'\x01') # Initialise pwr led on
        except Exception as e:
            print(i2c_err_str.format(self.addr))
            raise e
        if self.whoami[0] < 2: # volume deprecated in v20 design
            self.volume(volume)
        # TODO: Check device ID - seems to timeout on Raspberry Pi (clock stretching not implemented)
#         try:
#             if self.readID() != _DevID:
#                 print("* Incorrect device found at address {}".format(addr))
#         except:
#             print("* Couldn't find a device - check switches and wiring")
#