ECHONET-Lite Emergency Button

Button.java

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

package gpiotest;
import com.pi4j.io.gpio.GpioController;
import com.pi4j.io.gpio.GpioFactory;
import com.pi4j.io.gpio.GpioPinDigitalInput;
import com.pi4j.io.gpio.GpioPinDigitalOutput;
import com.pi4j.io.gpio.PinPullResistance;
import com.pi4j.io.gpio.PinState;
import com.pi4j.io.gpio.RaspiPin;
import com.pi4j.io.gpio.event.GpioPinDigitalStateChangeEvent;
import com.pi4j.io.gpio.event.GpioPinListenerDigital;
import echowand.common.EPC;
import echowand.info.EmergencyButtonInfo;
import echowand.info.NodeProfileInfo;
import echowand.info.ObjectInfo;
import echowand.logic.MainLoop;
import echowand.logic.RequestDispatcher;
import echowand.logic.TooManyObjectsException;
import echowand.logic.TransactionManager;
import echowand.net.Inet4Subnet;
import echowand.net.SubnetException;
import echowand.object.AnnounceRequestProcessor;
import echowand.object.LocalObject;
import echowand.object.LocalObjectDateTimeDelegate;
import echowand.object.LocalObjectDefaultDelegate;
import echowand.object.LocalObjectManager;
import echowand.object.LocalObjectNotifyDelegate;
import echowand.object.NodeProfileObjectDelegate;
import echowand.object.ObjectData;
import echowand.object.RemoteObjectManager;
import echowand.object.SetGetRequestProcessor;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 *
 * @author NaTcH
 */
class EmergencyButtonObject extends LocalObject{
    private boolean emergencyState;
    
    static ObjectData STATE_FOUND = new ObjectData ((byte)0x41);
    static ObjectData STATE_NOTFOUND = new ObjectData ((byte)0x42);
    
    public EmergencyButtonObject  (ObjectInfo objectInfo){
        super(objectInfo);
    }
    public void setEmergencyState(boolean newState){
        ObjectData presentState = getEmergencyStateObject();
        emergencyState = newState;
        notifyDataChanged(EPC.xB1,getEmergencyStateObject() , presentState);
    }
    public boolean getEmergencyState(){
        return emergencyState;
    }
    public ObjectData getEmergencyStateObject(){
        if(emergencyState) return STATE_FOUND;
        else return STATE_NOTFOUND;
    }
}

class EmergencyButtonDataDelegate extends LocalObjectDefaultDelegate {
    private EmergencyButtonObject object;
    private GpioPinDigitalInput gpioPin;
    private GpioPinDigitalOutput gpioOutput;
    
    public EmergencyButtonDataDelegate(EmergencyButtonObject object, GpioPinDigitalInput pin,  GpioPinDigitalOutput out) {
        this.object = object;
        this.gpioPin = pin;
        this.gpioOutput = out;
    }
     @Override
    public void getData(GetState result, LocalObject obj, EPC epc) {
        if (epc == EPC.xB1) {
//            result.setGetData(pinStateToData(gpioPin.getState().getValue()));
            result.setGetData(object.getEmergencyStateObject());
        }
    }
    @Override
    public void setData(SetState result, LocalObject obj, EPC epc, ObjectData newData, ObjectData curData){
        if (epc == EPC.xBF){
            // if reset status is setted
            if(Integer.parseInt(newData.toString())==0)
                System.out.println("==== Reset State ====");
                object.setEmergencyState(false);
                gpioOutput.blink(0);
                gpioOutput.setState(PinState.LOW);
                result.setSetData(curData, curData);
        }
    }
    
    public EmergencyButtonObject getObject() {
        return object;
    }
    protected ObjectData pinStateToData(int pinState) {
       // System.out.println("Status(" + eoj + "): " + stringData + " \"" + command + "\"");
        if(pinState == 1) return new ObjectData((byte)0x41);
        else return new ObjectData((byte)0x42);
    }
    
}

class EmergencyButtonListener implements GpioPinListenerDigital {
	GpioPinDigitalInput digitalSwitch;
        GpioPinDigitalOutput outputPin;
	EmergencyButtonObject emergencyBtn;
        
	public EmergencyButtonListener(GpioPinDigitalInput digitalSwitch,GpioPinDigitalOutput outPin, EmergencyButtonObject btn) {
		super();
		this.digitalSwitch = digitalSwitch;
                this.outputPin = outPin;
		this.emergencyBtn = btn;
	}
 
	@Override
	public void handleGpioPinDigitalStateChangeEvent(GpioPinDigitalStateChangeEvent arg0) {
		if(digitalSwitch.getState().getValue() == 1 && Integer.parseInt(emergencyBtn.getData(EPC.xBF).toString())==1
                        && emergencyBtn.getEmergencyState()== false ){
                        System.out.println("!!!!!!!! ALERT !!!!!!!!");
                        emergencyBtn.setEmergencyState(true);
                        outputPin.blink(100);
                }
	}
}

