DyIOAbstractPeripheral.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.peripherals;
 
import com.neuronrobotics.sdk.commands.bcs.io.AsyncThreshholdEdgeType;
import com.neuronrobotics.sdk.commands.bcs.io.GetDyIOChannelCountCommand;
import com.neuronrobotics.sdk.commands.bcs.io.SetChannelValueCommand;
import com.neuronrobotics.sdk.common.BowlerMethod;
import com.neuronrobotics.sdk.common.ByteList;
import com.neuronrobotics.sdk.common.InvalidResponseException;
import com.neuronrobotics.sdk.dyio.DyIOChannel;
import com.neuronrobotics.sdk.dyio.DyIOChannelMode;
import com.neuronrobotics.sdk.dyio.IDyIOChannel;
 
// TODO: Auto-generated Javadoc
public abstract class DyIOAbstractPeripheral implements IDyIOChannel {
    
    private DyIOChannel channel;
    
    private boolean enabled = false;
    
    private int configuration=0;
    
    public DyIOAbstractPeripheral(DyIOChannel channel, DyIOChannelMode myMode, boolean async) {
        this.channel = channel;
        this.enabled = true;
        if(channel.getMode() != myMode)
            channel.setMode(myMode, async);
        setConfiguration(getConfigurationFromDevice());
        //channel.removeAllChannelEventListeners();
        //Always notify any listeners of mode changes
            //channel.removeAllChannelModeChangeListener();
    }
    
    private int getConfigurationFromDevice() {
        if(getChannel().getDevice().isLegacyParser()){
            if(channel.getMode() == DyIOChannelMode.SERVO_OUT)
                return 128;
            return 0;
        }else{
            Object[] args = getChannel().getDevice().send("bcs.io.*;0.3;;",
                                            BowlerMethod.CRITICAL,
                                            "cchn",
                                            new Object[]{   255,
                                                            false,
                                                            new Integer[]{}
                                                        });
            Integer [] configs = (Integer[]) args[0];
            return configs[getChannel().getChannelNumber()];
        }
        
    }
    
    public  DyIOChannelMode getClassMode() {
        return channel.getMode();
    }
    
    public boolean isEnabled() {
        return enabled;
    }
    
    public boolean setMode(){
        return channel.setMode(getClassMode());
    }
    
    public boolean setMode( boolean async) {
        return channel.setMode(getClassMode(), async);
    }
    
    public boolean setMode(DyIOChannelMode mode, boolean async) {
        if(mode != getClassMode())
            throw new RuntimeException("The mode being set does not match the defined channel mode: "+mode+" is not"+getClassMode());
        return channel.setMode(getClassMode(), async);
    }
    
    public DyIOChannel getChannel() {
        return channel.getChannel();
    }
    
    public DyIOChannelMode getMode() {
        return channel.getMode();
    }
    
    public boolean setValue(int value) throws InvalidResponseException {
        return channel.setValue(value);
    }
    
    public boolean setValue(ByteList value)throws InvalidResponseException {
        return channel.setValue(value);
    }
    
    public int getValue()throws InvalidResponseException {
        //new RuntimeException().printStackTrace();
        return channel.getValue();
    }
    
    
    public boolean SavePosition(int pos){
        try {
            DyIOChannelMode mode = getChannel().getMode();
            switch(mode){
            case SERVO_OUT:
            case PWM_OUT :
                configuration = pos;
                if(getChannel().getDevice().isLegacyParser()){
                    getChannel().send(new SetChannelValueCommand(getChannel().getChannelNumber(), pos , getMode(), true));
                }else{
                    
                    getChannel().getDevice().send("bcs.io.*;0.3;;",
                                                    BowlerMethod.CRITICAL,
                                                    "cchn",
                                                    new Object[]{   getChannel().getChannelNumber(),
                                                                    true,
                                                                    new Integer[]{pos}
                                                                });
                    getChannel().setValue(pos);
                    try {
                        Thread.sleep(30);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                return true;
            default:
                return false;
            }
            
        } catch (InvalidResponseException e) {
            return false;
        }
    }
    
    abstract public boolean hasAsync();
    
    public boolean configAdvancedAsyncNotEqual(){
        return getChannel().configAdvancedAsyncNotEqual(100);
    }
    
    public boolean configAdvancedAsyncDeadBand(int deadbandSize){
        return  getChannel().configAdvancedAsyncDeadBand(100,deadbandSize);
    }
    
    public boolean configAdvancedAsyncTreshhold(int threshholdValue,AsyncThreshholdEdgeType edgeType){
        return  getChannel().configAdvancedAsyncTreshhold(100, threshholdValue, edgeType);
    }
    
    public boolean configAdvancedAsyncAutoSample(){
        return  getChannel().configAdvancedAsyncAutoSample(100);
    }
    public boolean configAdvancedAsyncNotEqual(int msTime){
        return getChannel().configAdvancedAsyncNotEqual(msTime);
    }
    
    public boolean configAdvancedAsyncDeadBand(int msTime,int deadbandSize){
        return  getChannel().configAdvancedAsyncDeadBand(msTime,deadbandSize);
    }
    
    public boolean configAdvancedAsyncTreshhold(int msTime,int threshholdValue, AsyncThreshholdEdgeType edgeType){
        return  getChannel().configAdvancedAsyncTreshhold(msTime, threshholdValue, edgeType);
    }
    
    public boolean configAdvancedAsyncAutoSample(int msTime){
        return  getChannel().configAdvancedAsyncAutoSample(msTime);
    }
    
    public boolean flush() {
        return getChannel().flush();
    }
    
    public void setAsync(boolean b) {
        channel.setMode(getClassMode(), b);
    }
    
    public int getConfiguration() {
        return configuration;
    }
    
    private void setConfiguration(int configuration) {
        this.configuration = configuration;
    }
}