JP1 Remotes

Posted: **Thu Mar 20, 2014 11:24 pm**

I think this is the only thread here concerning glow with the show ears. I don't see a protocols.ini entry, so please post a link to it.
Instead, the previous usage with JP1 remotes was to convert signals captured with a Widget into the learned signal format used in JP1 remotes, and then upload that to the remote. This approach uses up the available memory fairly quickly, so it may be desirable to write an executor that can send the signals. Presumably only a subset of the possible signals can be generated in an executor.

I suspect you're going to eventually want hardware with more memory, and an easier way to program than is available in a simple remote.

Posted: **Sat Mar 22, 2014 8:21 am**

I don't see a protocols.ini entry, so please post a link to it.

I may be wrong, but I think he was talking about Barf's earlier post in this thread: http://www.hifi-remote.com/forums/viewt ... 211#108211

Posted: **Sat Mar 22, 2014 6:56 pm**

Very cool! I have my proof of concept working off a universal remote. To incorporate these into my Christmas light show I need to build a beefier IR controller, then a software interface for sequencing.

Posted: **Tue Nov 10, 2015 6:09 pm**

Thanks for all the IR codes. It was really helpful! I made an app for my smartphone that can change the color of the ears.

I was wondering if anyone has seen any IR code that could put the ears back into the random mode that turns on after it doesn't receive any signals for a while?

Posted: **Wed May 30, 2018 12:54 pm**

I know this is an old thread, but this is the best info out there that got me to where I am now. I used an Arduino to transmit the IR codes. Here is my working sample code.

If anyone knows if there are codes to control the other ear, I'll update the post.

Thanks everyone!

Code: Select all

/*
Glow With The Show/Made With Magic IR Controller
ishootstuff 5/30/2018
IR Diode connected to D3
*/

#include <IRremote.h>
IRsend irsend;

void setup()
{
}

