This post explains how to send and receive messages from a System Message Pump. There is a previous post showing how to create a System Message Pump that you can access here. Please look over that post first as this one uses code from and references that post. 

After creating a Message Pump program from the previous System Message Pump sample, the next step is to create and receive messages between two different programs. To start, we can create a new program that will interact with the previous System Message Pump program. We’ll call this program our PostMessage program. This sample program only has two messages it can send, but could be edited to add more. These messages will also only pulse output relays but can be edited to do a lot of other actions as well.

import com.integpg.system.JANOS;
import com.integpg.system.SystemMsg;
import com.integpg.system.MessagePump;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Json;

public class CommunicationPost2 {

    //This funciton decides from the user input it gets whether or not the program should post another message or close the program.
    //The only message you can create is message 1300
    public static int getresponse(MessagePump closesPump) throws IOException {

        String type = "";
        BufferedReader reading = new BufferedReader(new InputStreamReader(System.in));
        int testtype = 0;
        boolean running = true;
        boolean typecheck = false;

        while (running == true) {

            System.out.println("\nPlease enter a System Pump command. Type 'create' to make a command. Type 'finished' when done.\n");
            String choice = reading.readLine();
            System.out.println("|" + choice + "|");

            switch (choice) {

                case "finished":
                    System.out.println("Finishing program...\n");
                    System.out.println();
                    closesPump.close();
                    System.out.println();
                    System.exit(0);

                case "create":
                    System.out.println();
                    System.out.println("\nPlease enter the type number\n");
                    System.out.println();
                    while (typecheck == false) {
                            type = reading.readLine();
                            try{
                            testtype = Integer.parseInt(type);
                            typecheck = true;
                            }
                            catch (NumberFormatException e) {
                                System.out.println("\nIncorrect input. Try again\n");
                            }
                    }
                    return testtype;

                default:
                    System.out.println("\nBad input. Try again.\n");
            }
        }
        return testtype;
    }

    //adds a value to the Json object that we be sent as part of the message to the other program
    public static Json addToJson(Json gettingJson, String value, Object jsonvalue) {

        gettingJson.put(value, jsonvalue);
        return gettingJson;

    }

    //creates the message that will be sent to the other program to complete
    public static SystemMsg createMessage(int messagetype, byte[] messageinfo) {

        SystemMsg newMsg = new SystemMsg();
        newMsg.type = messagetype;
        newMsg.msg = messageinfo;
        System.out.println(newMsg);
        return newMsg;

    }

    //completes the message 1301 if it was sent from the other program
    public static void completeMessage1301(String recievedJsonInfo) {

        Json holdinginfo = new Json(recievedJsonInfo);
        String[] arrayofkeys = holdinginfo.keyarray();
        int togglecheck = holdinginfo.getInt(arrayofkeys[0]);
        int channelscheck = holdinginfo.getInt(arrayofkeys[1]);
        int durationcheck = holdinginfo.getInt(arrayofkeys[2]);
        System.out.println(arrayofkeys[0] + ": " + togglecheck + ", " + arrayofkeys[1] + ": " + channelscheck + ", " + arrayofkeys[2] + ": " + durationcheck);
        try {
            JANOS.setOutputPulsed(togglecheck, channelscheck, durationcheck);
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }

    public static Json getInfoToJson() throws IOException {

        Json newJson = new Json();
        String tempduration = "";
        String tempchannels = "";
        String temp_O_or_C = "";
        boolean successcheck1 = false;
        boolean successcheck2 = false;
        boolean successcheck3 = false;
        BufferedReader reading = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("\nThis is for toggling pulse outputs.\n");
        System.out.println("\nPlease enter if which channels you are pulsing: ' 1 - 255'\n");

        while (successcheck1 == false) {
            try {
                temp_O_or_C = reading.readLine();
                successcheck1 = true;
            } catch (IOException | NumberFormatException e) {
                System.out.println("\nIncorrect format, try again.\n");
            }
            if (successcheck1 == true) {
                int O_or_C = Integer.parseInt(temp_O_or_C);
                newJson = addToJson(newJson, "Pulse", O_or_C);
            }
        }

        System.out.println("\nPlease enter what channels: '1 - 255'\n");
        while (successcheck2 == false) {
            try {
                tempchannels = reading.readLine();
                successcheck2 = true;
            } catch (IOException | NumberFormatException e) {
                System.out.println("\nIncorrect format, try again.\n");

            }
            if (successcheck2 == true) {
                int channels = Integer.parseInt(tempchannels);
                newJson = addToJson(newJson, "Channels", channels);
            }
        }

        System.out.println("\nPlease enter duration in milliseconds:\n");
        while (successcheck3 == false) {
            try {
                tempduration = reading.readLine();
                successcheck3 = true;
            } catch (IOException | NumberFormatException e) {
                System.out.println("\nIncorrect format, try again.\n");
            }
            if (successcheck3 == true) {
                int duration = Integer.parseInt(tempduration);
                newJson = addToJson(newJson, "Duration", duration);
            }
        }

        return newJson;

    }

    public static void main(String[] args) throws IOException, InterruptedException {

        MessagePump MESSAGE_PUMP = new MessagePump();

        MESSAGE_PUMP.open();

        while (true) {

            boolean checkmsg = false;

            int fixedtype = getresponse(MESSAGE_PUMP);

            if (fixedtype == 1300) {

                Json firstJson = getInfoToJson();
                SystemMsg systemMsg = createMessage(fixedtype, firstJson.toString().getBytes());
                MESSAGE_PUMP.postMessage(systemMsg);
                System.out.println();
            }

            while (checkmsg == false) {

                SystemMsg msgRecieved = MESSAGE_PUMP.getMessage(1301);

                if (msgRecieved.type == 1301) {
                    System.out.println("Message 1301 recieved, pulsing output 1.");
                    String jsoninfo2 = new String(msgRecieved.msg);
                    completeMessage1301(jsoninfo2);
                    checkmsg = true;
                }

            }

        }

    }

}

This PostMessage program will create a message that, after getting inputs from the user, will be sent to the previously created System Message Pump program. The program starts by asking the user if they wish to create a message or close the program, then calling the “getresponse” function to initiate whichever the user chooses.

