Compare String Node User Guide

The Compare String node is a Node-RED node that allows you to compare a string in the input message with a target string and return a boolean value indicating whether or not they match.

Using the Compare String Node

To use the Compare String node in your Node-RED flow, follow these steps:

1. Drag the Compare String node from the Node-RED palette and drop it onto the workspace.

2. Double-click the node to open its configuration panel.

3. In the configuration panel, you will see the following options:

   • StringToMatch: This is the target string that the input message string will be compared to.

4. Enter the target string you want to compare with the input message string in the "StringToMatch" field.

5. Connect the input message to the Compare String node input.

6. Connect the output of the Compare String node to any downstream nodes that you want to receive the output.

7. Deploy your Node-RED flow.

Understanding the Compare String Node Output

The Compare String node outputs a boolean value indicating whether the input message string matches the target string.

• If the input message string matches the target string, the node will output a true boolean value.

• If the input message string does not match the target string, the node will output a false boolean value.

• If there is an error, such as when the environment variable StringToMatch is not defined, the node will output an error message object.

Example

Suppose you have a Node-RED flow that receives input messages with a payload that contains a string property named text. You want to compare the value of text to the target string "hello world" and output a boolean value indicating whether or not they match.

Here's how you can use the Compare String node to achieve this:

1. Drag a Compare String node onto the workspace.

2. Double-click the node to open its configuration panel.

3. In the "StringToMatch" field, enter the target string "hello world".

4. Connect the input message to the node input.

5. Connect the node output to any downstream nodes that you want to receive the output.

6. Deploy your Node-RED flow.

Now, when an input message is received, the Compare String node will compare the value of the text property with the target string "hello world". If they match, the node will output a true boolean value. If they do not match, the node will output a false boolean value.

Example flow:

In this example, the Compare String Node is used to compare a user-defined value with the input from the touchpanel. If a match is found, the output of the Compare String Node is true, if no match is found, the output is false. In this case, the output of the Compare String Node drives a Digital Toggle Node high or low, then sets the digital feedback on the touchpanel.

Node Name: Digital Toggle

User Guide Summary:

The Digital Toggle node is designed to easily toggle a boolean value and create a message payload with the updated value. This node is helpful for controlling digital outputs or triggering actions based on changing states in your Node-RED flows.

Usage:

1. Add the Digital Toggle node to your Node-RED flow.
2. Connect the input and output wires as needed in your flow.

When the node is triggered with a high (true) value, it will toggle the state of the output.

The node then generates a msg.payload containing the updated boolean value.

Set/Reset Latch

Node Name: Set Digital Feedback

Note: use when you'd like to hardcode the value directly, otherwise see: Set Feedback Node.

User Guide Summary:

The Set Digital Feedback node allows you to create a message payload with a user-selected instance identifier (InstanceId) and a boolean state parameter. It simplifies defining and controlling digital output instances in your Node-RED flows. This node also provides a second output for error handling, which is useful when environment variables are not defined.

Usage:

1. Add the Set Digital Feedback node to your Node-RED flow.
2. In the subflow properties, define the following environment variables:
   • InstanceId: Set this to a number representing the instance identifier for the digital output.
   • State: Set this to a boolean value (true/false) representing the desired digital state.
3. Connect the input and output wires as needed in your flow.

When the node is triggered, it will generate a message payload based on the values of the environment variables "InstanceId" and "State". The payload will be in the following format:

Outputs:

1. Main Output:
   • Sends the digital feedback payload when both environment variables are defined.
   • Sends null when one or both environment variables are not defined.
2. Error Output:
   • Sends an error message ("One or both of the environment variables (InstanceId, State) are not defined.") when one or both environment variables are not defined.
   • Sends null otherwise.

If one or both environment variables are not defined, the node will output an error message on the second output.

Node Name: Set Analog Feedback

Note: use when you'd like to hardcode the value directly, otherwise see: Set Feedback Node.