void loop() {
  int khz = 38;
  int Delay = 100;
  
unsigned int Off[] = {2085 ,417 ,834 ,834 ,2502 ,834 ,417 ,417 ,834 ,834 ,834 ,417 ,417 ,834};
unsigned int R_Off[] = {2085 ,417 ,834 ,834 ,1668 ,417 ,417 ,834 ,417 ,417 ,1251 ,417 ,834 ,834 ,417 ,417};
unsigned int Red[] = {2085 ,417 ,834 ,834 ,1251 ,417 ,834 ,834 ,417 ,417 ,417 ,1251 ,1251 ,1251};
unsigned int R_Red[] = {2085 ,417 ,834 ,834 ,1251 ,834 ,417 ,834 ,417 ,417 ,417 ,417 ,417 ,417 ,2085 ,417};
unsigned int Blue[] = {2085 ,417 ,834 ,834 ,417 ,417 ,1668 ,834 ,417 ,417 ,1668 ,2502};
unsigned int R_Blue[] = {2085 ,417 ,834 ,834 ,417 ,417 ,834 ,417 ,417 ,834 ,417 ,417 ,834 ,417 ,417 ,1251 ,834 ,417};
unsigned int Yellow[] = {2085 ,417 ,834 ,834 ,834 ,834 ,834 ,834 ,417 ,417 ,417 ,834 ,417 ,1668 ,417 ,417};
unsigned int R_Yellow[] = {2085 ,417 ,834 ,834 ,834 ,1251 ,417 ,834 ,417 ,417 ,417 ,417 ,834 ,1251 ,417 ,834};
unsigned int White[] = {2085 ,417 ,834 ,834 ,417 ,1251 ,834 ,834 ,417 ,417 ,417 ,417 ,417 ,417 ,834 ,417 ,834 ,417};
unsigned int R_White[] = {2085 ,417 ,834 ,834 ,417 ,1668 ,417 ,834 ,417 ,417 ,417 ,1251 ,834 ,1668};
unsigned int Green[] = {2085 ,417 ,834 ,834 ,834 ,417 ,1251 ,834 ,417 ,417 ,834 ,417 ,417 ,834 ,1251 ,417};
unsigned int R_Green[] = {2085 ,417 ,834 ,834 ,834 ,417 ,417 ,417 ,417 ,834 ,417 ,417 ,1668 ,834 ,417 ,1251};
unsigned int Cyan[] = {2085 ,417 ,834 ,834 ,417 ,834 ,1251 ,834 ,417 ,417 ,1251 ,417 ,1251 ,417 ,417 ,417};
unsigned int R_Cyan[] = {2085 ,417 ,834 ,834 ,417 ,834 ,417 ,417 ,417 ,834 ,417 ,417 ,834 ,834 ,1668 ,834};
unsigned int Magenta[] = {2085 ,417 ,834 ,834 ,417 ,417 ,417 ,417 ,834 ,834 ,417 ,417 ,417 ,417 ,834 ,834 ,834 ,834};
unsigned int R_Magenta[] = {2085 ,417 ,834 ,834 ,417 ,417 ,417 ,834 ,417 ,834 ,417 ,417 ,417 ,834 ,417 ,834 ,417 ,417 ,417 ,417};
 
 
irsend.sendRaw(Off, sizeof(Off) / sizeof(Off[0]), khz);
delay(Delay);
irsend.sendRaw(R_White, sizeof(R_White) / sizeof(R_White[0]), khz);
delay(Delay);
irsend.sendRaw(White, sizeof(White) / sizeof(White[0]), khz);
delay(Delay);
irsend.sendRaw(R_Red, sizeof(R_Red) / sizeof(R_Red[0]), khz);
delay(Delay);
irsend.sendRaw(Red, sizeof(Red) / sizeof(Red[0]), khz);
delay(Delay);
irsend.sendRaw(R_Blue, sizeof(R_Blue) / sizeof(R_Blue[0]), khz);
delay(Delay);
irsend.sendRaw(Blue, sizeof(Blue) / sizeof(Blue[0]), khz);
delay(Delay);
irsend.sendRaw(R_Yellow, sizeof(R_Yellow) / sizeof(R_Yellow[0]), khz);
delay(Delay);
irsend.sendRaw(Yellow, sizeof(Yellow) / sizeof(Yellow[0]), khz);
delay(Delay);
irsend.sendRaw(R_Green, sizeof(R_Green) / sizeof(R_Green[0]), khz);
delay(Delay);
irsend.sendRaw(Green, sizeof(Green) / sizeof(Green[0]), khz);
delay(Delay);
irsend.sendRaw(R_Cyan, sizeof(R_Cyan) / sizeof(R_Cyan[0]), khz);
delay(Delay);
irsend.sendRaw(Cyan, sizeof(Cyan) / sizeof(Cyan[0]), khz);
delay(Delay);
irsend.sendRaw(R_Magenta, sizeof(R_Magenta) / sizeof(R_Magenta[0]), khz);
delay(Delay);
irsend.sendRaw(Magenta, sizeof(Magenta) / sizeof(Magenta[0]), khz);
delay(Delay);
irsend.sendRaw(R_Off, sizeof(R_Off) / sizeof(R_Off[0]), khz);
delay(Delay);
 irsend.sendRaw(Off, sizeof(Off) / sizeof(Off[0]), khz);
delay(Delay); 
}

Posted: **Thu May 31, 2018 7:22 am**

@ishootstuff: Nice. There are however two things I do not "like":

* Using platform dependent types (like [unsigned) int; it is 16 bits on e.g. the ATmega328 processors in the "classical" Arduinos (Uno, Nano, Mega), 32 bits in the more modern 32-bit processors). This leads to a program that behaves differently on different platforms
* Harvard-architecture processors like the ones in the Arduinos have "small" RAM memory and "large" flash (read-only) memory. Therefore it is a bad idea to use the former for static stuff as your data arrays. Using the standard tools or the Arduino, you can force the program to use read-only memory for this data, using the attribute PROGMEM, and some associated functions. It is not quite straight forward however. (See the sketch below.)

IrScrutinizer can generate this sort of code automatically; just "export" using the export format "Arduino Raw". The enclosed sketch supports not only the traditional IRremote, but also my Arduino IR library, Infrared4Arduino.

Code: Select all

// This Arduino sketch was automatically generated by IrScrutinizer.

// It supports:
//
// * IRremote https://github.com/z3t0/Arduino-IRremote
//            http://z3t0.github.io/Arduino-IRremote/
// * IRLib    https://github.com/cyborg5/IRLib
// * Infrared4Arduino https://github.com/bengtmartensson/Infrared4Arduino,
//                    http://www.harctoolbox.org/Infrared4Arduino.html (planned)

// For problems, bugs, and suggestions, please open an issue at
// https://github.com/bengtmartensson/harctoolboxbundle/issues

// This file contains C identifiers which have been translated from command names.

// Define exactly one of these
// #define IRREMOTE
// #define IRLIB
#define INFRARED4ARDUINO

