package art.servers.colorsserver.controller;

import art.library.interop.InteropParameters;
import art.library.interop.serialization.Serialization;
import art.library.interop.serialization.SerializationException;
import art.library.model.devices.DeviceAction;
import art.library.model.devices.DeviceActionResult;
import art.library.model.devices.DeviceCommands;
import static art.library.model.devices.DeviceCommands.CONDITION_DISABLED;
import static art.library.model.devices.DeviceCommands.CONDITION_ENABLED;
import static art.library.model.devices.DeviceCommands.CONDITION_NO;
import static art.library.model.devices.DeviceCommands.CONDITION_YES;
import art.library.model.devices.colors.controller.M.M_Controller;
import art.library.model.devices.colors.controller.M.M_ControllerCommands;
import art.library.model.devices.colors.controller.M.M_ControllerConfiguration;
import art.library.model.devices.colors.controller.M.M_ControllerInformation;
import art.library.model.devices.colors.controller.M.M_ControllerRealtime;
import art.library.model.devices.colors.controller.M.M_ControllerStatus;
import art.library.model.devices.colors.controller.M.realtime.M_ControllerRealtimeCountingDetector;
import art.library.model.devices.colors.controller.M.M_ControllerStatusSubcontroller;
import art.library.model.devices.colors.controller.M.M_SubcontrollerConfiguration;
import art.library.model.devices.colors.controller.M.commands.M_ControllerCommandsSpecialDemand;
import art.library.model.devices.colors.controller.M.commands.M_ControllerCommands_SPTP;
import art.library.model.devices.colors.controller.M.commands.M_ControllerCommands_SPTP_Demands;
import art.library.model.devices.colors.controller.M.commands.M_ControllerCommands_SPTP_OperationMode;
import art.library.model.devices.colors.controller.M.configuration.ALUVISA_Link;
import art.library.model.devices.colors.controller.M.configuration.ALUVISA_Phase;
import art.library.model.devices.colors.controller.M.configuration.ALUVISA_Plan;
import art.library.model.devices.colors.controller.M.configuration.M_Assignment;
import art.library.model.devices.colors.controller.M.configuration.M_Intergreen;
import art.library.model.devices.colors.controller.M.configuration.M_IntergreenPositionTimes;
import art.library.model.devices.colors.controller.M.configuration.M_IntergreenToTimeTable;
import art.library.model.devices.colors.controller.M.configuration.M_IntergreensPositionTimes;
import art.library.model.devices.colors.controller.M.configuration.M_MinimumExtension;
import art.library.model.devices.colors.controller.M.configuration.M_PhysicalDetectorStrategical;
import art.library.model.devices.colors.controller.M.configuration.M_Plan;
import art.library.model.devices.colors.controller.M.configuration.M_Structure;
import art.library.model.devices.colors.controller.M.configuration.M_TrafficGroup;
import art.library.model.devices.colors.controller.M.configuration.SPTP.M_SPTP_Configuration;
import art.library.model.devices.colors.controller.M.realtime.M_ControllerRealtimeGroup;
import art.library.model.devices.colors.controller.M.realtime.M_ControllerRealtimeSubcontroller;
import art.library.model.devices.colors.controller.M.status.M_ControllerStatusGroup;
import art.library.model.devices.colors.controller.M.tables.M_ControllerReader;
import art.library.model.devices.colors.controller.M.tables.M_ControllerWriter;
import art.library.model.devices.colors.controller.M.tables.M_Table;
import art.library.model.devices.colors.controller.M.tables.M_TableWriter;
import art.library.model.devices.colors.controller.M.types.SPTP.M_SPTP_Demand;
import art.library.model.devices.colors.controller.M.types.SPTP.M_SPTP_Demand_Result;
import art.library.model.devices.etd.EtdStatus;
import art.library.model.devices.etd.status.EtdStatusLane;
import art.library.persistence.Persistence;
import art.servers.ColorsServer;
import art.servers.ServerException;
import art.servers.colorsserver.M.protocol.M_ControllerComunicator;
import art.servers.colorsserver.Shared;
import art.servers.colorsserver.M.protocol.M_Message;
import art.servers.colorsserver.M.protocol.M_ProtocolAnalyser;
import art.servers.colorsserver.M.protocol.M_ProtocolConstructor;
import art.servers.colorsserver.M.protocol.M_ProtocolWriter;
import art.servers.colorsserver.M.protocol.M_Request;
import art.servers.controller.Controller;
import static art.servers.controller.ListenerImplementation.getTimestamp;
import static java.lang.Thread.sleep;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.HashMap;
import java.util.List;



public class ControllerController extends art.servers.controller.ControllerDevice
{
    private SimpleDateFormat sdh = new SimpleDateFormat("HH:mm");

    public static final int MAX_RETRIES = 6;


    protected M_Controller controller = null;
    public boolean hasCRC = false;
    protected String name = null;


    protected EtdStatus etdStatus = null;
    protected int forceRealtime = -1;
    protected int[] forcedUserControlPlan = new int[1];
    protected int forceCentralized = -1;
    protected List<M_ControllerStatusSubcontroller> lsubcontrollerUpdate = new ArrayList<M_ControllerStatusSubcontroller>();

    protected List<M_Controller> lcontroller = new ArrayList<M_Controller>();

    protected long lastQueryDetectorsRealtime = 0;
    protected long lastQueryGroupsRealtime = 0;
    protected long lastQueryStatus = 0;
    protected long lastQueryTrafficData = 0;
    protected long lastQueryTables = 0;
    protected boolean firstTime = true;

    private boolean usePRH = false;
    private boolean checkedPRH = false;

    private ControllerTrafficData controllerTrafficData = null;

    public M_ControllerCommands_SPTP_Demands commandsDemands = null;
    public M_SPTP_Configuration commandsConfiguration = null;


    public ControllerController(M_Controller m_controller, boolean hasCRC)
    {
        super(m_controller);
        this.controller = m_controller;
        this.forcedUserControlPlan[0] = M_ControllerCommands.CONDITION_NOTHING;
        this.hasCRC = hasCRC;
        this.name = "Controller " + m_controller.getIdentifier();
    }


    public ControllerController(M_Controller m_controller, List<M_Controller> lcontroller, boolean hasCRC)
    {
        super(m_controller);
        this.controller = m_controller;
        this.lcontroller = lcontroller;
        this.hasCRC = hasCRC;
        this.name = "Controller " + m_controller.getIdentifier() + " - " + lcontroller.size();

        forcedUserControlPlan = new int[lcontroller.size()];
        for (int i=0; i<forcedUserControlPlan.length; i++)
            forcedUserControlPlan[i] = M_ControllerCommands.CONDITION_NOTHING;
    }
    
    
    public M_Controller getController()
    {
        return controller;
    }



    // <editor-fold defaultstate="collapsed" desc="Run">

    public void run()
    {
        // <editor-fold defaultstate="collapsed" desc="Trace">
        Shared.traceInformation(name, Shared.getMessage("Starting"));
        // </editor-fold>      

        while ((isInterrupted() == false) && (exit == false))
        {
            long startTimestamp = System.currentTimeMillis();

            try
            {
                if (art.servers.Shared.isServerEnabled() == true)
                {
                    if (this.controllerTrafficData == null)
                    {
                        this.controllerTrafficData = new ControllerTrafficData();
                        this.controllerTrafficData.start();
                    }

                    if (forceCentralized == 0)
                    {
                        stopController();
                    }
                    else
                    {
                        resumeController();
                    }

                    update();
                }
            }
            catch (Exception e)
            {
            }

            try
            {
                if (startTimestamp > System.currentTimeMillis())
                {
                    startTimestamp = System.currentTimeMillis();
                }

                long stopTimestamp = startTimestamp + 1000;

                while ((System.currentTimeMillis() < stopTimestamp) && (exit == false))
                {
                    try
                    {
                        sleep(50);
                    }
                    catch (Exception e)
                    {
                    }
                }

                try{sleep(50);}catch (Exception e){};
            }
            catch (Exception e)
            {
                try
                {
                    sleep(1000);
                }
                catch (Exception ex)
                {
                    
                }
            }
        }

        this.controllerTrafficData.close();
        // <editor-fold defaultstate="collapsed" desc="Trace">
        Shared.traceInformation(name, Shared.getMessage("Finishing"));
        // </editor-fold>      
    }


    public void stopController()
    {
        try{getControllerConnection().stopConnection();} catch (Exception e){};
    }


    public void resumeController()
    {
        try{getControllerConnection().resumeconnection();} catch (Exception e){};
    }


    protected void update() throws ServerException, Exception
    {
        
    }


    public M_Controller cloneController()
    {
        M_Controller controllerclone = (M_Controller)Serialization.clone(controller);

        if (controller.realtime == null)
        {
            controller.realtime = new M_ControllerRealtime();
        }

        controllerclone.realtime = controller.realtime;

        controllerclone.getDeviceRealtime().identifier = controllerclone.getIdentifier();
        if (controllerclone.getDeviceRealtime().lastTimestampUpdate <= 0)
        {
            controllerclone.getDeviceRealtime().lastTimestampUpdate = System.currentTimeMillis();
        }

        if (ColorsServer.ACTIVATE_REALTIME == true)
        {
            this.forceRealtime = 1;
        }

        if (forceRealtime == 0)
        {
            controllerclone.getDeviceStatus().detectorsRealtime = M_ControllerStatus.NO;
            controllerclone.getDeviceStatus().groupsRealtime = M_ControllerStatus.NO;
            controllerclone.getDeviceRealtime().lpresence.clear();
            controllerclone.getDeviceRealtime().lgroup.clear();
            forceRealtime = -1;
        }
        else if (forceRealtime == 1)
        {
            controllerclone.getDeviceStatus().detectorsRealtime = M_ControllerStatus.YES;
            controllerclone.getDeviceStatus().groupsRealtime = M_ControllerStatus.YES;
            forceRealtime = -1;
        }

        if (controllerclone.getDeviceStatus().detectorsRealtime != M_ControllerStatus.YES)
        {
            controllerclone.getDeviceRealtime().lpresence.clear();
        }

        if (controllerclone.getDeviceStatus().groupsRealtime != M_ControllerStatus.YES)
        {
            controllerclone.getDeviceRealtime().lgroup.clear();
        }

        if ((controllerclone.getDeviceStatus().detectorsRealtime != M_ControllerStatus.NO) &&
            (controllerclone.getDeviceStatus().detectorsRealtime != M_ControllerStatus.YES))
        {
            controllerclone.getDeviceStatus().detectorsRealtime = M_ControllerStatus.NO;
        }

        if ((controllerclone.getDeviceStatus().groupsRealtime != M_ControllerStatus.NO) &&
            (controllerclone.getDeviceStatus().groupsRealtime != M_ControllerStatus.YES))
        {
            controllerclone.getDeviceStatus().groupsRealtime = M_ControllerStatus.NO;
        }

        for (M_ControllerStatusSubcontroller subcontrollerStatus : controllerclone.getDeviceStatus().lsubcontroller)
        {
            if ((subcontrollerStatus.userControlManual != M_ControllerStatus.NO) &&
                (subcontrollerStatus.userControlManual != M_ControllerStatus.YES))
            {
                subcontrollerStatus.userControlManual = M_ControllerStatus.NO;
            }

            if ((subcontrollerStatus.userControlPlan != M_ControllerStatus.NO) &&
                (subcontrollerStatus.userControlPlan != M_ControllerStatus.YES))
            {
                subcontrollerStatus.userControlPlan = M_ControllerStatus.NO;
            }
        }

        for (int i=0; i<forcedUserControlPlan.length; i++)
        {
            if (forcedUserControlPlan[i] == M_ControllerCommands.CONDITION_NO)
            {
                controllerclone.getDeviceStatus().getStatusSubcontroller(i+1).userControlPlan = M_ControllerStatus.NO;
                forcedUserControlPlan[i] = -1;
            }
            else if (forcedUserControlPlan[i] == M_ControllerCommands.CONDITION_YES)
            {
                controllerclone.getDeviceStatus().getStatusSubcontroller(i+1).userControlPlan = M_ControllerStatus.YES;
                forcedUserControlPlan[i] = -1;
            }
        }

        return(controllerclone);
    }


    public void offline(M_Controller controllerclone)throws Exception
    {
        if (this.lcontroller.size() == 0)
        {
            if ((controllerclone.alarms.alarm_offline <= 0) || (firstTime == true))
            {
                firstTime = false;
                String message = art.servers.Shared.getMessage("Controller offline");
                art.servers.Shared.println(name, message);
            }

            controllerclone.setAlarm("alarm_offline", System.currentTimeMillis());

            if (controllerclone.getDeviceStatus().lsubcontrollerUpdate != null)
            {
                if (controllerclone.getDeviceStatus().lsubcontrollerUpdate.size() <= 0)
                {
                    controllerclone.getDeviceStatus().lsubcontrollerUpdate = null;
                }
            }

            M_ControllerStatus statusController = controllerclone.getDeviceStatus();

            if (statusController.lsubcontroller != null)
            {
                if (statusController.lsubcontroller.size() == 0)
                {
                    M_ControllerStatusSubcontroller statussubcontroller = new M_ControllerStatusSubcontroller();
                    statussubcontroller.number = controllerclone.getDeviceInformation().subcontroller;
                    statusController.lsubcontroller.add(statussubcontroller);
                }
            }

            M_ControllerConfiguration configurationController = controllerclone.getDeviceConfiguration();

            if (configurationController.lsubcontroller != null)
            {
                for (M_SubcontrollerConfiguration configurationSubcontroller : configurationController.lsubcontroller)
                {
                    for (M_Plan m_plan : configurationSubcontroller.lplan)
                    {
                        ALUVISA_Plan plan = m_plan.toAluvisaPlan(configurationSubcontroller);
                        m_plan.numberOfPaths = plan.getPaths().size();
                    }
                }
            }

            try
            {
                controllerclone.getDeviceRealtime().lcounting.clear();
                controllerclone.getDeviceRealtime().lgroup.clear();
                controllerclone.getDeviceRealtime().lpresence.clear();
            }
            catch (Exception e)
            {
                
            }

            Shared.model.updateDevice(controller, controllerclone);
        }
        else if (this.lcontroller.size() > 0)
        {
            if ((controllerclone.alarms.alarm_offline <= 0) || (firstTime == true))
            {
                firstTime = false;
                String message = art.servers.Shared.getMessage("Controller offline");
                art.servers.Shared.println(name, message);
            }

            controllerclone.setAlarm("alarm_offline", System.currentTimeMillis());

            controllerclone.getDeviceInformation().serverAddress = art.servers.Shared.configuration.listener.address;
            controllerclone.getDeviceInformation().serverPort = art.servers.Shared.configuration.listener.port;
            controllerclone.getDeviceInformation().serverAddressExternal = art.servers.Shared.configuration.listener.addressExternal;
            controllerclone.getDeviceInformation().serverPortExternal = art.servers.Shared.configuration.listener.portExternal;
            controllerclone.getDeviceInformation().serverServiceName = art.servers.Shared.controllerStatus.getApplication().getDeviceInformation().serverServiceName;

            if (controllerclone.getDeviceStatus().lsubcontrollerUpdate != null)
            {
                if (controllerclone.getDeviceStatus().lsubcontrollerUpdate.size() <= 0)
                {
                    controllerclone.getDeviceStatus().lsubcontrollerUpdate = null;
                }
            }

            M_ControllerStatus statusController = controllerclone.getDeviceStatus();

            if (statusController.lsubcontroller != null)
            {
                if (statusController.lsubcontroller.size() == 0)
                {
                    M_ControllerStatusSubcontroller statussubcontroller = new M_ControllerStatusSubcontroller();
                    statussubcontroller.number = controllerclone.getDeviceInformation().subcontroller;
                    statusController.lsubcontroller.add(statussubcontroller);
                }
            }

            M_ControllerConfiguration configurationController = controllerclone.getDeviceConfiguration();

            if (configurationController.lsubcontroller != null)
            {
                for (M_SubcontrollerConfiguration configurationSubcontroller : configurationController.lsubcontroller)
                {
                    for (M_Plan m_plan : configurationSubcontroller.lplan)
                    {
                        ALUVISA_Plan plan = m_plan.toAluvisaPlan(configurationSubcontroller);
                        m_plan.numberOfPaths = plan.getPaths().size();
                    }
                }
            }

            try
            {
                controllerclone.getDeviceRealtime().lcounting.clear();
                controllerclone.getDeviceRealtime().lgroup.clear();
                controllerclone.getDeviceRealtime().lpresence.clear();
            }
            catch (Exception e)
            {
                
            }


            // Have more than one subcontroller
            // Must be clone for every subcontroller
            for (M_Controller m_controllerSubcontroller : this.lcontroller)
            {
                M_Controller m_subcontroller = getSubcontrollerOffline(controllerclone, m_controllerSubcontroller);
                M_Controller m_subcontrollerCurrent = (M_Controller)Shared.model.getDevice(m_controllerSubcontroller.getIdentifier());

                Shared.model.updateDevice(m_subcontrollerCurrent, m_subcontroller);
            }

            // this.controller.updateDevice(controllerclone);
            this.controller = controllerclone;

            try
            {
                this.controller.getDeviceConfiguration().toAluvisa();
            }
            catch (Exception e)
            {

            }
        }

        lastQueryDetectorsRealtime = 0;
        lastQueryGroupsRealtime = 0;
        lastQueryStatus = 0;
        lastQueryTrafficData = 0;
        lastQueryTables = 0;
    }


    public void disable(M_Controller controllerclone)throws Exception
    {
        if (this.lcontroller.size() == 0)
        {
            if ((controllerclone.alarms.alarm_disabled <= 0) || (firstTime == true))
            {
                firstTime = false;
                String message = art.servers.Shared.getMessage("Controller disabled");
                art.servers.Shared.println(name, message);
            }

            controllerclone.setAlarm("alarm_disabled", System.currentTimeMillis());

            if (controllerclone.getDeviceStatus().lsubcontrollerUpdate != null)
            {
                if (controllerclone.getDeviceStatus().lsubcontrollerUpdate.size() <= 0)
                {
                    controllerclone.getDeviceStatus().lsubcontrollerUpdate = null;
                }
            }

            M_ControllerStatus statusController = controllerclone.getDeviceStatus();

            if (statusController.lsubcontroller != null)
            {
                if (statusController.lsubcontroller.size() == 0)
                {
                    M_ControllerStatusSubcontroller statussubcontroller = new M_ControllerStatusSubcontroller();
                    statussubcontroller.number = controllerclone.getDeviceInformation().subcontroller;
                    statusController.lsubcontroller.add(statussubcontroller);
                }
            }

            M_ControllerConfiguration configurationController = controllerclone.getDeviceConfiguration();

            if (configurationController.lsubcontroller != null)
            {
                for (M_SubcontrollerConfiguration configurationSubcontroller : configurationController.lsubcontroller)
                {
                    for (M_Plan m_plan : configurationSubcontroller.lplan)
                    {
                        ALUVISA_Plan plan = m_plan.toAluvisaPlan(configurationSubcontroller);
                        m_plan.numberOfPaths = plan.getPaths().size();
                    }
                }
            }

            try
            {
                controllerclone.getDeviceRealtime().lcounting.clear();
                controllerclone.getDeviceRealtime().lgroup.clear();
                controllerclone.getDeviceRealtime().lpresence.clear();
            }
            catch (Exception e)
            {
                
            }

            Shared.model.updateDevice(controller, controllerclone);
        }
        else if (this.lcontroller.size() > 0)
        {
            if ((controllerclone.alarms.alarm_disabled <= 0) || (firstTime == true))
            {
                firstTime = false;
                String message = art.servers.Shared.getMessage("Controller disabled");
                art.servers.Shared.println(name, message);
            }

            controllerclone.setAlarm("alarm_disabled", System.currentTimeMillis());

            controllerclone.getDeviceInformation().serverAddress = art.servers.Shared.configuration.listener.address;
            controllerclone.getDeviceInformation().serverPort = art.servers.Shared.configuration.listener.port;
            controllerclone.getDeviceInformation().serverAddressExternal = art.servers.Shared.configuration.listener.addressExternal;
            controllerclone.getDeviceInformation().serverPortExternal = art.servers.Shared.configuration.listener.portExternal;
            controllerclone.getDeviceInformation().serverServiceName = art.servers.Shared.controllerStatus.getApplication().getDeviceInformation().serverServiceName;

            if (controllerclone.getDeviceStatus().lsubcontrollerUpdate != null)
            {
                if (controllerclone.getDeviceStatus().lsubcontrollerUpdate.size() <= 0)
                {
                    controllerclone.getDeviceStatus().lsubcontrollerUpdate = null;
                }
            }

            M_ControllerStatus statusController = controllerclone.getDeviceStatus();

            if (statusController.lsubcontroller != null)
            {
                if (statusController.lsubcontroller.size() == 0)
                {
                    M_ControllerStatusSubcontroller statussubcontroller = new M_ControllerStatusSubcontroller();
                    statussubcontroller.number = controllerclone.getDeviceInformation().subcontroller;
                    statusController.lsubcontroller.add(statussubcontroller);
                }
            }

            M_ControllerConfiguration configurationController = controllerclone.getDeviceConfiguration();

            if (configurationController.lsubcontroller != null)
            {
                for (M_SubcontrollerConfiguration configurationSubcontroller : configurationController.lsubcontroller)
                {
                    for (M_Plan m_plan : configurationSubcontroller.lplan)
                    {
                        ALUVISA_Plan plan = m_plan.toAluvisaPlan(configurationSubcontroller);
                        m_plan.numberOfPaths = plan.getPaths().size();
                    }
                }
            }

            try
            {
                controllerclone.getDeviceRealtime().lcounting.clear();
                controllerclone.getDeviceRealtime().lgroup.clear();
                controllerclone.getDeviceRealtime().lpresence.clear();
            }
            catch (Exception e)
            {
                
            }


            // Have more than one subcontroller
            // Must be clone for every subcontroller
            for (M_Controller m_controllerSubcontroller : this.lcontroller)
            {
                M_Controller m_subcontroller = getSubcontrollerOffline(controllerclone, m_controllerSubcontroller);
                M_Controller m_subcontrollerCurrent = (M_Controller)Shared.model.getDevice(m_controllerSubcontroller.getIdentifier());

                Shared.model.updateDevice(m_subcontrollerCurrent, m_subcontroller);
            }

            // this.controller.updateDevice(controllerclone);
            this.controller = controllerclone;

            try
            {
                this.controller.getDeviceConfiguration().toAluvisa();
            }
            catch (Exception e)
            {

            }
        }

        lastQueryDetectorsRealtime = 0;
        lastQueryGroupsRealtime = 0;
        lastQueryStatus = 0;
        lastQueryTrafficData = 0;
        lastQueryTables = 0;
    }