This user guide explains the functionality, inputs, outputs, and environment variable options for the Set Analog Feedback Node. The purpose of this node is to create and send a message object with a predefined structure containing a type, an instance ID, and a value. The node checks if the required environment variables are defined and sends either the message or an error message to the next connected node in the flow.

Inputs

The Set Analog Feedback Node requires two inputs:

1. InstanceId: This is an environment variable that represents a unique identifier for a particular instance. To set this value, you must define the InstanceId environment variable in your Node-RED environment.

2. Value: This is an environment variable that represents the analog value you want to include in the message payload. To set this value, you must define the Value environment variable in your Node-RED environment.

Outputs

The output of the Set Analog Feedback Node depends on whether the required environment variables are defined:

1. If both environment variables are defined, the node sends a message (msg) with the following structure:

Where and are the values of the InstanceId and Value environment variables, respectively. This message is sent to the next connected node in the flow for further processing.

2. If one or both environment variables are not defined, the node sends an error message with the following structure:

This error message is sent to the next connected node in the flow for error handling.

User-Defined Environment Variable Options

There are two environment variables you must define for the Set Analog Feedback Node:

1. InstanceId: Define this environment variable with a unique identifier for the particular instance you are working with. This identifier will be included in the message payload to distinguish between different instances.

2. Value: Define this environment variable with the analog value you want to include in the message payload. This value will be passed along with the message for further processing by downstream nodes.

Node Name: Set Serial Feedback  

Note: use when you'd like to hardcode the value directly, otherwise see: Set Feedback Node.

This user guide explains the functionality, inputs, outputs, and environment variable options for the Set Serial Feedback Node. The purpose of this node is to create a message object with a predefined structure containing a type, an instance ID, and a string value. The node then sends the message to the next connected node in the flow.

Inputs

The Set Serial Feedback Node requires two inputs:

1. InstanceId: This is an environment variable that represents a unique identifier for a particular instance. To set this value, you must define the InstanceId environment variable in your Node-RED environment.

2. String: This is an environment variable that represents the string you want to include in the message payload. To set this value, you must define the String environment variable in your Node-RED environment.

Outputs

The output of the Set Serial Feedback Node is a single message (msg) with the following structure:

Where and are the values of the InstanceId and String environment variables, respectively.

This message is sent to the next connected node in the flow for further processing (typically back to the touch panel)

User-Defined Environment Variable Options

There are two environment variables you must define for the Set Serial Feedback Node:

1. InstanceId: Define this environment variable with a unique identifier for the particular instance you are working with. This identifier will be included in the message payload to distinguish between different instances.

2. String: Define this environment variable with the string value you want to include in the message payload. This value will be passed along with the message for further processing by downstream nodes.

The Set Feedback node

Input: Accepts a msg.payload of type Boolean, String or Int. 

Output: Outputs a msg.payload that drives feedback on the touch panel to the associated instance id.

Configuration: requires a user specified instance id.

Usage: Connect the output to the digital, analog, or string mqtt feedback node. 

AND Gate with Dynamic Inputs

This is a custom Node-RED function node that implements an AND gate with dynamic inputs. The AND gate requires all input values to be true in order to produce a true output. The function node accepts messages with msg.payload and msg.input properties, and maintains the state of the input values across multiple messages.

Inputs

msg.payload

This property should be set to a boolean value that represents the input value for the current message. The AND gate requires all input values to be true in order to produce a true output.

msg.input

This property should be set to a number (1-based index) that represents the index of the input value for the current message. 

Outputs

The AND gate produces a single output message with a boolean value in the msg.payload property. The output value is true if all input values are true, and false otherwise.

Configuration

The AND gate uses a configuration parameter NUM_INPUTS to determine the number of inputs that it should expect. This parameter can be set in the Node-RED environment variables, and defaults to 2 if not set.

Example Usage

Example#1

Here's an example flow that uses the AND gate function node to check if all inputs are true: 

In this flow, the inject nodes are used to simulate the input values. The function node is configured with NUM_INPUTS=3 to accept three inputs. The msg.input field identifies the node as a unique input. The debug node is used to display the output value of the AND gate. When all three input values are true, the output value will be true as well. Otherwise, the output value will be false.