    public static int getresponse(MessagePump closesPump) throws IOException {

        String type = "";
        BufferedReader reading = new BufferedReader(new InputStreamReader(System.in));
        int testtype = 0;
        boolean running = true;
        boolean typecheck = false;

        while (running == true) {

            System.out.println("\nPlease enter a System Pump command. Type 'create' to make a command. Type 'finished' when done.\n");
            String choice = reading.readLine();
            System.out.println("|" + choice + "|");

            switch (choice) {

                case "finished":
                    System.out.println("Finishing program...\n");
                    System.out.println();
                    closesPump.close();
                    System.out.println();
                    System.exit(0);

                case "create":
                    System.out.println();
                    System.out.println("\nPlease enter the type number\n");
                    System.out.println();
                    while (typecheck == false) {
                            type = reading.readLine();
                            try{
                            testtype = Integer.parseInt(type);
                            typecheck = true;
                            }
                            catch (NumberFormatException e) {
                                System.out.println("\nIncorrect input. Try again\n");
                            }
                    }
                    return testtype;

                default:
                    System.out.println("\nBad input. Try again.\n");
            }
        }
        return testtype;
    }

If the user decides to create a message, it will call a function called “getInfoToJson”. This will gather information to form a Json object. The first two values are from 1 – 255 to represent the 8 outputs in bit values, and the last value is time in milliseconds. The “getInfoToJson” function will call the “addToJson” function to create the Json object “getInfoToJson” will return. 

public static Json getInfoToJson() throws IOException {

        Json newJson = new Json();
        String tempduration = "";
        String tempchannels = "";
        String temp_O_or_C = "";
        boolean successcheck1 = false;
        boolean successcheck2 = false;
        boolean successcheck3 = false;
        BufferedReader reading = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("\nThis is for toggling pulse outputs.\n");
        System.out.println("\nPlease enter if which channels you are pulsing: ' 1 - 255'\n");

        while (successcheck1 == false) {
            try {
                temp_O_or_C = reading.readLine();
                successcheck1 = true;
            } catch (IOException | NumberFormatException e) {
                System.out.println("\nIncorrect format, try again.\n");
            }
            if (successcheck1 == true) {
                int O_or_C = Integer.parseInt(temp_O_or_C);
                newJson = addToJson(newJson, "Pulse", O_or_C);
            }
        }

        System.out.println("\nPlease enter what channels: '1 - 255'\n");
        while (successcheck2 == false) {
            try {
                tempchannels = reading.readLine();
                successcheck2 = true;
            } catch (IOException | NumberFormatException e) {
                System.out.println("\nIncorrect format, try again.\n");

            }
            if (successcheck2 == true) {
                int channels = Integer.parseInt(tempchannels);
                newJson = addToJson(newJson, "Channels", channels);
            }
        }

        System.out.println("\nPlease enter duration in milliseconds:\n");
        while (successcheck3 == false) {
            try {
                tempduration = reading.readLine();
                successcheck3 = true;
            } catch (IOException | NumberFormatException e) {
                System.out.println("\nIncorrect format, try again.\n");
            }
            if (successcheck3 == true) {
                int duration = Integer.parseInt(tempduration);
                newJson = addToJson(newJson, "Duration", duration);
            }
        }

        return newJson;

    }

Then it will call the “createMessage” function to get the ID and information of the message that we are going to send.

public static SystemMsg createMessage(int messagetype, byte[] messageinfo) {

        SystemMsg newMsg = new SystemMsg();
        newMsg.type = messagetype;
        newMsg.msg = messageinfo;
        System.out.println(newMsg);
        return newMsg;

    }

After this message is sent, it will be received from an edited version of the System Message Pump program and then send a certain message. The code for the edited Engine Pump file of the System Message Pump program is below.

import com.integpg.system.JANOS;
import com.integpg.system.MessagePump;
import com.integpg.system.SystemMsg;
import java.io.IOException;
import java.util.Json;
import java.util.Vector;

public class MessagePumpEngine implements Runnable {

    private static final MessagePumpEngine THIS = new MessagePumpEngine();
    private static final MessagePump MESSAGE_PUMP = new MessagePump();
    private static final Vector LISTENERS = new Vector<>();

    private static Thread _thread;

    /**
     * Singleton constructor
     */
    private MessagePumpEngine() {
    }