/////////////////////////////////////////////////////
// Sanity check
#if defined(IRREMOTE) & ( defined(IRLIB) | defined(INFRARED4ARDUINO) )
#error Must define only one of IRREMOTE, IRLIB, or INFRARED4ARDUINO
#endif

#if defined(IRLIB) & ( defined(IRREMOTE) | defined(INFRARED4ARDUINO) )
#error Must define only one of IRREMOTE, IRLIB, or INFRARED4ARDUINO
#endif

#if defined(INFRARED4ARDUINO) & ( defined(IRLIB) | defined(IRREMOTE) )
#error Must define only one of IRREMOTE, IRLIB, or INFRARED4ARDUINO
#endif

#ifdef IRREMOTE
#include <IRremote.h>
#elif defined(IRLIB)
#include <IRLib.h>
#define sendRaw send
#elif defined(INFRARED4ARDUINO)
#include <IrSenderPwm.h>
#else
#error Must defined one of IRREMOTE, IRLIB, or INFRARED4ARDUINO
#endif

#if defined(IRREMOTE) | defined(IRLIB)
typedef uint16_t microseconds_t; // Change if desired
typedef uint16_t frequency_t;    // Change if desired

static inline unsigned hz2khz(frequency_t f) { return f/1000U; }
#endif

// Constants
static const long BAUD = 115200UL; // Change if desired

// Global variables
#ifdef IRREMOTE
IRsend irsend;
#elif defined(IRLIB)
IRsendRaw irsend;
#else
IrSender *irsend = IrSenderPwm::getInstance(true);
#endif


// Command #1: off
// Protocol: gwts, Parameters: CRC=166 F=96
const microseconds_t intro_off[] PROGMEM = { 2085U, 417U, 834U, 834U, 2502U, 834U, 417U, 417U, 834U, 834U, 834U, 417U, 417U, 834 };

// Command #2: blue
// Protocol: gwts, Parameters: CRC=248 F=97
const microseconds_t intro_blue[] PROGMEM = { 2085U, 417U, 834U, 834U, 417U, 417U, 1668U, 834U, 417U, 417U, 1668U, 2502 };

// Command #3: green
// Protocol: gwts, Parameters: CRC=26 F=98
const microseconds_t intro_green[] PROGMEM = { 2085U, 417U, 834U, 834U, 834U, 417U, 1251U, 834U, 417U, 417U, 834U, 417U, 417U, 834U, 1251U, 417 };

// Command #4: cyan
// Protocol: gwts, Parameters: CRC=68 F=99
const microseconds_t intro_cyan[] PROGMEM = { 2085U, 417U, 834U, 834U, 417U, 834U, 1251U, 834U, 417U, 417U, 1251U, 417U, 1251U, 417U, 417U, 417 };

// Command #5: red
// Protocol: gwts, Parameters: CRC=199 F=100
const microseconds_t intro_red[] PROGMEM = { 2085U, 417U, 834U, 834U, 1251U, 417U, 834U, 834U, 417U, 417U, 417U, 1251U, 1251U, 1251 };

// Command #6: magenta
// Protocol: gwts, Parameters: CRC=153 F=101
const microseconds_t intro_magenta[] PROGMEM = { 2085U, 417U, 834U, 834U, 417U, 417U, 417U, 417U, 834U, 834U, 417U, 417U, 417U, 417U, 834U, 834U, 834U, 834 };

// Command #7: yellow
// Protocol: gwts, Parameters: CRC=123 F=102
const microseconds_t intro_yellow[] PROGMEM = { 2085U, 417U, 834U, 834U, 834U, 834U, 834U, 834U, 417U, 417U, 417U, 834U, 417U, 1668U, 417U, 417 };

// Command #8: white
// Protocol: gwts, Parameters: CRC=37 F=103
const microseconds_t intro_white[] PROGMEM = { 2085U, 417U, 834U, 834U, 417U, 1251U, 834U, 834U, 417U, 417U, 417U, 417U, 417U, 417U, 834U, 417U, 834U, 417 };

// Command #9: off_r
// Protocol: gwts, Parameters: CRC=100 F=104
const microseconds_t intro_off_r[] PROGMEM = { 2085U, 417U, 834U, 834U, 1668U, 417U, 417U, 834U, 417U, 417U, 1251U, 417U, 834U, 834U, 417U, 417 };

// Command #10: blue_r
// Protocol: gwts, Parameters: CRC=58 F=105
const microseconds_t intro_blue_r[] PROGMEM = { 2085U, 417U, 834U, 834U, 417U, 417U, 834U, 417U, 417U, 834U, 417U, 417U, 834U, 417U, 417U, 1251U, 834U, 417 };