Example#2

Using the Input Select node.

In this example we use the Input Select node to set the associated input for the AND gate. This way the AND gate can know which input the event came from. This removed the need for adding in the msg.input value as seen on the inject node. Additionally, we set the NUM_INPUTS field in the AND gate to 2, so it knows how many inputs to expect.

Node Name: Or Gate Node 

The Or Gate node is a Node-RED node that performs a logical OR operation on its input messages and outputs a boolean value indicating whether any of the input messages have a payload of true.

Using the Or Gate Node

To use the Or Gate node in your Node-RED flow, follow these steps:

1. Drag the Or Gate node from the Node-RED palette and drop it onto the workspace.

2. Connect any input messages that you want to be part of the logical OR operation to the node input.

3. Connect the output of the Or Gate node to any downstream nodes that you want to receive the output.

4. Deploy your Node-RED flow.

Understanding the Or Gate Node Output

The Or Gate node outputs a boolean value indicating whether any of the input messages have a payload of true.

• If any of the input messages have a payload of true, the node will output a true boolean value.

• If all of the input messages have a payload of false, the node will output a false boolean value.

• If there is an error, such as when an input message is not received, the node will output an error message object.

The Or Gate node updates the msg.payload property with the OR operation result and returns it along with a null value to indicate that there are no errors. The context object is updated with the new input message payloads so that they can be used in the next invocation of the node.

Example

Suppose you have a Node-RED flow that receives input messages from two different sensors. You want to create an Or Gate node that checks if either of the sensors detects an event, and outputs a boolean value indicating whether an event has occurred.

Here's how you can use the Or Gate node to achieve this:

1. Drag an Or Gate node onto the workspace.

2. Connect the output of both sensor nodes to the input of the Or Gate node.

3. Connect the output of the Or Gate node to any downstream nodes that you want to receive the output.

4. Deploy your Node-RED flow.

Now, when an input message is received from either of the sensors, the Or Gate node will check if either of the messages have a payload of true. If either of the messages have a payload of true, the node will output a true boolean value. If both of the messages have a payload of false, the node will output a false boolean value.

Node Name: Invert Boolean

Description: This node takes a boolean value as input and returns the opposite (inverted) value.

Usage:

1. Connect the input wire to the input of the Invert Boolean node.
2. Connect the output wire to the next node in the flow.
3. Deploy the flow.

Inputs:

• msg.payload: a boolean value to invert

Outputs:

• msg.payload: the inverted boolean value

Example Flow:

In this example flow, the Inject node sends a true value to the Invert Boolean node. The Invert Boolean node inverts the value to false and sends it to the Debug node. The Debug node outputs the inverted value to the debug console.

Notes:

• This node can be used with any boolean input value (true or false).
• The input and output values can be of any data type, as long as they can be interpreted as boolean values (i.e. true or false).

Inverter Gate:

Example#1:

Using the inject nodes, setup as msg.payload

Node Name:

Get Value Node

Configuration:

None

Input:

Accepts a msg.payload object

Processing:

Extracts the msg.payload.Value property from the msg.payload object.

Output:

Outputs a msg.payload with value of type boolean, integer or string.

Usage:

The Get Value node is used to extract the msg.payload.Value from the msg.payload object. This contains the boolean, integer or string value sent from the touch panel and allows the programmer to manipulate the logic without needing to write a custom function to parse out the value from the original msg.payload object.

The Get Value node connected after the switch node. 

Accepts a msg.payload boolean value.

Outputs the boolean value, along with the specified input selection.

This node allows for dynamic configuration of an input parameter, which is expected to be a number. When a message is passed to this node, it appends this configured input number to the message object as msg.input and then forwards the modified message to its output.

The primary use case of this node is to dynamically tag incoming messages with a specific numeric identifier or selection based on the node's configuration. This can be particularly useful in scenarios where you need to process or route messages differently based on a configurable parameter.

In summary, the node acts as a dynamic tagging mechanism, appending a user-configurable numeric value to each incoming message for further processing down the flow.