    /**
     * adds a listener that will be alerted of all received messages. The
     * listener will be responsible for determining if the message has meaning
     * to them
     *
     * @param listener
     */
    public static void addListener(MessagePumpListener listener) {
        synchronized (LISTENERS) {
            LISTENERS.addElement(listener);
        }
    }

    /**
     * starts our message pump engine.
     */
    static void start() {
        if (null == _thread) {
            _thread = new Thread(THIS);
            _thread.setName("message-pump-engine");
            _thread.setDaemon(true);
            _thread.start();
        }
    }
    
    //completes the message 1300 after being sent from the other application
    
    public static void completeMessage1300 (String recievedJsonInfo) {
        
        Json holdinginfo = new Json(recievedJsonInfo);
        String[] arrayofkeys = holdinginfo.keyarray();
        int togglecheck = holdinginfo.getInt(arrayofkeys[0]);
        int channelscheck = holdinginfo.getInt(arrayofkeys[1]);
        int durationcheck = holdinginfo.getInt(arrayofkeys[2]);
        System.out.println(arrayofkeys[0] + ": " + togglecheck + ", " + arrayofkeys[1] + ": " + channelscheck + ", " + arrayofkeys[2] + ": " + durationcheck);
        try {
            JANOS.setOutputPulsed(togglecheck, channelscheck, durationcheck);
        } 
        catch (IOException ex) {
            ex.printStackTrace();
        }
    }
    
    //creates the message that will be sent to the other program to complete
    
    public static SystemMsg createMessage (int messageType, byte [] messageInfo) {
        
        SystemMsg returnMsg = new SystemMsg();
        returnMsg.type = messageType;
        returnMsg.msg = messageInfo;
        
        System.out.println(returnMsg);
        return returnMsg;
        
    }
    
    //adds a value to the Json object that we be sent as part of the message to the other program
    
    public static Json addToJson(Json Jsonadd, String valuename, Object jsonvalue) {
    
        Jsonadd.put(valuename, jsonvalue);
        return Jsonadd;
        
    }
    
    @Override
    public void run() {
        System.out.println("open the message pump and start monitoring.\r\n");
        MESSAGE_PUMP.open();

        for (;;) {
            // read all messages from the message pump
            SystemMsg systemMsg = MESSAGE_PUMP.getMessage();

            // we must repost as fast as we can
            MESSAGE_PUMP.postMessage(systemMsg);

            // notify all of our listeners

            if (systemMsg.type == 1300) {

                System.out.println();
                System.out.println("Recieved command 1300, pulsing output. Sending another command.\n");
                String jsoninfo = new String(systemMsg.msg);
                completeMessage1300(jsoninfo);
                Json thirdjson = new Json();
                addToJson(thirdjson, "setclose", 1); 
                addToJson(thirdjson, "settingchannel", 1);
                addToJson(thirdjson, "timeset", 5000);
                SystemMsg returnMsg = createMessage(1301, thirdjson.toString().getBytes());
                MESSAGE_PUMP.postMessage(returnMsg);                

            }

        }

    }

    /**
     * Exposes the postMesssage method of the System MessagePump
     *
     * @param msg the message the will be sent to the system message pump
     */
    public static void postMessage(SystemMsg msg) {
        MESSAGE_PUMP.postMessage(msg);
    }

}

When this file of code replaces the engine pump file in the System Message Pump program, there is a loop that will be listening for the message sent from our previous program with the message type of 1300. After it receives that message, it will create a string from all of the message’s info, and then call the “completeMessage1301” function to pulse the correct outputs. Once the program does that, it will then use the “createMessage” function to create another message for the PostMessage program to read. There is another loop for the listeners to read that message when its sent as well.

public void run() {
        System.out.println("open the message pump and start monitoring.\r\n");
        MESSAGE_PUMP.open();

        for (;;) {
            // read all messages from the message pump
            SystemMsg systemMsg = MESSAGE_PUMP.getMessage();

            // we must repost as fast as we can
            MESSAGE_PUMP.postMessage(systemMsg);
            

            if (systemMsg.type == 1300) {

                System.out.println();
                System.out.println("Recieved command 1300, pulsing output. Sending another command.\n");
                String jsoninfo = new String(systemMsg.msg);
                completeMessage1300(jsoninfo);
                Json thirdjson = new Json();
                addToJson(thirdjson, "setclose", 1); 
                addToJson(thirdjson, "settingchannel", 1);
                addToJson(thirdjson, "timeset", 5000);
                SystemMsg returnMsg = createMessage(1301, thirdjson.toString().getBytes());
                MESSAGE_PUMP.postMessage(returnMsg);

                    }
                }

            }

        }

    }

This will have us go back to the PostMessage program to receive the message the Engine Pump file sent back. The PostMessage program calls the completeMessage1301 function to grab the values from the message and pulse the correct outputs. After that, the program will loop back to the beginning and re-prompt the user if they want to create or finish the program, and repeat this process until the user decides to finish the program.

 while (checkmsg == false) {

                SystemMsg msgRecieved = MESSAGE_PUMP.getMessage(1301);

                if (msgRecieved.type == 1301) {
                    System.out.println("Message 1301 recieved, pulsing output 1.");
                    String jsoninfo2 = new String(msgRecieved.msg);
                    completeMessage1301(jsoninfo2);
                    checkmsg = true;
                }

            }

There has been an update to the Update Project for OS 4.8.

