DyIOChannel.java

Go to the documentation of this file.

/*******************************************************************************
 * Copyright 2010 Neuron Robotics, LLC
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 ******************************************************************************/
package com.neuronrobotics.sdk.dyio;
 
import java.util.ArrayList;
import java.util.Collection;
 
import com.neuronrobotics.sdk.commands.bcs.io.AsyncThreshholdEdgeType;
import com.neuronrobotics.sdk.commands.bcs.io.GetChannelModeCommand;
import com.neuronrobotics.sdk.commands.bcs.io.GetValueCommand;
import com.neuronrobotics.sdk.commands.bcs.io.SetChannelValueCommand;
import com.neuronrobotics.sdk.commands.bcs.io.setmode.SetChannelModeCommand;
import com.neuronrobotics.sdk.common.BowlerAbstractCommand;
import com.neuronrobotics.sdk.common.BowlerDatagram;
import com.neuronrobotics.sdk.common.BowlerMethod;
import com.neuronrobotics.sdk.common.ByteList;
import com.neuronrobotics.sdk.common.InvalidResponseException;
import com.neuronrobotics.sdk.common.Log;
import com.neuronrobotics.sdk.dyio.peripherals.DyIOAbstractPeripheral;
import com.neuronrobotics.sdk.util.ThreadUtil;
// TODO: Auto-generated Javadoc
public class DyIOChannel implements IDyIOChannel {
    
    private int MAXATTEMPTS = 3;
    
    private float cachedTime=0;
    
    private DyIO device;
    
    private int number;
    
    private boolean editable;
    
    private DyIOChannelMode current=null;
    
    private boolean isAsync=true;
    
    private ArrayList<IChannelEventListener> listeners = new ArrayList<IChannelEventListener>();
    
    private ArrayList< IDyIOChannelModeChangeListener> modeListeners = new ArrayList< IDyIOChannelModeChangeListener>();
    
    protected int cachedValue = 0;
    
    private boolean cachedMode=false;
    
    private DyIOAbstractPeripheral dap=null;
    
    private int previousValue = 1;
    
    private boolean haveSetMode = false;
    
    private boolean settingMode=false;
    public DyIOChannel(DyIO dyio, int channel, DyIOChannelMode mode, boolean isEditable) {
        update(dyio, channel, mode,  isEditable);
    }
    
    public void update(DyIO dyio, int channel, DyIOChannelMode mode, boolean isEditable) {
        setDevice(dyio);
        number = channel;
        editable = isEditable;
        if(getCurrentMode() == null){
            setMode(mode);
        }else{
            setMode(mode,isAsync);
        }
        fireModeChangeEvent(mode);
        if(getCurrentMode() == DyIOChannelMode.NO_CHANGE) {
            Log.error("Failed to update channel: "+ channel);
            throw new RuntimeException("Failed to update channel: "+ channel);
        }
    }
 
 
    public int getChannelNumber() {
        return number;
    }
    
    public boolean isEditable() {
        return editable;
    }
    
    public void send(BowlerAbstractCommand command) {
        getDevice().send(command);
    }
    
    
    public void removeAllChannelModeChangeListener() {
        modeListeners.clear();
    }
    
    public void removeChannelModeChangeListener(IDyIOChannelModeChangeListener l) {
        if(!modeListeners.contains(l)) {
            return;
        }
        
        modeListeners.remove(l);
    }
    
    public void addChannelModeChangeListener(IDyIOChannelModeChangeListener l) {
        if(modeListeners.contains(l)) {
            return;
        }
        modeListeners.add(l);
    }
    
    public void removeAllChannelEventListeners() {
        listeners.clear();
    }
    
    public void removeChannelEventListener(IChannelEventListener l) {
        if(!listeners.contains(l)) {
            return;
        }
        
        listeners.remove(l);
    }
    
    public void addChannelEventListener(IChannelEventListener l) {
        if(listeners.contains(l)) {
            return;
        }
        
        listeners.add(l);
    }
    
    public boolean setMode(DyIOChannelMode mode) {
        return setMode(mode, isDefaultAsync(mode));
    }
    