    public void online(M_Controller controllerclone) throws ServerException, Exception
    {
        if (this.lcontroller.size() == 0)
        {
            // Only have one subcontroller, so it works how until now
            if ((controllerclone.alarms.alarm_offline > 0) || (firstTime == true))
            {
                firstTime = false;
                String message = art.servers.Shared.getMessage("Controller online");
                art.servers.Shared.println(name, message);
            }

            controllerclone.setAlarm("alarm_offline", false);
            controllerclone.setAlarm("alarm_disabled", false);
            controllerclone.setAlarm("alarm_invalid", false);

            // Update alarm_off and alarm_flashing
            boolean alarm_off = false;
            boolean alarm_flashing = false;
            for (M_ControllerStatusSubcontroller statusSubcontroller : controllerclone.getDeviceStatus().lsubcontroller)
            {
                if (statusSubcontroller.colorsMode == M_ControllerStatusSubcontroller.COLORS_OFF) alarm_off = true;
                if (statusSubcontroller.colorsMode == M_ControllerStatusSubcontroller.COLORS_FLASHING) alarm_flashing = true;
            }

            controllerclone.setAlarm("alarm_off", alarm_off);
            controllerclone.setAlarm("alarm_flashing", alarm_flashing);

            if (controllerclone.getAlarm("alarm_manual_control") > 0)
            {
                for (M_ControllerStatusSubcontroller statusSubcontroller : controllerclone.getDeviceStatus().lsubcontroller)
                {
                    statusSubcontroller.localControl = DeviceCommands.CONDITION_YES;
                }
            }
            else if (controllerclone.getAlarm("alarm_manual_control") <= 0)
            {
                for (M_ControllerStatusSubcontroller statusSubcontroller : controllerclone.getDeviceStatus().lsubcontroller)
                {
                    if (statusSubcontroller.userControlManual == DeviceCommands.CONDITION_NO)
                        statusSubcontroller.localControl = DeviceCommands.CONDITION_NO;
                }
            }

            for (M_SubcontrollerConfiguration subcontrollerConfiguration : controllerclone.getDeviceConfiguration().lsubcontroller)
            {
                for (M_Plan m_plan : subcontrollerConfiguration.lplan)
                {
                    m_plan.cycleTime = calculateCycleTime(m_plan, controllerclone, subcontrollerConfiguration.number);
                    ALUVISA_Plan plan = m_plan.toAluvisaPlan(subcontrollerConfiguration);
                    m_plan.numberOfPaths = plan.getPaths().size();
                }
            }

            if (controllerclone.getDeviceStatus().lsubcontrollerUpdate != null)
            {
                if (controllerclone.getDeviceStatus().lsubcontrollerUpdate.size() <= 0)
                {
                    controllerclone.getDeviceStatus().lsubcontrollerUpdate = null;
                }
            }

            Shared.model.updateDevice(controller, controllerclone);

            try
            {
                this.controller.getDeviceConfiguration().toAluvisa();
            }
            catch (Exception e)
            {

            }
        }
        else if (this.lcontroller.size() > 0)
        {
            if ((controllerclone.alarms.alarm_offline > 0) || (firstTime == true))
            {
                firstTime = false;
                String message = art.servers.Shared.getMessage("Controller online");
                art.servers.Shared.println(name, message);
            }

            controllerclone.setAlarm("alarm_offline", false);
            controllerclone.setAlarm("alarm_disabled", false);
            controllerclone.setAlarm("alarm_invalid", false);

            controllerclone.getDeviceInformation().serverAddress = art.servers.Shared.configuration.listener.address;
            controllerclone.getDeviceInformation().serverPort = art.servers.Shared.configuration.listener.port;
            controllerclone.getDeviceInformation().serverAddressExternal = art.servers.Shared.configuration.listener.addressExternal;
            controllerclone.getDeviceInformation().serverPortExternal = art.servers.Shared.configuration.listener.portExternal;
            controllerclone.getDeviceInformation().serverServiceName = art.servers.Shared.controllerStatus.getApplication().getDeviceInformation().serverServiceName;

            for (M_SubcontrollerConfiguration subcontrollerConfiguration : controllerclone.getDeviceConfiguration().lsubcontroller)
            {
                for (M_Plan m_plan : subcontrollerConfiguration.lplan)
                {
                    m_plan.cycleTime = calculateCycleTime(m_plan, controllerclone, subcontrollerConfiguration.number);
                    ALUVISA_Plan plan = m_plan.toAluvisaPlan(subcontrollerConfiguration);
                    m_plan.numberOfPaths = plan.getPaths().size();
                }
            }

            // Have more than one subcontroller
            // Must be clone for every subcontroller
            for (M_Controller m_controllerSubcontroller : this.lcontroller)
            {
                M_Controller m_subcontroller = getSubcontrollerOnline(controllerclone, m_controllerSubcontroller);
                M_Controller m_subcontrollerCurrent = (M_Controller)Shared.model.getDevice(m_controllerSubcontroller.getIdentifier());
                if (controllerclone.getDeviceStatus().lsubcontrollerUpdate != null)
                {
                    if (controllerclone.getDeviceStatus().lsubcontrollerUpdate.size() <= 0)
                    {
                        controllerclone.getDeviceStatus().lsubcontrollerUpdate = null;
                    }
                }

                Shared.model.updateDevice(m_subcontrollerCurrent, m_subcontroller);

                try
                {
                    m_subcontrollerCurrent.getDeviceConfiguration().toAluvisa();
                }
                catch (Exception e)
                {

                }
            }

            // this.controller.updateDevice(controllerclone);
            this.controller = controllerclone;

            try
            {
                this.controller.getDeviceConfiguration().toAluvisa();
            }
            catch (Exception e)
            {

            }
        }
    }


    private M_Controller getSubcontrollerOffline(M_Controller controllerInput, M_Controller m_controllerSubcontroller)
    {
        int subcontroller = m_controllerSubcontroller.getDeviceInformation().subcontroller;

        M_Controller m_subcontroller = Serialization.clone(controllerInput);
        m_subcontroller.realtime = Serialization.clone(controllerInput.getDeviceRealtime());
        m_subcontroller.getDeviceRealtime().identifier = m_controllerSubcontroller.getIdentifier();

        // Update M_ControllerInformation with subcontroller information
        m_subcontroller.information = m_controllerSubcontroller.getDeviceInformation();

        // Remove from M_ControllerConfiguration.lsubcontroller the other subcontrollers
        List<M_SubcontrollerConfiguration> lremoveConfiguration = new ArrayList<M_SubcontrollerConfiguration>();
        for (M_SubcontrollerConfiguration subcontrollerConfiguration : m_subcontroller.getDeviceConfiguration().lsubcontroller)
        {
            if (subcontrollerConfiguration.number != subcontroller)
            {
                lremoveConfiguration.add(subcontrollerConfiguration);
            }
        }

        m_subcontroller.getDeviceConfiguration().lsubcontroller.removeAll(lremoveConfiguration);

        // Remove from M_ControllerStatus.lsubcontroller the other subcontrollers
        List<M_ControllerStatusSubcontroller> lremoveStatus = new ArrayList<M_ControllerStatusSubcontroller>();
        for (M_ControllerStatusSubcontroller subcontrollerStatus : m_subcontroller.getDeviceStatus().lsubcontroller)
        {
            if (subcontrollerStatus.number != subcontroller)
            {
                lremoveStatus.add(subcontrollerStatus);
            }
        }

        m_subcontroller.getDeviceStatus().lsubcontroller.removeAll(lremoveStatus);

        if (m_subcontroller.getDeviceStatus().lsubcontrollerUpdate != null)
        {
            // Remove from M_ControllerStatus.lsubcontrollerUpdate the other subcontrollers
            List<M_ControllerStatusSubcontroller> lremoveStatusUpdate = new ArrayList<M_ControllerStatusSubcontroller>();
            for (M_ControllerStatusSubcontroller subcontrollerStatusUpdate : m_subcontroller.getDeviceStatus().lsubcontrollerUpdate)
            {
                if (subcontrollerStatusUpdate.number != subcontroller)
                {
                    lremoveStatusUpdate.add(subcontrollerStatusUpdate);
                }
            }

            m_subcontroller.getDeviceStatus().lsubcontrollerUpdate.removeAll(lremoveStatusUpdate);
        }

        // Remove from M_ControllerRealtime.lsubcontroller the other subcontrollers
        List<M_ControllerRealtimeSubcontroller> lremoveRealtime = new ArrayList<M_ControllerRealtimeSubcontroller>();
        for (M_ControllerRealtimeSubcontroller subcontrollerRealtime : m_subcontroller.getDeviceRealtime().lsubcontroller)
        {
            if (subcontrollerRealtime.number != subcontroller)
            {
                lremoveRealtime.add(subcontrollerRealtime);
            }
        }

        m_subcontroller.getDeviceRealtime().lsubcontroller.removeAll(lremoveRealtime);

        return(m_subcontroller);
    }


    private M_Controller getSubcontrollerOnline(M_Controller controllerInput, M_Controller m_controllerSubcontroller)
    {
        int subcontroller = m_controllerSubcontroller.getDeviceInformation().subcontroller;
        M_Controller m_subcontroller = Serialization.clone(controllerInput);
        m_subcontroller.realtime = Serialization.clone(controllerInput.getDeviceRealtime());
        m_subcontroller.getDeviceRealtime().identifier = m_controllerSubcontroller.getIdentifier();

        // Update M_ControllerInformation with subcontroller information
        m_subcontroller.information = m_controllerSubcontroller.getDeviceInformation();

        // Remove from M_ControllerConfiguration.lsubcontroller the other subcontrollers
        List<M_SubcontrollerConfiguration> lremoveConfiguration = new ArrayList<M_SubcontrollerConfiguration>();
        for (M_SubcontrollerConfiguration subcontrollerConfiguration : m_subcontroller.getDeviceConfiguration().lsubcontroller)
        {
            if (subcontrollerConfiguration.number != subcontroller)
            {
                lremoveConfiguration.add(subcontrollerConfiguration);
            }
        }

        m_subcontroller.getDeviceConfiguration().lsubcontroller.removeAll(lremoveConfiguration);

        // Remove from M_ControllerStatus.lsubcontroller the other subcontrollers
        List<M_ControllerStatusSubcontroller> lremoveStatus = new ArrayList<M_ControllerStatusSubcontroller>();
        for (M_ControllerStatusSubcontroller subcontrollerStatus : m_subcontroller.getDeviceStatus().lsubcontroller)
        {
            if (subcontrollerStatus.number != subcontroller)
            {
                lremoveStatus.add(subcontrollerStatus);
            }
        }

        m_subcontroller.getDeviceStatus().lsubcontroller.removeAll(lremoveStatus);

        // Remove from M_ControllerStatus.lsubcontrollerUpdate the other subcontrollers
        List<M_ControllerStatusSubcontroller> lremoveStatusUpdate = new ArrayList<M_ControllerStatusSubcontroller>();
        for (M_ControllerStatusSubcontroller subcontrollerStatusUpdate : m_subcontroller.getDeviceStatus().lsubcontrollerUpdate)
        {
            if (subcontrollerStatusUpdate.number != subcontroller)
            {
                lremoveStatusUpdate.add(subcontrollerStatusUpdate);
            }
        }

        m_subcontroller.getDeviceStatus().lsubcontrollerUpdate.removeAll(lremoveStatusUpdate);

        // Remove from M_ControllerRealtime.lsubcontroller the other subcontrollers
        List<M_ControllerRealtimeSubcontroller> lremoveRealtime = new ArrayList<M_ControllerRealtimeSubcontroller>();
        for (M_ControllerRealtimeSubcontroller subcontrollerRealtime : m_subcontroller.getDeviceRealtime().lsubcontroller)
        {
            if (subcontrollerRealtime.number != subcontroller)
            {
                lremoveRealtime.add(subcontrollerRealtime);
            }
        }

        m_subcontroller.getDeviceRealtime().lsubcontroller.removeAll(lremoveRealtime);

        // Update alarm_off and alarm_flashing
        boolean alarm_off = false;
        boolean alarm_flashing = false;
        for (M_ControllerStatusSubcontroller statusSubcontroller : m_subcontroller.getDeviceStatus().lsubcontroller)
        {
            if (statusSubcontroller.colorsMode == M_ControllerStatusSubcontroller.COLORS_OFF) alarm_off = true;
            if (statusSubcontroller.colorsMode == M_ControllerStatusSubcontroller.COLORS_FLASHING) alarm_flashing = true;
        }

        m_subcontroller.setAlarm("alarm_off", alarm_off);
        m_subcontroller.setAlarm("alarm_flashing", alarm_flashing);

        if (controllerInput.getAlarm("alarm_manual_control") > 0)
        {
            for (M_ControllerStatusSubcontroller statusSubcontroller : controllerInput.getDeviceStatus().lsubcontroller)
            {
                statusSubcontroller.localControl = DeviceCommands.CONDITION_YES;
            }
        }
        else if (controllerInput.getAlarm("alarm_manual_control") <= 0)
        {
            for (M_ControllerStatusSubcontroller statusSubcontroller : controllerInput.getDeviceStatus().lsubcontroller)
            {
                if (statusSubcontroller.userControlManual == DeviceCommands.CONDITION_NO)
                    statusSubcontroller.localControl = DeviceCommands.CONDITION_NO;
            }
        }

        return(m_subcontroller);
    }

    // </editor-fold>  

    // <editor-fold defaultstate="collapsed" desc="Actions">

    // <editor-fold defaultstate="collapsed" desc="Send commands">

    public DeviceAction[] sendCommands(int subcontroller, InteropParameters parameters) throws SerializationException, Exception
    {
        try
        {
            List<DeviceAction> result = new ArrayList<DeviceAction>();

            M_ControllerCommands m_controllerCommands = parameters.getBodyContentValue(M_ControllerCommands.class);

            Shared.println(name, this.controller.getIdentifier() + " - Commands:");
            Shared.println(name, Serialization.toPrettyString(m_controllerCommands));

            if (m_controllerCommands.centralized != M_ControllerCommands.CONDITION_NOTHING)
            {
                M_ControllerCommands command = new M_ControllerCommands();
                command.centralized = m_controllerCommands.centralized;
                result.add(centralized(subcontroller, parameters, command));
            }

            if (m_controllerCommands.specialDemandSelection != null)
            {
                M_ControllerCommands command = new M_ControllerCommands();
                command.specialDemandSelection = m_controllerCommands.specialDemandSelection;
                result.add(selectSpecialDemandSubcontroller(subcontroller, parameters, command));
            }

            if (m_controllerCommands.specialDemandCancel != null)
            {
                M_ControllerCommands command = new M_ControllerCommands();
                command.specialDemandCancel = m_controllerCommands.specialDemandCancel;
                result.add(cancelSpecialDemandSubcontroller(subcontroller, parameters, command));
            }

            if ((m_controllerCommands.colorsMode != M_ControllerCommands.COLORS_NOTHING) ||
                (m_controllerCommands.operationMode != M_ControllerCommands.OPERATIONMODE_NOTHING) ||
                (m_controllerCommands.userControlManual != M_ControllerCommands.CONDITION_NOTHING) ||
                ((m_controllerCommands.sptp != null) && (m_controllerCommands.sptp.operationMode != null)) ||
                (m_controllerCommands.emergency != M_ControllerCommands.CONDITION_NOTHING))
            {
                M_ControllerCommands command = new M_ControllerCommands();
                command.colorsMode = m_controllerCommands.colorsMode;
                command.operationMode = m_controllerCommands.operationMode;
                command.userControlManual = m_controllerCommands.userControlManual;
                command.emergency = m_controllerCommands.emergency;
                if ((m_controllerCommands.sptp != null) && (m_controllerCommands.sptp.operationMode != null))
                {
                    command.sptp = new M_ControllerCommands_SPTP();
                    command.sptp.operationMode = new M_ControllerCommands_SPTP_OperationMode();
                    command.sptp.operationMode.mode = m_controllerCommands.sptp.operationMode.mode;
                }
                int planSelection = -1;  // M_ControllerStatusSubcontroller.PLANSELECTION_COMPUTER;
                int coordinationMode = M_ControllerStatusSubcontroller.COORDINATION_COMPUTER;
                int centralizedMode = DeviceCommands.CONDITION_YES;
                int controlComputerDirectGroups = CONDITION_NO;
                int adaptative = DeviceCommands.CONDITION_NO;
                int adaptativeDetectors = DeviceCommands.CONDITION_NO;
                result.addAll(setStateSubcontroller(subcontroller, adaptative, adaptativeDetectors, centralizedMode, 
                        controlComputerDirectGroups, coordinationMode, planSelection, parameters, command));
            }

            int userControlPlan = this.controller.getDeviceStatus().getStatusSubcontroller(subcontroller).userControlPlan;
            if (m_controllerCommands.userControlPlan != DeviceCommands.CONDITION_NOTHING)
            {
                userControlPlan = m_controllerCommands.userControlPlan;
                M_ControllerCommands command = new M_ControllerCommands();
                command.userControlPlan = m_controllerCommands.userControlPlan;
                result.add(setUserControlPlan(subcontroller, parameters, command));
            }

            if ((m_controllerCommands.recordablePlan != null) && (userControlPlan == DeviceCommands.CONDITION_YES))
            {
                M_ControllerCommands command = new M_ControllerCommands();
                command.recordablePlan = m_controllerCommands.recordablePlan;
                result.add(setRecordablePlanSubcontroller(subcontroller, parameters, command));
            }

            if ((m_controllerCommands.recordablePlan != null) && (userControlPlan != DeviceCommands.CONDITION_YES))
            {
                M_ControllerCommands command = new M_ControllerCommands();
                command.recordablePlan = m_controllerCommands.recordablePlan;
                result.add(saveRecordablePlanSubcontroller(subcontroller, parameters, command));
            }

            if ((m_controllerCommands.localPlan != DeviceCommands.CONDITION_NOTHING) && (userControlPlan == DeviceCommands.CONDITION_YES))
            {
                M_ControllerCommands command = new M_ControllerCommands();
                command.localPlan = m_controllerCommands.localPlan;
                result.add(setLocalPlanSubcontroller(subcontroller, parameters, command));
            }

            if ((m_controllerCommands.forceCycle != null) && (userControlPlan == DeviceCommands.CONDITION_YES))
            {
                M_ControllerCommands command = new M_ControllerCommands();
                command.forceCycle = m_controllerCommands.forceCycle;
                result.add(createForceCycleRecordablePlan(subcontroller, command, parameters));
                if (command.recordablePlan != null)
                {
                    result.add(setRecordablePlanSubcontroller(subcontroller, parameters, command));
                }
            }

            if (m_controllerCommands.updateTime == M_ControllerCommands.CONDITION_YES)
            {
                M_ControllerCommands command = new M_ControllerCommands();
                command.updateTime = m_controllerCommands.updateTime;
                result.add(updateTime(parameters, command));
            }

            if (m_controllerCommands.realtime != DeviceCommands.CONDITION_NOTHING)
            {
                M_ControllerCommands command = new M_ControllerCommands();
                command.realtime = m_controllerCommands.realtime;
                result.add(setRealtime(parameters, command));
            }

            if (m_controllerCommands.clearAlarms == DeviceCommands.CONDITION_YES)
            {
                M_ControllerCommands command = new M_ControllerCommands();
                command.clearAlarms = m_controllerCommands.clearAlarms;
                result.add(clearAlarms(parameters, command));
            }

            if (m_controllerCommands.shiftPhase == M_ControllerCommands.CONDITION_YES)
            {
                M_ControllerCommands command = new M_ControllerCommands();
                command.shiftPhase = m_controllerCommands.shiftPhase;
                result.add(shiftPhase(parameters, command));
            }

            if ((m_controllerCommands.sptp != null) &&
                (m_controllerCommands.sptp.configuration != null))
            {
                M_ControllerCommands command = new M_ControllerCommands();
                command.sptp = new M_ControllerCommands_SPTP();
                command.sptp.configuration = m_controllerCommands.sptp.configuration;
                result.add(sendSPTPConfiguration(subcontroller, parameters, command));
            }

            if ((m_controllerCommands.sptp != null) &&
                (m_controllerCommands.sptp.demands != null))
            {
                M_ControllerCommands command = new M_ControllerCommands();
                command.sptp = new M_ControllerCommands_SPTP();
                command.sptp.demands = m_controllerCommands.sptp.demands;
                result.add(getBusDemandsController(subcontroller, parameters, command));
            }

            return result.toArray(new DeviceAction[result.size()]);
        }
        finally
        {
        }
    }

    // </editor-fold>  


