Configuring a Komby RF1-12V to drive a Light-O-Rama controller
Scope:
This process will cover the steps needed to configure a RF1-12V to control a Light-O-Rama controller via the Komby Wireless DMX protocol. It will cover the Transmitter, Receiver, and the Light-O-Rama software setup. It is assumed that the hardware has already been assembled as required.
Controller Hardware Used:
Light-O-Rama CTB16PC
Transmitter Hardware Used:
Arduino Uno or Uno compatible board
Arduino Ethernet Shield or compatible board (the one with the Wiznet chip)
Komby Minimalist Shield
NRF24L01+ 2.4 GHz RF PA radio module
Receiver Hardware Used:
Komby RF1-12V NRF24L01 radio module with zigzag antenna Komby RS485 Serial Board (2014 revision)
Programmer Used:
Komby FTDI serial programmer
Software Used:
Arduino IDE 1.0.6
http://arduino.cc/en/Main/Software
Komby RFshowControl Release 3.0.1
github.com/komby/RFShowControl/releases/tag/v1-RC-3.0.1
Light-O-Rama V 3.11.2 (Advanced License required to output E1.31)
Setup considerations:
Before starting, you first must decide a few things.
1. Addressing Scheme to use with LOR controllers
2. DMX Universe and Channels you will use
Addressing Scheme:
LOR controllers set the DMX channel address based on the controller ID.
Controller ID1 will have DMX addresses 1-16, Controller ID2 will have addresses 17-32.
www1.lightorama.com/Documents/DMX-DOC.pdf. There are 2 approaches we can take to drive a LOR controller with a RF1-12V.
The first Addressing scheme would be to use different controller ID’s for each controller and use the LOR cross reference to get the channel addresses. The benefit of this approach is that all of the RF1-12V receivers can be programmed exactly the same to listen to the entire universe of DMX addresses, and the controller will only respond to it’s specific addresses. You can also hardwire another controller with a different ID to the one that has the wireless connection, and it will get it’s commands too. (this like using a LOR ELL system) A potential drawback of this approach is that the RF1-12V has to process commands that it may not need and could limit performance during heavy load. (although I have not seen this happen in real life)
The second Addressing scheme is to set all of the controllers to ID1 and then program each specific RV1-12V to only Listen for the channels that you want sent to that controller. The RF1-12V lets you set a “Start Channel” and Number of channels to listen for. So if we want DMX channel 305 to control Channel 1 of the LOR controller, we set the RF1-12V start_channel to 305 and number of channels to 16. So when the RF1-12V gets a command for DMX channel 305, it will convert that to DMX channel 1 and send that out to the LOR controller, and since it’s ID is set to 1, it will respond to that command. So the benefit here is possible better performance and the ability to swap out LOR controllers without changing their ID setting. The drawback is that you need to program every RF1-12V differently.
In this example, I am going to use the First addressing scheme as it is what I use in my show and is similar to how most LOR users currently use their hardware.
DMX Universe and Channels:
If you are new to DMX, then the Universe concept is probably also new to you.
Basically a DMX universe is just a group of 512 channels. If you need more than 512 channels, then you just add another universe. So in the LOR software, you will need to set up the channels on a DMX universe and define which addresses to use. In addition, you will need to set up the LOR network configuration to tell LOR where to send the DMX commands. In our case, we will tell it to send them to a DMX E1.31 network address. A Single Komby Sandwich Transmitter can transmit 1 Universe of DMX data.
Step 1. Install the Arduino IDE Software and Komby Libraries as instructed here:
learn.komby.com/wiki/3/how-to-setup-arduino-ide
Ignore any instructions on a Hardware Serial modification, it is not needed.
Step 2. Build and program the “Komby Sandwich” Transmitter
We will be using the Arduino UNO as a E1.31 DMX device. This will take the E1.31 data from LOR and convert it to the Komby RF wireless protocol. The steps for assembling and programming the sandwich can be found at the following link:
learn.komby.com/wiki/56/komby-sandwich. During this step, the Arduino UNO is connected to your PC with a USB cable and the correct COM port is selected in the IDE.
We will be loading the sketch “RF_Out_E131_In” There are a few changes that will need to be made. So start up the Arduino IDE and locate the sketch under the examples section Once the Sketch is in the IDE editor, you will see the following parts of the configuration section:
/************** START OF REQUIRED CONFIGURATION ****************/
// NRF_TYPE Description: http://learn.komby.com/wiki/58/configuration-settings#NRF_TYPE
// Valid Values: RF1, MINIMALIST_SHIELD, WM_2999_NRF, RFCOLOR_2_4
#define NRF_TYPE MINIMALIST_SHIELD
// UNIVERSE Description: http://learn.komby.com/wiki/58/configuration-settings#UNIVERSE
// Valid Values: 1-255
#define UNIVERSE 1
// MAC Address Description: http://learn.komby.com/wiki/58/configuration-settings#Mac-Address
static uint8_t mac[] = { 0x5B, 0xD0, 0x00, 0xEA, 0x80, 0x85 };
// IP Address Description: http://learn.komby.com/wiki/58/configuration-settings#IP-Address
static uint8_t ip[] = { 192, 168, 1, 99 };
/*************** END OF REQUIRED CONFIGURATION *****************/
/************ START OF NON-OTA CONFIGURATION SECTION *************/
// TRANSMIT_CHANNEL Description: http://learn.komby.com/wiki/58/configuration-settings#TRANSMIT_CHANNEL
// Valid Values: 0-83, 101-127 (Note: use of channels 84-100 is not allowed in the US)
#define TRANSMIT_CHANNEL 10
// DATA_RATE Description: http://learn.komby.com/wiki/58/configuration-settings#DATA_RATE
// Valid Values: RF24_250KBPS, RF24_1MBPS
#define DATA_RATE RF24_250KBPS
/************* END OF NON-OTA CONFIGURATION SECTION **************/
You will need to make some changes depending on your specific use. Note the settings below that I used.
First you need to set which DMX universe we will be listening for on the network. This needs to be set for both Unicast or Multicast. This setting does matter so make sure it matches the DMX Universe you set in the LOR Channel settings and Network configuration.
I am using Universe 10
#define UNIVERSE 10
Then you need to set the MAC address of your Sandwich. If you will only have one of these transmitters, then you can leave this alone, but if you plan to have more than one, then each one must have a unique MAC address. The simple way to do this is to add 1 to the last number in the line. (so below, you could make 85 an 86 on your second transmitter).
I left it alone.
static uint8_t mac[] = { 0x5B, 0xD0, 0x00, 0xEA, 0x80, 0x85 };
Next you need to set an IP address. This must be unique on your network, and be a valid IP address. It is highly recommended that you use a separate network for your DMX E1.31 than your home network. If you are unsure how to do this, Google it.
I have changed this to 192.168.0.103 for my show network.
static uint8_t ip[] = { 192, 168, 0, 103 };
Next you need to set which RF channel the transmitter will use. If you only have 1 of these transmitters, you can leave this setting alone. If you have more than 1 transmitter, you will need to make each one unique.
I left it at 10
#define TRANSMIT_CHANNEL 10
The last thing you need to set is the Data Rate, This is how fast the data is sent over the wireless signal. I have found that this needs to be set to the RF24_1MBPS rate in order to get the data out to the controller fast enough.
I changed this to RF24_1MBPS
#define DATA_RATE RF24_1MBPS
Once you have made these changes (you do not have to save them) upload the sketch to the sandwich. After the upload completes, you can disconnect the Arduino UNO from the USB port.
Step 3. Program the RF1-12V
We will now use a similar process to program the RF1-12V.
We need to make sure that we program it so it can properly communicate with the transmitter and listening for the correct channels. The directions for this step can be found at:
learn.komby.com/wiki/28/configure-dmx-receiver
We will be using the Komby Serial programmer for this step. The Programmer will plug into a header on your RF1-12V and then attach to your PC with a USB cable.
We will be loading the sketch “RF_In_DMX_Out” There are a few changes that will need to be made. So start up the Arduino IDE and locate the sketch under the examples section Once the Sketch is in the IDE editor, you will see the following parts of the configuration section:
/************** START OF REQUIRED CONFIGURATION ****************/ // NRF_TYPE Description: http://learn.komby.com/wiki/58/configuration-settings#NRF_TYPE // Valid Values: RF1, MINIMALIST_SHIEILD, WM_2999_NRF, RFCOLOR_2_4 #define NRF_TYPE RF1 // OVER_THE_AIR_CONFIG_ENABLE Description: http://learn.komby.com/wiki/58/configuration-settings#OVER_THE_AIR_CONFIG_ENABLE // Valid Values: OTA_ENABLED, OTA_DISABLED #define OVER_THE_AIR_CONFIG_ENABLE 0 // RECEIVER_UNIQUE_ID Description: http://learn.komby.com/wiki/58/configuration-settings#RECEIVER_UNIQUE_ID // Valid Values: 1-255 #define RECEIVER_UNIQUE_ID 33 /*************** END OF REQUIRED CONFIGURATION *****************/ /************ START OF NON-OTA CONFIGURATION SECTION *************/ // LISTEN_CHANNEL Description: http://learn.komby.com/wiki/58/configuration-settings#LISTEN_CHANNEL // Valid Values: 0-83, 101-127 (Note: use of channels 84-100 is not allowed in the US) #define LISTEN_CHANNEL 10 // DATA_RATE Description: http://learn.komby.com/wiki/58/configuration-settings#DATA_RATE // Valid Values: RF24_250KBPS, RF24_1MBPS #define DATA_RATE RF24_250KBPS // HARDCODED_START_CHANNEL Description: http://learn.komby.com/wiki/58/configuration-settings#HARDCODED_START_CHANNEL // Valid Values: 1-512 #define HARDCODED_START_CHANNEL 1 // HARDCODED_NUM_CHANNELS Description: http://learn.komby.com/wiki/58/configuration-settings#HARDCODED_NUM_CHANNELS // Valid Values: 1-512 #define HARDCODED_NUM_CHANNELS 512 /************* END OF NON-OTA CONFIGURATION SECTION **************/First you need to set which RF channel this receiver is going to listen to. Since we set up the transmitter on channel 10, we need to have the receiver listen on channel 10, since this is the default, we don’t have to change this.
I left it at 10
#define LISTEN_CHANNEL 10
The next thing you need to set is the Data Rate, This is how fast the data is sent over the wireless signal. I have found that this needs to be set to the RF24_1MBPS rate in order to get the data out to the controller fast enough. This must match what you have set up in the transmitter.
I changed this to RF24_1MBPS
#define DATA_RATE RF24_1MBPS
Next you have to tell the receiver which DMX channel you are going to start listening at. Since we are using the addressing scheme where we listen for the entire DMX Universe, we will leave this set at the default of 1.
I left it at 1
#define HARDCODED_START_CHANNEL 1
Finally we need to tell the receiver how many DMX channels we want to output to the controller(s). Since we are using the addressing scheme where we want to output the entire DMX Universe, we will leave this set at the default of 512.
I left it at 512
#define HARDCODED_NUM_CHANNELS 512
Once you have made these changes (you do not have to save them) upload the sketch to the RF1-12V. After the upload completes, you can disconnect the RF1-12V and programmer from the USB port.
Step 4. Setting the RS485 serial board
Now that we have the receiver programmed, we need to make sure the RS485 Serial board is configured correctly for LOR. The cool thing about the board is that it can be configured to pull the DC power from the LOR controller (Just like the LOR ELL). There is a row of header pins on the board labeled 1-10. We want to put jumpers on locations 3,6,and 9. This will set the pin out to match the LOR pin-out. In addition, there is a 2 pin jumper labeled VIN_ENABLE located by the connecter on the side, Put a jumper on this pair of pins too. Now, attach the RS485 board to the RF1-12V.
Step 5. Connect the RF1-12V and RS485 Serial board to the LOR controller
Start with the LOR Controller powered off .Using a standard Cat5 cable, connect the RJ45 jack of the RS485 board to the RJ45 input jack of the LOR controller. Now, power the LOR controller on. The Activity LED on the LOR controller should flash a few times, then become lit solid. This indicates that it is receiving the DMX signal from the RF1-12V. In addition the red power LED and the green RX LED on the RS485 Serial board should be lit, indicating it is receiving the DMX signal from the RF1-12V. If you do not see the LEDs as described, then check the Jumpers again, make sure you have a good cable, and possibly, re-check your programming on the RF1-12V
Step 6. Connect the Komby Sandwich to your network
Now we need to get the transmitter connected to your show computer.
If you are unsure on basic computer networking, then you may have to do some reading up on how to set up a network. I will assume that you know enough about computer networking to make this work. SInce I use a laptop computer to run my show, I will describe the basics. The laptop has a WiFi network that is connected to my home network. I use this to get sequences onto it from my sequencing computer. The laptop also has a ethernet port, which I have configured to be my “Show Network” This network is only used for DMX E1.31.
So the Laptop’s hardwire network address is 192.168.0.1 . Previously we set the transmitter’s address to 192.168.0.103. Both the laptop and the transmitter are plugged into a basic 100Mb ethernet switch. You will also need to supply power to the Komby Sandwich. 9 Volts, 400ma works just fine for me. Once the network is connected and everything is powered up, you should be able to use the “ping” command to verify that the transmitter is up on the network.
Step 7. Configure the Light-O-Rama Network Preferences.
Now we need to tell Light-O-Rama how to talk to the transmitter.
We are going to set up DMX Universe 10 to send it’s data to IP address 192.168.0.103.
In this example, we will use Unicast to keep things simple.
Start up Programs>Light-O-Rama>Light-O-Rama Network Configuration.
When the program starts up, you will see 4 tabs. We are going to select the second tab “DMX”. Next click the “Advanced” button. Once there, click on Unv 10 and a window will pop up. Click the radio button “Use E1.31”. Next under “IP Address” click Specify, and enter the ip address of the Receiver, in this case, 192.168.0.103. That’s it, don’t change anything else. Click OK. Then click OK in the LOR Network Preferences window.
IMPORTANT TIP: If you do not have a LOR adapter connected to the system at this time, you will need to either connect one, or you will need to delete the LOR network information from the LOR tab in the LOR Network Preferences window. If you do not do this, you will not be able to send output to the transmitter.
Step 8. Set up the Light-O-Rama Channel configuration.
Now we will define the DMX Universe and channels in the Light-O-Rama Sequence Editor. This is done exactly like setting up a LOR controller except instead of selecting a LOR controller, we select DMX universe. Then we tell it which Universe, in our case it will be Universe 10, Then finally we select the Address, which will be from 1 to 512. To keep things simple right now, we will assume the LOR controller has been set Previously to ID1 using the LOR hardware utility and a LOR serial adapter. So that means that we will set the channels as follows:
Device Type: DMX Universe Universe: 10 Addresses: 1 to 16
Step 9. Play a sequence and watch the lights blink.
Start up the Light-O-Rama Control panel
Programs>Light-O-Rama>Light-O-Rama Control Panel
This must be running in order to control DMX devices.
You can confirm that Universe 10 is opened by looking at the status window that opened up when you started the Control Panel.
Open up your sequence in the LOR Sequence Editor. Make Sure control lights is check in the LOR Sequence editor. Play the sequence. The Controller should be responding to the commands.