001package com.pi4j.io.i2c.impl; 002 003/* 004 * #%L 005 * ********************************************************************** 006 * ORGANIZATION : Pi4J 007 * PROJECT : Pi4J :: Java Library (Core) 008 * FILENAME : I2CBusImpl.java 009 * 010 * This file is part of the Pi4J project. More information about 011 * this project can be found here: https://www.pi4j.com/ 012 * ********************************************************************** 013 * %% 014 * Copyright (C) 2012 - 2019 Pi4J 015 * %% 016 * This program is free software: you can redistribute it and/or modify 017 * it under the terms of the GNU Lesser General Public License as 018 * published by the Free Software Foundation, either version 3 of the 019 * License, or (at your option) any later version. 020 * 021 * This program is distributed in the hope that it will be useful, 022 * but WITHOUT ANY WARRANTY; without even the implied warranty of 023 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 024 * GNU General Lesser Public License for more details. 025 * 026 * You should have received a copy of the GNU General Lesser Public 027 * License along with this program. If not, see 028 * <http://www.gnu.org/licenses/lgpl-3.0.html>. 029 * #L% 030 */ 031 032import java.io.IOException; 033import java.nio.ByteBuffer; 034import java.nio.IntBuffer; 035import java.util.concurrent.Callable; 036import java.util.concurrent.TimeUnit; 037import java.util.concurrent.locks.ReentrantLock; 038import java.util.logging.Level; 039import java.util.logging.Logger; 040 041import com.pi4j.io.file.LinuxFile; 042import com.pi4j.io.i2c.I2CBus; 043import com.pi4j.io.i2c.I2CConstants; 044import com.pi4j.io.i2c.I2CDevice; 045import com.pi4j.io.i2c.I2CFactory; 046 047/** 048 * This is implementation of i2c bus. This class keeps underlying linux file descriptor of particular bus. As all reads and writes from/to i2c bus are blocked I/Os current implementation uses only one file per bus for all devices. Device 049 * implementations use this class file handle. 050 * 051 * Hint: For concurrency-locking the methods lock() and unlock() are provided. This requires that there is exactly one I2CBus-instance per bus-number what is guaranteed by the I2CFactory class. The locking is done by I2CDeviceImpl by using 052 * those methods. The reason for this is to enable other locking-strategies than the simple "lock before and release after access"-strategy. 053 * 054 * @author Daniel Sendula, refactored by <a href="http://raspelikan.blogspot.co.at">RasPelikan</a> 055 * 056 */ 057public class I2CBusImpl implements I2CBus { 058 059 private static final Logger logger = Logger.getLogger(I2CBusImpl.class.getCanonicalName()); 060 061 /** File handle for this i2c bus */ 062 protected LinuxFile file = null; 063 064 protected int lastAddress = -1; 065 066 /** File name of this i2c bus */ 067 protected String filename; 068 069 /** Used to identifiy the i2c bus within Pi4J **/ 070 protected int busNumber; 071 072 protected long lockAquireTimeout; 073 074 protected TimeUnit lockAquireTimeoutUnit; 075 076 private final ReentrantLock accessLock = new ReentrantLock(true); 077 078 /** 079 * Constructor of i2c bus implementation. 080 * 081 * @param busNumber used to identifiy the i2c bus within Pi4J 082 083 * @throws IOException thrown in case that file cannot be opened 084 */ 085 protected I2CBusImpl(final int busNumber, final String fileName, final long lockAquireTimeout, final TimeUnit lockAquireTimeoutUnit) { 086 this.filename = fileName; 087 this.busNumber = busNumber; 088 089 if (lockAquireTimeout < 0) { 090 this.lockAquireTimeout = I2CFactory.DEFAULT_LOCKAQUIRE_TIMEOUT; 091 } else { 092 this.lockAquireTimeout = lockAquireTimeout; 093 } 094 095 if (lockAquireTimeoutUnit == null) { 096 this.lockAquireTimeoutUnit = I2CFactory.DEFAULT_LOCKAQUIRE_TIMEOUT_UNITS; 097 } else { 098 this.lockAquireTimeoutUnit = lockAquireTimeoutUnit; 099 } 100 } 101 102 /** 103 * Returns i2c device implementation ({@link I2CDeviceImpl}). 104 * 105 * @param address address of i2c device 106 * 107 * @return implementation of i2c device with given address 108 * 109 * @throws IOException never in this implementation 110 */ 111 @Override 112 public I2CDevice getDevice(int address) throws IOException { 113 return new I2CDeviceImpl(this, address); 114 } 115 116 /** 117 * Opens the bus. 118 * 119 * @throws IOException thrown in case there are problems opening the i2c bus. 120 */ 121 protected void open() throws IOException { 122 if (file != null) { 123 return; 124 } 125 126 file = new LinuxFile(filename, "rw"); 127 128 lastAddress = -1; 129 } 130 131 /** 132 * Closes this i2c bus. Can be used in a thread safe way during bus operations. 133 * 134 * @throws IOException never in this implementation 135 */ 136 @Override 137 public synchronized void close() throws IOException { 138 if (file != null) { 139 file.close(); 140 file = null; 141 } 142 } 143 144 public int readByteDirect(final I2CDevice device) throws IOException { 145 return runBusLockedDeviceAction(device, () -> file.readUnsignedByte()); 146 } 147 148 public int readBytesDirect(final I2CDevice device, final int size, final int offset, final byte[] buffer) throws IOException { 149 return runBusLockedDeviceAction(device, () -> file.read(buffer, offset, size)); 150 } 151 152 public int readByte(final I2CDevice device, final int localAddress) throws IOException { 153 return runBusLockedDeviceAction(device, () -> { 154 file.writeByte(localAddress); 155 156 return file.readUnsignedByte(); 157 }); 158 } 159 160 public int readBytes(final I2CDevice device, final int localAddress, final int size, final int offset, final byte[] buffer) throws IOException { 161 return runBusLockedDeviceAction(device, () -> { 162 file.writeByte(localAddress); 163 164 return file.read(buffer, offset, size); 165 }); 166 } 167 168 public void writeByteDirect(final I2CDevice device, final byte data) throws IOException { 169 runBusLockedDeviceAction(device, () -> { 170 file.writeByte(data & 0xFF); 171 172 return null; 173 }); 174 } 175 176 public void writeBytesDirect(final I2CDevice device, final int size, final int offset, final byte[] buffer) throws IOException { 177 runBusLockedDeviceAction(device, () -> { 178 file.write(buffer, offset, size); 179 180 return null; 181 }); 182 } 183 184 public void writeByte(final I2CDevice device, final int localAddress, final byte data) throws IOException { 185 runBusLockedDeviceAction(device, () -> { 186 file.write(new byte[] { (byte)localAddress, data }); 187 188 return null; 189 }); 190 } 191 192 public void writeBytes(final I2CDevice device, final int localAddress, final int size, final int offset, final byte[] buffer) throws IOException { 193 runBusLockedDeviceAction(device, () -> { 194 byte[] buf = new byte[size + 1]; 195 196 buf[0] = (byte)localAddress; 197 198 System.arraycopy(buffer, offset, buf, 1, size); 199 200 file.write(buf); 201 202 return null; 203 }); 204 } 205 206 public int writeAndReadBytesDirect(final I2CDevice device, final int writeSize, final int writeOffset, final byte[] writeBuffer, 207 final int readSize, final int readOffset, final byte[] readBuffer) throws IOException { 208 return runBusLockedDeviceAction(device, () -> { 209 file.write(writeBuffer, writeOffset, writeSize); 210 211 return file.read(readBuffer, readOffset, readSize); 212 }); 213 } 214 215 public void ioctl(final I2CDevice device, final long command, final int value) throws IOException { 216 runBusLockedDeviceAction(device, () -> { 217 file.ioctl(command, value); 218 219 return null; 220 }); 221 } 222 223 public void ioctl(final I2CDevice device, final long command, final ByteBuffer values, final IntBuffer offsets) throws IOException { 224 runBusLockedDeviceAction(device, () -> { 225 file.ioctl(command, values, offsets); 226 227 return null; 228 }); 229 } 230 231 /** 232 * Selects a device on the bus for an action, and locks parallel access around file descriptor operations. 233 * Multiple bus instances may be used in parallel, but a single bus instance must limit parallel access. 234 * <p> 235 * The timeout used for the acquisition of the lock may be defined on getting the I2CBus from I2CFactory. 236 * <p> 237 * The 'run'-method of 'action' may throw an 'IOExceptionWrapperException' to wrap IOExceptions. The wrapped IOException is unwrapped by this method and rethrown as IOException. 238 * 239 * @param <T> The result-type of the method 240 * @param device Device to be selected on the bus 241 * @param action The action to be run 242 * @throws RuntimeException thrown by the custom code 243 * @throws IOException see method description above 244 * @see I2CFactory#getInstance(int, long, java.util.concurrent.TimeUnit) 245 */ 246 public <T> T runBusLockedDeviceAction(final I2CDevice device, final Callable<T> action) throws IOException { 247 if (action == null) { 248 throw new NullPointerException("Parameter 'action' is mandatory!"); 249 } 250 251 testForProperOperationConditions(device); 252 253 try { 254 if (accessLock.tryLock(lockAquireTimeout, lockAquireTimeoutUnit)) { 255 try { 256 testForProperOperationConditions(device); 257 258 selectBusSlave(device); 259 260 return action.call(); 261 } finally { 262 accessLock.unlock(); 263 } 264 } 265 } catch (InterruptedException e) { 266 logger.log(Level.FINER, "Failed locking I2CBusImpl-" + busNumber, e); 267 throw new RuntimeException("Could not obtain an access-lock!", e); 268 } catch (IOException e) { // unwrap IOExceptionWrapperException 269 throw e; 270 } catch (RuntimeException e) { 271 throw e; 272 } catch (Exception e) { // unexpected exceptions 273 throw new RuntimeException(e); 274 } 275 throw new RuntimeException("Could not obtain an access-lock!"); 276 } 277 278 /** 279 * Selects the slave device if not already selected on this bus. 280 * Uses SharedSecrets to get the POSIX file descriptor, and runs 281 * the required ioctl's via JNI. 282 * 283 * @param device Device to select 284 */ 285 protected void selectBusSlave(final I2CDevice device) throws IOException { 286 final int addr = device.getAddress(); 287 288 if (lastAddress != addr) { 289 lastAddress = addr; 290 291 file.ioctl(I2CConstants.I2C_SLAVE, addr & 0xFF); 292 } 293 } 294 295 protected void testForProperOperationConditions(final I2CDevice device) throws IOException { 296 if (file == null) { 297 throw new IOException(toString() + " has already been closed! A new bus has to be acquired."); 298 } 299 300 if (device == null) { 301 throw new NullPointerException("Parameter 'device' is mandatory!"); 302 } 303 } 304 305 @Override 306 public int getBusNumber() { 307 return busNumber; 308 } 309 310 @Override 311 public String toString() { 312 return "I2CBus '" + busNumber + "' ('" + filename + "')"; 313 } 314}