Name Version Release Date Size MD5
Series 3 All-In-One v4.8 Nov 11 2019 251.7 KB ef6a2613188b70725b155c9c026064b3

Browsers no longer support Java Applets.  Therefore, the web files have been removed from the JNIOR in this update. This fixes flash space issues. The applets can still be loaded from within the JNIOR Support Tool.  To load the Applets, right click on the JNIOR  in the Beacon Tab.  Then go to Tools -> Open Classic Monitor, Configure, Control Application.

Creating the Libraries

Code examples for the JNIOR use a library that makes creating applications far easier on the JNIOR. To get started first download the SDK file containing the libraries below.

Name Version Release Date Size MD5
Embedded JNIOR SDK v1.0 Nov 08 2019 1.6 MB 75233695d8010ef8bea3a791c76d43be

Once this file is downloaded, you’ll want to extract the files to a folder you create.  Make sure you remember the file location, as we’ll be using it later. You can get it by right clicking the location bar at the top when in the file explorer.

Once you’ve extracted the SDK, you’ll then want to setup the library in your IDE. INTEG creates applications for the JNIOR through NetBeans, so how to setup the library will be explained in NetBeans. In NetBeans, you’ll want to create the library by going to Tools -> Libraries. This will open the Ant Library Manager Dialog Box.

Library option for JNIOR in netbeans

You’ll then want to create two new libraries by selecting the New Library button at the bottom left of the dialog box. This will prompt the New Library Dialog Box which will ask you what you want to name the library and what type it is. When naming, name the library with the _Common.jar file as INTEG.Common and the Janos_Runtime1.8.jar file as JanosLibrary. Once you finish leave the type as it is and click OK. Then you will need to add the _Common.jar file from the SDK file you extracted previously to the library you create which will now be on the left. You can then repeat this process for the Janos_Runtime1.8.jar file.

Adding The Library To A Project

Now that the libraries are created, we’ll want to add them to our project. If you haven’t created a project yet, create a java project to add a library to. Once the project is created, click on File -> Project Properties. This will open the Project Properties Dialog Box of the current project.

Project Properties for JNIOR Netbeans Project

Here we’ll want to click on the Libraries Category and click the Add Library button to add the Janos_Runtime1.8 Library and then the _Common Library we created previously.

Project Properties for JNIOR Netbeans Project

Once the libraries are added, click OK and the project should now include the libraries in them. One thing to note is that the size of the libraries are very big, and including every class in the library might take a lot of space in the JNIOR, so we are going add some code to the xml.build file to only include classes we use from the library in our project. If you want to learn more about editing the xml.build file, click here.

Adding Only The Classes Needed

In NetBeans, go over to the Projects, Services, Files tabs and select the Files tab. Inside the project’s files should be a file called xml.build. Open that file by double clicking it.

Files for JNIOR netbeans project

Once the file is open, scroll down to the bottom of the file right before the </project> tag at the files end. The first bit of code we are adding is to set the bootclasspath and reference the correct place the files are in. Take the code below and copy and paste it above the </project> tag. One change you’ll need to make to this code is where there is capitalized text, it needs to be changed to file location of the SDK file that was extracted and mentioned at the beginning of this tutorial.

<target name="-pre-init">
<!--  tell the compiler about our library 
  --> 
  <property name="javac.compilerargs" value="-bootclasspath '${libs.JanosClasses.classpath}'" /> 
<!--  set a property for the INTEG SDK 
  --> 
  <property name="janossdk.home" value="INSERT FILE PATH HERE" />  <!--  set a property for the javadepencies application 
  --> 
  <property name="janossdk.javadependencies" value="${janossdk.home}/JavaDependencies.exe" /> 
</target>

Here is where this code should be inserted for the libraries to only use classes referenced in the project. Take the code below and copy and paste it below the previous code, but not past the  </project> tag.

<target name="-pre-jar">
 <!-- 
 before we build the JAR file we need to get all of the classes out of the 
        library that our application depends on 

  --> 
  <echo>Update classes directory with library dependencies</echo> 
      <exec dir="" resolveexecutable="true" 
          executable="${janossdk.javadependencies}">
      <arg line="${build.classes.dir} '${libs.INTEG.Common.classpath}'" /> 
  </exec>
</target>

Also add the code below so the jar file that you throw into the JNIOR to run it is easier to find. It also updates the current version of the project. Copy and paste this right below the previous code you just added, but not past the </project> tag.

<target name="-post-jar">
   <!-- 
      copies the built JAR file out of the dist directory and into the root 
      of the project folder 
  --> 
  <copy file="${dist.jar}" todir="." /> 
  </target>

Now your project should be able to call pre-made classes to help you create the application you want, while not calling every class available and take up space on the JNIOR!

The JNIOR Support Tool will allow foreign characters in the filenames for macro and device files. Here is a quick video showing how to delete them.

1. Create a console session.
2. login
3. type rm mac
4. Then press tab

The JNIOR will fill in the name of the macro file.  In your case, press tab until you get the file with the offending name.

5. Then use the left arrow key to go back and insert a quote at the beginning of the file name

6. Press enter

You can then go back to the folders tab to see that the file is gone.

Repeat the same steps for the “macro file not found.log” file.