    public DeviceAction centralized(int subcontroller, InteropParameters parameters, M_ControllerCommands command) throws SerializationException
    {
        String language = (String)parameters.getParameterValue("language");
        DeviceAction action = new DeviceAction(controller, parameters, command);
        action.actionName = command.getActionName();

        try
        {
            M_SubcontrollerConfiguration subcontrollerConfiguration = controller.getDeviceConfiguration().getSubcontroller(subcontroller);
            if (subcontrollerConfiguration == null) throw new ServerException(Shared.getMessage("Subcontroller does not exist"));

            if (command.centralized == DeviceCommands.CONDITION_YES)
            {
                Shared.println(name, "CENTRALIZED!!!!!!");
                this.forceCentralized = 1;
            }
            else if (command.centralized == DeviceCommands.CONDITION_NO)
            {
                Shared.println(name, "NOT CENTRALIZED!!!!!!");
                this.forceCentralized = 0;
            }

            DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_CORRECT);
            action.setResult(actionResult);
            Shared.model.addAction(action);
            return action;
        }
        catch (Exception exception)
        {
            Shared.printstack(name, exception); 
            DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_ERROR, exception.getMessage());
            action.setResult(actionResult);
            Shared.model.addAction(action);
            return action;
        }
    }


    public DeviceAction sendSPTPConfiguration(int subcontroller, InteropParameters parameters, M_ControllerCommands command) throws SerializationException
    {
        String language = (String)parameters.getParameterValue("language");
        DeviceAction action = new DeviceAction(controller, parameters, command);
        action.actionName = command.getActionName();

        try
        {
            M_SubcontrollerConfiguration subcontrollerConfiguration = controller.getDeviceConfiguration().getSubcontroller(subcontroller);
            if (subcontrollerConfiguration == null) throw new ServerException(Shared.getMessage("Subcontroller does not exist"));

            Shared.println(name, command.sptp.configuration);
            commandsConfiguration = Serialization.deserialize(M_SPTP_Configuration.class, command.sptp.configuration);

            String resource = Serialization.toPrettyString(commandsConfiguration);
            Shared.traceInformation(name, "Activate sending of SPTP configuration tables", resource);

            DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_CORRECT);
            action.setResult(actionResult);
            Shared.model.addAction(action);
            return action;
        }
        catch (Exception exception)
        {
            Shared.traceError(name, "Activate sending of SPTP configuration tables", exception);
            DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_ERROR, exception.getMessage());
            action.setResult(actionResult);
            Shared.model.addAction(action);
            return action;
        }
    }




    public DeviceAction getBusDemandsController(int subcontroller, InteropParameters parameters, M_ControllerCommands command) throws SerializationException
    {
        String language = (String)parameters.getParameterValue("language");
        DeviceAction action = new DeviceAction(controller, parameters, command);
        action.actionName = command.getActionName();

        try
        {
            SimpleDateFormat sdfh = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss");
            M_SubcontrollerConfiguration subcontrollerConfiguration = controller.getDeviceConfiguration().getSubcontroller(subcontroller);
            if (subcontrollerConfiguration == null) throw new ServerException(Shared.getMessage("Subcontroller does not exist"));

            String resource = Serialization.toPrettyString(command.sptp.demands);
            Shared.traceInformation(name, "Activate the request for bus demands", resource);

            commandsDemands = command.sptp.demands;

            DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_CORRECT);
            action.setResult(actionResult);
            Shared.model.addAction(action);
            return action;
        }
        catch (Exception exception)
        {
            Shared.traceError(name, "Activate the request for bus demands", exception);
            DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_ERROR, exception.getMessage());
            action.setResult(actionResult);
            Shared.model.addAction(action);
            return action;
        }
    }




    public void getBusDemandsControllerReal(int subcontroller) throws SerializationException
    {
        try
        {
            SimpleDateFormat sdfh = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss");
            M_SubcontrollerConfiguration subcontrollerConfiguration = controller.getDeviceConfiguration().getSubcontroller(subcontroller);
            if (subcontrollerConfiguration == null) throw new ServerException(Shared.getMessage("Subcontroller does not exist"));

            Calendar calendarStart = Calendar.getInstance();
            calendarStart.setTimeInMillis(commandsDemands.starttime);
            Calendar calendarEnd = Calendar.getInstance();
            calendarEnd.setTimeInMillis(commandsDemands.endtime);

            String resource = "From: " + sdfh.format(calendarStart.getTimeInMillis()) + ", To: " + sdfh.format(calendarEnd.getTimeInMillis());
            Shared.traceInformation(name, "Asking for bus demands", resource);

            M_Message command = M_ProtocolConstructor.getBusDetectionsPeriod(subcontroller, calendarStart, calendarEnd, hasCRC);
            M_Request request = new M_Request();
            request.controller = this;
            request.request = command;

            if (ColorsServer.TEST_SPTP == true)
            {
                String s = "Get Bus detections >> ";
                byte[] data = command.toByteArray();
                for (int i=0; i<data.length; i++)
                {
                    s += String.format(" %02X", data[i]);
                }
                Shared.traceInformation(name, s);

                request.response = generateExampleResponse(subcontroller, calendarStart, calendarEnd, hasCRC);
                s = "Get Bus detections << ";
                data = request.response.toByteArray();
                for (int i=0; i<data.length; i++)
                {
                    s += String.format(" %02X", data[i]);
                }
                Shared.println(name, s);
            }
            else
            {
                this.getControllerConnection().addM_Request(request);
                request.waitResponse(controller.getDeviceInformation().timeout);
            }

            Shared.traceInformation(name, "Received response for bus demands", resource);
            M_ProtocolAnalyser.analyseGetBusDemandsResponse(controller.getIdentifier(), request.response, subcontroller);
            Shared.traceInformation(name, "Analysed correctly response for bus demands", resource);

            commandsDemands = null;
        }
        catch (Exception exception)
        {
            Shared.printstack(name, exception);
            Shared.traceError(name, "Get Bus demands from controller", exception);
        }
    }




    public void sendSPTPConfigurationToController(int subcontroller, M_SPTP_Configuration configuration) throws SerializationException
    {
        try
        {
            String resource = Serialization.toPrettyString(configuration);
            Shared.traceInformation(name, "Sending SPTP configuration", resource);
            // M_ControllerComunicator comunicator = new M_ControllerComunicator(getControllerConnection().socket, hasCRC);
            M_ControllerComunicator comunicator = new M_ControllerComunicator(this.controller, this);
            comunicator.writeSPTPTables(subcontroller, controller.getDeviceInformation().configurationCode, controller.getDeviceInformation().controllerNumber, configuration);
            Shared.traceInformation(name, "Sent SPTP configuration", resource);

            commandsConfiguration = null;
        }
        catch (Exception exception)
        {
            Shared.traceError(name, "Sending SPTP configuration tables to Controller", exception);
        }
    }




    public void getBusDemands(InteropParameters parameters, M_SPTP_Demand_Result result) throws SerializationException
    {
        PreparedStatement statement = null;
        ResultSet resultSet = null;

        try
        {
            SimpleDateFormat sdfh = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss");
            long from = (parameters.hasParameter("from") == true) ? getTimestamp((String)parameters.getParameterValue("from")) : 0;
            long to = (parameters.hasParameter("to") == true) ? getTimestamp((String)parameters.getParameterValue("to")) : System.currentTimeMillis();
            int offset = (parameters.hasParameter("offset") == true) ? Integer.parseInt((String)parameters.getParameterValue("offset")) : -1;
            int limit = (parameters.hasParameter("limit") == true) ? Integer.parseInt((String)parameters.getParameterValue("limit")) : -1;

            String resource = "From: " + sdfh.format(from) + ", To: " + sdfh.format(to) + ", Offset: " + offset + ", Limit: " + limit;
            Shared.traceInformation(name, "Getting bus demands", resource);

            Persistence persistence = Shared.controllerDatabase.getHistoricalPersistance().get(0);

            try
            {
                statement = persistence.getPreparedStatement("SELECT COUNT(*) FROM SPTP_DEMANDS WHERE activation>=? AND activation<=?");
                statement.setLong(1, from);
                statement.setLong(2, to);
                Shared.traceInformation(name, "Getting bus demands - count query", statement.toString());
                resultSet = statement.executeQuery();

                if (resultSet.next() == true)
                {
                    result.total = resultSet.getInt(1);
                }
            }
            finally
            {
                try{resultSet.close();} catch (Exception e){};
                try{statement.close();} catch (Exception e){};
            }

            try
            {
                String query = "SELECT value FROM SPTP_DEMANDS WHERE activation>=? AND activation<=?";
                query += " ORDER BY activation ASC";
                if (offset >= 0) query += " OFFSET " + offset;
                if (limit > 0) query += " LIMIT " + limit;
                statement = persistence.getPreparedStatement(query);
                statement.setLong(1, from);
                statement.setLong(2, to);
                Shared.traceInformation(name, "Getting bus demands - results query", statement.toString());
                resultSet = statement.executeQuery();

                while (resultSet.next() == true)
                {
                    String value = resultSet.getString(1);
                    M_SPTP_Demand demand = Serialization.deserialize(M_SPTP_Demand.class, value);
                    result.demands.add(demand);
                }
            }
            finally
            {
                try{resultSet.close();} catch (Exception e){};
                try{statement.close();} catch (Exception e){};
            }
        }
        catch (Exception exception)
        {
            Shared.traceError(name, "Get bus demands", exception);
            throw new SerializationException(Shared.getMessage("Error getting bus demands"), exception);
        }
        finally
        {
            try{resultSet.close();} catch (Exception e){};
            try{statement.close();} catch (Exception e){};
        }
    }




    public void addBusDemands(InteropParameters parameters) throws SerializationException
    {
        try
        {
            M_SPTP_Demand[] demands = parameters.getBodyContentValue(M_SPTP_Demand[].class);
            for (M_SPTP_Demand demand : demands)
            {
                Shared.controllerDatabase.historical_addObject(demand);
            }
        }
        catch (Exception exception)
        {
            Shared.traceError(name, "Get bus demands", exception);
            throw new SerializationException(Shared.getMessage("Error getting bus demands"), exception);
        }
    }




    public void checkNewUpdateCommands (M_Controller controllerclone)
    {
        try
        {
            List<M_ControllerStatusSubcontroller> lremove = new ArrayList<M_ControllerStatusSubcontroller>();
            for (M_ControllerStatusSubcontroller statusSubcontroller : this.lsubcontrollerUpdate)
            {
                boolean found = false;
                if (controllerclone.getDeviceStatus().lsubcontrollerUpdate != null)
                {
                    for (M_ControllerStatusSubcontroller statusSubcontrollerUpdate : controllerclone.getDeviceStatus().lsubcontrollerUpdate)
                    {
                        if (statusSubcontrollerUpdate.number == statusSubcontroller.number)
                        {
                            if (found == true)
                            {
                                lremove.add(statusSubcontrollerUpdate);
                            }
                            else
                            {
                                M_ControllerStatusSubcontroller currentStatusSubcontroller = controllerclone.getDeviceStatus().getStatusSubcontroller(statusSubcontroller.number);
                                updateStatusSubcontroller(currentStatusSubcontroller, statusSubcontrollerUpdate, statusSubcontroller);
                                found = true;
                            }
                        }
                    }
                }

                if (found == false)
                {
                    if (controllerclone.getDeviceStatus().lsubcontrollerUpdate == null) controllerclone.getDeviceStatus().lsubcontrollerUpdate = new ArrayList<M_ControllerStatusSubcontroller>();
                    controllerclone.getDeviceStatus().lsubcontrollerUpdate.add(statusSubcontroller);
                }
            }

            if (controllerclone.getDeviceStatus().lsubcontrollerUpdate != null)
            {
                controllerclone.getDeviceStatus().lsubcontrollerUpdate.removeAll(lremove);
            }

            this.lsubcontrollerUpdate.clear();

            lremove.clear();
            HashMap<Integer, Integer> hsubcontrollers = new HashMap<Integer, Integer>();
            if (controllerclone.getDeviceStatus().lsubcontrollerUpdate != null)
            {
                for (M_ControllerStatusSubcontroller statusSubcontrollerUpdate : controllerclone.getDeviceStatus().lsubcontrollerUpdate)
                {
                    if (hsubcontrollers.containsKey(statusSubcontrollerUpdate.number) == true)
                    {
                        lremove.add(statusSubcontrollerUpdate);
                    }
                    else
                    {
                        hsubcontrollers.put(statusSubcontrollerUpdate.number, statusSubcontrollerUpdate.number);
                    }
                }

                controllerclone.getDeviceStatus().lsubcontrollerUpdate.removeAll(lremove);

                if (controllerclone.getDeviceStatus().lsubcontrollerUpdate.size() == 0)
                {
                    controllerclone.getDeviceStatus().lsubcontrollerUpdate = null;
                }
                else
                {
                    for (M_ControllerStatusSubcontroller statusSubcontrollerUpdate : controllerclone.getDeviceStatus().lsubcontrollerUpdate)
                    {
                        M_ControllerStatusSubcontroller currentStatusSubcontroller = controllerclone.getDeviceStatus().getStatusSubcontroller(statusSubcontrollerUpdate.number);
                        updateStatusSubcontroller(currentStatusSubcontroller, statusSubcontrollerUpdate, null);
                    }
                }
            }

            if (this.lcontroller.size() == 0)
            {
                Shared.model.updateDevice(controller, controllerclone);
            }
            else if (this.lcontroller.size() > 0)
            {
                this.controller = controllerclone;
            }
        }
        catch (Exception e)
        {

        }
    }


    public void checkUpdateStatus (M_Controller controllerclone)
    {
        try
        {
            for (int i=1; i<=controllerclone.getDeviceConfiguration().lsubcontroller.size(); i++)
            {
                try
                {
                    boolean remove = true;
                    M_ControllerStatusSubcontroller currentStatusSubcontroller = controllerclone.getDeviceStatus().getStatusSubcontroller(i);
                    M_ControllerStatusSubcontroller statusSubcontrollerUpdate = controllerclone.getDeviceStatus().getStatusSubcontrollerUpdate(i);
                    if ((statusSubcontrollerUpdate.recordablePlan != null) && (currentStatusSubcontroller.recordablePlan != null))
                    {
                        if (Serialization.equals(statusSubcontrollerUpdate.recordablePlan, currentStatusSubcontroller.recordablePlan) == false)
                        {
                            remove = false;

                            // Send again save recordable plan command
                            M_ControllerCommands commands = new M_ControllerCommands();
                            commands.recordablePlan = new ALUVISA_Plan();
                            commands.recordablePlan.initialise(controllerclone.getDeviceConfiguration().getSubcontroller(currentStatusSubcontroller.number), statusSubcontrollerUpdate.recordablePlan);

                            InteropParameters parameters = new InteropParameters();
                            parameters.addParameter("language", "en-GB");
                            parameters.addParameter("username", "system");
                            parameters.addParameter("computer", controller.getDeviceInformation().serverAddress);
                            parameters.addBodycontent(commands);
                            sendCommands(currentStatusSubcontroller.number, parameters);
                        }
                    }
                    else if ((statusSubcontrollerUpdate.recordablePlan != null) && (currentStatusSubcontroller.recordablePlan == null))
                    {
                        remove = false;

                        // Send again save recordable plan command
                        M_ControllerCommands commands = new M_ControllerCommands();
                        commands.recordablePlan = new ALUVISA_Plan();
                        commands.recordablePlan.initialise(controllerclone.getDeviceConfiguration().getSubcontroller(currentStatusSubcontroller.number), statusSubcontrollerUpdate.recordablePlan);

                        InteropParameters parameters = new InteropParameters();
                        parameters.addParameter("language", "en-GB");
                        parameters.addParameter("username", "system");
                        parameters.addParameter("computer", controller.getDeviceInformation().serverAddress);
                        parameters.addBodycontent(commands);
                        sendCommands(currentStatusSubcontroller.number, parameters);
                    }

                    if (stateSubcontrollerDifferent(currentStatusSubcontroller, statusSubcontrollerUpdate) == true)
                    {
                        remove = false;

                        // Send again set state subcontroller command
                        M_ControllerCommands commands = new M_ControllerCommands();

                        int adaptative = CONDITION_NO;
                        int adaptativeDetectors = statusSubcontrollerUpdate.adaptativeDetectors;
                        int centralizedMode = statusSubcontrollerUpdate.centralizedMode;
                        commands.colorsMode = statusSubcontrollerUpdate.colorsMode;
                        int controlComputerDirectGroups = statusSubcontrollerUpdate.controlComputerDirectGroups;
                        int coordinationMode = statusSubcontrollerUpdate.coordinationMode;
                        commands.emergency = statusSubcontrollerUpdate.emergency;
                        commands.userControlManual = statusSubcontrollerUpdate.userControlManual;
                        commands.operationMode = statusSubcontrollerUpdate.operationMode;
                        int planSelection = statusSubcontrollerUpdate.planSelection;

                        InteropParameters parameters = new InteropParameters();
                        parameters.addParameter("language", "en-GB");
                        parameters.addParameter("username", "system");
                        parameters.addParameter("computer", controller.getDeviceInformation().serverAddress);
                        parameters.addBodycontent(commands);
                        setStateSubcontroller(statusSubcontrollerUpdate.number, adaptative, adaptativeDetectors, centralizedMode, controlComputerDirectGroups, 
                                coordinationMode, planSelection, parameters, commands);
                    }

                    if ((statusSubcontrollerUpdate.plan != currentStatusSubcontroller.plan) && 
                        (currentStatusSubcontroller.planSelection != M_ControllerStatusSubcontroller.PLANSELECTION_TIMETABLE) &&
                        (statusSubcontrollerUpdate.planSelection != M_ControllerStatusSubcontroller.PLANSELECTION_TIMETABLE))
                    {
                        remove = false;

                        if (statusSubcontrollerUpdate.plan == 0)
                        {
                            // Send again set plan command
                            M_ControllerCommands commands = new M_ControllerCommands();

                            InteropParameters parameters = new InteropParameters();
                            parameters.addParameter("language", "en-GB");
                            parameters.addParameter("username", "system");
                            parameters.addParameter("computer", controller.getDeviceInformation().serverAddress);
                            parameters.addBodycontent(commands);
                            setPlanSubcontroller(currentStatusSubcontroller.number, parameters, commands);
                        }
                        else if (statusSubcontrollerUpdate.plan > 0)
                        {
                            // Send again set plan command
                            M_ControllerCommands commands = new M_ControllerCommands();
                            commands.localPlan = statusSubcontrollerUpdate.plan;

                            InteropParameters parameters = new InteropParameters();
                            parameters.addParameter("language", "en-GB");
                            parameters.addParameter("username", "system");
                            parameters.addParameter("computer", controller.getDeviceInformation().serverAddress);
                            parameters.addBodycontent(commands);
                            setLocalPlanSubcontroller(currentStatusSubcontroller.number, parameters, commands);
                        }
                    }

                    if ((remove == true) && (controllerclone.getDeviceStatus().lsubcontrollerUpdate != null))
                    {
                        controllerclone.getDeviceStatus().lsubcontrollerUpdate.remove(statusSubcontrollerUpdate);
                    }
                }
                catch (Exception e)
                {
                    
                }
            }
        }
        catch (Exception e)
        {
            // Shared.printstack(name, e);
        }
    }



    private DeviceAction createForceCycleRecordablePlan (int subcontroller, M_ControllerCommands commands, InteropParameters parameters)
    {
        String language = (String)parameters.getParameterValue("language");
        DeviceAction action = new DeviceAction(controller, parameters, commands);
        action.actionName = commands.getActionName();

        try
        {
            M_ControllerStatusSubcontroller statusSubcontroller = this.controller.getDeviceStatus().getStatusSubcontroller(subcontroller);
            M_SubcontrollerConfiguration configurationSubcontroller = this.controller.getDeviceConfiguration().getSubcontroller(subcontroller);
            commands.recordablePlan = configurationSubcontroller.getAluvisaPlan(statusSubcontroller.plan);
            if (commands.recordablePlan.structure != commands.forceCycle.structure)
            {
                commands.recordablePlan = null;
                DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_ERROR, Shared.getMessage("Structure not valid"));
                action.setResult(actionResult);
                Shared.model.addAction(action);
                return action;
            }

            if (commands.recordablePlan.changeCycle(commands.forceCycle.cycle) == false)
            {
                commands.recordablePlan = null;
                DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_ERROR, Shared.getMessage("Error forcing cycle time"));
                action.setResult(actionResult);
                Shared.model.addAction(action);
                return action;
            }

            float[] lphases = new float[commands.forceCycle.lphases.size()];
            for (int i=0; i<lphases.length; i++)
            {
                lphases[i] = (float)commands.forceCycle.lphases.get(i).doubleValue();
            }

            if (commands.recordablePlan.changeSplitPercentages(lphases) == false)
            {
                commands.recordablePlan = null;
                DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_ERROR, Shared.getMessage("Error forcing split percentages"));
                action.setResult(actionResult);
                Shared.model.addAction(action);
                return action;
            }

            return(action);
        }
        catch (ServerException exception)
        {
            commands.recordablePlan = null;
            DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_ERROR, exception);
            action.setResult(actionResult);
            Shared.model.addAction(action);
            return action;
        }
        catch (Exception exception)
        {
            commands.recordablePlan = null;
            DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_ERROR, exception);
            action.setResult(actionResult);
            Shared.model.addAction(action);
            return action;
        }
    }


    // <editor-fold defaultstate="collapsed" desc="Set recordable plan">

    public DeviceAction setRecordablePlanSubcontroller(int subcontroller, InteropParameters parameters, M_ControllerCommands command) throws SerializationException
    {
        String language = (String)parameters.getParameterValue("language");
        DeviceAction action = new DeviceAction(controller, parameters, command);
        action.actionName = command.getActionName();

        try
        {
            M_ControllerStatusSubcontroller currentStatusSubcontroller = controller.getDeviceStatus().getStatusSubcontroller(subcontroller);
            // Y el algoritmo como lo envía??????
//            if ((command.userControlPlan != M_ControllerCommands.CONDITION_YES) &&
//                (currentStatusSubcontroller.userControlPlan != M_ControllerCommands.CONDITION_YES))
//            {
//                DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_ERROR, Shared.getMessage("User control plan not enabled"));
//                action.setResult(actionResult);
//                Shared.model.addAction(action);
//                return action;
//            }

            ALUVISA_Plan recordablePlan = command.recordablePlan;
            if (recordablePlan.offset > 256)
            {
                DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_ERROR, Shared.getMessage("Offset value is not valid"));
                action.setResult(actionResult);
                Shared.model.addAction(action);
                return action;
            }

            M_ControllerConfiguration controllerConfiguration = controller.getDeviceConfiguration();
            M_SubcontrollerConfiguration subcontrollerConfiguration = controllerConfiguration.getSubcontroller(subcontroller);
            if (subcontrollerConfiguration == null) throw new ServerException(Shared.getMessage("Subcontroller does not exist"));

            try
            {
                M_Structure structure = subcontrollerConfiguration.getStructure(recordablePlan.structure);
            }
            catch (Exception exception)
            {
                DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_ERROR, exception.getMessage());
                action.setResult(actionResult);
                Shared.model.addAction(action);
                return action;
            }

            ALUVISA_Link link1 = command.recordablePlan.lLink.get(0);
            M_Intergreen intergren = subcontrollerConfiguration.getIntergreenPositionsTime(link1);
            M_IntergreensPositionTimes intergreensPositionTimes = subcontrollerConfiguration.getIntergreensPositionTimes(intergren);
            int transitionsToTimesTable = intergreensPositionTimes.number;

            try
            {
                M_IntergreenToTimeTable intergreenTable = subcontrollerConfiguration.getIntergreenToTimeTable(transitionsToTimesTable);
            }
            catch (Exception exception)
            {
                DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_ERROR, exception.getMessage());
                action.setResult(actionResult);
                Shared.model.addAction(action);
                return action;
            }

            M_MinimumExtension minimumExtension = subcontrollerConfiguration.getMinimumExtension(command.recordablePlan);
            int minimumAndExtensionTimesTable = minimumExtension.number;

            M_MinimumExtension minimumTable = null;

            try
            {
                minimumTable = subcontrollerConfiguration.getMinimumExtension(minimumAndExtensionTimesTable);
            }
            catch (Exception exception)
            {
                DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_ERROR, exception.getMessage());
                action.setResult(actionResult);
                Shared.model.addAction(action);
                return action;
            }

            for (int i=0; i<recordablePlan.lPhase.size(); i++)
            {
                int duration = recordablePlan.lPhase.get(i).maximumTime;
                if (duration > 120)
                {
                    DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_ERROR, Shared.getMessage("Phase duration is not valid"));
                    action.setResult(actionResult);
                    Shared.model.addAction(action);
                    return action;
                }
                if (duration < minimumTable.lMinimum.get(i).intValue())
                {
                    DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_ERROR, Shared.getMessage("Phase duration lower than minimum time defined"));
                    action.setResult(actionResult);
                    Shared.model.addAction(action);
                    return action;
                }
            }

            boolean found = false;
            for (M_ControllerStatusSubcontroller statusSubcontroller : this.lsubcontrollerUpdate)
            {
                if (statusSubcontroller.number == subcontroller)
                {
                    found = true;
                    if (statusSubcontroller.recordablePlan == null) statusSubcontroller.recordablePlan = new M_Plan();
                    statusSubcontroller.recordablePlan.controlMode = recordablePlan.controlMode;
                    statusSubcontroller.recordablePlan.minimumAndExtensionTimesTable = minimumAndExtensionTimesTable;
                    statusSubcontroller.recordablePlan.offset = recordablePlan.offset;
                    statusSubcontroller.recordablePlan.number = 0;  // recordablePlan.number;
                    statusSubcontroller.recordablePlan.structure = recordablePlan.structure;
                    statusSubcontroller.recordablePlan.transitionsToTimesTable = transitionsToTimesTable;
                    statusSubcontroller.recordablePlan.lPhaseTime.clear();
                    for (ALUVISA_Phase phase : recordablePlan.lPhase)
                    {
                        statusSubcontroller.recordablePlan.lPhaseTime.add(phase.maximumTime);
                    }
                }
            }

            if (found == false)
            {
                M_ControllerStatusSubcontroller statusSubcontroller = new M_ControllerStatusSubcontroller();
                statusSubcontroller.number = subcontroller;

                if (statusSubcontroller.recordablePlan == null) statusSubcontroller.recordablePlan = new M_Plan();
                statusSubcontroller.recordablePlan.controlMode = recordablePlan.controlMode;
                statusSubcontroller.recordablePlan.minimumAndExtensionTimesTable = minimumAndExtensionTimesTable;
                statusSubcontroller.recordablePlan.offset = recordablePlan.offset;
                statusSubcontroller.recordablePlan.number = 0;  // recordablePlan.number;
                statusSubcontroller.recordablePlan.structure = recordablePlan.structure;
                statusSubcontroller.recordablePlan.transitionsToTimesTable = transitionsToTimesTable;
                statusSubcontroller.recordablePlan.lPhaseTime.clear();
                for (ALUVISA_Phase phase : recordablePlan.lPhase)
                {
                    statusSubcontroller.recordablePlan.lPhaseTime.add(phase.maximumTime);
                }

                this.lsubcontrollerUpdate.add(statusSubcontroller);
            }

            M_Message request = M_ProtocolConstructor.setRecordablePlan(recordablePlan, subcontroller, transitionsToTimesTable, minimumAndExtensionTimesTable, hasCRC);
            getControllerConnection().send(request.toByteArray());

            setPlanSubcontroller(subcontroller, parameters, command);
