IOIO: lock now uses simpler mutex object for synchronisation

Author: chrisws

ioio/main.cpp

@@ -251,7 +251,7 @@ FUNC_SIG lib_proc[] = {
   {0, 0, "HARDRESET", cmd_ioio_hardreset},
   {0, 0, "SOFTRESET", cmd_ioio_softreset},
   {0, 0, "SYNC", cmd_ioio_sync},
-  {0, 0, "WAITFORCONNECT", cmd_ioio_waitforconnect},
+  {1, 1, "WAITFORCONNECT", cmd_ioio_waitforconnect},
   {0, 0, "WAITFORDISCONNECT", cmd_ioio_waitfordisconnect},
 };
 

ioio/samples/duino-1088AS.bas

@@ -48,19 +48,20 @@ const dinPin = 2
 const csPin = 3
 const clkPin = 4
 
-ioio.waitForConnect(10)
-
 din = ioio.openDigitalOutput(dinPin)
 cs = ioio.openDigitalOutput(csPin)
 clk = ioio.openDigitalOutput(clkPin)
 
+ioio.waitForConnect(10)
+
 while 1
-  shiftOut(0x55)  
+  shiftOut(0x55) 
+  delay 10000
 wend
 
 sub shiftOut(_data)
   cs.write(false); ' Enable the chip
-  for i = 7 to 0
+  for i = 7 to 0 step -1
     clk.write(false) ' Start clock pulse
     din.write((_data band (1 lshift i)) != 0) ' Send bit
     clk.write(true) ' End clock pulse

ioio/samples/led.bas

@@ -20,6 +20,3 @@ for i = 0 to 5
 next
 
 print "done"
-
-
-

ioio/samples/slider-pot.bas

@@ -1,9 +1,20 @@
 import ioio
 
+rem
+rem PIN CONNECTIONS:
+rem GND -> GND
+rem VCC -> 3.3v
+rem OTA -> 46
+rem
+
 analogIn = ioio.openAnalogInput(46)
+out = ioio.openDigitalOutput(0)
+
 ioio.waitForConnect(10)
 
 while 1
-  print analogIn.read()
+  n = analogIn.read()
+  out.write(n > .5)
+  print n
   delay 10
 wend

ioio/src/main/java/ioio/PausedInputStream.java

@@ -1,36 +1,49 @@
 package ioio;
 
-import java.io.BufferedInputStream;
 import java.io.IOException;
 import java.io.InputStream;
 
 /**
  * Pause between read() to avoid excessive CPU usage
  */