If the JNIOR series 4, models 410, 412 or 414, is not working with the GDC Cinema Server then check to make sure MODBUS is enabled. The built-in library for the JNIOR on the GDC server uses MODBUS.

MODBUS communicates on port 502.

The series 3 enabled the MODBUS server by default. The MODBUS server is an optional application that needs to be enabled on the series 4. You can look at the following links for more information

A series 3 JNIOR has a limited amount of flash memory. The update can fail because the the flash is close to being full. There are many files that are loaded on the JNIOR that are not being used.

To get this unit to succeed we will remove files from the flash filesystem. Since the JAVA Applets can no longer be loaded in a browser. This article, https://www.theverge.com/2016/1/28/10858250/oracle-java-plugin-deprecation-jdk-9, explains why browsers stopped supporting the JAVA Applet technology.

Since the Applets can no longer be loaded in a browser there is no reason to keep them in flash so that the web server has access to them. You can safely remove the flash/www contents. You can use the latest Series 3 All-In-One to accomplish this.

Once files have been removed, reboot the JNIOR. Once the JNIOR has booted, try the update project again. If the flash filesystem space was the issue then the update should now work!

Run Linux or Mac?

The JNIOR Support Tool has always been a Windows application. There have been ways to get the Support Tool to run on a Mac but I am not sure anyone has been successful on a Linux box.

Well work has begun to supply the features of the Support Tool in a cross-platform Java application. The thought will be to implement the Beacon and Snapshot functionality first and then the Update tab.

JNIOR Supporter Application

This project is in its infancy. Please let us know if we should continue working on it and prioritze it.

The iBoot device from dataprobe is a Web Enabled Power Switch. We can command the devices by issuing HTTP Requests. To do this we will add an iBoot device to the Devices file and add “Power On” and “Power Off” actions to the Macro file. We then associate the actions with macros. We might want separate macros for power on, power off and power cycle.

To create the iBoot device in the devices file go to the Devices tab in the JNIOR Support Tool. Then in the lower left click ‘Add’. Then fill out the information as follows. This device can be added to an existing devices file or a new one. We are going to use the HTTP Request device type.

Then click over to the Macro tab and click on Link Devices. This will link the devices file so that the configured devices are available to create macro actions.

Now click ‘Add’ below the Macro Action View. You can rename the action. Click in the Device column for the new Action and scroll to the bottom to select your linked device. Select the iBoot device. Now click on Action and select “GET”. In the data field enter the resource portion of the URL””. It should look like this… Remember to enter the username and password if needed.

You can now add the action to any macro by selecting both the macro you wish to add it to and the new iBoot action.s Then use the <- button between the two views like this…

We can command the Nagra myCinema player to start playing its content. To do this we will add a myCinema device to the Devices file and a “Play” action to the Macro file. We then associate the “Play” Action with a macro. It’s that easy!

To create the myCinema device in the devices file go to the Devices tab in the JNIOR Support Tool. Then in the lower left click ‘Add’. Then fill out the information as follows. This device can be added to an existing devices file or a new one. We are going to use a RAW ETHERNET device so that we can send any command we want. The command is a simple text string.

Then click over to the Macro tab and click on Link Devices. This will link the devices file so that the configured devices are available to create macro actions. Now click ‘Add’ below the Macro Action View. You can rename the action. Click in the Device column for the new Action and scroll to the bottom to select your linked device. Select the myCinema device. Now click on Action and select Send. In the data field enter “play”. It should look like this…

You can now add the action to any macro by selecting both the macro you wish to add it to and the new myCinema action. Then use the <- button between the two views like this…

The Cinema application for the JNIOR enhances the JNIOR capabilities. While the JNIOR can be used in its most basic form, the Cinema application provides the ability to execute macros, sequence of actions.

The Cinema application does not ship preinstalled. You MUST obtain the application from our website. There is a download on the website that will be opened in the JNIOR Support Tool and published to the JNIOR. This is called an Update Project.

Here are links to latest versions of the JNIOR Support Tool and the Cinema application.

NOTE: This link for the Cinema Update Project is Cinema.jar, if you are using a Series 3 JNIOR you need Cinema.jnior instead. This can be retrieved from the legacy section of our downloads on our site.

Name Version Release Date Size MD5
JNIOR Support Tool v7.15 Nov 20 2023 10.5 MB 688524ba37066aab6e327a79f0cfb0b5
Cinema.jar - Update Project v6.9 Jan 03 2024 545.1 KB 0a2c670e461116768b75288e652c5253

After installing both the JNIOR Support Tool and the Cinema Update Project, you’ll want to open the Support Tool and click on the Update Tab. Once there, the first thing you’ll want to do is select the Open Project button, and select the Cinema Update Project you just downloaded. When you open the Cinema Update Project in the Support Tool you will see the following.

Cinema Update Project

Click Publish and select the JNIOR you want to update. Once the update is complete the JNIOR will have rebooted and the application will be ready to configure. Configuration is largely dependent on what you are trying to do.

Within the Support Tool you can configure devices and macros. Devices are outbound connections from the Cinema application. For example, a projector, sound processor, or lighting system. Those devices can be serial or Ethernet. We have not implemented very many devices but the ones that are implemented satisfy a very large majority of the installations. If you need a device that is not implemented, you can use the “Raw Serial” or “Raw Ethernet” device. This will allow you to send commands that you define to those devices. Even if you pick a device that we have implemented, you may need to add a new command. You can use the Send action and define the bytes that need to be sent.