//            long referenceTime = 0;
//            M_Message requestPlan = M_ProtocolConstructor.setPlan(0, referenceTime, subcontroller, hasCRC);
//            getControllerConnection().send(requestPlan.toByteArray());

            DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_CORRECT);
            action.setResult(actionResult);
            Shared.model.addAction(action);
            return action;
        }
        catch (Exception exception)
        {
            Shared.printstack(name, exception); 
            DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_ERROR, exception.getMessage());
            action.setResult(actionResult);
            Shared.model.addAction(action);
            return action;
        }
    }

    // </editor-fold>  




    // <editor-fold defaultstate="collapsed" desc="Save recordable plan">

    public DeviceAction saveRecordablePlanSubcontroller(int subcontroller, InteropParameters parameters, M_ControllerCommands command) throws SerializationException
    {
        String language = (String)parameters.getParameterValue("language");
        DeviceAction action = new DeviceAction(controller, parameters, command);
        action.actionName = command.getActionName();

        try
        {
            M_ControllerStatusSubcontroller currentStatusSubcontroller = controller.getDeviceStatus().getStatusSubcontroller(subcontroller);

            ALUVISA_Plan recordablePlan = command.recordablePlan;
            if (recordablePlan.offset > 256)
            {
                DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_ERROR, Shared.getMessage("Offset value is not valid"));
                action.setResult(actionResult);
                Shared.model.addAction(action);
                return action;
            }

            M_ControllerConfiguration controllerConfiguration = controller.getDeviceConfiguration();
            M_SubcontrollerConfiguration subcontrollerConfiguration = controllerConfiguration.getSubcontroller(subcontroller);
            if (subcontrollerConfiguration == null) throw new ServerException(Shared.getMessage("Subcontroller does not exist"));

            try
            {
                M_Structure structure = subcontrollerConfiguration.getStructure(recordablePlan.structure);
            }
            catch (Exception exception)
            {
                DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_ERROR, exception.getMessage());
                action.setResult(actionResult);
                Shared.model.addAction(action);
                return action;
            }

            ALUVISA_Link link1 = command.recordablePlan.lLink.get(0);
            M_Intergreen intergren = subcontrollerConfiguration.getIntergreenPositionsTime(link1);
            M_IntergreensPositionTimes intergreensPositionTimes = subcontrollerConfiguration.getIntergreensPositionTimes(intergren);
            int transitionsToTimesTable = intergreensPositionTimes.number;

            try
            {
                M_IntergreenToTimeTable intergreenTable = subcontrollerConfiguration.getIntergreenToTimeTable(transitionsToTimesTable);
            }
            catch (Exception exception)
            {
                DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_ERROR, exception.getMessage());
                action.setResult(actionResult);
                Shared.model.addAction(action);
                return action;
            }

            M_MinimumExtension minimumExtension = subcontrollerConfiguration.getMinimumExtension(command.recordablePlan);
            int minimumAndExtensionTimesTable = minimumExtension.number;

            M_MinimumExtension minimumTable = null;

            try
            {
                minimumTable = subcontrollerConfiguration.getMinimumExtension(minimumAndExtensionTimesTable);
            }
            catch (Exception exception)
            {
                DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_ERROR, exception.getMessage());
                action.setResult(actionResult);
                Shared.model.addAction(action);
                return action;
            }

            for (int i=0; i<recordablePlan.lPhase.size(); i++)
            {
                int duration = recordablePlan.lPhase.get(i).maximumTime;
                if (duration > 120)
                {
                    DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_ERROR, Shared.getMessage("Phase duration is not valid"));
                    action.setResult(actionResult);
                    Shared.model.addAction(action);
                    return action;
                }
                if (duration < minimumTable.lMinimum.get(i).intValue())
                {
                    DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_ERROR, Shared.getMessage("Phase duration lower than minimum time defined"));
                    action.setResult(actionResult);
                    Shared.model.addAction(action);
                    return action;
                }
            }

            boolean found = false;
            for (M_ControllerStatusSubcontroller statusSubcontroller : this.lsubcontrollerUpdate)
            {
                if (statusSubcontroller.number == subcontroller)
                {
                    found = true;
                    statusSubcontroller.recordablePlan.controlMode = recordablePlan.controlMode;
                    statusSubcontroller.recordablePlan.minimumAndExtensionTimesTable = minimumAndExtensionTimesTable;
                    statusSubcontroller.recordablePlan.offset = recordablePlan.offset;
                    statusSubcontroller.recordablePlan.number = 0;  // recordablePlan.number;
                    statusSubcontroller.recordablePlan.structure = recordablePlan.structure;
                    statusSubcontroller.recordablePlan.transitionsToTimesTable = transitionsToTimesTable;
                    statusSubcontroller.recordablePlan.lPhaseTime.clear();
                    for (ALUVISA_Phase phase : recordablePlan.lPhase)
                    {
                        statusSubcontroller.recordablePlan.lPhaseTime.add(phase.maximumTime);
                    }
                }
            }

            if (found == false)
            {
                M_ControllerStatusSubcontroller statusSubcontroller = new M_ControllerStatusSubcontroller();
                statusSubcontroller.number = subcontroller;

                statusSubcontroller.recordablePlan = new M_Plan();
                statusSubcontroller.recordablePlan.controlMode = recordablePlan.controlMode;
                statusSubcontroller.recordablePlan.minimumAndExtensionTimesTable = minimumAndExtensionTimesTable;
                statusSubcontroller.recordablePlan.offset = recordablePlan.offset;
                statusSubcontroller.recordablePlan.number = 0;  // recordablePlan.number;
                statusSubcontroller.recordablePlan.structure = recordablePlan.structure;
                statusSubcontroller.recordablePlan.transitionsToTimesTable = transitionsToTimesTable;
                statusSubcontroller.recordablePlan.lPhaseTime.clear();
                for (ALUVISA_Phase phase : recordablePlan.lPhase)
                {
                    statusSubcontroller.recordablePlan.lPhaseTime.add(phase.maximumTime);
                }

                this.lsubcontrollerUpdate.add(statusSubcontroller);
            }

            M_Message request = M_ProtocolConstructor.setRecordablePlan(recordablePlan, subcontroller, transitionsToTimesTable, minimumAndExtensionTimesTable, hasCRC);
            getControllerConnection().send(request.toByteArray());

            DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_CORRECT);
            action.setResult(actionResult);
            Shared.model.addAction(action);
            return action;
        }
        catch (Exception exception)
        {
            Shared.printstack(name, exception); 
            DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_ERROR, exception.getMessage());
            action.setResult(actionResult);
            Shared.model.addAction(action);
            return action;
        }
    }

    // </editor-fold>  




    // <editor-fold defaultstate="collapsed" desc="Select special demand">

    public DeviceAction selectSpecialDemandSubcontroller(int subcontroller, InteropParameters parameters, M_ControllerCommands command) throws SerializationException
    {
        String language = (String)parameters.getParameterValue("language");
        DeviceAction action = new DeviceAction(controller, parameters, command);
        action.actionName = command.getActionName();

        try
        {
            M_ControllerStatusSubcontroller currentStatusSubcontroller = controller.getDeviceStatus().getStatusSubcontroller(subcontroller);
            M_ControllerConfiguration controllerConfiguration = controller.getDeviceConfiguration();
            M_SubcontrollerConfiguration subcontrollerConfiguration = controller.getDeviceConfiguration().getSubcontroller(subcontroller);
            if (subcontrollerConfiguration == null) throw new ServerException(Shared.getMessage("Subcontroller does not exist"));

            M_ControllerCommandsSpecialDemand commandsSpecialDemand = command.specialDemandSelection;

            M_Message request = M_ProtocolConstructor.selectSpecialDemand(commandsSpecialDemand, subcontroller, hasCRC);
            getControllerConnection().send(request.toByteArray());

            DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_CORRECT);
            action.setResult(actionResult);
            Shared.model.addAction(action);
            return action;
        }
        catch (Exception exception)
        {
            Shared.printstack(name, exception); 
            DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_ERROR, exception.getMessage());
            action.setResult(actionResult);
            Shared.model.addAction(action);
            return action;
        }
    }

    // </editor-fold>  




    // <editor-fold defaultstate="collapsed" desc="Cancel special demand">

    public DeviceAction cancelSpecialDemandSubcontroller(int subcontroller, InteropParameters parameters, M_ControllerCommands command) throws SerializationException
    {
        String language = (String)parameters.getParameterValue("language");
        DeviceAction action = new DeviceAction(controller, parameters, command);
        action.actionName = command.getActionName();

        try
        {
            M_ControllerStatusSubcontroller currentStatusSubcontroller = controller.getDeviceStatus().getStatusSubcontroller(subcontroller);
            M_ControllerConfiguration controllerConfiguration = controller.getDeviceConfiguration();
            M_SubcontrollerConfiguration subcontrollerConfiguration = controller.getDeviceConfiguration().getSubcontroller(subcontroller);
            if (subcontrollerConfiguration == null) throw new ServerException(Shared.getMessage("Subcontroller does not exist"));

            M_ControllerCommandsSpecialDemand commandsSpecialDemand = command.specialDemandSelection;

            M_Message request = M_ProtocolConstructor.cancelSpecialDemand(commandsSpecialDemand, subcontroller, hasCRC);
            getControllerConnection().send(request.toByteArray());  

            DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_CORRECT);
            action.setResult(actionResult);
            Shared.model.addAction(action);
            return action;
        }
        catch (Exception exception)
        {
            Shared.printstack(name, exception); 
            DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_ERROR, exception.getMessage());
            action.setResult(actionResult);
            Shared.model.addAction(action);
            return action;
        }
    }

    // </editor-fold>  



    // <editor-fold defaultstate="collapsed" desc="Set local plan">

    public DeviceAction setLocalPlanSubcontroller(int subcontroller, InteropParameters parameters, M_ControllerCommands command) throws SerializationException
    {
        String language = (String)parameters.getParameterValue("language");
        DeviceAction action = new DeviceAction(controller, parameters, command);
        action.actionName = command.getActionName();

        try
        {
            M_ControllerConfiguration controllerConfiguration = controller.getDeviceConfiguration();
            M_SubcontrollerConfiguration subcontrollerConfiguration = controllerConfiguration.getSubcontroller(subcontroller);
            if (subcontrollerConfiguration == null) throw new ServerException(Shared.getMessage("Subcontroller does not exist"));

            try
            {
                M_Plan m_plan = subcontrollerConfiguration.getMPlan(command.localPlan);
            }
            catch (Exception exception)
            {
                DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_ERROR, exception.toString());
                action.setResult(actionResult);
                Shared.model.addAction(action);
                return action;
            }

            boolean found = false;
            for (M_ControllerStatusSubcontroller statusSubcontroller : this.lsubcontrollerUpdate)
            {
                if (statusSubcontroller.number == subcontroller)
                {
                    found = true;
                    statusSubcontroller.plan = command.localPlan;
                }
            }

            if (found == false)
            {
                M_ControllerStatusSubcontroller statusSubcontroller = new M_ControllerStatusSubcontroller();
                statusSubcontroller.number = subcontroller;
                statusSubcontroller.plan = command.localPlan;
                this.lsubcontrollerUpdate.add(statusSubcontroller);
            }

            sendLocalPlanSubcontroller(subcontroller, parameters, command);

            DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_CORRECT);
            action.setResult(actionResult);
            Shared.model.addAction(action);
            return action;
        }
        catch (Exception exception)
        {
            Shared.printstack(name, exception); 
            DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_ERROR, exception.getMessage());
            action.setResult(actionResult);
            Shared.model.addAction(action);
            return action;
        }
    }

    // </editor-fold>  

    // <editor-fold defaultstate="collapsed" desc="Set user control plan">

    public DeviceAction setUserControlPlan(int subcontroller, InteropParameters parameters, M_ControllerCommands command) throws SerializationException
    {
        String language = (String)parameters.getParameterValue("language");
        DeviceAction action = new DeviceAction(controller, parameters, command);
        
        action.actionName = command.getActionName();

        try
        {
            this.forcedUserControlPlan[subcontroller-1] = command.userControlPlan;

            if (command.userControlPlan == DeviceCommands.CONDITION_NO)
            {
                // TODO
                // Release forced plan
                // Now for Ghana I will send timetable 
                M_ControllerCommands commandsTimetable = new M_ControllerCommands();
                int planSelection = M_ControllerStatusSubcontroller.PLANSELECTION_TIMETABLE;
                int coordinationMode = M_ControllerStatusSubcontroller.COORDINATION_COMPUTER;
                int centralizedMode = DeviceCommands.CONDITION_YES;
                int controlComputerDirectGroups = CONDITION_NO;
                int adaptative = DeviceCommands.CONDITION_NO;
                int adaptativeDetectors = DeviceCommands.CONDITION_NO;
                setStateSubcontroller(subcontroller, adaptative, adaptativeDetectors, centralizedMode, 
                        controlComputerDirectGroups, coordinationMode, planSelection, parameters, commandsTimetable);
            }

            DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_CORRECT);
            action.setResult(actionResult);
            Shared.model.addAction(action);
            return action;
        }
        catch (Exception exception)
        {
            Shared.printstack(name, exception); 
            DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_ERROR, exception.getMessage());
            action.setResult(actionResult);
            Shared.model.addAction(action);
            return action;
        }
    }

    // </editor-fold>  

    // <editor-fold defaultstate="collapsed" desc="Set plan">

    public List<DeviceAction> setPlanSubcontroller(int subcontroller, InteropParameters parameters, M_ControllerCommands command) throws SerializationException
    {
        List<DeviceAction> lresult = new ArrayList<DeviceAction>();

        String language = (String)parameters.getParameterValue("language");
        DeviceAction action = new DeviceAction(controller, parameters, command);
        action.actionName = command.getActionName();

        try
        {
            // Before setting plan controller must be configure in computer mode and with centralized enabled
            M_ControllerCommands stateCommand = new M_ControllerCommands();

            int planSelection = M_ControllerStatusSubcontroller.PLANSELECTION_COMPUTER;
            int coordinationMode = M_ControllerStatusSubcontroller.COORDINATION_COMPUTER;
            int centralizedMode = DeviceCommands.CONDITION_YES;
            int controlComputerDirectGroups = CONDITION_NO;
            int adaptative = DeviceCommands.CONDITION_NO;
            int adaptativeDetectors = DeviceCommands.CONDITION_NO;

            List<DeviceAction> stateAction = setStateSubcontroller(subcontroller, adaptative, adaptativeDetectors, centralizedMode, 
                    controlComputerDirectGroups, coordinationMode, planSelection, parameters, stateCommand);
            lresult.addAll(stateAction);

            M_ControllerConfiguration controllerConfiguration = controller.getDeviceConfiguration();
            M_SubcontrollerConfiguration subcontrollerConfiguration = controllerConfiguration.getSubcontroller(subcontroller);
            if (subcontrollerConfiguration == null)
            {
                DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_ERROR, Shared.getMessage("Subcontroller does not exist"));
                action.setResult(actionResult);
                Shared.model.addAction(action);
                lresult.add(action);
                return lresult;
            }

            // It is the recordable plan (0)
            // Must be checked that everything is ok
            M_ControllerStatus controllerStatus = controller.getDeviceStatus();
            M_ControllerStatusSubcontroller subcontrollerStatus = controllerStatus.getStatusSubcontroller(subcontroller);
            if (subcontrollerStatus.recordablePlan == null)
            {
                DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_ERROR, Shared.getMessage("Recordable plan does not exist"));
                action.setResult(actionResult);
                Shared.model.addAction(action);
                lresult.add(action);
                return lresult;
            }

            boolean found = false;
            for (M_ControllerStatusSubcontroller statusSubcontroller : this.lsubcontrollerUpdate)
            {
                if (statusSubcontroller.number == subcontroller)
                {
                    found = true;
                    statusSubcontroller.plan = 0;
                    statusSubcontroller.planSelectionComputer = M_ControllerStatusSubcontroller.PLANSELECTION_COMPUTER_PLAN_SELECTION;
                    statusSubcontroller.number = subcontroller;
                }
            }

            if (found == false)
            {
                M_ControllerStatusSubcontroller statusSubcontroller = new M_ControllerStatusSubcontroller();
                statusSubcontroller.number = subcontroller;

                statusSubcontroller.plan = 0;
                statusSubcontroller.planSelectionComputer = M_ControllerStatusSubcontroller.PLANSELECTION_COMPUTER_PLAN_SELECTION;
                statusSubcontroller.number = subcontroller;

                this.lsubcontrollerUpdate.add(statusSubcontroller);
            }

            long referenceTime = 0;
            M_Message request = M_ProtocolConstructor.setPlan(0, referenceTime, subcontroller, hasCRC);
            getControllerConnection().send(request.toByteArray());

            this.controller.getDeviceStatus().getStatusSubcontroller(subcontroller).planSelectionComputer = M_ControllerStatusSubcontroller.PLANSELECTION_COMPUTER_PLAN_SELECTION;

            DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_CORRECT);
            action.setResult(actionResult);
            Shared.model.addAction(action);
            lresult.add(action);
            return lresult;
        }
        catch (Exception exception)
        {
            DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_ERROR, exception.getMessage());
            action.setResult(actionResult);
            Shared.model.addAction(action);
            lresult.add(action);
            return lresult;
        }
    }

    // </editor-fold>  

    // <editor-fold defaultstate="collapsed" desc="Send local plan">

    public List<DeviceAction> sendLocalPlanSubcontroller(int subcontroller, InteropParameters parameters, M_ControllerCommands command) throws SerializationException
    {
        List<DeviceAction> lresult = new ArrayList<DeviceAction>();

        String language = (String)parameters.getParameterValue("language");
        DeviceAction action = new DeviceAction(controller, parameters, command);
        action.actionName = command.getActionName();

        try
        {
            // Before setting plan controller must be configure in computer mode and with centralized enabled
            M_ControllerCommands stateCommand = new M_ControllerCommands();

            int planSelection = M_ControllerStatusSubcontroller.PLANSELECTION_COMPUTER;
            int coordinationMode = M_ControllerStatusSubcontroller.COORDINATION_COMPUTER;
            int centralizedMode = DeviceCommands.CONDITION_YES;
            int controlComputerDirectGroups = CONDITION_NO;
            int adaptative = DeviceCommands.CONDITION_NO;
            int adaptativeDetectors = DeviceCommands.CONDITION_NO;

            List<DeviceAction> stateAction = setStateSubcontroller(subcontroller, adaptative, adaptativeDetectors, centralizedMode, 
                    controlComputerDirectGroups, coordinationMode, planSelection, parameters, stateCommand);
            lresult.addAll(stateAction);

            M_ControllerConfiguration controllerConfiguration = controller.getDeviceConfiguration();
            M_SubcontrollerConfiguration subcontrollerConfiguration = controllerConfiguration.getSubcontroller(subcontroller);
            if (subcontrollerConfiguration == null)
            {
                DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_ERROR, Shared.getMessage("Subcontroller does not exist"));
                action.setResult(actionResult);
                Shared.model.addAction(action);
                lresult.add(action);
                return lresult;
            }

            boolean found = false;
            for (M_ControllerStatusSubcontroller statusSubcontroller : this.lsubcontrollerUpdate)
            {
                if (statusSubcontroller.number == subcontroller)
                {
                    found = true;
                    statusSubcontroller.plan = command.localPlan;
                    statusSubcontroller.planSelectionComputer = M_ControllerStatusSubcontroller.PLANSELECTION_COMPUTER_PLAN_SELECTION;
                    statusSubcontroller.number = subcontroller;
                }
            }

            if (found == false)
            {
                M_ControllerStatusSubcontroller statusSubcontroller = new M_ControllerStatusSubcontroller();
                statusSubcontroller.number = subcontroller;

                statusSubcontroller.plan = command.localPlan;
                statusSubcontroller.planSelectionComputer = M_ControllerStatusSubcontroller.PLANSELECTION_COMPUTER_PLAN_SELECTION;
                statusSubcontroller.number = subcontroller;

                this.lsubcontrollerUpdate.add(statusSubcontroller);
            }

            long referenceTime = 0;  // TODO??????
            M_Message request = M_ProtocolConstructor.setPlan(command.localPlan, referenceTime, subcontroller, hasCRC);
            getControllerConnection().send(request.toByteArray());

            this.controller.getDeviceStatus().getStatusSubcontroller(subcontroller).planSelectionComputer = M_ControllerStatusSubcontroller.PLANSELECTION_COMPUTER_PLAN_SELECTION;

            DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_CORRECT);
            action.setResult(actionResult);
            Shared.model.addAction(action);
            lresult.add(action);
            return lresult;
        }
        catch (Exception exception)
        {
            DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_ERROR, exception.getMessage());
            action.setResult(actionResult);
            Shared.model.addAction(action);
            lresult.add(action);
            return lresult;
        }
    }

    // </editor-fold>  


    // <editor-fold defaultstate="collapsed" desc="Update time">

    public DeviceAction updateTime(InteropParameters parameters, M_ControllerCommands command) throws SerializationException
    {
        String language = (String)parameters.getParameterValue("language");
        DeviceAction action = new DeviceAction(controller, parameters, command);
        action.actionName = command.getActionName();

        try
        {
            M_Message request = M_ProtocolConstructor.setDateTime(0x00, System.currentTimeMillis()+1000, hasCRC);
            getControllerConnection().send(request.toByteArray());

            M_Message requestHTR = M_ProtocolConstructor.HTR();
            getControllerConnection().send(requestHTR.toByteArray());

            DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_CORRECT);
            action.setResult(actionResult);
            Shared.model.addAction(action);
            return action;
        }
        catch (Exception exception)
        {
            DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_ERROR, exception.getMessage());
            action.setResult(actionResult);
            Shared.model.addAction(action);
            return action;
        }
    }

    // </editor-fold>  


    // <editor-fold defaultstate="collapsed" desc="Set realtime detectors">

    public DeviceAction setRealtime(InteropParameters parameters, M_ControllerCommands command) throws SerializationException
    {
        String language = (String)parameters.getParameterValue("language");
        DeviceAction action = new DeviceAction(controller, parameters, command);
        action.actionName = command.getActionName();

        try
        {
            if (command.realtime == DeviceCommands.CONDITION_ENABLED)
            {
                this.forceRealtime = 1;
            }
            else if (command.realtime == DeviceCommands.CONDITION_DISABLED)
            {
                this.forceRealtime = 0;
            }
            
            DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_CORRECT);
            action.setResult(actionResult);
            Shared.model.addAction(action);
            return action;
        }
        catch (Exception exception)
        {
            DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_ERROR, exception.getMessage());
            action.setResult(actionResult);
            Shared.model.addAction(action);
            return action;
        }
    }
    
    // </editor-fold>  


    // <editor-fold defaultstate="collapsed" desc="Set state subcontroller">

    public List<DeviceAction> setStateSubcontroller(int subcontroller, int adaptative, int adaptativeDetectors, int centralizedMode, int controlComputerDirectGroups, 
        int coordinationMode, int planSelectionReceived, InteropParameters parameters, M_ControllerCommands command) throws SerializationException
    {
        String language = (String)parameters.getParameterValue("language");
        List<DeviceAction> laction = new ArrayList<DeviceAction>();

        try
        {
            int colorsMode = command.colorsMode;
            int operationMode = command.operationMode;
            int userControlManual = command.userControlManual;
            int emergency = command.emergency;
            int sptpOperationMode = -1;

            if ((command.sptp != null) && (command.sptp.operationMode != null))
            {
                sptpOperationMode = command.sptp.operationMode.mode;
            }

            M_ControllerConfiguration controllerConfiguration = controller.getDeviceConfiguration();
            M_SubcontrollerConfiguration subcontrollerConfiguration = controllerConfiguration.getSubcontroller(subcontroller);
            if (subcontrollerConfiguration == null)
            {
                if (command.colorsMode != M_ControllerCommands.COLORS_NOTHING)
                {
                    M_ControllerCommands specificCommand = new M_ControllerCommands();
                    specificCommand.colorsMode = command.colorsMode;
                    DeviceAction action = new DeviceAction(controller, parameters, specificCommand);

                    action.actionName = specificCommand.getActionName();

                    DeviceActionResult actionResult2 = new DeviceActionResult(DeviceActionResult.RESULT_ERROR, Shared.getMessage("Subcontroller does not exist"));
                    action.setResult(actionResult2);
                    Shared.model.addAction(action);
                    laction.add(action);
                }

                if (command.operationMode != M_ControllerCommands.OPERATIONMODE_NOTHING)
                {
                    M_ControllerCommands specificCommand = new M_ControllerCommands();
                    specificCommand.operationMode = command.operationMode;
                    DeviceAction action2 = new DeviceAction(controller, parameters, specificCommand);
                    
                    action2.actionName = specificCommand.getActionName();

                    DeviceActionResult actionResult2 = new DeviceActionResult(DeviceActionResult.RESULT_ERROR, Shared.getMessage("Subcontroller does not exist"));
                    action2.setResult(actionResult2);
                    Shared.model.addAction(action2);
                    laction.add(action2);
                }

                if (command.userControlManual != M_ControllerCommands.CONDITION_NOTHING)
                {
                    M_ControllerCommands specificCommand = new M_ControllerCommands();
                    specificCommand.userControlManual = command.userControlManual;
                    DeviceAction action2 = new DeviceAction(controller, parameters, specificCommand);

                    action2.actionName = specificCommand.getActionName();

                    DeviceActionResult actionResult2 = new DeviceActionResult(DeviceActionResult.RESULT_ERROR, Shared.getMessage("Subcontroller does not exist"));
                    action2.setResult(actionResult2);
                    Shared.model.addAction(action2);
                    laction.add(action2);
                }

                if (command.emergency != M_ControllerCommands.CONDITION_NOTHING)
                {
                    M_ControllerCommands specificCommand = new M_ControllerCommands();
                    specificCommand.emergency = command.emergency;
                    DeviceAction action2 = new DeviceAction(controller, parameters, specificCommand);

                    action2.actionName = specificCommand.getActionName();

                    DeviceActionResult actionResult2 = new DeviceActionResult(DeviceActionResult.RESULT_ERROR, Shared.getMessage("Subcontroller does not exist"));
                    action2.setResult(actionResult2);
                    Shared.model.addAction(action2);
                    laction.add(action2);
                }

                return laction;
            }

            M_ControllerStatusSubcontroller subcontrollerStatus = this.controller.getDeviceStatus().getStatusSubcontroller(subcontroller);
            boolean allNothing = true;
            if (colorsMode == M_ControllerCommands.COLORS_NOTHING)
            {
                colorsMode = subcontrollerStatus.colorsMode;
            }
            else
            {
                allNothing = false;
            }

            if (userControlManual == M_ControllerCommands.CONDITION_NOTHING)
            {
                userControlManual = subcontrollerStatus.userControlManual;
            }
            else
            {
                allNothing = false;
            }

            if (operationMode == M_ControllerCommands.OPERATIONMODE_NOTHING)
            {
                operationMode = subcontrollerStatus.operationMode;
            }
            else
            {
                allNothing = false;
            }

            if (emergency == M_ControllerCommands.CONDITION_NOTHING)
            {
                emergency = subcontrollerStatus.emergency;
            }
            else
            {
                allNothing = false;
            }

            if (sptpOperationMode == -1)
            {
                sptpOperationMode = subcontrollerStatus.sptpOperation;
            }
            else
            {
                allNothing = false;
            }

            int planSelection = planSelectionReceived;
            if (planSelection < 0)
            {
                planSelection = subcontrollerStatus.planSelection;
                if (planSelection < 0)
                {
                    planSelection = M_ControllerStatusSubcontroller.PLANSELECTION_COMPUTER;
                }
            }

            if ((colorsMode < M_ControllerCommands.COLORS_OFF) || (colorsMode > M_ControllerCommands.COLORS_COLORS))
            {
                M_ControllerCommands specificCommand = new M_ControllerCommands();
                specificCommand.colorsMode = command.colorsMode;
                DeviceAction action = new DeviceAction(controller, parameters, specificCommand);

                action.actionName = specificCommand.getActionName();

                DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_ERROR, Shared.getMessage("Colors mode value is not valid"));
                action.setResult(actionResult);
                Shared.model.addAction(action);
                laction.add(action);

                if (command.operationMode != M_ControllerCommands.OPERATIONMODE_NOTHING)
                {
                    specificCommand = new M_ControllerCommands();
                    specificCommand.operationMode = command.operationMode;
                    DeviceAction action2 = new DeviceAction(controller, parameters, specificCommand);

                    action2.actionName = specificCommand.getActionName();

                    DeviceActionResult actionResult2 = new DeviceActionResult(DeviceActionResult.RESULT_NOTSEND);
                    action2.setResult(actionResult2);
                    Shared.model.addAction(action2);
                    laction.add(action2);
                }

                if (command.userControlManual != M_ControllerCommands.CONDITION_NOTHING)
                {
                    specificCommand = new M_ControllerCommands();
                    specificCommand.userControlManual = command.userControlManual;
                    DeviceAction action2 = new DeviceAction(controller, parameters, specificCommand);
                    action2.actionName = specificCommand.getActionName();
                    
                    DeviceActionResult actionResult2 = new DeviceActionResult(DeviceActionResult.RESULT_NOTSEND);
                    action2.setResult(actionResult2);
                    Shared.model.addAction(action2);
                    laction.add(action2);
                }

                if (command.emergency != M_ControllerCommands.CONDITION_NOTHING)
                {
                    specificCommand = new M_ControllerCommands();
                    specificCommand.emergency = command.emergency;
                    DeviceAction action2 = new DeviceAction(controller, parameters, specificCommand);
                    action2.actionName = specificCommand.getActionName();

                    DeviceActionResult actionResult2 = new DeviceActionResult(DeviceActionResult.RESULT_NOTSEND);
                    action2.setResult(actionResult2);
                    Shared.model.addAction(action2);
                    laction.add(action2);
                }

                return laction;
            }
            if ((operationMode < M_ControllerCommands.OPERATIONMODE_FIXED) || (operationMode > M_ControllerCommands.OPERATIONMODE_ACTUATED))
            {
                if (command.colorsMode != M_ControllerCommands.COLORS_NOTHING)
                {
                    M_ControllerCommands specificCommand = new M_ControllerCommands();
                    specificCommand.colorsMode = command.colorsMode;
                    DeviceAction action = new DeviceAction(controller, parameters, specificCommand);
                    action.actionName = specificCommand.getActionName();

                    DeviceActionResult actionResult2 = new DeviceActionResult(DeviceActionResult.RESULT_NOTSEND);
                    action.setResult(actionResult2);
                    Shared.model.addAction(action);
                    laction.add(action);
                }
                
                M_ControllerCommands specificCommand = new M_ControllerCommands();
                specificCommand.operationMode = command.operationMode;
                DeviceAction action = new DeviceAction(controller, parameters, specificCommand);
                action.actionName = specificCommand.getActionName();
                

                DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_ERROR, Shared.getMessage("Operation mode value is not valid"));
                action.setResult(actionResult);
                Shared.model.addAction(action);
                laction.add(action);

                if (command.userControlManual != M_ControllerCommands.CONDITION_NOTHING)
                {
                    specificCommand = new M_ControllerCommands();
                    specificCommand.userControlManual = command.userControlManual;
                    DeviceAction action2 = new DeviceAction(controller, parameters, specificCommand);

                    action2.actionName = specificCommand.getActionName();

                    DeviceActionResult actionResult2 = new DeviceActionResult(DeviceActionResult.RESULT_NOTSEND);
                    action2.setResult(actionResult2);
                    Shared.model.addAction(action2);
                    laction.add(action2);
                }

                if (command.emergency != M_ControllerCommands.CONDITION_NOTHING)
                {
                    specificCommand = new M_ControllerCommands();
                    specificCommand.emergency = command.emergency;
                    DeviceAction action2 = new DeviceAction(controller, parameters, specificCommand);
                    action2.actionName = specificCommand.getActionName();
                    switch (command.emergency)
                    {
                        case CONDITION_ENABLED: action2.actionName = Shared.getMessage(language, "Emergency (on)"); break;
                        case CONDITION_DISABLED: action2.actionName = Shared.getMessage(language, "Emergency (off)"); break;
                    }

                    DeviceActionResult actionResult2 = new DeviceActionResult(DeviceActionResult.RESULT_NOTSEND);
                    action2.setResult(actionResult2);
                    Shared.model.addAction(action2);
                    laction.add(action2);
                }

                return laction;
            }
            if ((centralizedMode < M_ControllerCommands.CONDITION_NO) || (centralizedMode > M_ControllerCommands.CONDITION_YES))
            {
                centralizedMode = CONDITION_YES;
            }
            if ((userControlManual < M_ControllerCommands.CONDITION_NO) || (userControlManual > M_ControllerCommands.CONDITION_YES))
            {
                userControlManual = CONDITION_NO;
            }
            if ((controlComputerDirectGroups < M_ControllerCommands.CONDITION_NO) || (controlComputerDirectGroups > M_ControllerCommands.CONDITION_YES))
            {
                controlComputerDirectGroups = CONDITION_NO;
            }
            if ((emergency < M_ControllerCommands.CONDITION_NO) || (emergency > M_ControllerCommands.CONDITION_YES))
            {
                emergency = CONDITION_NO;
            }

            boolean found = false;
            for (M_ControllerStatusSubcontroller statusSubcontroller : this.lsubcontrollerUpdate)
            {
                if (statusSubcontroller.number == subcontroller)
                {
                    found = true;
//                    if (allNothing == true)
//                        statusSubcontroller.planSelectionComputer = M_ControllerStatusSubcontroller.UNKNOWN;
//                    else
//                        statusSubcontroller.planSelectionComputer = M_ControllerStatusSubcontroller.PLANSELECTION_COMPUTER_PLAN_SELECTION;
                    statusSubcontroller.adaptativeDetectors = adaptativeDetectors;
                    statusSubcontroller.centralizedMode = centralizedMode;
                    statusSubcontroller.colorsMode = colorsMode;
                    statusSubcontroller.controlComputerDirectGroups = controlComputerDirectGroups;
                    statusSubcontroller.coordinationMode = coordinationMode;
                    statusSubcontroller.emergency = emergency;
                    statusSubcontroller.userControlManual = userControlManual;
                    statusSubcontroller.operationMode = operationMode;
                    statusSubcontroller.planSelection = planSelection;
                    statusSubcontroller.number = subcontroller;
                }
            }

            if (found == false)
            {
                M_ControllerStatusSubcontroller statusSubcontroller = new M_ControllerStatusSubcontroller();
                statusSubcontroller.number = subcontroller;

//                if (allNothing == true)
//                    statusSubcontroller.planSelectionComputer = M_ControllerStatusSubcontroller.UNKNOWN;
//                else
//                    statusSubcontroller.planSelectionComputer = M_ControllerStatusSubcontroller.PLANSELECTION_COMPUTER_PLAN_SELECTION;
                statusSubcontroller.adaptativeDetectors = adaptativeDetectors;
                statusSubcontroller.centralizedMode = centralizedMode;
                statusSubcontroller.colorsMode = colorsMode;
                statusSubcontroller.controlComputerDirectGroups = controlComputerDirectGroups;
                statusSubcontroller.coordinationMode = coordinationMode;
                statusSubcontroller.emergency = emergency;
                statusSubcontroller.userControlPlan = userControlManual;
                statusSubcontroller.operationMode = operationMode;
                statusSubcontroller.planSelection = planSelection;
                statusSubcontroller.number = subcontroller;

                this.lsubcontrollerUpdate.add(statusSubcontroller);
            }

            M_Message request = M_ProtocolConstructor.setState(subcontroller, colorsMode, planSelection, adaptative, adaptativeDetectors, coordinationMode, 
                        centralizedMode, userControlManual, controlComputerDirectGroups, operationMode, sptpOperationMode, emergency, hasCRC);
            if (ColorsServer.TEST_SPTP == true)
            {
                String s = "Set State >> ";
                byte[] data = request.toByteArray();
                for (int i=0; i<data.length; i++)
                {
                    s += String.format(" %02X", data[i]);
                }
                Shared.traceInformation(name, s);
            }
            getControllerConnection().send(request.toByteArray());

            if (command.colorsMode != M_ControllerCommands.COLORS_NOTHING)
            {
                M_ControllerCommands specificCommand = new M_ControllerCommands();
                specificCommand.colorsMode = command.colorsMode;
                DeviceAction action = new DeviceAction(controller, parameters, specificCommand);

                action.actionName = specificCommand.getActionName();

                DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_CORRECT);
                action.setResult(actionResult);
                Shared.model.addAction(action);
                laction.add(action);
            }

            if (command.operationMode != M_ControllerCommands.OPERATIONMODE_NOTHING)
            {
                M_ControllerCommands specificCommand = new M_ControllerCommands();
                specificCommand.operationMode = command.operationMode;
                DeviceAction action = new DeviceAction(controller, parameters, specificCommand);
                
                action.actionName = specificCommand.getActionName();

                DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_CORRECT);
                action.setResult(actionResult);
                Shared.model.addAction(action);
                laction.add(action);
            }

            if (command.userControlManual != M_ControllerCommands.CONDITION_NOTHING)
            {
                M_ControllerCommands specificCommand = new M_ControllerCommands();
                specificCommand.userControlManual = command.userControlManual;
                DeviceAction action = new DeviceAction(controller, parameters, specificCommand);

                action.actionName = specificCommand.getActionName();

                DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_CORRECT);
                action.setResult(actionResult);
                Shared.model.addAction(action);
                laction.add(action);
            }

            if (command.emergency != M_ControllerCommands.CONDITION_NOTHING)
            {
                M_ControllerCommands specificCommand = new M_ControllerCommands();
                specificCommand.emergency = command.emergency;
                DeviceAction action = new DeviceAction(controller, parameters, specificCommand);

                action.actionName = specificCommand.getActionName();

                DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_CORRECT);
                action.setResult(actionResult);
                Shared.model.addAction(action);
                laction.add(action);
            }

            if ((command.sptp != null) && 
                (command.sptp.operationMode != null))
            {
                M_ControllerCommands specificCommand = new M_ControllerCommands();
                specificCommand.sptp = new M_ControllerCommands_SPTP();
                specificCommand.sptp.operationMode = new M_ControllerCommands_SPTP_OperationMode();
                specificCommand.sptp.operationMode.mode = command.sptp.operationMode.mode;
                DeviceAction action = new DeviceAction(controller, parameters, specificCommand);
                
                action.actionName = specificCommand.getActionName();

                DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_CORRECT);
                action.setResult(actionResult);
                Shared.model.addAction(action);
                laction.add(action);
            }

            return laction;
        }
        catch (Exception exception)
        {
            Shared.printstack(name, exception); 
            if (command.colorsMode != M_ControllerCommands.COLORS_NOTHING)
            {
                M_ControllerCommands specificCommand = new M_ControllerCommands();
                specificCommand.colorsMode = command.colorsMode;
                
                DeviceAction action = new DeviceAction(controller, parameters, specificCommand);
                
                action.actionName = specificCommand.getActionName();

                DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_ERROR, exception);
                action.setResult(actionResult);
                Shared.model.addAction(action);
                laction.add(action);
            }

            if (command.operationMode != M_ControllerCommands.OPERATIONMODE_NOTHING)
            {
                M_ControllerCommands specificCommand = new M_ControllerCommands();
                specificCommand.operationMode = command.operationMode;
                
                DeviceAction action = new DeviceAction(controller, parameters, specificCommand);
                
                action.actionName = specificCommand.getActionName();
                

                DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_ERROR, exception);
                action.setResult(actionResult);
                Shared.model.addAction(action);
                laction.add(action);
            }

            if (command.userControlManual != M_ControllerCommands.CONDITION_NOTHING)
            {
                M_ControllerCommands specificCommand = new M_ControllerCommands();
                specificCommand.userControlManual = command.userControlManual;
                
                DeviceAction action = new DeviceAction(controller, parameters, specificCommand);

                action.actionName = specificCommand.getActionName();

                DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_ERROR, exception);
                action.setResult(actionResult);
                Shared.model.addAction(action);
                laction.add(action);
            }

            if (command.emergency != M_ControllerCommands.CONDITION_NOTHING)
            {
                M_ControllerCommands specificCommand = new M_ControllerCommands();
                specificCommand.emergency = command.emergency;
                
                DeviceAction action = new DeviceAction(controller, parameters, specificCommand);

                action.actionName = specificCommand.getActionName();

                DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_ERROR, exception);
                action.setResult(actionResult);
                Shared.model.addAction(action);
                laction.add(action);
            }

            return laction;
        }
    }

    // </editor-fold>  


    // <editor-fold defaultstate="collapsed" desc="Shift phase">

    public DeviceAction shiftPhase(InteropParameters parameters, M_ControllerCommands command) throws SerializationException
    {
        String language = (String)parameters.getParameterValue("language");
        DeviceAction action = new DeviceAction(controller, parameters, command);
        action.actionName = command.getActionName();

        try
        {
//            M_ControllerCommandsPhaseChanging phaseChangingCommands = command.phaseChanging;
//            M_ControllerConfiguration controllerConfiguration = controller.getDeviceConfiguration();
//            M_SubcontrollerConfiguration subcontrollerConfiguration = controllerConfiguration.getSubcontroller(phaseChangingCommands.subcontroller);
//            if (subcontrollerConfiguration == null)
//            {
//                DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_ERROR, Shared.getMessage("Subcontroller does not exist"));
//                action.setResult(actionResult);
//                Shared.model.addAction(action);
//                return action;
//            }
//
//            M_Message request = M_ProtocolConstructor.phaseChanging(phaseChangingCommands, hasCRC);
//            getControllerConnection().send(request.toByteArray());
//
//            DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_CORRECT);
//            action.setResult(actionResult);
//            Shared.model.addAction(action);
//            return action;

            DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_NOTSEND);
            action.setResult(actionResult);
            Shared.model.addAction(action);
            return action;
        }
        catch (Exception exception)
        {
            DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_ERROR, exception.getMessage());
            action.setResult(actionResult);
            Shared.model.addAction(action);
            return action;
        }
    }

    // </editor-fold>  


    // <editor-fold defaultstate="collapsed" desc="Set direct group output">