## User Manual: Node-RED Dictionary Node

---

### Introduction:

This Node-RED node allows you to create a message payload based on certain environment variables. Specifically, it helps to generate a STRING_DICTIONARY payload with a given instance ID and key-value pair.

When used in conjunction with the DynamicDataArray script in Unity, the programmer can set text values for specific fields based on the element of the object.

---

### Pre-requisites:

- **Node-RED**: Ensure you have Node-RED installed and running.

- **Environment Variables**: This node works by fetching environment variables. Ensure that the required environment variables (`InstanceId`, `Key`, and `Value`) are set before executing this node.

---

### Using the Dictionary Node:

1. **Add the Dictionary Node to your flow**:

    - Drag and drop the provided Dictionary Node into your Node-RED flow.

2. **Set the Required Environment Variables**:

    - `InstanceId`: This variable should store the instance ID you want to associate with the message payload.

    - `Key`: This should be the key you want to set in your dictionary payload. When using this node with the DynamicDataArray script in Unity, the key is associated with the element of the item in your list.

    - `Value`: This should be the value associated with the provided key in your dictionary payload.

3. **Execute the node**:

    - Connect the Dictionary Node to the desired input and output nodes.

    - Deploy your flow and activate the node.

4. **Observe the output**:

    - If all environment variables are set correctly, the output message (`msg.payload`) will be a structured JSON with the following format:

    ```json

    {

        "Type": "STRING_DICTIONARY",

        "InstanceId": "",

        "Value": {

            "": ""

        }

    }

    ```

    - If there is an issue fetching the environment variables, an error message will be output indicating the specific problem.

---

### Troubleshooting:

- **Error getting environment variables**: This means there was a problem fetching the environment variables. Double-check that the Node-RED environment has the necessary permissions and that the variables are set correctly.

- **Environment variables not defined**: If you see an output message stating that one or more of the environment variables are not defined, make sure that you've set the `InstanceId`, `Key`, and `Value` variables correctly in your environment.

---

### Conclusion:

The Dictionary Node for Node-RED provides a streamlined way to generate dictionary payloads from environment variables. With this node, you can ensure that your flows can dynamically create dictionary payloads based on the given configuration. Make sure to check and set your environment variables correctly to get the desired outputs.

SAMPLE USAGE:

When paired with the DynamicDataArray script, the SendStringDictionaryPayload can populate each element of the list with the values from the dictionary.

For instance, in this 0-based list, a Key value of "0" corresponds to the first element, this TextMeshPro Object will be dynamically populated with the text "hello". 

Snippet from the Dynamic Data Array script.

The Dynamic Data Array script is setup to look for the InstanceId, as well as the Data Type; in this case String Dictionary. The Tag to Match In Prefab is used to match the TextMeshPro objects which are tagged only, and ignores TextMeshPro objects which are not tagged in the prefab. 

## User Manual: Node-RED Dictionary Node

## User Manual: Node-RED SendBoolDictionary Node

---

### Introduction:

The SendBoolDictionary Node in Node-RED facilitates the generation of a message payload constructed from predefined environment variables. This node is designed to produce a BOOL_DICTIONARY payload with a specified instance ID and key-value pair.

---

### Pre-requisites:

- **Node-RED**: Make sure you have Node-RED set up and operational.

- **Environment Variables**: This node operates by obtaining environment variables. Thus, you need to ensure that the necessary environment variables (`InstanceId`, `Key`, and `Value`) are predefined prior to deploying this node.

---

### How to Use the SendBoolDictionary Node:

1. **Integrate the SendBoolDictionary Node into your flow**:

   - Incorporate the SendBoolDictionary Node into your Node-RED workflow by dragging and positioning it.

2. **Define the Essential Environment Variables**:

   - `InstanceId`: This variable should signify the instance ID you wish to be associated with the message payload.

   - `Key`: This is the key you intend to establish in your dictionary payload.

   - `Value`: This represents the corresponding value of the assigned key in your dictionary payload.

3. **Run the node**:

   - Link the SendBoolDictionary Node to the preferred input and output nodes.

   - Deploy your workflow and initiate the node.