-public class PausedInputStream extends BufferedInputStream {
+public class PausedInputStream extends InputStream {
   private long lastAccessMillis;
+  private final InputStream wrapped;
+  private boolean closed;
 
   public PausedInputStream(InputStream inputStream) {
-    super(inputStream);
-    lastAccessMillis = System.currentTimeMillis();
+    this.wrapped = inputStream;
+    this.lastAccessMillis = System.currentTimeMillis();
+    this.closed = false;
   }
 
   @Override
-  public synchronized int read(byte[] bytes, int i, int i1) throws IOException {
-    pause();
-    return super.read(bytes, i, i1);
+  public void close() throws IOException {
+    wrapped.close();
+    closed = true;
+  }
+
+  @Override
+  public synchronized int read(byte[] bytes, int offset, int len) throws IOException {
+    throw new UnsupportedOperationException();
   }
 
   @Override
   public int read(byte[] bytes) throws IOException {
     pause();
-    return super.read(bytes);
+    int result = -1;
+    while (!closed) {
+      result = wrapped.read(bytes);
+      if (result > 0) {
+        break;
+      }
+    }
+    return result;
   }
 
   @Override
   public synchronized int read() throws IOException {
-    pause();
-    return super.read();
+    throw new UnsupportedOperationException();
   }
 
   private void pause() throws IOException {

ioio/src/main/java/ioio/lib/pc/SerialPortIOIOConnection.java

@@ -28,6 +28,11 @@
  */
 package ioio.lib.pc;
 
+import java.io.BufferedOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
 import ioio.PausedInputStream;
 import ioio.lib.api.IOIOConnection;
 import ioio.lib.api.exception.ConnectionLostException;
@@ -38,11 +43,6 @@
 import purejavacomm.NoSuchPortException;
 import purejavacomm.SerialPort;
 
-import java.io.BufferedOutputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.OutputStream;
-
 class SerialPortIOIOConnection implements IOIOConnection {
   private final String name_;
   // private static final String TAG = "SerialPortIOIOConnection";

ioio/src/main/java/ioio/lib/pc/SerialPortIOIOConnectionBootstrap.java

@@ -29,6 +29,11 @@
 
 package ioio.lib.pc;
 
+import java.util.Collection;
+import java.util.Enumeration;
+import java.util.LinkedList;
+import java.util.List;
+
 import ioio.lib.api.IOIOConnection;
 import ioio.lib.spi.IOIOConnectionBootstrap;
 import ioio.lib.spi.IOIOConnectionFactory;
@@ -37,11 +42,6 @@
 import purejavacomm.CommPortIdentifier;
 import purejavacomm.PortInUseException;
 
-import java.util.Collection;
-import java.util.Enumeration;
-import java.util.LinkedList;
-import java.util.List;
-
 public class SerialPortIOIOConnectionBootstrap implements IOIOConnectionBootstrap {
   private static final String TAG = "SerialPortIOIOConnectionBootstrap";
 

ioio/src/main/java/net/sourceforge/smallbasic/ioio/DigitalOutputImpl.java

@@ -5,11 +5,9 @@
 import ioio.lib.api.exception.ConnectionLostException;
 import ioio.lib.spi.Log;
 
-import java.util.concurrent.atomic.AtomicBoolean;
-
 public class DigitalOutputImpl extends IOTask implements DigitalOutput {
   private static final String TAG = "DigitalOutput";
-  private final AtomicBoolean value = new AtomicBoolean(false);
+  private final IOLock<DigitalOutput> lock = new IOLock<>();
   private DigitalOutput output;
 
   public DigitalOutputImpl() {
@@ -26,7 +24,7 @@ public void close() {
 
   @Override
   public void loop() throws ConnectionLostException {
-    output.write(value.get());
+    lock.process(output);
   }
 
   @Override
@@ -41,7 +39,10 @@ public void setup(IOIO ioio) {
   }
 
   @Override
-  public void write(boolean value) {
-    this.value.set(value);
+  public void write(final boolean value) {
+    handleError();
+    lock.invoke((i) -> {
+      i.write(value);
+    });
   }
 }

ioio/src/main/java/net/sourceforge/smallbasic/ioio/IOIOImpl.java

@@ -1,11 +1,11 @@
 package net.sourceforge.smallbasic.ioio;
 
+import java.io.IOException;
+
 import ioio.TimerUtil;
 import ioio.lib.api.IOIO;
 import ioio.lib.spi.Log;
 
-import java.io.IOException;
-
 public class IOIOImpl extends IOTask {
   private static final String TAG = "IOIOImpl";
   private final IOLock<IOIO> lock = new IOLock<>();

ioio/src/main/java/net/sourceforge/smallbasic/ioio/IOLock.java

@@ -1,80 +1,63 @@
 package net.sourceforge.smallbasic.ioio;
 
-import ioio.lib.api.exception.ConnectionLostException;
-import ioio.lib.api.exception.IncompatibilityException;
-
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.atomic.AtomicReference;
-import java.util.concurrent.locks.ReadWriteLock;
-import java.util.concurrent.locks.ReentrantReadWriteLock;
+
+import ioio.lib.api.exception.ConnectionLostException;
+import ioio.lib.api.exception.IncompatibilityException;
 
 public class IOLock<I> {
-  private final ReadWriteLock lock = new ReentrantReadWriteLock();
+  private final Object mutex = new Object();
   private Consumer<I> consumer;
 
-  public float invoke(Function<Float, I> function) {
+  public void invoke(Consumer<I> consumer) {
     CountDownLatch latch = beginLatch();
-    lock.writeLock().lock();
-    AtomicReference<Float> result = new AtomicReference<>();
-    try {
+    synchronized (mutex) {
       this.consumer = (i) -> {
-        result.set(function.apply(i));
+        consumer.accept(i);
         latch.countDown();
       };
     }
-    finally {
-      lock.writeLock().unlock();
-    }
     endLatch(latch);
-    return result.get();
   }
 
-  public void invoke(Consumer<I> consumer) {
+  public float invoke(Function<Float, I> function) {
     CountDownLatch latch = beginLatch();
-    lock.writeLock().lock();
-    try {
+    AtomicReference<Float> result = new AtomicReference<>();
+    synchronized (mutex) {
       this.consumer = (i) -> {
-        consumer.accept(i);
+        result.set(function.apply(i));
         latch.countDown();
       };
     }
-    finally {
-      lock.writeLock().unlock();
-    }
     endLatch(latch);
+    return result.get();
   }
 
   public int invokeInt(Function<Integer, I> function) {
     CountDownLatch latch = beginLatch();
-    lock.writeLock().lock();
     AtomicReference<Integer> result = new AtomicReference<>();
-    try {
+    synchronized (mutex) {
       this.consumer = (i) -> {
         result.set(function.apply(i));
         latch.countDown();
       };
     }
-    finally {
-      lock.writeLock().unlock();
-    }
     endLatch(latch);
     return result.get();
   }
 
   public void process(I input) {
-    lock.readLock().lock();
-    try {
+    synchronized (mutex) {
       if (input != null && consumer != null) {
-        consumer.accept(input);
+        try {
+          consumer.accept(input);
+        } catch (ConnectionLostException | InterruptedException | IncompatibilityException e) {
+          throw new RuntimeException(e);
+        }
         consumer = null;
       }
     }
-    catch (IncompatibilityException | ConnectionLostException | InterruptedException e) {
-      throw new RuntimeException(e);
-    }
-    finally {
-      lock.readLock().unlock();
-    }
   }
 
   /**