The Temperature / Humidity Sensor with Cable

INTEG resells a Temperature / Humidity Sensor that is manufactured by Embedded Data Systems. We often refer to this as the Environmental Sensor. As part of the offering from INTEG you get a 12′ cable with an RJ-12 connector that is tested to work with the JNIOR. We also had to create certain applications that work with the module. JANOS only natively supports INTEG expansion modules.

To wire the sensor you will need 3 wires that are for Power, Ground and One Wire Data. Even though the JNIOR uses an RJ-12 connector with 6 pins, only 3 are needed.

In the picture below you can see the 3 wires that are connected. We wire the flat black cable through the side of the sensor. The sensor does come with a mounting plate with a hole in the center. If you wire the unit yourself, you can use that hole for your installation. We chose not to use the bracket so that the device can be mounted flush without the need for rewiring or cutting a hole in the wall or surface.

Humidity Sensor expansion module for JNIOR

A closer look shows us the connection in the terminal block that each wire is connected to. As with INTEG modules, this terminal block gives you the ability to daisy-chain multiple devices.

Wiring for JNIOR Humidity Sensor

The wire needed is a modular flat 6 conductor cable. We use this one from digikey. The other end of the wire is the RJ-12 connector. We use pins 1 – 3. With the connector tab up you can see that the wires in use are on the right.

Wire end for expansion module sensor cable

You can use the Cinema application to execute DMX scripts. Those scripts can be on the same JNIOR or on another JNIOR. Both situations require making a TCP or Raw Ethernet connection to port 10000.

To execute a script once you will send go SCRIPTNAME\r\n

To execute a script a certain number of times you will send the same command but with a repeat parameter. For example, to execute 3 times we would send go SCRIPTNAME -r 3\r\n

To execute a script and have it repeat forever, until you abort it or reboot the JNIOR, you will send the -f parameter. For example, go SCRIPTNAME -f\r\n

Create a DMX device to use in the Macro

Create a Macro to call a DMX script with the Device we just created

Macro tab of the JNIOR Support Tool

You can use the scheduling in Cinema.jar to schedule macros daily, weekly or monthly.

When Cinema.jar is installed and executed for the first time it will create 3 default keys. They will look like this in the registry.

The configuration is a multi-part registry key. There are three parts. The type, the time of day, and the macro to execute.

Here are examples of the different scheduling types

Daily

You can define a macro to execute at a specific time every day. To do this we use the daily type. An example of executing a macro daily at 3:30pm with the name test would be:

daily, 15:30, test

Weekly

You can define a macro to execute on certain days of the week. To do this we use the 2 character day abbreviations in place of the type field. The 2 character day abbreviations are Su, Mo, Tu, We, Th, Fr and Sa. An example of executing a macro every day of the week at 3:30pm with the name test would be:

sumotuwethfrsa, 15:30, test

Monthly

Macros can be defined to execute on a certain date of the month, every month. To do this we use the monthly type followed the day of the month inside the parenthesis. An example of executing a macro with the name test would be:

montly(15), 15:30, test

You can also select to only execute the macro on certain months. Do do this we use 3 character month abbreviations. Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov and Dec. Only one month can be selected at a time.

sep(15), 15:30, test

Reboot Example

Here is a registry example. Below each schedule rule uses the command ‘reboot’. ‘reboot’ and ‘reboot -a’ are two commands that have been implemented in the scheduling logic that don’t need a macro to perform an action. As their names suggest, ‘reboot’ will perform a reboot and ‘reboot -a’ will perform a reboot -a.

There are many reasons to upgrade a series 3 JNIOR to a series 4. While we believe the experience and reliability are much better with the newer hardware and software we understand that in most cases the “if it isn’t broke, don’t fix it” rule applies.

When you are ready, use the following steps to help the transition go smoothly.

Can I just perform a backup from the series 3 and restore onto the series 4?

You can perform a backup and restore. BUT, this will copy over the cinema.jnior application. This file will not run on the series 4. There is a specific cinema file, cinema.JAR, that will run on the series 4.

If the cinema.jnior file gets copied over there will only be one small issue. A restore will set that file to run on boot. Every time the JNIOR boots it will throw an error regarding the cinema.jnior file being there and being the incorrect format.

The procedure

1. Update the Series 4 Operating System

Make sure the new series 4 JNIOR’s Operating System and Cinema application are up to date. You can find those applications on the All Downloads page.

The Cinema update will ensure that the Cinema application is present that will run on the Series 4. The version of the application that is loaded on the Series 3 will NOT run on the Series 4.

2. Take a Snapshot of the series 3 JNIOR to wish to replace

3. Extract the Snapshot

Open the Snapshot zip file and extract the macro file, devices file and flash/jnior.ini file.

4. Upload the macro and devices files to the destination series 4 JNIOR

5. Edit the jnior.ini file

The configuration is stored in the flash/jnior.ini file. Before you upload it we will need to remove two sections from the file. We will remove the [ipConfig] section so that the IP Address remains and the [run] section so that cinema.jnior does not try to start on boot.

jnior.ini file

6. Upload the updated jnior.ini file