4. **Inspect the Result**:

   - Given all environment variables have been correctly configured, the output message (`msg.payload`) will emerge in this structure:

    ```json

    {

        "Type": "BOOL_DICTIONARY",

        "InstanceId": "",

        "Value": {

            "": ""

        }

    }

    ```

   - If any complications arise during the retrieval of the environment variables, a corresponding error message will elucidate the specific concern.

---

### Troubleshooting:

- **Encountering Errors Retrieving Environment Variables**: If this scenario arises, it indicates a potential complication in fetching the environment variables. Confirm that Node-RED's environment possesses the appropriate permissions and that the variables are aptly set.

- **Undefined Environment Variables**: If you observe an output signifying the non-definition of one or more of the environment variables, it's crucial to ascertain that you've accurately set the `InstanceId`, `Key`, and `Value` variables in your environment.

---

### Conclusion:

The SendBoolDictionary Node for Node-RED is a robust solution for dynamically generating BOOL_DICTIONARY payloads anchored on environmental configurations. By ensuring accurate setting and permission grants for environment variables, you can exploit this node to the fullest and streamline your Node-RED flows.

EXAMPLE USAGE:

When paired with the DynamicDataArray script, the SendBoolDictionaryPayload can populate each element of the list with the values from the dictionary.

For instance, in this 0-based list, a Key value of "1" corresponds to the second element, the Button object will be set with the value of 1, signal high. The Value will be set with the value True.

## User Manual: Node-RED SendFloatDictionaryPayload Node

---

### Introduction:

The SendFloatDictionaryPayload Node is specifically designed for Node-RED, which aids in constructing message payloads rooted in predefined environment variables. Tailored for the creation of a FLOAT_DICTIONARY type payload, this node outputs a payload with an instance ID alongside the specified key-value pairing.

---

### Pre-requisites:

- **Node-RED Installation**: Ensure you have Node-RED set up and actively running on your system.

- **Environment Variables Configuration**: This node operates based on the retrieval of certain environment variables. Ensure `InstanceId`, `Key`, and `Value` are pre-configured before deploying this node.

---

### Node Operation:

1. **Node Integration**:
- Insert the SendFloatDictionaryPayload Node into your Node-RED flow by dragging and dropping it into the desired position.

2. **Environment Variables Configuration**:
- `InstanceId`: Defines the unique ID for the instance you're associating with the payload.
- `Key`: Specifies the dictionary key for your payload.
- `Value`: Assigns the corresponding value associated with the defined key in the dictionary payload.

3. **Node Execution**:
- Connect the SendFloatDictionaryPayload Node to appropriate input and output nodes.
- Deploy your flow and initiate the node operation.

4. **Output Evaluation**:
- With all environment variables set correctly, your output message (`msg.payload`) will appear as:

```json
{
"Type": "FLOAT_DICTIONARY",
"InstanceId": "",
"Value": {
"": ""
}
}
```

- If there are issues retrieving the environment variables, an error message will be provided detailing the problem.

---

### Troubleshooting:

- **Environment Variables Retrieval Error**: If this arises, it indicates a problem accessing the environment variables. Ensure Node-RED has the required permissions and that the variables (`InstanceId`, `Key`, and `Value`) are set appropriately.

- **Environment Variables Undefined Error**: If you're alerted that one or more environment variables are undefined, verify the correct configuration of `InstanceId`, `Key`, and `Value` within Node-RED's environment.

---

### Conclusion:

With the SendFloatDictionaryPayload Node in Node-RED, generating FLOAT_DICTIONARY payloads based on environmental configurations becomes seamless. Ensure all necessary environment variables are set correctly to capitalize on the efficiency and utility of this node within your Node-RED flows.

Sample Usage:

When paired with the DynamicDataArray script, the SendFloatDictionaryPayload can populate each element of the list with the values from the dictionary.

For instance, in this 0-based list, a Key value of "1" corresponds to the second element, this TextMeshPro Object will be dynamically populated with the text "hello".