class ResetEmergencyButtonListener implements GpioPinListenerDigital {
	GpioPinDigitalInput resetPin;
        GpioPinDigitalOutput outputPin;
	LocalObject emergencyBtn;
        
	public ResetEmergencyButtonListener(GpioPinDigitalInput resetPin,GpioPinDigitalOutput outputPin, LocalObject button) {
		super();
		this.resetPin = resetPin;
                this.outputPin = outputPin;
		this.emergencyBtn = button;
	}
 
	@Override
	public void handleGpioPinDigitalStateChangeEvent(GpioPinDigitalStateChangeEvent arg0) {
//      System.out.println("resetPin : "+resetPin.getState().getValue());
		if(resetPin.getState().getValue() == 0){
          emergencyBtn.forceSetData(EPC.xBF, new ObjectData((byte)0x00));
		}	
	}
}

public class Button implements Runnable{
    private Inet4Subnet subnet;
    private TransactionManager transactionManager;
    private RemoteObjectManager remoteManager;
    private LocalObjectManager localManager;
    private RequestDispatcher dispatcher;
    
    final GpioController gpio;
    final GpioPinDigitalInput gpioPin;
    final GpioPinDigitalInput resetPin;
    final GpioPinDigitalOutput outputPin;

     public Button() {
         gpio = GpioFactory.getInstance();
         gpioPin = gpio.provisionDigitalInputPin(RaspiPin.GPIO_06, PinPullResistance.PULL_DOWN);
         resetPin = gpio.provisionDigitalInputPin(RaspiPin.GPIO_05, PinPullResistance.PULL_UP);
         outputPin = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_04, PinState.LOW);
         outputPin.setShutdownOptions(true,PinState.LOW, PinPullResistance.OFF);
    }
     
     public NodeProfileInfo getNodeProfileInfo() {
        NodeProfileInfo info = new NodeProfileInfo();
        info.add(EPC.x97, true, false, false, 2);
        info.add(EPC.x98, true, false, false, 4);
        return info;
     }
     public EmergencyButtonInfo getEmergencyButtonInfo(){
         EmergencyButtonInfo info = new EmergencyButtonInfo();
         info.add(EPC.xBF, true, true ,false, new byte[]{0x01});
         return info;
     }
     private void initialize() throws SubnetException {
        subnet = new Inet4Subnet();
        //subnet.startService();
        transactionManager = new TransactionManager(subnet);
        remoteManager = new RemoteObjectManager();
        localManager = new LocalObjectManager();

        dispatcher = new RequestDispatcher();
        dispatcher.addRequestProcessor(new SetGetRequestProcessor(localManager));
        dispatcher.addRequestProcessor(new AnnounceRequestProcessor(localManager, remoteManager));
    }
    private void createNodeProfileObject() throws TooManyObjectsException {
        NodeProfileInfo nodeProfileInfo = getNodeProfileInfo();
        LocalObject nodeProfileObject = new LocalObject(nodeProfileInfo);
        nodeProfileObject.addDelegate(new LocalObjectNotifyDelegate(subnet, transactionManager));
        nodeProfileObject.addDelegate(new NodeProfileObjectDelegate(localManager));
        nodeProfileObject.addDelegate(new LocalObjectDateTimeDelegate());
        localManager.add(nodeProfileObject);
    }
    private void createEmergencyButton() throws TooManyObjectsException {
        EmergencyButtonInfo emergencyButtonInfo = getEmergencyButtonInfo();
        EmergencyButtonObject btn = new EmergencyButtonObject(emergencyButtonInfo);
        btn.addDelegate(new LocalObjectNotifyDelegate(subnet, transactionManager));
        btn.addDelegate( new EmergencyButtonDataDelegate(btn,gpioPin,outputPin));
        gpioPin.addListener(new EmergencyButtonListener(gpioPin,outputPin,btn));
        resetPin.addListener(new ResetEmergencyButtonListener(resetPin,outputPin,btn));
        localManager.add(btn);
    }
    
    private void startMainThread() {
        MainLoop mainLoop = new MainLoop();
        mainLoop.setSubnet(subnet);
        mainLoop.addListener(transactionManager);
        mainLoop.addListener(dispatcher);

        Thread mainThread = new Thread(mainLoop);
        // mainThread.setDaemon(true);
        System.out.println("Start MainLoop");
        mainThread.start();
    }
    @Override
    public void run() {
        try {
            initialize();
            createNodeProfileObject();
            createEmergencyButton();
//            System.out.println("MainThread...");
            startMainThread();
        } catch (Exception ex) {
            Logger.getLogger(Button.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
   public static void main(String[] args) throws InterruptedException{
       Button btn = new Button();       
        Thread mainThread = new Thread(btn);
//        System.out.println("Thread Start...");
        mainThread.start();
   }
           
}