To upload the file you have two options. You can use your favorite FTP client or use the DCP. If you use the DCP you will want to go to the Folders Tab. From there you can simply drag and drop your ini file to the temp/ folder. I recommend the temp/ folder for the upload so the file gets cleaned up after a reboot.

7. Ingesting the new configuration

To ingest the new configuration we will run the reg -i command from a command-line connection. Again you have multiple options for making the command-line connection. You can use an application like Putty, The JNIOR Command Line tool that is part of the JNIOR Support Tool or the Console tab in the DCP. If you use the DCP your command will look like this.

reg command for JNIOR command line

8. Enable MODBUS Server (If you are using a GDC Cinema Server)

The MODBUS server ran by default in the series 3 operating system. It is a separate application on the Series 4 that must be enabled to provide MODBUS connectivity.

You can enable MODBUS via the DCP. http://JNIOR_IP_ADDRESS in your browser.

Configuration tab for JNIOR Web Page

9. Reboot the JNIOR again.

Your new Series 4 should be running the Cinema application with the configuration and settings from your previous series 3 JNIOR.

Sometimes the JNIOR doesn’t appear to be working but follow these steps and you might be able to determine why. There are a few steps that you can take before contacting INTEG or declaring that the JNIOR is not functioning. Hopefully the steps below will help save some time.

The number one way for INTEG to help provide support is to send us a Snapshot using the Support Tool. We can use the Snapshot to look at logs, analyze your configuration and to look at network interactions. Snapshots are most effective when taken soon after the issue is noticed. If too much time has passed the logs and network information may no longer contain relevant information pertaining to the time of the issue.

Power

The JNIOR requires 12 – 24v DC. We recommend a power supply capable of 1 Amp.

The very first thing to check is to make sure the unit has power. No, I don’t mean “did you plug the JNIOR in?” We need to make sure that the internal power supply is functioning and that the wires going in to the connector on the outside of the JNIOR have not broken.

To check the internal power supply we need to verify that the BLUE LED is illuminated next to the power connector.

If the BLUE LED is not illuminated then we want to make sure the wires have not been broken. This can easily happen if there is stress put on the wires during installation or if the connector was not securely fastened before being shipped.

Operating System

Is the OS running? To check this remove power. Upon applying power the amber light next to the BLUE power LED should come on for two or three seconds and then go out. Another thing we can check is to unplug the Ethernet cable. As of JANOS v1.8 the Status LED will blink Morse code indicating the value of the last octet of the IP Address when the Ethernet cable is unplugged.

Ethernet

The first thing to check regarding Ethernet connectivity is that the lights on the Ethernet port are lit. If they are not, please check both end of the cable to make sure it is connected. If the cable appears to be properly connected and the lights are not lit, please try a different cable.

Check Beacon to see that the JNIOR is on the network. Beacon is a feature on the JNIOR that uses UDP to broadcast itself on the network. The JNIOR Support Tool implements beacon and will query the network for any JNIORs. Any JNIOR that hears the query will respond. Because this feature uses UDP a valid working IP Address is not necessary.

If the cable, lights and beacon all appear to be in working order then the last thing to check here is the IpConfig/Allow setting. That will need to be done using the serial port. You can read about that procedure in the Dangers of IpConfig/Allow.

As of JANOS v1.8 the Status LED will blink Morse code indicating the value of the last octet of the IP Address when the Ethernet cable is unplugged.

Serial Port

The serial port can be used to diagnose JNIOR issues. Most of the time the Ethernet connection will be used to do this but in the case that the Ethernet connection is suspect we will need to use the serial port. There are two serial ports on the JNIOR but the RS-232 port is the is the port that facilitates the command line functionality. To connect to the JNIOR for command line use you will need to use the following settings. 115200 baud, 8 data bits, 1 stop bit and no parity. Once the cable is connected and you launched your favorite serial application you will need to press enter to see the login prompt. You could also reboot the JNIOR to observe the banner.

Configuration

If the hardware steps above do not alert you to the issue you are having then configuration is most likely to blame. Please contact us INTEG for further assistance. We can walk you through configuration issues, connect to your computer via TeamViewer, or determine if your unit needs to be replaced.

Name Version Release Date Size MD5
Grapher v4.0 Aug 22 2019 783.4 KB a7967fd9878171af565ff1faf677ae14

Several changes affecting how you navigate in time.

Added the ability to change the configured duration view of the graph. Previously the default was a hard-coded 4 hours. Once you brought up the graph you could have used the mouse wheel to zoom out or zoom in. The graph would always load showing the past 4 hours.

In this version we removed the ability to zoom in and out using the mouse wheel. We also removed dragging the graph in the future or past using the mouse. This was done because it was noted that too often the mouse is accidentally being used to modify the graph view.

Since the mouse interaction was removed to zoom and pan, we added buttons below the graph the facilitate the ability to move forward and backward in time.

The fast step buttons move the graph forward or backward by the entire duration. If you are looking at today, as shown below, pressing the fast backwards button will show you yesterday. The single step buttons move by 1/4 the duration. Looking at 24 hours and pressing the single step buttons will move the graph by 6 hours.

MODBUS client is not able to connect to the JNIOR

The MODBUS server running on the JNIOR is a separate application from the Operating System. It does not run by default when the JNIOR is shipped. It is installed by default. It must be activated by the end user before the the MODBUS connection can be successful.