// Command #11: green_r
// Protocol: gwts, Parameters: CRC=216 F=106
const microseconds_t intro_green_r[] PROGMEM = { 2085U, 417U, 834U, 834U, 834U, 417U, 417U, 417U, 417U, 834U, 417U, 417U, 1668U, 834U, 417U, 1251 };

// Command #12: cyan_r
// Protocol: gwts, Parameters: CRC=134 F=107
const microseconds_t intro_cyan_r[] PROGMEM = { 2085U, 417U, 834U, 834U, 417U, 834U, 417U, 417U, 417U, 834U, 417U, 417U, 834U, 834U, 1668U, 834 };

// Command #13: red_r
// Protocol: gwts, Parameters: CRC=5 F=108
const microseconds_t intro_red_r[] PROGMEM = { 2085U, 417U, 834U, 834U, 1251U, 834U, 417U, 834U, 417U, 417U, 417U, 417U, 417U, 417U, 2085U, 417 };

// Command #14: magenta_r
// Protocol: gwts, Parameters: CRC=91 F=109
const microseconds_t intro_magenta_r[] PROGMEM = { 2085U, 417U, 834U, 834U, 417U, 417U, 417U, 834U, 417U, 834U, 417U, 417U, 417U, 834U, 417U, 834U, 417U, 417U, 417U, 417 };

// Command #15: yellow_r
// Protocol: gwts, Parameters: CRC=185 F=110
const microseconds_t intro_yellow_r[] PROGMEM = { 2085U, 417U, 834U, 834U, 834U, 1251U, 417U, 834U, 417U, 417U, 417U, 417U, 834U, 1251U, 417U, 834 };

// Command #16: white_r
// Protocol: gwts, Parameters: CRC=231 F=111
const microseconds_t intro_white_r[] PROGMEM = { 2085U, 417U, 834U, 834U, 417U, 1668U, 417U, 834U, 417U, 417U, 417U, 1251U, 834U, 1668 };


static void sendRaw(const microseconds_t intro_P[], size_t lengthIntro, const microseconds_t repeat_P[],
             size_t lengthRepeat, frequency_t frequency, unsigned times) {
    microseconds_t intro[lengthIntro];
    microseconds_t repeat[lengthRepeat];
    memcpy_PF(intro, (uint_farptr_t) intro_P, sizeof(microseconds_t) * lengthIntro);
    memcpy_PF(repeat, (uint_farptr_t) repeat_P, sizeof(microseconds_t) * lengthRepeat);

#if defined(IRREMOTE) | defined(IRLIB)
    if (lengthIntro > 0U)
        irsend.sendRaw(intro, lengthIntro, hz2khz(frequency));
    if (lengthRepeat > 0U)
        for (unsigned i = 0U; i < times - (lengthIntro > 0U); i++)
            irsend.sendRaw(repeat, lengthRepeat, hz2khz(frequency));
#else // INFRARED4ARDUINO
    IrSignal irSignal(intro, lengthIntro, repeat, lengthRepeat, NULL, 0U, frequency);
    irsend->sendIrSignal(irSignal, times);
#endif
}

void setup() {
    Serial.begin(BAUD);
    Serial.setTimeout(60000UL);
}

// A pretty silly main loop; just intended as an example.
void loop() {
    Serial.println(F("Enter number of signal to send (1 .. 16)"));
    long commandno = Serial.parseInt();
    Serial.println(F("Enter number of times to send it"));
    long times = Serial.parseInt();
    switch (commandno) {
    case 1U:
        sendRaw(intro_off, 14U, NULL, 0U, 38005U, times);
        break;
    case 2U:
        sendRaw(intro_blue, 12U, NULL, 0U, 38005U, times);
        break;
    case 3U:
        sendRaw(intro_green, 16U, NULL, 0U, 38005U, times);
        break;
    case 4U:
        sendRaw(intro_cyan, 16U, NULL, 0U, 38005U, times);
        break;
    case 5U:
        sendRaw(intro_red, 14U, NULL, 0U, 38005U, times);
        break;
    case 6U:
        sendRaw(intro_magenta, 18U, NULL, 0U, 38005U, times);
        break;
    case 7U:
        sendRaw(intro_yellow, 16U, NULL, 0U, 38005U, times);
        break;
    case 8U:
        sendRaw(intro_white, 18U, NULL, 0U, 38005U, times);
        break;
    case 9U:
        sendRaw(intro_off_r, 16U, NULL, 0U, 38005U, times);
        break;
    case 10U:
        sendRaw(intro_blue_r, 18U, NULL, 0U, 38005U, times);
        break;
    case 11U:
        sendRaw(intro_green_r, 16U, NULL, 0U, 38005U, times);
        break;
    case 12U:
        sendRaw(intro_cyan_r, 16U, NULL, 0U, 38005U, times);
        break;
    case 13U:
        sendRaw(intro_red_r, 16U, NULL, 0U, 38005U, times);
        break;
    case 14U:
        sendRaw(intro_magenta_r, 20U, NULL, 0U, 38005U, times);
        break;
    case 15U:
        sendRaw(intro_yellow_r, 16U, NULL, 0U, 38005U, times);
        break;
    case 16U:
        sendRaw(intro_white_r, 14U, NULL, 0U, 38005U, times);
        break;
    default:
        Serial.println(F("Invalid number entered, try again"));
        break;
    }
}