    public DyIOChannelMode getMode(boolean resync) {
        resync(false);
        return getMode();
    }
    
 
    public DyIO getDevice() {
        return device;
    }
    
    public void resync(boolean all) {
        
        if(all) {
            getDevice().resync();
            return;
        }
        BowlerDatagram bd = getDevice().send(new GetChannelModeCommand(number));
        //System.out.println(bd);
        fireModeChangeEvent(DyIOChannelMode.get(bd.getData().getByte(1)));
        throw new RuntimeException();
    }
    
    public boolean canBeMode(DyIOChannelMode m) {
        Collection<DyIOChannelMode> modes = getAvailableModes();
        for(DyIOChannelMode mo:modes) {
            if(mo == m)
                return true;
        }
        return false;
    }
    public boolean hasAsync(){
        if(getMode() == null)
            return false;
        switch(getMode()){
        case ANALOG_IN:
        case COUNT_IN_INT:
        case COUNT_OUT_INT:
        case DIGITAL_IN:
            return true;
        default:
            return false;   
        }
    }
    private ArrayList<DyIOChannelMode> myModes;
    
    public Collection<DyIOChannelMode> getAvailableModes() {
        if(myModes== null)
            myModes = getDevice().getAvailibleChannelModes(getChannelNumber());
        
        for(int i=0;i<myModes.size();i++){
            if(myModes.get(i) == DyIOChannelMode.SERVO_OUT){
                myModes.remove(i);
            }
        }
            
        if(getDevice().isServoPowerSafeMode()){
            if(number < (getDevice().getDyIOChannelCount()/2) && device.getBankAState() != DyIOPowerState.REGULATED) {
                myModes.add(DyIOChannelMode.SERVO_OUT); 
            }
    
            if(number >= (getDevice().getDyIOChannelCount()/2) && device.getBankBState() != DyIOPowerState.REGULATED) {
                myModes.add(DyIOChannelMode.SERVO_OUT); 
            }
        }else{
            myModes.add(DyIOChannelMode.SERVO_OUT); 
        }
 
        return myModes;
    }
    
    public int parseDyIOChannelEvent(DyIOChannelEvent e){
        if(isStreamChannel())
            return 0;
        return e.getValue();
    }
    
    protected void fireChannelEvent(DyIOChannelEvent e) {
        int value= parseDyIOChannelEvent(e);
        if((getPreviousValue() == value) && !isStreamChannel() ){
            //
            return;
        }else{
            Log.info("Value is not the same, last was: "+getPreviousValue()+" current: "+value);
        }
        setPreviousValue(value);
        for(int i=0;i<listeners.size();i++) {
            listeners.get(i).onChannelEvent(e);
        }
    }
    
    protected void fireModeChangeEvent(DyIOChannelMode e) {
        boolean ok = false;
        String modeList=" ";
        for (DyIOChannelMode md :getAvailableModes()){
            if(md == e)
                ok=true;
            modeList +=" "+md.toString()+",";
        }
        if(! ok){
            Log.error(e+" Mode is invalid for: "+number+modeList);
            e = DyIOChannelMode.DIGITAL_IN;
        }
 
        try {
            if(!canBeMode(e)) {
                String message = this.getClass()+" Can not set channel: "+getChannelNumber()+" to mode: "+e;
                Log.error(message);
                //throw new RuntimeException(message);
            }
        }catch(RuntimeException ex) {
            ex.printStackTrace();
            throw ex;
        }
        if(e==getMode()) {
            Log.info("Mode not changed: "+getChannelNumber()+" mode: "+getMode()+" not notifying");
            //return;
        }
        this.current = e;
        for(int i=0;i<modeListeners.size();i++) {
            //Log.debug("Notifying: "+modeListeners.get(i).getClass());
            modeListeners.get(i).onModeChange(e);
        }
    }
    /* (non-Javadoc)
     * @see java.lang.Object#toString()
     */
     
    public String toString() {
        return String.format("(%02d) - %-20s", getChannelNumber(), getMode());
    }
    
    /* (non-Javadoc)
     * @see com.neuronrobotics.sdk.dyio.IDyIOChannel#getChannel()
     */
     
    public DyIOChannel getChannel() {
        return this;
    }
    