To activate it go to the DCP, click on the Configuration tab. Half way down the left side click on Applications. You will see a list of applications that are loaded on the JNIOR. Check the box next to Modbus Server. This will tell the JNIOR to run the application when the JNIOR boots up. You will need to reboot the JNIOR at this point to get the MODBUS Server to start.

To verify that the MODBUS server is running we can list the listening network sockets using the netstat command.

Lastly, you can change a few configuration parameters for the MODBUS server under the registry tab.

Port 502 is the default MODBUS port. Most likely this will NOT need to be changed. The Timeout setting is the number of milliseconds to wait for a MODBUS client to poll the server. If a request is not made within this amount of time then the JNIOR will close the connection. If any configuration needs to be changed it will probably be the Login setting. Not very many MODBUS clients implement a login. If they dont log in then you will see the following in the Modbus Server log…

Setting the Login key to false will allow this device to connect successfully.

The problem: You get the following screen when trying to go to the DCP or any web page on the JNIOR.

In this image we tried to go to the IP Address of the JNIOR.  This should present us with the DCP web page.  In this case we are presented with the “Page not found” response page.

This means that the file cannot be found in the filesystem for this page resource.

To troubleshoot this we need to look at the filesystem.  Since the DCP is not available we need to use FTP or a telnet session.

Using FTP

Open Windows Explorer. In the address bar type ftp://IP ADDRESS. You might see the message that Windows Explorer cannot access your folder.

Most likely this is because you need to provide credentials. To do that you need to right click in the white-space in the window and select Login As…

Once you log in navigate to the flash directory.

If the the DCP or default web page is missing then all of the following must be met:

  • www.zip is missing
  • public.zip is missing
  • www/ directory is missing or there is not an index.php file in the www/ directory
  • public/ directory is missing or there is not an index.php file in the public/ directory

Using Telnet

We can use Telnet to look at the filesystem as well. To do this, open your favorite Telnet application. Make a connection to the JNIOR. Log in. You will then use either the dir command or the ls command. Both commands are the same and will list the directory contents.

Use the command of your choice, whichever command is easier to remember, and add “flash” as a parameter. This wil cause the command to list the contents of the flash directory. If the the DCP or default web page is missing then all of the following must be met:

  • flash/www/config.zip
  • www.zip is missing
  • public.zip is missing
  • www/ directory is missing or there is not an index.php file in the www/ directory
  • public/ directory is missing or there is not an index.php file in the public/ directory

If you are having issues accessing your JNIOR’s webpage, please reach out to our support to get your setup working again.

Name Version Release Date Size MD5
Cinema.jar - Update Project v3.6 Aug 14 2019 334.6 KB d96d4ae9b9adc4f0b8cdaf9bd87518f3

+ Adding web handlers for getDevice without a device for internal io getAll.

Cinema.jar 3.5 June 2, 2019

Name Version Release Date Size MD5
Cinema.jar - Update Project v3.5 Jun 02 2019 327.0 KB 57a834f2c5ac177b7b19b6dec52350ce

+ Added HTTP POST method to Macro Actions.

+ Added the ability the use HTTPS for GETs and POSTs

Cinema.jar 3.4.1 May 29, 2019

  Cinema.jar - Update Project v3.4.1 [ May 28 2019, 320.47 KB, MD5: 74f51ea7ccb40962eb2118bf16457c50 ]

  • Released May 28 2019

! Fixed a bug where the watchdog was no longer working. If the Cinema application crashed it would not be restarted.

 

Cinema.jar 3.4.0 May 16, 2019

  Cinema.jar - Update Project v3.4 [ May 16 2019, 320.36 KB, MD5: 63b627ede9c8a79710ddb3d7fd3ca852 ]

  • Released May 16 2019

+ Allow you to query the temperature sensor via a HTTP Request.  A JSON representation of the device will be returned.

As of now the only available devices are Type28 and Type7E...

Type28 is the temperature probe and Type7E is the environmental sensor.

To enable this you will need to set the AppData/Cinema/WebServer/Port registry key. The JNIOR will need to be rebooted after this key has been changed. In this example I chose 8081. Port 80 or 443 is normally the default web server port. This web server port is an additional web server that cinema is hosting to handle these types of requests.

Security is a good thing. It is also hard. The IpConfig/Allow registry key will help you filter the connections permitted by the JNIOR.

The documentation for the use of the IpConfig/Allow key is as follows…

The IpConfig/Allow Registry key when present defines specific IP addresses and IP address subnets that are to be granted access to the JNIOR. All others are ignored. If undefined then all routable clients have access. For example, to restrict access only to your IP address (say 50.197.34.73) and your entire local subnet (10.0.0.x with mask 255.255.255.0) you would define the following:

reg IpConfig/Allow = “10.0.0.0/24, 50.197.34.73” 

In this case you, using that specific address, and everyone on the local subnet would be able to see the JNIOR and access its functions while everyone else is blocked.

This therefore is a list of IP address/subnet specifications of the form:

nnn.nnn.nnn.nnn/dd 

Here the 4 octet IP address for IPv4 is specified and ‘/dd’ if present indicates the number of bits from the left that must match. If the ‘/dd’ parameter is omitted it is the same as specifying ‘/32’ and as if you used a subnet mask of 255.255.255.255. In other words that IP address must match in its entirety.

Changes to this configuration setting take effect on reboot.