Thanks to visit codestin.com
Credit goes to github.com

Skip to content
This repository was archived by the owner on Sep 30, 2019. It is now read-only.

Commit 0dd29cd

Browse files
xtacocorexxtacocorex
committed
Adding protection for IOError in accessing i2c
1 parent 43a23ec commit 0dd29cd

File tree

1 file changed

+92
-36
lines changed

1 file changed

+92
-36
lines changed

‎Adafruit_GPIO/I2C.py‎

Lines changed: 92 additions & 36 deletions
Original file line numberDiff line numberDiff line change
@@ -21,6 +21,7 @@
2121
# THE SOFTWARE.
2222
import logging
2323
import subprocess
24+
import time
2425

2526
import smbus
2627

@@ -104,97 +105,152 @@ def __init__(self, address, busnum):
104105
def writeRaw8(self, value):
105106
"""Write an 8-bit value on the bus (without register)."""
106107
value = value & 0xFF
107-
self._bus.write_byte(self._address, value)
108-
self._logger.debug("Wrote 0x%02X",
108+
try:
109+
self._bus.write_byte(self._address, value)
110+
self._logger.debug("Wrote 0x%02X",
109111
value)
112+
except IOError, err:
113+
self._logger.exception("error in writeRaw8: %s", err)
114+
time.sleep(0.001)
110115

111116
def write8(self, register, value):
112117
"""Write an 8-bit value to the specified register."""
113118
value = value & 0xFF
114-
self._bus.write_byte_data(self._address, register, value)
115-
self._logger.debug("Wrote 0x%02X to register 0x%02X",
119+
try:
120+
self._bus.write_byte_data(self._address, register, value)
121+
self._logger.debug("Wrote 0x%02X to register 0x%02X",
116122
value, register)
123+
except IOError, err:
124+
self._logger.exception("error in write8: %s", err)
125+
time.sleep(0.001)
117126

118127
def write16(self, register, value):
119128
"""Write a 16-bit value to the specified register."""
120129
value = value & 0xFFFF
121-
self._bus.write_word_data(self._address, register, value)
122-
self._logger.debug("Wrote 0x%04X to register pair 0x%02X, 0x%02X",
130+
try:
131+
self._bus.write_word_data(self._address, register, value)
132+
self._logger.debug("Wrote 0x%04X to register pair 0x%02X, 0x%02X",
123133
value, register, register+1)
134+
except IOError, err:
135+
self._logger.exception("error in write16: %s", err)
136+
time.sleep(0.001)
124137

125138
def writeList(self, register, data):
126139
"""Write bytes to the specified register."""
127-
self._bus.write_i2c_block_data(self._address, register, data)
128-
self._logger.debug("Wrote to register 0x%02X: %s",
140+
try:
141+
self._bus.write_i2c_block_data(self._address, register, data)
142+
self._logger.debug("Wrote to register 0x%02X: %s",
129143
register, data)
144+
except IOError, err:
145+
self._logger.exception("error in writeList: %s", err)
146+
time.sleep(0.001)
130147

131148
def readList(self, register, length):
132149
"""Read a length number of bytes from the specified register. Results
133150
will be returned as a bytearray."""
134-
results = self._bus.read_i2c_block_data(self._address, register, length)
135-
self._logger.debug("Read the following from register 0x%02X: %s",
151+
try:
152+
results = self._bus.read_i2c_block_data(self._address, register, length)
153+
self._logger.debug("Read the following from register 0x%02X: %s",
136154
register, results)
137-
return results
155+
return results
156+
except IOError, err:
157+
self._logger.exception("error in readList: %s", err)
158+
time.sleep(0.001)
138159

139160
def readRaw8(self):
140161
"""Read an 8-bit value on the bus (without register)."""
141-
result = self._bus.read_byte(self._address) & 0xFF
142-
self._logger.debug("Read 0x%02X",
162+
try:
163+
result = self._bus.read_byte(self._address) & 0xFF
164+
self._logger.debug("Read 0x%02X",
143165
result)
144-
return result
166+
return result
167+
except IOError, err:
168+
self._logger.exception("error in readRaw8: %s", err)
169+
time.sleep(0.001)
145170

146171
def readU8(self, register):
147172
"""Read an unsigned byte from the specified register."""
148-
result = self._bus.read_byte_data(self._address, register) & 0xFF
149-
self._logger.debug("Read 0x%02X from register 0x%02X",
173+
try:
174+
result = self._bus.read_byte_data(self._address, register) & 0xFF
175+
self._logger.debug("Read 0x%02X from register 0x%02X",
150176
result, register)
151-
return result
177+
return result
178+
except IOError, err:
179+
self._logger.exception("error in readU8: %s", err)
180+
time.sleep(0.001)
152181

153182
def readS8(self, register):
154183
"""Read a signed byte from the specified register."""
155-
result = self.readU8(register)
156-
if result > 127:
157-
result -= 256
158-
return result
184+
try:
185+
result = self.readU8(register)
186+
if result > 127:
187+
result -= 256
188+
return result
189+
except IOError, err:
190+
self._logger.exception("error in readS8: %s", err)
191+
time.sleep(0.001)
159192

160193
def readU16(self, register, little_endian=True):
161194
"""Read an unsigned 16-bit value from the specified register, with the
162195
specified endianness (default little endian, or least significant byte
163196
first)."""
164-
result = self._bus.read_word_data(self._address,register) & 0xFFFF
165-
self._logger.debug("Read 0x%04X from register pair 0x%02X, 0x%02X",
197+
try:
198+
result = self._bus.read_word_data(self._address,register) & 0xFFFF
199+
self._logger.debug("Read 0x%04X from register pair 0x%02X, 0x%02X",
166200
result, register, register+1)
167-
# Swap bytes if using big endian because read_word_data assumes little
168-
# endian on ARM (little endian) systems.
169-
if not little_endian:
170-
result = ((result << 8) & 0xFF00) + (result >> 8)
171-
return result
201+
# Swap bytes if using big endian because read_word_data assumes little
202+
# endian on ARM (little endian) systems.
203+
if not little_endian:
204+
result = ((result << 8) & 0xFF00) + (result >> 8)
205+
return result
206+
except IOError, err:
207+
self._logger.exception("error in readU16: %s", err)
172208

173209
def readS16(self, register, little_endian=True):
174210
"""Read a signed 16-bit value from the specified register, with the
175211
specified endianness (default little endian, or least significant byte
176212
first)."""
177-
result = self.readU16(register, little_endian)
178-
if result > 32767:
179-
result -= 65536
180-
return result
213+
try:
214+
result = self.readU16(register, little_endian)
215+
if result > 32767:
216+
result -= 65536
217+
return result
218+
except IOError, err:
219+
self._logger.exception("error in readS16: %s", err)
220+
time.sleep(0.001)
181221

182222
def readU16LE(self, register):
183223
"""Read an unsigned 16-bit value from the specified register, in little
184224
endian byte order."""
185-
return self.readU16(register, little_endian=True)
225+
try:
226+
return self.readU16(register, little_endian=True)
227+
except IOError, err:
228+
self._logger.exception("error in readU16LE: %s", err)
229+
time.sleep(0.001)
186230

187231
def readU16BE(self, register):
188232
"""Read an unsigned 16-bit value from the specified register, in big
189233
endian byte order."""
190-
return self.readU16(register, little_endian=False)
234+
try:
235+
return self.readU16(register, little_endian=False)
236+
except IOError, err:
237+
self._logger.exception("error in readU16BE: %s", err)
238+
time.sleep(0.001)
191239

192240
def readS16LE(self, register):
193241
"""Read a signed 16-bit value from the specified register, in little
194242
endian byte order."""
195-
return self.readS16(register, little_endian=True)
243+
try:
244+
return self.readS16(register, little_endian=True)
245+
except IOError, err:
246+
self._logger.exception("error in readS16LE: %s", err)
247+
time.sleep(0.001)
196248

197249
def readS16BE(self, register):
198250
"""Read a signed 16-bit value from the specified register, in big
199251
endian byte order."""
200-
return self.readS16(register, little_endian=False)
252+
try:
253+
return self.readS16(register, little_endian=False)
254+
except IOError, err:
255+
self._logger.exception("error in readS16BE: %s", err)
256+
time.sleep(0.001)

0 commit comments

Comments
 (0)