    /* (non-Javadoc)
     * @see com.neuronrobotics.sdk.dyio.IDyIOChannel#getMode()
     */
     
    public DyIOChannelMode getMode() {      
        return getCurrentMode();
    }
    
    /* (non-Javadoc)
     * @see com.neuronrobotics.sdk.dyio.IDyIOChannel#getValue()
     */
     
    public int getValue() {
        
        int val=0;
        if(getDevice().isLegacyParser()){
            BowlerDatagram response=null;
            try {
                response = getDevice().send(new GetValueCommand(number));
            } catch (InvalidResponseException e) {
                response = getDevice().send(new GetValueCommand(number));
            }
            ByteList bl = response.getData();
            
            Byte b = bl.pop();
            if(b==null || b.intValue()!=number){
                Log.error("Failed to get value "+response);
                return 0;
            }
            
            val = new DyIOChannelEvent(this,bl).getValue();
            setCachedValue(val);
            setPreviousValue(val);
        }else{
            
//          Object [] args =getDevice().send("bcs.io.*;0.3;;",
//                  BowlerMethod.GET,
//                  "gchv",
//                  new Object[]{number});
//          val=(Integer)args[1];
//          Log.debug("Got Value: "+val);
            
            // For the new API the channel values should come in through the asynchronous path. 
            val = getPreviousValue();
        }
        
        return val;
    }
    
    /* (non-Javadoc)
     * @see com.neuronrobotics.sdk.dyio.IDyIOChannel#setMode(com.neuronrobotics.sdk.dyio.DyIOChannelMode, boolean)
     */
    