Posted: **Thu May 31, 2018 8:06 am**

Thanks for the code. Unfortunately it's way beyond my skill level. I'm not a programmer. I just started with Arduino 6 months ago because a brain tumor turned my life upside down. I have some trouble learning new things now in addition to lots of other issues. My hobbies used to include engine swaps and motorcycle riding.

Posted: **Fri Jun 01, 2018 1:33 am**

ishootstuff wrote:Thanks for the code. Unfortunately it's way beyond my skill level. I'm not a programmer.

My intent was to show that you can automatically generate that kind of code, using free software. You do not have to "understand" the code to use it (although it certainly does not hurt either

).

I just started with Arduino 6 months ago because a brain tumor turned my life upside down.

Sorry to hear that. But, as we see, it had at least one positive effect. Welcome to the community!

Posted: **Fri Jun 01, 2018 2:08 am**

I know you had good intentions and I thank you. If I can't understand the code produced, I can't change it to suit my needs. Don't waste your time trying to explain it to me, I'll read it 100 times and just end up frustrated.

Thanks for the welcome! Sorry I don't have more to contribute.

Posted: **Fri Jun 01, 2018 8:40 am**

ishootstuff wrote:I know this is an old thread, but this is the best info out there that got me to where I am now. I used an Arduino to transmit the IR codes. Here is my working sample code.

If anyone knows if there are codes to control the other ear, I'll update the post.

Thanks everyone! I think I'll program my MX-600 remote and take it to Disney.

We only know the codes that are posted. If you were to find a source of any other codes that exist, like for the other ear, I could format them in the same fashion as the codes you posted.

I just looked back and I can't believe that we never created a JP1 upgrade for these ears. Is there anyone here who could test an upgrade if I created one?

Posted: **Sat Jun 02, 2018 1:38 pm**

The Robman wrote:... any other codes that exist, like for the other ear,...

Hmm, my understanding is that, for the named commands we have, command does something for the left ear-thingy, while command_r does the same thing for the right ear-thingy. I suspect that "the other ear" is some misunderstanding (man only have two ears

). If I am wrong, please correct me.

Posted: **Sat Jun 02, 2018 2:18 pm**

I that were true, wouldn't ishootstuff have noticed that? I suspect that "blue" works both ears while "blue_r" only works the right ear, so we're missing "blue_l", etc.

Posted: **Sat Jun 02, 2018 2:42 pm**

Jstorms created a youtube video for this:
https://www.youtube.com/watch?v=kdiWtt24QEI
https://sites.google.com/site/listentoo ... iththeshow
https://sites.google.com/site/listentoo ... hacking-gw
https://sites.google.com/site/listentoo ... sal-remote

website for calculating the checksum:
http://www.datastat.com/sysadminjournal/maximcrc.cgi

other:
http://doityourselfchristmas.com/forums ... 25142.html

Posted: **Sat Jun 02, 2018 5:34 pm**

Barf wrote:(man only have two ears )

Most of them anyway.

I have two ears, but only one of them works thanks to the aforementioned brain tumor. I'm not sensitive about it. Here's my hat and the sad little remote I made. I didn't have enough buttons laying around.

Posted: **Sat Jun 02, 2018 5:50 pm**

I just watched some of the youtube vids on the hats in action and there are definitely more codes out there. I haven't even researched capturing the raw data.

It's funny, I took the ears apart to add LEDs and saw there was far more circuitry in there than required to flash two LEDs. I didn't even know the ears I have had for months interacted with anything. I was all ready to fire up a Disney conspiracy theory on mind control.

JP1 Remotes

Glow with the Show ears