//    public DeviceAction setDirectGroupOutput(InteropParameters parameters, M_ControllerCommands command) throws SerializationException
//    {
//        String language = (String)parameters.getParameterValue("language");
//        DeviceAction action = new DeviceAction(controller, parameters, command);
//        action.actionName = command.getActionName();
//
//        try
//        {
//            List<M_ControllerCommandsDirectGroupOutput> ldirectGroupCommand = command.ldirectGroupOutput;
//            M_ControllerConfiguration controllerConfiguration = controller.getDeviceConfiguration();
//
//            for (M_ControllerCommandsDirectGroupOutput directGroupOutput : ldirectGroupCommand)
//            {
//                try
//                {
//                    controllerConfiguration.getDirectGroup(directGroupOutput.group);
//                }
//                catch (Exception exception)
//                {
//                    DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_ERROR, Shared.getMessage("Direct group %1 does not exists").replace("%1", "" + directGroupOutput.group));
//                    action.setResult(actionResult);
//                    Shared.model.addAction(action);
//                    return action;
//                }
//            }
//
//            M_Message request = M_ProtocolConstructor.setDirectGroupOutput(0x00, ldirectGroupCommand, hasCRC);
//            getControllerConnection().send(request.toByteArray());
//
//            DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_CORRECT);
//            action.setResult(actionResult);
//            Shared.model.addAction(action);
//            return action;
//        }
//        catch (Exception exception)
//        {
//            DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_ERROR, exception.getMessage());
//            action.setResult(actionResult);
//            Shared.model.addAction(action);
//            return action;
//        }
//    }

    // </editor-fold>  


    // <editor-fold defaultstate="collapsed" desc="Clear alarms">

    public DeviceAction clearAlarms(InteropParameters parameters, M_ControllerCommands command) throws SerializationException
    {
        String language = (String)parameters.getParameterValue("language");
        DeviceAction action = new DeviceAction(controller, parameters, command);
        action.actionName = command.getActionName();

        try
        {
            M_Message request = M_ProtocolConstructor.clearAlarms(0x00, hasCRC);
            getControllerConnection().send(request.toByteArray());

            DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_CORRECT);
            action.setResult(actionResult);
            Shared.model.addAction(action);
            return action;
        }
        catch (Exception exception)
        {
            DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_ERROR, exception.getMessage());
            action.setResult(actionResult);
            Shared.model.addAction(action);
            return action;
        }
    }
    
    // </editor-fold>  


    // <editor-fold defaultstate="collapsed" desc="Get status functions">

    protected void getCurrentSubcontrollersState(M_Controller m_controllerClone) throws ServerException, Exception
    {
        if (m_controllerClone.getDeviceStatus().lsubcontroller.size() == 0)
        {
            createStatusSubcontrollers(m_controllerClone);
        }
        else
        {
            int number = 1;
            for (M_ControllerStatusSubcontroller m_controllerStatusSubcontroller : m_controllerClone.getDeviceStatus().lsubcontroller)
            {
                m_controllerStatusSubcontroller.number = number++;
                M_Message command = M_ProtocolConstructor.getCurrentState(m_controllerStatusSubcontroller.number, hasCRC);
                M_Request request = new M_Request();
                request.controller = this;
                request.request = command;

                this.getControllerConnection().addM_Request(request);
                request.waitResponse(m_controllerClone.getDeviceInformation().timeout);

                M_ProtocolAnalyser.analyseCurrentStateResponse(m_controllerStatusSubcontroller, request.response, m_controllerStatusSubcontroller.number);
            }
        }
    }


    protected int getAlarms(M_Controller m_controllerClone) throws ServerException, Exception
    {
        if (m_controllerClone.getDeviceStatus().lgroup.size() == 0)
        {
            M_ControllerConfiguration configuration = m_controllerClone.getDeviceConfiguration();
            for (M_TrafficGroup trafficGroup : configuration.ltrafficGroup)
            {
                M_ControllerStatusGroup group = new M_ControllerStatusGroup();
                group.number = trafficGroup.number;
                m_controllerClone.getDeviceStatus().lgroup.add(group);
            }
        }

        M_Message command = M_ProtocolConstructor.getAlarms(0x00, hasCRC);
        M_Request request = new M_Request();
        request.controller = this;
        request.request = command;

        this.getControllerConnection().addM_Request(request);
        request.waitResponse(m_controllerClone.getDeviceInformation().timeout);

        int result = M_ProtocolAnalyser.analyseAlarmsResponse(m_controllerClone, request.response, 0x00);
        return(result);
    }


    protected void getBlownLampAlarms(M_Controller m_controllerClone) throws ServerException, Exception
    {
        M_Message command = M_ProtocolConstructor.getBlownLampsAlarms(0x00, hasCRC);
        M_Request request = new M_Request();
        request.controller = this;
        request.request = command;

        this.getControllerConnection().addM_Request(request);
        request.waitResponse(m_controllerClone.getDeviceInformation().timeout);

        M_ProtocolAnalyser.analyseBlownLampsAlarmsResponse(m_controllerClone, request.response, 0x00);
    }


    protected void getDamagedGroupAlarms(M_Controller m_controllerClone) throws ServerException, Exception
    {
        M_Message command = M_ProtocolConstructor.getDamagedGroupAlarms(0x00, hasCRC);
        M_Request request = new M_Request();
        request.controller = this;
        request.request = command;

        this.getControllerConnection().addM_Request(request);
        request.waitResponse(m_controllerClone.getDeviceInformation().timeout);

        M_ProtocolAnalyser.analyseDamagedGroupAlarmsResponse(m_controllerClone, request.response, 0x00);
    }


    protected void getIncompatibilityAlarms(M_Controller m_controllerClone) throws ServerException, Exception
    {
        M_Message command = M_ProtocolConstructor.getIncompatibilityAlarms(0x00, hasCRC);
        M_Request request = new M_Request();
        request.controller = this;
        request.request = command;

        this.getControllerConnection().addM_Request(request);
        request.waitResponse(m_controllerClone.getDeviceInformation().timeout);

        M_ProtocolAnalyser.analyseIncompatibilityAlarmsResponse(m_controllerClone, request.response, 0x00);
    }


    protected M_Plan getCurrentRecordablePlan(int subcontroller) throws ServerException, Exception
    {
        M_ControllerConfiguration controllerConfiguration = controller.getDeviceConfiguration();
        M_SubcontrollerConfiguration subcontrollerConfiguration = controllerConfiguration.getSubcontroller(subcontroller);

        if (subcontrollerConfiguration == null) throw new ServerException(Shared.getMessage("Subcontroller does not exist"));

        M_Message command = M_ProtocolConstructor.getRecordablePlan(subcontroller, hasCRC);
        M_Request request = new M_Request();
        request.controller = this;
        request.request = command;

        this.getControllerConnection().addM_Request(request);
        request.waitResponse(controller.getDeviceInformation().timeout);

        M_Plan recordablePlan = M_ProtocolAnalyser.analyseGetRecordablePlanResponse(request.response, subcontroller, subcontrollerConfiguration.lphaseStable.size());
        if (recordablePlan == null)
        {
            M_Plan subcontrollerRecordablePlan = controller.getDeviceStatus().getStatusSubcontroller(subcontroller).recordablePlan;
            if (subcontrollerRecordablePlan == null)
            {
                throw new ServerException(Shared.getMessage("Recordable plan is not configured") + ", " + Shared.getMessage("Subcontroller") + " : " + subcontroller);
            }

            try
            {
                // Send again save recordable plan command
                M_ControllerCommands commands = new M_ControllerCommands();
                // commands.userControlPlan = CONDITION_YES;
                commands.recordablePlan = new ALUVISA_Plan();
                commands.recordablePlan.initialise(subcontrollerConfiguration, subcontrollerRecordablePlan);

                InteropParameters parameters = new InteropParameters();
                parameters.addParameter("language", "en-GB");
                parameters.addParameter("username", "system");
                parameters.addParameter("computer", controller.getDeviceInformation().serverAddress);
                parameters.addBodycontent(commands);

                DeviceAction[] laction = sendCommands(subcontroller, parameters);
            }
            catch (Exception e)
            {
                Shared.printstack(name, e); 
                throw e;
            }

            throw new ServerException(Shared.getMessage("Recordable plan is not configured") + ", " + Shared.getMessage("Subcontroller") + " : " + subcontroller);
        }

        ALUVISA_Plan aluvisaPlan = new ALUVISA_Plan();
        aluvisaPlan.initialise(this.controller.getDeviceConfiguration().getSubcontroller(subcontroller), recordablePlan);

        int cycleTime = 0;
        for (ALUVISA_Phase phase : aluvisaPlan.lPhase)
        {
            cycleTime += phase.maximumTime;
        }

        HashMap<Integer, Integer> hdestination = new HashMap<Integer, Integer>();
        for (ALUVISA_Link link : aluvisaPlan.lLink)
        {
            if (hdestination.containsKey(link.destination) == false)
            {
                hdestination.put(link.destination, link.destination);
                for (ALUVISA_Phase phase : link.lTransition)
                {
                    cycleTime += phase.maximumTime;
                }
            }
        }

        recordablePlan.cycleTime = cycleTime;

        return(recordablePlan);
    }

    // </editor-fold>  



    // <editor-fold defaultstate="collapsed" desc="Get realtime functions">

    protected void getCurrentPlan(M_Controller m_controllerClone) throws ServerException, Exception
    {
        if (m_controllerClone.getDeviceRealtime().lsubcontroller.size() == 0)
        {
            createRealtimeSubcontrollers(m_controllerClone);
        }
        else
        {
            for (M_ControllerRealtimeSubcontroller m_controllerRealtimeSubcontroller : m_controllerClone.getDeviceRealtime().lsubcontroller)
            {
                M_Message command = M_ProtocolConstructor.getCurrentPlan(m_controllerRealtimeSubcontroller.number, hasCRC);
                M_Request request = new M_Request();
                request.controller = this;
                request.request = command;

                this.getControllerConnection().addM_Request(request);
                request.waitResponse(m_controllerClone.getDeviceInformation().timeout);

                M_ProtocolAnalyser.analyseCurrentPlanResponse(m_controllerClone.getDeviceStatus().getStatusSubcontroller(m_controllerRealtimeSubcontroller.number), m_controllerRealtimeSubcontroller, request.response, m_controllerRealtimeSubcontroller.number);
//                String message = Shared.getMessage("Subcontroller = %1, Current Plan = %2, Phase = %3, Time = %4, Starttime = %5, Adjust = %6");
//                message = message.replace("%1", "" + m_controllerRealtimeSubcontroller.number);
//                message = message.replace("%2", "" + m_controllerRealtimeSubcontroller.plan);
//                message = message.replace("%3", "" + m_controllerRealtimeSubcontroller.phase);
//                message = message.replace("%4", "" + m_controllerRealtimeSubcontroller.cycle);
//                message = message.replace("%5", sdh.format(new Date(m_controllerRealtimeSubcontroller.startTimestamp)));
//                message = message.replace("%6", "" + m_controllerRealtimeSubcontroller.adjust);
//                Shared.println(name, "\t" + this.controller.getIdentifier() + " - 1.CurrentPlan: " + message);
            }
        }
    }


    protected void getCurrentPresenceDetectors(M_Controller m_controllerClone) throws ServerException, Exception
    {
        M_Message command = M_ProtocolConstructor.getCurrentPresenceDetectors(0x00, hasCRC);
        M_Request request = new M_Request();
        request.controller = this;
        request.request = command;

        this.getControllerConnection().addM_Request(request);
        request.waitResponse(m_controllerClone.getDeviceInformation().timeout);

        try{M_ProtocolAnalyser.analyseCurrentPresenceDetectorsResponse(m_controllerClone, request.response, 0x00);} catch (Exception e){};
    }


    protected long[] getCurrentTime(M_Controller m_controllerClone) throws ServerException, Exception
    {
        try
        {
            if (m_controllerClone.getDeviceInformation().type == M_ControllerInformation.TYPE_RTAC)
            {
                M_Message command = null;
                if (checkedPRH == false)
                {
                    command = M_ProtocolConstructor.PRH();

                    M_Request request = new M_Request();
                    request.controller = this;
                    request.request = command;

                    this.getControllerConnection().addM_Request(request);
                    request.waitResponse(m_controllerClone.getDeviceInformation().timeout);

                    checkedPRH = true;
                    if (request.response == null)
                    {
                        usePRH = false;
                    }
                    else
                    {
                        usePRH = true;
                    }

                    return(M_ProtocolAnalyser.analyseCurrentTimeResponse(m_controllerClone, request.response, 0x00));
                }
                else
                {
                    if (usePRH == true)
                    {
                        command = M_ProtocolConstructor.PRH();
                    }
                    else
                    {
                        command = M_ProtocolConstructor.getCurrentTime(0x00, hasCRC);
                    }

                    M_Request request = new M_Request();
                    request.controller = this;
                    request.request = command;

                    this.getControllerConnection().addM_Request(request);
                    request.waitResponse(m_controllerClone.getDeviceInformation().timeout);

                    return(M_ProtocolAnalyser.analyseCurrentTimeResponse(m_controllerClone, request.response, 0x00));
                }
            }
            else
            {
                M_Message command = null;
                if (m_controllerClone.getDeviceInformation().type == M_ControllerInformation.TYPE_RTAC)
                {
                    command = M_ProtocolConstructor.PRH();
                }
                else
                {
                    command = M_ProtocolConstructor.getCurrentTime(0x00, hasCRC);
                }

                M_Request request = new M_Request();
                request.controller = this;
                request.request = command;

                this.getControllerConnection().addM_Request(request);
                request.waitResponse(m_controllerClone.getDeviceInformation().timeout);

                return(M_ProtocolAnalyser.analyseCurrentTimeResponse(m_controllerClone, request.response, 0x00));
            }
        }
        catch (Exception e)
        {
            throw e;
        }
    }


    protected void getCurrentStatusGroups(M_Controller m_controllerClone) throws ServerException, Exception
    {
        try
        {
            M_Message command = M_ProtocolConstructor.getCurrentStatusGroups(0x00, hasCRC);
            M_Request request = new M_Request();
            request.controller = this;
            request.request = command;

            this.getControllerConnection().addM_Request(request);
            request.waitResponse(m_controllerClone.getDeviceInformation().timeout);
            M_ProtocolAnalyser.analyseCurrentStatusGroupsResponse(m_controllerClone, request.response, 0x00);
        }
        catch (Exception e)
        {
        }
    }

    // </editor-fold>  
    

    // <editor-fold defaultstate="collapsed" desc="Get traffic data functions">

    protected void getCurrentCountingDetectors(M_Controller m_controllerClone) throws ServerException, Exception
    {
        try
        {
            M_Message command = M_ProtocolConstructor.getCurrentCountingDetectors(0x00);
            M_Request request = new M_Request();
            request.controller = this;
            request.request = command;

            this.getControllerConnection().addM_Request(request);
            request.waitResponse(m_controllerClone.getDeviceInformation().timeout);

            EtdStatus newEtdStatus = createEtdStatus();
            M_ProtocolAnalyser.analyseCurrentCountingDetectorsResponse(m_controllerClone, request.response, 0x00, newEtdStatus);
            Shared.println(name, "1.EtdStatus: " + newEtdStatus.getMeasurementTimestamp() + ", " + newEtdStatus.status + ", " + newEtdStatus.period + ", " + newEtdStatus.total + ", " + newEtdStatus.llane.size());
            Shared.println(name, "2.EtdStatus: " + newEtdStatus.getMeasurementTimestamp() + ", " + newEtdStatus.total.correctMeasurements + ", " + newEtdStatus.total.totalMeasurements);
            Shared.println(name, "3.EtdStatus: " + newEtdStatus.getMeasurementTimestamp() + ", " + newEtdStatus.total.counting + ", " + newEtdStatus.total.occupancy + ", " + newEtdStatus.total.status);

            this.etdStatus = newEtdStatus;

            Shared.println(name, "4.EtdStatus: " + this.etdStatus.getMeasurementTimestamp() + ", " + this.etdStatus.status + ", " + this.etdStatus.period + ", " + this.etdStatus.total + ", " + this.etdStatus.llane.size());
            Shared.println(name, "5.EtdStatus: " + this.etdStatus.getMeasurementTimestamp() + ", " + this.etdStatus.total.correctMeasurements + ", " + this.etdStatus.total.totalMeasurements);
            Shared.println(name, "6.EtdStatus: " + this.etdStatus.getMeasurementTimestamp() + ", " + this.etdStatus.total.counting + ", " + this.etdStatus.total.occupancy + ", " + this.etdStatus.total.status);
            
        }
        catch (Exception e)
        {
            Shared.printstack(name, e);
            // throw e;
        }
    }

    // </editor-fold>  


    // <editor-fold defaultstate="collapsed" desc="Get realtime traffic data">

    public EtdStatus getRealtimeTrafficData(long timestamp) throws ServerException, Exception
    {
        if (this.etdStatus.measurementTimestamp > timestamp)
        {
            return(this.etdStatus);
        }
        else
        {
            // QUITARLO
            if (this.etdStatus.measurementTimestamp > 0)
            {
                this.etdStatus.measurementTimestamp = this.etdStatus.measurementTimestamp + 60000L;
            }
        }

        throw new ServerException(Shared.getMessage("Not new information"));
    }
    
    // </editor-fold>  

    // <editor-fold defaultstate="collapsed" desc="Private functions">

    private void updateStatusSubcontroller(M_ControllerStatusSubcontroller currentRealStatus, M_ControllerStatusSubcontroller currentStatus, M_ControllerStatusSubcontroller newStatus) throws Exception
    {
        if (newStatus != null)
        {
            if (newStatus.adaptativeDetectors != M_ControllerStatusSubcontroller.UNKNOWN) currentStatus.adaptativeDetectors = newStatus.adaptativeDetectors;
            if (newStatus.centralizedMode != M_ControllerStatusSubcontroller.UNKNOWN) currentStatus.centralizedMode = newStatus.centralizedMode;
            if (newStatus.colorsMode != M_ControllerStatusSubcontroller.UNKNOWN) currentStatus.colorsMode = newStatus.colorsMode;
            if (newStatus.controlComputerDirectGroups != M_ControllerStatusSubcontroller.UNKNOWN) currentStatus.controlComputerDirectGroups = newStatus.controlComputerDirectGroups;
            if (newStatus.coordinationMode != M_ControllerStatusSubcontroller.UNKNOWN) currentStatus.coordinationMode = newStatus.coordinationMode;
            if (newStatus.emergency != M_ControllerStatusSubcontroller.UNKNOWN) currentStatus.emergency = newStatus.emergency;
            if (newStatus.userControlManual != M_ControllerStatusSubcontroller.UNKNOWN) currentStatus.userControlManual = newStatus.userControlManual;
            if (newStatus.operationMode != M_ControllerStatusSubcontroller.UNKNOWN) currentStatus.operationMode = newStatus.operationMode;
            if (newStatus.plan != M_ControllerStatusSubcontroller.UNKNOWN) currentStatus.plan = newStatus.plan;
            if (newStatus.planSelection != M_ControllerStatusSubcontroller.UNKNOWN) currentStatus.planSelection = newStatus.planSelection;
            if (newStatus.localControl != M_ControllerStatusSubcontroller.UNKNOWN) currentStatus.localControl = newStatus.localControl;

            if (newStatus.userControlPlan != M_ControllerStatusSubcontroller.UNKNOWN) currentStatus.userControlPlan = newStatus.userControlPlan;
            if (newStatus.planSelectionComputer != M_ControllerStatusSubcontroller.UNKNOWN) currentStatus.planSelectionComputer = newStatus.planSelectionComputer;
            if (newStatus.recordablePlan != null)
            {
                if (currentStatus.recordablePlan == null)
                    currentStatus.recordablePlan = newStatus.recordablePlan;
                else
                {
                    currentStatus.recordablePlan.controlMode = newStatus.recordablePlan.controlMode;
                    currentStatus.recordablePlan.minimumAndExtensionTimesTable = newStatus.recordablePlan.minimumAndExtensionTimesTable;
                    currentStatus.recordablePlan.offset = newStatus.recordablePlan.offset;
                    currentStatus.recordablePlan.number = 0;  // newStatus.recordablePlan.number;
                    currentStatus.recordablePlan.structure = newStatus.recordablePlan.structure;
                    currentStatus.recordablePlan.transitionsToTimesTable = newStatus.recordablePlan.transitionsToTimesTable;
                    currentStatus.recordablePlan.lPhaseTime.clear();
                    currentStatus.recordablePlan.lPhaseTime.addAll(newStatus.recordablePlan.lPhaseTime);
                }

                currentStatus.recordablePlan.cycleTime = calculateCycleTime(currentStatus.recordablePlan, this.controller, currentStatus.number);
            }
        }

        if (currentStatus.adaptativeDetectors == M_ControllerStatusSubcontroller.UNKNOWN) currentStatus.adaptativeDetectors = currentRealStatus.adaptativeDetectors;
        if (currentStatus.centralizedMode == M_ControllerStatusSubcontroller.UNKNOWN) currentStatus.centralizedMode = currentRealStatus.centralizedMode;
        if (currentStatus.colorsMode == M_ControllerStatusSubcontroller.UNKNOWN) currentStatus.colorsMode = currentRealStatus.colorsMode;
        if (currentStatus.controlComputerDirectGroups == M_ControllerStatusSubcontroller.UNKNOWN) currentStatus.controlComputerDirectGroups = currentRealStatus.controlComputerDirectGroups;
        if (currentStatus.coordinationMode == M_ControllerStatusSubcontroller.UNKNOWN) currentStatus.coordinationMode = currentRealStatus.coordinationMode;
        if (currentStatus.emergency == M_ControllerStatusSubcontroller.UNKNOWN) currentStatus.emergency = currentRealStatus.emergency;
        if (currentStatus.userControlManual == M_ControllerStatusSubcontroller.UNKNOWN) currentStatus.userControlManual = currentRealStatus.userControlManual;
        if (currentStatus.operationMode == M_ControllerStatusSubcontroller.UNKNOWN) currentStatus.operationMode = currentRealStatus.operationMode;
        if (currentStatus.plan == M_ControllerStatusSubcontroller.UNKNOWN) currentStatus.plan = currentRealStatus.plan;
        if (currentStatus.planSelection == M_ControllerStatusSubcontroller.UNKNOWN) currentStatus.planSelection = currentRealStatus.planSelection;
        if (currentStatus.localControl == M_ControllerStatusSubcontroller.UNKNOWN) currentStatus.localControl = currentRealStatus.localControl;

        if (currentStatus.userControlPlan == M_ControllerStatusSubcontroller.UNKNOWN) currentStatus.userControlPlan = currentRealStatus.userControlPlan;
        if (currentStatus.planSelectionComputer == M_ControllerStatusSubcontroller.UNKNOWN) currentStatus.planSelectionComputer = currentRealStatus.planSelectionComputer;
        if (currentStatus.recordablePlan == null) currentStatus.recordablePlan = currentRealStatus.recordablePlan;
    }


    protected int calculateCycleTime(M_Plan plan, M_Controller controller, int subcontroller) throws Exception
    {
        controller.getDeviceConfiguration().toAluvisa();
        ALUVISA_Plan aluvisaPlan = new ALUVISA_Plan();
        aluvisaPlan.initialise(controller.getDeviceConfiguration().getSubcontroller(subcontroller), plan);

        return(aluvisaPlan.getCycleTime());
    }


    protected void recreateStatus(M_Controller m_controllerClone) throws ServerException, Exception
    {
        if (m_controllerClone.getDeviceStatus().lsubcontroller.size() > m_controllerClone.getDeviceConfiguration().lsubcontroller.size())
        {
            
            for (int i=m_controllerClone.getDeviceConfiguration().lsubcontroller.size(); i<m_controllerClone.getDeviceStatus().lsubcontroller.size(); i++)
            {
                m_controllerClone.getDeviceStatus().lsubcontroller.remove(m_controllerClone.getDeviceStatus().lsubcontroller.size()-1);
            }
        }
        else if (m_controllerClone.getDeviceStatus().lsubcontroller.size() < m_controllerClone.getDeviceConfiguration().lsubcontroller.size())
        {
            for (int i=1; i<=4; i++)
            {
                try
                {
                    M_ControllerStatusSubcontroller statusSubcontroller = new M_ControllerStatusSubcontroller();
                    statusSubcontroller.number = i;
                    M_Message command = M_ProtocolConstructor.getCurrentState(i, hasCRC);
                    M_Request request = new M_Request();
                    request.controller = this;
                    request.request = command;

                    this.getControllerConnection().addM_Request(request);
                    request.waitResponse(m_controllerClone.getDeviceInformation().timeout);

                    M_ProtocolAnalyser.analyseCurrentStateResponse(statusSubcontroller, request.response, i);
                    m_controllerClone.getDeviceStatus().lsubcontroller.add(statusSubcontroller);
                }
                catch (Exception e)
                {
                    i = 5;
                }
            }
        }
    }

    protected void createStatusSubcontrollers(M_Controller m_controllerClone) throws ServerException, Exception
    {
        for (int i=1; i<=4; i++)
        {
            try
            {
                M_ControllerStatusSubcontroller statusSubcontroller = new M_ControllerStatusSubcontroller();
                statusSubcontroller.number = i;
                M_Message command = M_ProtocolConstructor.getCurrentState(i, hasCRC);
                M_Request request = new M_Request();
                request.controller = this;
                request.request = command;

                this.getControllerConnection().addM_Request(request);
                request.waitResponse(m_controllerClone.getDeviceInformation().timeout);

                M_ProtocolAnalyser.analyseCurrentStateResponse(statusSubcontroller, request.response, i);
                m_controllerClone.getDeviceStatus().lsubcontroller.add(statusSubcontroller);
            }
            catch (Exception e)
            {
                i = 5;
            }
        }
    }


    protected void createRealtimeSubcontrollers(M_Controller m_controllerClone) throws ServerException, Exception
    {
        for (int i=1; i<=4; i++)
        {
            try
            {
                M_ControllerRealtimeSubcontroller realtimeSubcontroller = new M_ControllerRealtimeSubcontroller();
                realtimeSubcontroller.number = i;
                M_Message command = M_ProtocolConstructor.getCurrentPlan(i, hasCRC);
                M_Request request = new M_Request();
                request.controller = this;
                request.request = command;

                this.getControllerConnection().addM_Request(request);
                request.waitResponse(m_controllerClone.getDeviceInformation().timeout);

                M_ProtocolAnalyser.analyseCurrentPlanResponse(m_controllerClone.getDeviceStatus().getStatusSubcontroller(realtimeSubcontroller.number), realtimeSubcontroller, request.response, i);
                m_controllerClone.getDeviceRealtime().lsubcontroller.add(realtimeSubcontroller);
            }
            catch (Exception e)
            {
                i = 5;
            }
        }
    }


    protected EtdStatus createEtdStatus() throws ServerException, Exception
    {
        EtdStatus result = new EtdStatus();
        result.period = this.controller.getDeviceInformation().pollingTrafficData;
        result.llane = new ArrayList<EtdStatusLane>();
        for (M_PhysicalDetectorStrategical strategicalDetector : this.controller.getDeviceConfiguration().lstrategicalDetector)
        {
            EtdStatusLane lane = new EtdStatusLane();
            result.llane.add(lane);
        }

        result.total = new EtdStatusLane();
        return(result);
    }


    protected void clearBlownLampsGroupAlarms(M_Controller m_controllerClone)
    {
        for (M_ControllerStatusGroup m_controllerStatusGroup : m_controllerClone.getDeviceStatus().lgroup)
        {
            m_controllerStatusGroup.redOutputBlown = M_ControllerRealtimeGroup.NO;
            m_controllerStatusGroup.yellowOutputBlown = M_ControllerRealtimeGroup.NO;
            m_controllerStatusGroup.greenOutputBlown = M_ControllerRealtimeGroup.NO;
        }
    }


    protected void clearDamagedGroupAlarms(M_Controller m_controllerClone)
    {
        for (M_ControllerStatusGroup m_controllerStatusGroup : m_controllerClone.getDeviceStatus().lgroup)
        {
            m_controllerStatusGroup.redOutputDamaged = M_ControllerRealtimeGroup.NO;
            m_controllerStatusGroup.yellowOutputDamaged = M_ControllerRealtimeGroup.NO;
            m_controllerStatusGroup.greenOutputDamaged = M_ControllerRealtimeGroup.NO;
        }
    }


    protected void clearIncompatibilityGroupAlarms(M_Controller m_controllerClone)
    {
        for (M_ControllerStatusGroup m_controllerStatusGroup : m_controllerClone.getDeviceStatus().lgroup)
        {
            m_controllerStatusGroup.lincompatibility.clear();
        }
    }

    // </editor-fold>  


    // <editor-fold defaultstate="collapsed" desc="Read tables functions">

    public M_ControllerConfiguration readAllTables() throws ServerException, Exception
    {
        ControllerConnection controllerRead = null;

        try
        {
            if (controller.getDeviceInformation().type == M_ControllerInformation.TYPE_DYNAMIC)
            {
                controllerRead = new ControllerConnection(controller.getDeviceInformation().address, controller.getDeviceInformation().portM, controller.getDeviceInformation().timeout, hasCRC);
                controllerRead.connect();
            }
            else
            {
                if (controller.getIdentifier().equalsIgnoreCase("controller-almeria-00740") == true)
                {
                    Shared.println(name, "1.ReadAllTables");
                }
                controllerRead = getControllerConnection();
                if (controller.getIdentifier().equalsIgnoreCase("controller-almeria-00740") == true)
                {
                    Shared.println(name, "2.ReadAllTables");
                }
            }

            List<Byte> lTableData = new ArrayList<Byte>();

            if (controller.getIdentifier().equalsIgnoreCase("controller-almeria-00740") == true)
            {
                Shared.println(name, "3.ReadAllTables");
            }
            lTableData.addAll(readTable(controllerRead, 0x00, M_Table.M_TABLE_A_GROUPS));
            if (controller.getIdentifier().equalsIgnoreCase("controller-almeria-00740") == true)
            {
                Shared.println(name, "4.ReadAllTables");
            }
            lTableData.addAll(readTable(controllerRead, 0x00, M_Table.M_TABLE_B_PHYSICAL_DETECTORS));
            lTableData.addAll(readTable(controllerRead, 0x00, M_Table.M_TABLE_C_LOGICAL_DETECTORS));
            lTableData.addAll(readTable(controllerRead, 0x00, M_Table.M_TABLE_D_DEMANDS));
            lTableData.addAll(readTable(controllerRead, 0x00, M_Table.M_TABLE_E_INCOMPATIBILITIES));
            lTableData.addAll(readTable(controllerRead, 0x00, M_Table.M_TABLE_F_SPECIAL_DAYS));
            lTableData.addAll(readTable(controllerRead, 0x00, M_Table.M_TABLE_G_INTERMITENCES));
            lTableData.addAll(readTable(controllerRead, 0x00, M_Table.M_TABLE_H_OPERATION_MODE));
            lTableData.addAll(readTable(controllerRead, 0x00, M_Table.M_TABLE_I_ALARMS_MANAGEMENT));

            try
            {
                // TODO Los reguladores dynamics viejos no tienen estas tablas
//                if (controller.getDeviceInformation().type == M_ControllerInformation.TYPE_DYNAMIC)
//                {
//                    lTableData.addAll(readTable(controllerRead, 0x00, M_Table.M_TABLE_DYNAMIC_LAMPS));
//                    lTableData.addAll(readTable(controllerRead, 0x00, M_Table.M_TABLE_DYNAMIC_DETECTORS));
//                    lTableData.addAll(readTable(controllerRead, 0x00, M_Table.M_TABLE_DYNAMIC_GENERAL_PARAMETERS));
//                    lTableData.addAll(readTable(controllerRead, 0x00, M_Table.M_TABLE_DYNAMIC_BUTTON_GUARD));
//                    lTableData.addAll(readTable(controllerRead, 0x00, M_Table.M_TABLE_DYNAMIC_ALARMS_CONFIGURATION));
//                }
            }
            catch (Exception e)
            {
                
            }


            // Reading M_TABLE_A_PHASES_STABLES we can detect how many subcontrollers 
            // are really configured in controller (1, 2, 3 or 4)
            // And then we can request only the correspondant tables.
            // It will not be necessary to ask for tables of subcontrollers that we know that don't exist.
            int numberOfSubcontrollers = 0;
            for (int i=0; i<M_ControllerConfiguration.MAXIMUM_NUMBER_SUBCONTROLLERS; i++)
            {
                List<Byte> ldata = readTable(controllerRead, i+1, M_Table.M_TABLE_A_PHASES_STABLES);
                if (ldata.size() > 5)
                {
                    lTableData.addAll(ldata);
                    numberOfSubcontrollers = numberOfSubcontrollers + 1;
                }
                else
                {
                    i = M_ControllerConfiguration.MAXIMUM_NUMBER_SUBCONTROLLERS;
                }
            }

            for (int i=0; i<numberOfSubcontrollers; i++) lTableData.addAll(readTable(controllerRead, i+1, M_Table.M_TABLE_B_PHASES_TRANSITIONS));
            for (int i=0; i<numberOfSubcontrollers; i++) lTableData.addAll(readTable(controllerRead, i+1, M_Table.M_TABLE_C_TRANSITIONS));
            for (int i=0; i<numberOfSubcontrollers; i++) lTableData.addAll(readTable(controllerRead, i+1, M_Table.M_TABLE_D_STRUCTURES));
            for (int i=0; i<numberOfSubcontrollers; i++) lTableData.addAll(readTable(controllerRead, i+1, M_Table.M_TABLE_E_ACTION_ON_DEMAND));
            for (int i=0; i<numberOfSubcontrollers; i++) lTableData.addAll(readTable(controllerRead, i+1, M_Table.M_TABLE_F_TRANSITIONS_TO_TIMES));
            for (int i=0; i<numberOfSubcontrollers; i++) lTableData.addAll(readTable(controllerRead, i+1, M_Table.M_TABLE_G_TRANSITIONS_TIMES));
            for (int i=0; i<numberOfSubcontrollers; i++) lTableData.addAll(readTable(controllerRead, i+1, M_Table.M_TABLE_H_MINIMUM_EXTENSION_TIMES));
            for (int i=0; i<numberOfSubcontrollers; i++) lTableData.addAll(readTable(controllerRead, i+1, M_Table.M_TABLE_I_PLANS));
            for (int i=0; i<numberOfSubcontrollers; i++) lTableData.addAll(readTable(controllerRead, i+1, M_Table.M_TABLE_J_EMERGENCY));
            for (int i=0; i<numberOfSubcontrollers; i++) lTableData.addAll(readTable(controllerRead, i+1, M_Table.M_TABLE_K_STARTUP));
            for (int i=0; i<numberOfSubcontrollers; i++) lTableData.addAll(readTable(controllerRead, i+1, M_Table.M_TABLE_L_CONFLICTIVE_TRANSITIONS));
            for (int i=0; i<numberOfSubcontrollers; i++) lTableData.addAll(readTable(controllerRead, i+1, M_Table.M_TABLE_M_TIMETABLE));

            try{for (int i=0; i<numberOfSubcontrollers; i++) lTableData.addAll(readTable(controllerRead, i+1, M_Table.M_TABLE_N_SPARE_TIMES));} catch (Exception e){};
            byte[] result = new byte[lTableData.size()];

            for (int i=0; i<result.length; i++)
            {
                result[i] = lTableData.get(i).byteValue();
            }

            M_ControllerConfiguration controllerConfiguration = new M_ControllerReader().load(result);

            for (M_SubcontrollerConfiguration subcontrollerConfiguration : controllerConfiguration.lsubcontroller)
            {
                for (M_Plan m_plan : subcontrollerConfiguration.lplan)
                {
                    int cycleTime = 0;
                    for (Integer duration : m_plan.lPhaseTime)
                    {
                        cycleTime += duration.intValue();
                    }

                    M_Structure structure = subcontrollerConfiguration.getStructure(m_plan.structure);
                    M_IntergreenToTimeTable transitionsToTimeTable = subcontrollerConfiguration.getIntergreenToTimeTable(m_plan.transitionsToTimesTable);
                    for (M_Assignment assignment : transitionsToTimeTable.lAssignment)
                    {
                        M_IntergreensPositionTimes intergreensPositionTimes = subcontrollerConfiguration.getIntergreensPositionTimes(assignment.timetable);
                        for (M_IntergreenPositionTimes intergreen : intergreensPositionTimes.lIntegreenTimes)
                        {
                            if (intergreen.intergreen == assignment.intergreen)
                            {
                                for (Integer time : intergreen.times)
                                {
                                    cycleTime += time.intValue();
                                }
                            }
                        }
                    }

                    m_plan.cycleTime = cycleTime;
                }
            }

            return(controllerConfiguration);
        }
        catch (Exception e)
        {
            if (controller.getDeviceInformation().type != M_ControllerInformation.TYPE_DYNAMIC)
            {
                Shared.printstack(name, e);
            }
            throw e;
        }
        finally
        {
            if (controller.getDeviceInformation().type == M_ControllerInformation.TYPE_DYNAMIC)
            {
                try{controllerRead.disconnect();} catch (Exception e){};
            }
        }
    }


    public List<Byte> readTable(ControllerConnection controllerRead, int controller, int tableCode) throws ServerException, Exception
    {
        if (this.controller.getIdentifier().equalsIgnoreCase("controller-almeria-00740") == true)
        {
            Shared.println(name, "1.ReadTable: " + controller + " - " + tableCode);
        }
        M_Message message = M_ProtocolConstructor.readTableMessage(controller, tableCode, hasCRC);
        if (this.controller.getIdentifier().equalsIgnoreCase("controller-almeria-00740") == true)
        {
            Shared.println(name, "2.ReadTable: " + controller + " - " + tableCode);
        }
        M_Request request = new M_Request();
        request.controller = this;
        request.request = message;

        this.getControllerConnection().addM_Request(request);
        request.waitResponse(this.controller.getDeviceInformation().timeout);
        M_Message response = request.response;
//        M_Message response = controllerRead.read(command);
        if (this.controller.getIdentifier().equalsIgnoreCase("controller-almeria-00740") == true)
        {
            Shared.println(name, "3.ReadTable: " + controller + " - " + tableCode + " - " + response);
        }
        // controllerRead.ack();
        if (this.controller.getIdentifier().equalsIgnoreCase("controller-almeria-00740") == true)
        {
            Shared.println(name, "4.ReadTable: " + controller + " - " + tableCode + " - " + response);
        }

        boolean salir = false;
        int retries = 0;
        while ((salir == false) && (retries < MAX_RETRIES))
        {
            if (M_ProtocolAnalyser.isReadTableMessage(this.controller, response, controller, tableCode) == true)
            {
                if (this.controller.getIdentifier().equalsIgnoreCase("controller-almeria-00740") == true)
                {
                    Shared.println(name, "5.ReadTable: " + controller + " - " + tableCode + " - " + response);
                }
                List<Byte> lTableData = M_ProtocolAnalyser.analyseReadTable(response, tableCode, hasCRC);
                if (this.controller.getIdentifier().equalsIgnoreCase("controller-almeria-00740") == true)
                {
                    Shared.println(name, "6.ReadTable: " + controller + " - " + tableCode + " - " + lTableData.size());
                }
                controllerRead.ack();
                if (this.controller.getIdentifier().equalsIgnoreCase("controller-almeria-00740") == true)
                {
                    Shared.println(name, "7.ReadTable: " + controller + " - " + tableCode + " - " + lTableData.size());
                }
                return(lTableData);
            }

            if (this.controller.getIdentifier().equalsIgnoreCase("controller-almeria-00740") == true)
            {
                Shared.println(name, "8.ReadTable: " + controller + " - " + tableCode + " - " + retries);
            }
            // response = controllerRead.receive();
            request = new M_Request();
            request.controller = this;
            request.request = message;

            this.getControllerConnection().addM_Request(request);
            request.waitResponse(this.controller.getDeviceInformation().timeout);
            response = request.response;
            if (this.controller.getIdentifier().equalsIgnoreCase("controller-almeria-00740") == true)
            {
                Shared.println(name, "9.ReadTable: " + controller + " - " + tableCode + " - " + retries);
            }
            // controllerRead.ack();
            if (this.controller.getIdentifier().equalsIgnoreCase("controller-almeria-00740") == true)
            {
                Shared.println(name, "10.ReadTable: " + controller + " - " + tableCode + " - " + retries);
            }
            retries++;
        }

        throw new Exception("Error reading table " + controller + " - " + tableCode);
    }

    // </editor-fold>  


    // <editor-fold defaultstate="collapsed" desc="Write tables functions">

    public void writeAllTables(M_ControllerConfiguration controllerConfiguration) throws ServerException, Exception
    {
        ControllerConnection controllerWrite = null;

        try
        {
            controllerWrite = new ControllerConnection(controller.getDeviceInformation().address, controller.getDeviceInformation().portM, controller.getDeviceInformation().timeout, hasCRC);
            controllerWrite.connect();

            startRecordingTables(controllerWrite, controllerConfiguration);

            writeTable(controllerWrite, 0x00, controllerConfiguration, null, M_Table.M_TABLE_A_GROUPS);
            writeTable(controllerWrite, 0x00, controllerConfiguration, null, M_Table.M_TABLE_B_PHYSICAL_DETECTORS);
            writeTable(controllerWrite, 0x00, controllerConfiguration, null, M_Table.M_TABLE_C_LOGICAL_DETECTORS);
            writeTable(controllerWrite, 0x00, controllerConfiguration, null, M_Table.M_TABLE_D_DEMANDS);
            writeTable(controllerWrite, 0x00, controllerConfiguration, null, M_Table.M_TABLE_E_INCOMPATIBILITIES);
            writeTable(controllerWrite, 0x00, controllerConfiguration, null, M_Table.M_TABLE_F_SPECIAL_DAYS);
            writeTable(controllerWrite, 0x00, controllerConfiguration, null, M_Table.M_TABLE_G_INTERMITENCES);
            writeTable(controllerWrite, 0x00, controllerConfiguration, null, M_Table.M_TABLE_H_OPERATION_MODE);
            writeTable(controllerWrite, 0x00, controllerConfiguration, null, M_Table.M_TABLE_I_ALARMS_MANAGEMENT);

            try
            {
                if (controller.getDeviceInformation().type == M_ControllerInformation.TYPE_DYNAMIC)
                {
                    writeTable(controllerWrite, 0x00, controllerConfiguration, null, M_Table.M_TABLE_DYNAMIC_LAMPS);
                    writeTable(controllerWrite, 0x00, controllerConfiguration, null, M_Table.M_TABLE_DYNAMIC_DETECTORS);
                    writeTable(controllerWrite, 0x00, controllerConfiguration, null, M_Table.M_TABLE_DYNAMIC_GENERAL_PARAMETERS);
                    writeTable(controllerWrite, 0x00, controllerConfiguration, null, M_Table.M_TABLE_DYNAMIC_BUTTON_GUARD);
                    writeTable(controllerWrite, 0x00, controllerConfiguration, null, M_Table.M_TABLE_DYNAMIC_ALARMS_CONFIGURATION);
                }
            }
            catch (Exception e)
            {
                
            }

            int number = 0;
            for (M_SubcontrollerConfiguration subcontrollerConfiguration : controllerConfiguration.lsubcontroller)
            {
                writeTable(controllerWrite, subcontrollerConfiguration.number, controllerConfiguration, subcontrollerConfiguration, M_Table.M_TABLE_A_PHASES_STABLES);
                writeTable(controllerWrite, subcontrollerConfiguration.number, controllerConfiguration, subcontrollerConfiguration, M_Table.M_TABLE_B_PHASES_TRANSITIONS);
                writeTable(controllerWrite, subcontrollerConfiguration.number, controllerConfiguration, subcontrollerConfiguration, M_Table.M_TABLE_C_TRANSITIONS);
                writeTable(controllerWrite, subcontrollerConfiguration.number, controllerConfiguration, subcontrollerConfiguration, M_Table.M_TABLE_D_STRUCTURES);
                writeTable(controllerWrite, subcontrollerConfiguration.number, controllerConfiguration, subcontrollerConfiguration, M_Table.M_TABLE_E_ACTION_ON_DEMAND);
                writeTable(controllerWrite, subcontrollerConfiguration.number, controllerConfiguration, subcontrollerConfiguration, M_Table.M_TABLE_F_TRANSITIONS_TO_TIMES);
                writeTable(controllerWrite, subcontrollerConfiguration.number, controllerConfiguration, subcontrollerConfiguration, M_Table.M_TABLE_G_TRANSITIONS_TIMES);
                writeTable(controllerWrite, subcontrollerConfiguration.number, controllerConfiguration, subcontrollerConfiguration, M_Table.M_TABLE_H_MINIMUM_EXTENSION_TIMES);
                writeTable(controllerWrite, subcontrollerConfiguration.number, controllerConfiguration, subcontrollerConfiguration, M_Table.M_TABLE_I_PLANS);
                writeTable(controllerWrite, subcontrollerConfiguration.number, controllerConfiguration, subcontrollerConfiguration, M_Table.M_TABLE_J_EMERGENCY);
                writeTable(controllerWrite, subcontrollerConfiguration.number, controllerConfiguration, subcontrollerConfiguration, M_Table.M_TABLE_K_STARTUP);
                writeTable(controllerWrite, subcontrollerConfiguration.number, controllerConfiguration, subcontrollerConfiguration, M_Table.M_TABLE_L_CONFLICTIVE_TRANSITIONS);
                writeTable(controllerWrite, subcontrollerConfiguration.number, controllerConfiguration, subcontrollerConfiguration, M_Table.M_TABLE_M_TIMETABLE);
                writeTable(controllerWrite, subcontrollerConfiguration.number, controllerConfiguration, subcontrollerConfiguration, M_Table.M_TABLE_N_SPARE_TIMES);
                number = subcontrollerConfiguration.number;
            }

            if (number > 0)
            {
                number++;
                for (int i=number; i<=4; i++)
                {
                    writeEmptyTable(controllerWrite, i, M_Table.M_TABLE_A_PHASES_STABLES);
                    writeEmptyTable(controllerWrite, i, M_Table.M_TABLE_B_PHASES_TRANSITIONS);
                    writeEmptyTable(controllerWrite, i, M_Table.M_TABLE_C_TRANSITIONS);
                    writeEmptyTable(controllerWrite, i, M_Table.M_TABLE_D_STRUCTURES);
                    writeEmptyTable(controllerWrite, i, M_Table.M_TABLE_E_ACTION_ON_DEMAND);
                    writeEmptyTable(controllerWrite, i, M_Table.M_TABLE_F_TRANSITIONS_TO_TIMES);
                    writeEmptyTable(controllerWrite, i, M_Table.M_TABLE_G_TRANSITIONS_TIMES);
                    writeEmptyTable(controllerWrite, i, M_Table.M_TABLE_H_MINIMUM_EXTENSION_TIMES);
                    writeEmptyTable(controllerWrite, i, M_Table.M_TABLE_I_PLANS);
                    writeEmptyTable(controllerWrite, i, M_Table.M_TABLE_J_EMERGENCY);
                    writeEmptyTable(controllerWrite, i, M_Table.M_TABLE_K_STARTUP);
                    writeEmptyTable(controllerWrite, i, M_Table.M_TABLE_L_CONFLICTIVE_TRANSITIONS);
                    writeEmptyTable(controllerWrite, i, M_Table.M_TABLE_M_TIMETABLE);
                    writeEmptyTable(controllerWrite, i, M_Table.M_TABLE_N_SPARE_TIMES);
                }
            }

        }
        catch (Exception e)
        {
            throw e;
        }
        finally
        {
            endRecordingTables(controllerWrite, controllerConfiguration);
            try{controllerWrite.disconnect();} catch (Exception e){};
        }
    }
    

    public void writeTable(ControllerConnection controllerWrite, int controller, M_ControllerConfiguration controllerConfiguration, M_SubcontrollerConfiguration subcontrollerConfiguration, int tableCode) throws ServerException, Exception
    {
        List<Byte> lTableContent = null;
        if (subcontrollerConfiguration == null)
            lTableContent = M_ControllerWriter.getTableController(controllerConfiguration, tableCode);
        else
            lTableContent = M_ControllerWriter.getTableSubcontroller(controllerConfiguration, subcontrollerConfiguration, tableCode);

        if (lTableContent.size() <= 0) return;

        M_Message message = M_ProtocolConstructor.writeTableMessage(controller, lTableContent, hasCRC);
        // M_Message response = controllerWrite.read(command);
        M_Request request = new M_Request();
        request.controller = this;
        request.request = message;

        this.getControllerConnection().addM_Request(request);
        request.waitResponse(this.controller.getDeviceInformation().timeout);
        M_Message response = request.response;

        boolean salir = false;
        int retries = 0;
        while ((salir == false) && (retries < MAX_RETRIES))
        {
            if (M_ProtocolAnalyser.isACKMessage(response) == true)
            {
                return;
            }
            else if (M_ProtocolAnalyser.isNACKMessage(response) == true)
            {
                throw new Exception(Shared.getMessage("Error sending table %1 (nack)").replaceAll("%1", "" + tableCode));
            }

            // response = controllerWrite.receive();
            request = new M_Request();
            request.controller = this;
            request.request = message;

            this.getControllerConnection().addM_Request(request);
            request.waitResponse(this.controller.getDeviceInformation().timeout);
            response = request.response;
            retries++;
        }
    }
    

    public void writeEmptyTable(ControllerConnection controllerWrite, int controller, int tableCode) throws ServerException, Exception
    {
        List<Byte> lTableContent = new ArrayList<Byte>();
        M_TableWriter writer = new M_TableWriter();
        writer.STX();
        writer.write(controller);
        writer.write(tableCode);
        writer.EOB12();
        writer.ETX();
        byte[] content = writer.toByteArray();
        for (int i=0; i<content.length; i++)
            lTableContent.add(new Byte(content[i]));

        M_Message message = M_ProtocolConstructor.writeTableMessage(controller, lTableContent, hasCRC);
        // M_Message response = controllerWrite.read(command);
        M_Request request = new M_Request();
        request.controller = this;
        request.request = message;

        this.getControllerConnection().addM_Request(request);
        request.waitResponse(this.controller.getDeviceInformation().timeout);
        M_Message response = request.response;

        boolean salir = false;
        int retries = 0;
        while ((salir == false) && (retries < MAX_RETRIES))
        {
            if (M_ProtocolAnalyser.isACKMessage(response) == true)
            {
                return;
            }
            else if (M_ProtocolAnalyser.isNACKMessage(response) == true)
            {
                throw new Exception(Shared.getMessage("Error sending table %1 (nack)").replaceAll("%1", "" + tableCode));
            }

            // response = controllerWrite.receive();
            request = new M_Request();
            request.controller = this;
            request.request = message;

            this.getControllerConnection().addM_Request(request);
            request.waitResponse(this.controller.getDeviceInformation().timeout);
            response = request.response;
            retries++;
        }

        throw new Exception(Shared.getMessage("Error sending table %1 (invalid)").replaceAll("%1", "" + tableCode));
    }


    protected void startRecordingTables(ControllerConnection controllerWrite, M_ControllerConfiguration controllerConfiguration) throws ServerException, Exception
    {
        M_Message message = M_ProtocolConstructor.startRecordingTablesMessage(0x00, controllerConfiguration.propietary.configurationCode, controllerConfiguration.propietary.controllerNumber, hasCRC);
        // M_Message response = controllerWrite.read(command);
        M_Request request = new M_Request();
        request.controller = this;
        request.request = message;

        this.getControllerConnection().addM_Request(request);
        request.waitResponse(this.controller.getDeviceInformation().timeout);
        M_Message response = request.response;

        boolean salir = false;
        int retries = 0;
        while ((salir == false) && (retries < MAX_RETRIES))
        {
            if (M_ProtocolAnalyser.isStartRecordingResponse(response) == true)
            {
                return;
            }
            else if (M_ProtocolAnalyser.isNACKMessage(response) == true)
            {
                throw new Exception(Shared.getMessage("Error starting recording (nack)"));
            }

            // response = controllerWrite.receive();
            request = new M_Request();
            request.controller = this;
            request.request = message;

            this.getControllerConnection().addM_Request(request);
            request.waitResponse(this.controller.getDeviceInformation().timeout);
            response = request.response;
            retries++;
        }

        throw new Exception(Shared.getMessage("Error starting recording (invalid)"));
    }


    protected void endRecordingTables(ControllerConnection controllerWrite, M_ControllerConfiguration controllerConfiguration) throws ServerException, Exception
    {
        M_Message message = M_ProtocolConstructor.endRecordingTablesMessage(0x00, hasCRC);
        controllerWrite.setTimeout(60000);
        // M_Message response = controllerWrite.read(command);
        M_Request request = new M_Request();
        request.controller = this;
        request.request = message;

        this.getControllerConnection().addM_Request(request);
        request.waitResponse(this.controller.getDeviceInformation().timeout);
        M_Message response = request.response;

        boolean salir = false;
        int retries = 0;
        while ((salir == false) && (retries < MAX_RETRIES))
        {
            if (M_ProtocolAnalyser.isEndRecordingResponse(response) == true)
            {
                M_ProtocolAnalyser.analyseEndRecordingResponse(response);
                return;
            }
            else if (M_ProtocolAnalyser.isNACKMessage(response) == true)
            {
                throw new Exception(Shared.getMessage("End recording response is NACK"));
            }

            // response = controllerWrite.receive();
            request = new M_Request();
            request.controller = this;
            request.request = message;

            this.getControllerConnection().addM_Request(request);
            request.waitResponse(this.controller.getDeviceInformation().timeout);
            response = request.response;
            retries++;
        }
    }

    // </editor-fold>  


    public M_ControllerRealtimeCountingDetector[][] getTrafficDataPeriod(long from, long to) throws ServerException, Exception
    {
        // TODO in all controllers of the different controller types (Dynamic, Rtac, Telvent, etc)

        throw new ServerException ("Not supported");
    }


    private void removeSubcontrollerUpdate(M_Controller controllerclone, int subcontroller)
    {
        try
        {
            M_ControllerStatusSubcontroller subcontroller1 = controllerclone.getDeviceStatus().getStatusSubcontroller(subcontroller);

            for (M_ControllerStatusSubcontroller subcontroller2 : controllerclone.getDeviceStatus().lsubcontrollerUpdate)
            {
                if (subcontroller2.number == subcontroller1.number)
                {
                    if (Serialization.equals(subcontroller1, subcontroller2) == true)
                    {
                        controllerclone.getDeviceStatus().lsubcontrollerUpdate.remove(subcontroller2);
                        return;
                    }
                }
            }
        }
        catch (Exception e)
        {
        }
    }


    private boolean stateSubcontrollerDifferent(M_ControllerStatusSubcontroller currentStatus, M_ControllerStatusSubcontroller updateStatus)
    {
        try
        {
            if ((updateStatus.adaptativeDetectors != M_ControllerStatusSubcontroller.UNKNOWN) && (updateStatus.adaptativeDetectors != currentStatus.adaptativeDetectors))
                return(true);
            if ((updateStatus.centralizedMode != M_ControllerStatusSubcontroller.UNKNOWN) && (updateStatus.centralizedMode != currentStatus.centralizedMode))
                return(true);
            if ((updateStatus.colorsMode != M_ControllerStatusSubcontroller.UNKNOWN) && (updateStatus.colorsMode != currentStatus.colorsMode))
                return(true);
            if ((updateStatus.controlComputerDirectGroups != M_ControllerStatusSubcontroller.UNKNOWN) && (updateStatus.controlComputerDirectGroups != currentStatus.controlComputerDirectGroups))
                return(true);
            if ((updateStatus.coordinationMode != M_ControllerStatusSubcontroller.UNKNOWN) && (updateStatus.coordinationMode != currentStatus.coordinationMode) &&
                (currentStatus.planSelection != M_ControllerStatusSubcontroller.PLANSELECTION_TIMETABLE) &&
                (updateStatus.planSelection != M_ControllerStatusSubcontroller.PLANSELECTION_TIMETABLE))
                return(true);
            if ((updateStatus.emergency != M_ControllerStatusSubcontroller.UNKNOWN) && (updateStatus.emergency != currentStatus.emergency))
                return(true);
//            if ((updateStatus.manualControl != M_ControllerStatusSubcontroller.UNKNOWN) && (updateStatus.manualControl != currentStatus.manualControl))
//                return(true);
            if ((updateStatus.operationMode != M_ControllerStatusSubcontroller.UNKNOWN) && (updateStatus.operationMode != currentStatus.operationMode))
                return(true);
            if ((updateStatus.planSelection != M_ControllerStatusSubcontroller.UNKNOWN) && (updateStatus.planSelection != currentStatus.planSelection))
                return(true);
        }
        catch (Exception exception)
        {
        }

        return(false);
    }




    public ControllerConnection getControllerConnection()
    {
        return(Shared.getControllerConnection(controller.getDeviceInformation().address + ":" + controller.getDeviceInformation().portM));
    }



    private M_Message generateExampleResponse(int subcontroller, Calendar calendarStart, Calendar calendarEnd, boolean hasCRC)
    {
        M_Message response = new M_Message();

        try
        {
            Calendar calendar = Calendar.getInstance();
            calendar.setTimeInMillis(calendarStart.getTimeInMillis());

            M_ProtocolWriter writer = new M_ProtocolWriter();

            writer.STX();
            writer.write(subcontroller);
            writer.write(writer.M_BUS_DETECTIONS_QUERY);
            int numDemands = 10;
            for (int i=0; i<numDemands; i++)
            {
                int line = i+1;
                int trackAngle = (i+1)*5;
                int vehicle = (i+2)*5;
                int delay = (i+3)*5;
                writer.write(line);
                writer.write((trackAngle >> 7) & 0x7F);
                writer.write(trackAngle & 0x7F);
                writer.write((vehicle >> 7) & 0x7F);
                writer.write(vehicle & 0x7F);
                writer.write((delay >> 7) & 0x7F);
                writer.write(delay & 0x7F);

                // Start
                {
                    writer.write(calendar.get(Calendar.DATE));
                    writer.write(calendar.get(Calendar.MONTH) + 1);
                    writer.write(calendar.get(Calendar.YEAR) - 2000);
                    writer.write(calendar.get(Calendar.HOUR_OF_DAY));
                    writer.write(calendar.get(Calendar.MINUTE));
                    writer.write(calendar.get(Calendar.SECOND));
                }

                long millis = (i+1)*60000L;
                calendar.setTimeInMillis(calendar.getTimeInMillis() + millis);

                // End
                {
                    writer.write(calendar.get(Calendar.DATE));
                    writer.write(calendar.get(Calendar.MONTH) + 1);
                    writer.write(calendar.get(Calendar.YEAR) - 2000);
                    writer.write(calendar.get(Calendar.HOUR_OF_DAY));
                    writer.write(calendar.get(Calendar.MINUTE));
                    writer.write(calendar.get(Calendar.SECOND));
                }

                boolean granted = ((i%2) == 0);
                if (granted == true)
                {
                    writer.write(0x01);
                    writer.write(0x00);
                }
                else
                {
                    writer.write(0x00);
                    int reason = (i % 5);
                    reason = (int)Math.pow(2, reason);
                    writer.write(reason);
                }

                if (i < (numDemands-1))
                    writer.EOB14();
            }

            writer.EOB12();
            writer.ETX(hasCRC);

            response = writer.createMessage(subcontroller);
        }
        catch (Exception exception)
        {
        }

        return(response);
    }




    public class ControllerTrafficData extends Controller
    {
        
        public void run ()
        {
            boolean second0Found = false;
            boolean query = false;

            while (exit == false)
            {
                try
                {
                    Calendar calendar = Calendar.getInstance();
                    calendar.setTimeInMillis(System.currentTimeMillis());
                    if ((calendar.get(Calendar.SECOND) == 0) || (query == true))
                    {
                        if (second0Found == false)
                        {
                            second0Found = true;
                            query = true;

                            if (controller.getDeviceConfiguration().lstrategicalDetector.size() > 0)
                            {
                                // d - 1 min (Detectores contaje)
                                getCurrentCountingDetectors(controller);
                                query = false;
                            }
                        }
                    }
                    else
                    {
                        second0Found = false;
                    }
                }
                catch (Exception e)
                {
                    
                }

                try{sleep(100);} catch (Exception e){};
            }
        }
    }

}