    public boolean setMode(DyIOChannelMode mode, boolean async) {
        if(settingMode)
            return true;
        
        //resyncIfNotSynced();
        if(mode == null) {
            throw new RuntimeException("Mode can not be set to null, must be set to a mode");
        }
        if(getMode()  == null) {
            Log.info(this.getClass()+" First time setting mode.");
            fireModeChangeEvent(mode); 
            isAsync = isDefaultAsync(mode);
            haveSetMode=false;
        }else if ((getMode() == mode) && (async == isAsync) ) {
            Log.debug(this.getClass()+"Channel: "+getChannelNumber()+" is already "+getMode());
                return true;
        }
        
        if(!canBeMode(mode)){
            if(mode == DyIOChannelMode.SERVO_OUT)
                new RuntimeException("\nChannel: "+getChannelNumber()+" can not be mode '"+mode+"' in current configuration. \nCheck the power switch settings and availible modes.").printStackTrace();
            else
                new RuntimeException("\nChannel: "+getChannelNumber()+" can not be mode '"+mode+"'.").printStackTrace();
            mode=getMode();
        }
        settingMode=true;
        
        for(int i = 0; i < MAXATTEMPTS; i++) {
            try {
                isAsync = async;
                haveSetMode=true;
                if(getDevice().isLegacyParser()){
                    getDevice().send(new SetChannelModeCommand(number, mode, async));           
                    
                    if(!getDevice().isMuteResyncOnModeChange()){
                        try {
                            getDevice().resync();
                        }catch(RuntimeException e) {
                            e.printStackTrace();
                            getDevice().setMuteResyncOnModeChange(true);
                        }
                    }else{
                        Log.info("Not resyncing from channel: "+getChannelNumber());
                        fireModeChangeEvent(mode); 
                    }   
                }else{
                    //int printlevel = Log.getMinimumPrintLevel();
                    //Log.enableInfoPrint();
                    Object [] args = getDevice().send("bcs.io.setmode.*;0.3;;",
                            BowlerMethod.POST,
                                            "schm",
                                            new Object[]{getChannelNumber(),mode.getValue(),async?1:0});
                    ByteList currentModes = (ByteList) args[0];
                    //System.out.println("Setting # "+getChannelNumber()+" to "+mode);
                    for (int j=0;j<getDevice().getChannels().size();j++){
                        DyIOChannelMode cm = DyIOChannelMode.get(currentModes.getByte(j));
                        if(getDevice().getChannel(j).getCurrentMode()!=cm ){
                            //System.err.println("Setting # "+j+" to "+cm);
                            getDevice().getChannel(j).fireModeChangeEvent(cm); 
                        }
                    }
                    //Log.setMinimumPrintLevel(printlevel);
                }
                settingMode=false;
                // Defaultuing the advanced async to on
                if(isAsync)
                    getDevice().configAdvancedAsyncNotEqual(number,10);
                return true;
            } catch (InvalidResponseException e) {
                Log.error(e.getMessage());
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e1) {
                    settingMode=false;
                    return false;
                }
            }
        }
        settingMode=false;
        return false;
    }
 
 
    /* (non-Javadoc)
     * @see com.neuronrobotics.sdk.dyio.IDyIOChannel#setValue(int)
     */
     
    public boolean setValue(int value) {
 
        setCachedValue(value);
        setCachedTime(0);
        if(cachedMode)
            return true;
        if(dap!=null)
            return dap.flush();
        return flush();
    }
    public boolean flush() {
//      if(getCachedMode())
//          throw new RuntimeException("In chached mode and flushing from channel");
        //Log.enableDebugPrint(true);
        Log.info("Flushing channel: "+number);
        if(getDevice().isLegacyParser()){
            ByteList b = new ByteList();
            switch(getMode()){
            case COUNT_IN_INT:
            case COUNT_IN_DIR:
            case COUNT_IN_HOME:
            case COUNT_OUT_INT:
            case COUNT_OUT_DIR:
            case COUNT_OUT_HOME:
                b.addAs32(getCachedValue());
                b.addAs32((int)(getCachedTime()*1000));
                break;
            case SERVO_OUT:
                b.add(getCachedValue());
                b.addAs16((int)(getCachedTime()*1000));
                break;
            default:
                b.add(getCachedValue());
            }
            Log.info("Setting channel: "+getChannelNumber()+" to value: "+b);
            boolean back = setValue(b);
            //Log.enableDebugPrint(false);
            return back;
        }else{
            //Log.info("Setting channel: "+number+" to value: "+getCachedValue());
            getDevice().send(   "bcs.io.*;0.3;;",
                                BowlerMethod.POST,
                                "schv",
                                new Object[]{number,getCachedValue(),(int)(getCachedTime()*1000)});
            return true;
        }
    }
 
 
    
    
    public void setCachedValue(int cachedValue) {
        this.cachedValue = cachedValue;
    }
    
    public int getCachedValue() {
        return cachedValue;
    }
    public boolean getCachedMode() {
        return cachedMode;
    }
    
    public void setCachedMode(boolean mode) {
        cachedMode=mode;
    }
    
    public void setDap(DyIOAbstractPeripheral dap) {
        this.dap = dap;
    }
    
    public DyIOAbstractPeripheral getDap() {
        return dap;
    }
 
    
    public boolean configAdvancedAsyncNotEqual(){
        return configAdvancedAsyncNotEqual(100);
    }
    
    public boolean configAdvancedAsyncDeadBand(int deadbandSize){
        return  configAdvancedAsyncDeadBand(100,deadbandSize);
    }
    
    public boolean configAdvancedAsyncTreshhold(int threshholdValue, AsyncThreshholdEdgeType edgeType){
        return  configAdvancedAsyncTreshhold(100, threshholdValue, edgeType);
    }
    
    public boolean configAdvancedAsyncAutoSample(){
        return  configAdvancedAsyncAutoSample(100);
    }
    
    public boolean configAdvancedAsyncNotEqual(int msTime){
        isAsync=true;
        return  getDevice().configAdvancedAsyncNotEqual(getChannelNumber(),msTime);
    }
    
    public boolean configAdvancedAsyncDeadBand(int msTime,int deadbandSize){
        isAsync=true;
        return  getDevice().configAdvancedAsyncDeadBand(getChannelNumber(),msTime,deadbandSize);
    }
    
    public boolean configAdvancedAsyncTreshhold(int msTime,int threshholdValue, AsyncThreshholdEdgeType edgeType){
        isAsync=true;
        return  getDevice().configAdvancedAsyncTreshhold(getChannelNumber(),msTime, threshholdValue, edgeType);
    }
    
    public boolean configAdvancedAsyncAutoSample(int msTime){
        isAsync=true;
        return  getDevice().configAdvancedAsyncAutoSample(getChannelNumber(),msTime);
    }
    
