Glow with the Show ears

If you have learned signals that don't get decoded when you look at them in IR.exe, post your file to the Diagnosis Area then post your question here (including a link to the file).

Moderator: Moderators

Post Reply
3FG
Expert
Posts: 3434
Joined: Mon May 18, 2009 11:48 pm

Post by 3FG »

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.
Top
pH7_jp1
Posts: 485
Joined: Sun Sep 14, 2003 4:17 pm
Location: Sterling Heights, MI

Post by pH7_jp1 »

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
Top
jstorms
Posts: 5
Joined: Sat Mar 15, 2014 2:10 pm

Post by jstorms »

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.
Top
kaczmajj
Posts: 1
Joined: Tue Nov 10, 2015 6:06 pm

Post by kaczmajj »

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?
Top
ishootstuff
Posts: 11
Joined: Wed May 30, 2018 12:39 pm

Post by ishootstuff »

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); 
}
Last edited by ishootstuff on Sun Jun 03, 2018 10:40 am, edited 1 time in total.
Top
Barf
Expert
Posts: 1524
Joined: Fri Oct 24, 2008 1:54 pm
Location: Munich, Germany
Contact:
Contact Barf

Post by Barf »

@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;
    }
}
Top
ishootstuff
Posts: 11
Joined: Wed May 30, 2018 12:39 pm

Post by ishootstuff »

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.
Top
Barf
Expert
Posts: 1524
Joined: Fri Oct 24, 2008 1:54 pm
Location: Munich, Germany
Contact:
Contact Barf

Post by Barf »

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 :wink:).
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! 8-)
Top
ishootstuff
Posts: 11
Joined: Wed May 30, 2018 12:39 pm

Post by ishootstuff »

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.
Top
The Robman
Site Owner
Posts: 21884
Joined: Fri Aug 01, 2003 9:37 am
Location: Chicago, IL
Contact:
Contact The Robman

Post by The Robman »

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?
Rob
www.hifi-remote.com
Please don't PM me with remote questions, post them in the forums so all the experts can help!
Top
Barf
Expert
Posts: 1524
Joined: Fri Oct 24, 2008 1:54 pm
Location: Munich, Germany
Contact:
Contact Barf

Post by Barf »

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 :wink:). If I am wrong, please correct me.
Top
The Robman
Site Owner
Posts: 21884
Joined: Fri Aug 01, 2003 9:37 am
Location: Chicago, IL
Contact:
Contact The Robman

Post by The Robman »

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.
Rob
www.hifi-remote.com
Please don't PM me with remote questions, post them in the forums so all the experts can help!
Top
The Robman
Site Owner
Posts: 21884
Joined: Fri Aug 01, 2003 9:37 am
Location: Chicago, IL
Contact:
Contact The Robman

Post by The Robman »

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
Last edited by The Robman on Sun Jun 24, 2018 1:43 pm, edited 3 times in total.
Rob
www.hifi-remote.com
Please don't PM me with remote questions, post them in the forums so all the experts can help!
Top
ishootstuff
Posts: 11
Joined: Wed May 30, 2018 12:39 pm

Post by ishootstuff »

Barf wrote:(man only have two ears :wink:)
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.

Image
Top
ishootstuff
Posts: 11
Joined: Wed May 30, 2018 12:39 pm

Post by ishootstuff »

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. ;)
Top
Post Reply

Return to “JP1 - Protocol Decodes”