//  /**
//   * Sets the current internal mode variable. 
//   * @param mode the mode to set to.
//   */
//  private void setCurrentMode(DyIOChannelMode mode) {
//      
//  }
    public DyIOChannelMode getCurrentMode() {
        return current;
    }
    
    public void setCachedTime(float cachedTime) {
        this.cachedTime = cachedTime;
    }
    
    public float getCachedTime() {
        return cachedTime;
    }
    
    public void setAsync(boolean b) {
        setMode(getMode(), b);
    }
    
    /*
     * Helpers
     */
    private void setPreviousValue(int previousValue) {
        this.previousValue = previousValue;
    }
 
    protected int getPreviousValue() {
        return previousValue;
    }
    
    public boolean isStreamChannel(){
        switch(getMode()){
        case USART_RX:
        case USART_TX:
        case SPI_CLOCK:
        case SPI_MISO:
        case SPI_MOSI:
        case PPM_IN:
            return true;
        default:
            return false;
        }
    }
    
    private void setDevice(DyIO device) {
        this.device = device;
    }
 
    private boolean isDefaultAsync(DyIOChannelMode m) {
        return true;
    }
    
    private boolean synced = false;
    
    private void resyncIfNotSynced() {
        if(synced==false) {
            synced = true;
            resync(false);
        }
    }
    
    public boolean isStreamtMode( DyIOChannelMode m) {
        switch(m) {
        case USART_RX:
        case PPM_IN:
        case SPI_CLOCK:
        case SPI_MISO:
        case SPI_MOSI:
        case USART_TX:
            return true;
        case SERVO_OUT:
        case ANALOG_OUT:
        case DC_MOTOR_DIR:
        case DC_MOTOR_VEL:
        case PWM_OUT:
        case SPI_SELECT:
        case DIGITAL_OUT:
        case COUNT_OUT_DIR:
        case COUNT_OUT_HOME:
        case COUNT_OUT_INT:
        case ANALOG_IN:
        case COUNT_IN_DIR:
        case COUNT_IN_HOME:
        case COUNT_IN_INT:
        case DIGITAL_IN:
        case NO_CHANGE:
        case OFF:
            return false;
        }
        return false;
    }
    
    private boolean isOutputMode( DyIOChannelMode m) {
        switch(m) {
        case SERVO_OUT:
        case ANALOG_OUT:
        case DC_MOTOR_DIR:
        case DC_MOTOR_VEL:
        case PWM_OUT:
        case SPI_CLOCK:
        case SPI_MISO:
        case SPI_MOSI:
        case SPI_SELECT:
        case USART_TX:
        case DIGITAL_OUT:
        case COUNT_OUT_DIR:
        case COUNT_OUT_HOME:
        case COUNT_OUT_INT:
            return true;
        case ANALOG_IN:
        case COUNT_IN_DIR:
        case COUNT_IN_HOME:
        case COUNT_IN_INT:
        case DIGITAL_IN:
        case NO_CHANGE:
        case OFF:
        case PPM_IN:
        case USART_RX:
            return false;
        }
        return false;
    }
 
    /* (non-Javadoc)
     * @see com.neuronrobotics.sdk.dyio.IDyIOChannel#setValue(com.neuronrobotics.sdk.common.ISendable)
     */
     
    public boolean setValue(ByteList data) {
 
        if(getDevice().isLegacyParser()){
            int attempts = MAXATTEMPTS;
            if(getMode() == DyIOChannelMode.USART_RX ||getMode() == DyIOChannelMode.USART_TX )
                attempts=1;
            for(int i = 0; i < attempts; i++) {
                try {
                    getDevice().send(new SetChannelValueCommand(number, data));
                    return true;
                } catch (InvalidResponseException e) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e1) {
                        return false;
                    }
                }
            }
        }else{
            if(!isStreamChannel())
                throw new RuntimeException("Only stream channels should talk to this method");
            getDevice().send("bcs.io.*;0.3;;",
                    BowlerMethod.POST,
                    "strm",
                    new Object[]{number,data});
        }
        
        return false;
    }
}