Simple pattern editor for the cube like WYSIWYG

[Dirk S.]

I´m a real noob regarding programming code line by line for the L3D cube in the small online editor.

Therefore I would like to know if Lookingglass is working on an WYSIWYG editor to design colourful pattern for the L3D cube quite fast and simple, either for a noob like me?

I have already installed the Processing prog including the L3D cube library, but it´s still not as easy as I would like to have it - but I love the cube! 

Can I expect such a tool in the near future?

[Werner M.]

That's actually not a bad idea.

I've seen this implemented for other cubes out there. Something that would let users create animations 'painting the dots' frame-by-frame with mouse clicks, selecting colors from a pallette.
Nice.

Could be done in C#. Then the cube could be put in 'listening mode' (aka, running the listener firmware) and the application would stream the animation from the user's PC to the cube.

[Joep Schipper]

On the first (youtube) movie of Lookingglass on Kickstarter plays a nice girl with the WYSIWYG editor of the cube. So it must be possible!  Is that editor in really working order?

Op maandag 7 september 2015 23:48:48 UTC+2 schreef Dirk S.:

[Dirk S.]

Check out this Youtube video: https://www.youtube.com/watch?v=bEFVLrZZHtU

Starting with second 0:44 you will see that kind of software I´m thinking about.

Such software in combination with the Cubetube would be gorgeous. ;)

[Werner M.]

(Sehr schön, gibt es auch grösseren Grösse (8x8x8, 16x16x16) verfugbar?)

I like that cube. The software portrayed is very similar to other ones I've seen. E.g.: https://youtu.be/s1uE12blZIQ

This guy did a nice job. And his code is open source, written in java, me thinks easy to port to the L3D hardware.

This discussion also made me think if the listener program could be integrated in the L3D library, to work in the background (same way as there are functions running already, to check for the cloud connection and "online/offline" switch) - that would be a cool thing to do, so whenever the cube is connected to the cloud it would be already "listening" and we wouldn't have to load the listener before running the interactive visualizations.

 "C makes it easy to shoot yourself in the foot; C++ makes it harder, but when you do it blows your whole leg off" - Bjarne Stroustrup 

--
You received this message because you are subscribed to a topic in the Google Groups "cubetalk" group.
To unsubscribe from this topic, visit https://groups.google.com/d/topic/cubetalk/w2NAQsHQlIw/unsubscribe.
To unsubscribe from this group and all its topics, send an email to cubetalk+u...@googlegroups.com.
To post to this group, send email to cube...@googlegroups.com.
To view this discussion on the web visit https://groups.google.com/d/msgid/cubetalk/f3383f0e-808a-4390-ae18-47bb94a61e98%40googlegroups.com.

For more options, visit https://groups.google.com/d/optout.

[Werner M.]

Found this one too, another nice WYSIWYG editor: https://youtu.be/_4Wlle8P84A?t=35s

I'm feeling like we could do something like that to our beloved L3D. I'm rusty on Java, but maybe if I can find those old Java handouts from a course I did couple years ago...
But only after I get done with the stuff on the pipeline I've set out to do.

[Dirk S.]

Yeeeaah...this software seems great and exactly what I´m looking for!!! 

Who of you specialists is able to adapt that soft to our L3D cube tube????

[Werner M.]

Aaah, pleeease!!

Will someone let me finish once and for all my remote control project for the cube?!? C'mon!!  ;-)

(damn! that was supposed to be secret)

[Ben Ledbury]

I started looking into a potential JavaScript based editor.

Very rough around the edges but if there's interest I might develop it further.

The next step would be to have storing and editing separate frames and live-streaming to the cube.

https://jsfiddle.net/5515tqqd/3/

[Joep Schipper]

I believe that Lookingglass has her own WYSIWYG editor. I am curious about the progress of it. Does it work?  Ben and Werner  do both marvelous things but is there coworking possible with Lookingglas?

Op maandag 7 september 2015 23:48:48 UTC+2 schreef Dirk S.:

[Dirk S.]

WOW...that looks already pretty amazing!! Please continue with that trial! I´m looking forward how it will grow...

[Werner M.]

Ok. Stop.

Seriously, I think I may have made a breakthrough.
So I found out there's this software program, it's called "Jinx! – LED Matrix Control". What it does, is control almost any type of RGB LED matrix panel (like the neopixel ones - "uh, but isn't the L3D cube made of those?" - Aahmm, YEA!!)
It is designed to communicate and stream animations, text, pictures, even.. VIDEO to those panels. To that end, it's highly configurable: the first thing you need to do is set up certain parameters, in order for the software to be able to talk to the RGB matrix and tell it where, when and how to paint a "voxel" in your RGB matrix.

With me so far?
OK. So we have a software that is multi-protocol, multi-platform, has lots of built-in features - it can even take an audio input from your PC and do the "spectrum analyzer" (not as pretty as my "FFT_Meteors" viz) or the "VU meter" (again, not as pretty as my "3D Audio Rainbow" viz) and it can control the neopixel LEDs in the L3D! Ah, and it's FREE. And it's done. Ah yes, if you get tired of playing with the built-in visualizations that come with it, it also allows for programming your own visualizations in a scripting language (Jinx!Script) and stream them to the RGB matrix.

So I've spent a couple hours playing with it and done a few experiments, until I had some results. Turns out after a bit of fiddling, I was able to get this thing to light up my cube.
But (there's always a butt - sorry, but), the data sent to the cube is obviously wrong, as the cube isn't exactly lighting up as it's supposed to - the LEDs light up, but not displaying the colors like in the preview window on the application. And currently, not all LEDs are lighting up. But we'll get to the details on that later.

** But hey, I've been able to make the cube "listen" to UDP packets, I've streamed some data to it from the application, the cube has acknowledged that, and even tried to show the data in the LED strips! That's a ton of progress for just a couple hours work, IMHO.

So, what I've done to achieve that, was a combination of setting the parameters into the program and creating my own "listener" sketch in Particle's Web IDE.

Still with me?
OK, so let me show you what steps I've taken to get to where I am at this time:

• Downloaded Jinx! and installed it on my machine;
• Read the user manual (not as thoroughly as I should have yet, as I was overly-excited to start doing something with it);
• Then, I started looking at what options I needed to set up. Basically, you've got 3 parameters to configure (refer to the attached pictures for reference):

1. The matrix dimensions (width X height): since we've got a 3D cube that is made of 8 panels of 64 LEDs, I've set it up as a 64 (width) by 8 (height) matrix.
2. The type of output device: the list of devices has a few presets; after reading the included user manual, I've determined that the best option would be to configure the output device as a "tpm2.net" device. This one allows for configuring an IP address for the target device, with the given port for UDP streaming. Since the cube allows for UDP protocol streaming, this means I could get the animations from my PC to the cube wirelessly, via my own home network (same thing as if you'd be streaming an "interactive" app from cubetube.)
3. The output "patch" mapping, for each of the LEDs: This is one of the things that are still a grey area to me. I haven't understood exactly how to work this out for the cube. Even the documentation is not clear on what this does and how I need to see the mappings in relation to the LED strips in the cube. So I decided to try the "Fast Patch" option first.

So, in order for the cube to be ready for this program, it needs to be made a "listener". And the astute ones who are still with me, must have noticed that the port number is fixed, so I wrote a small sketch that has the sole purpose of making the cube constantly listen to UDP packets on that port (65506) and draw the "voxels" according to the data received. There's absolutely no special treatment being given to that data (no skipping first few bytes, no parsing) - apart from just "cutting off" any remainder bytes after the data receive buffer has been completely filled out. So here's the sketch I wrote:

#include "beta-cube-library-v3.h"

Cube cube = Cube();

// UDP Port used for UDP communication
unsigned int localPort = 65506;

// An UDP instance to let us receive packets over UDP
UDP Udp;

// This stores how many bytes we've received via UDP
int32_t bytesrecv;

void setup() {
    cube.begin();
    cube.background(black);
    cube.show();

    // start the UDP
    Udp.begin(localPort);
}

void loop() {
    bytesrecv = Udp.parsePacket();
    if (bytesrecv > 0) {
        if(bytesrecv >= PIXEL_COUNT) {
            char data[PIXEL_COUNT];
            // Read first 512 chars of data received
            Udp.read(data, PIXEL_COUNT);
            // Ignore all other chars
            Udp.flush();
            // Start painting the cube with the data received
            for(int x = 0; x < cube.size; x++)
                for(int y = 0; y < cube.size; y++)
                    for(int z = 0; z < cube.size; z++) {
                        int index = z*cube.size + y*cube.size + x;
                        Color pixelColor = Color((data[index]&0xE0)>>2, (data[index]&0x1C)<<1, (data[index]&0x03)<<4);   //colors with max brightness set to 64
                        cube.setVoxel(x, y, z, pixelColor);
                    }
            // Display!!
            cube.show();
        }        
    }
}

As you can see, it's a simple UDP listener; it takes data that comes in through specified UDP port that we've specified at setup() function and tries to paint the LED strips according to what that data says.
If you are going to try this out on the Particle IDE, remember to include the beta-cube-library-v3.1 (either by searching in the IDE and adding it to the sketch, or including the .h and .cpp files to your sketch).

The two issues I think need to be worked out are:

• The format in which the data is being sent from the program, in order to know better if we need to do some processing to it before going off painting the cube. I just took the raw data coming in and sent it straight to the cube - which I am a 100% certain is the wrong way to do it.
• The other thing is to get the output patch mappings right. As I mentioned earlier, I haven't grasped the concept yet, so I'm in the dark here.

But, the cube responds to the program! And it reacts amazingly fast as well. You turn on the program's output (Setup > Start Output) and the cube lights up. You turn the output off (same option), and it immediately turns off. Faster than cubetube (of course - you're over a LAN, not talking to a web server that's a hundred thousand miles away from you).

So what needs to be done now is to figure out these variables. I'm hoping maybe Alex and Shawn will take an interest and jump in to shed some light. In the meantime, I will continue to experiment until I get it right, eventually.

With this, I hope to have brought some good news to this discussion. Maybe we're just a few steps to a final solution. The more help I get, the faster we'll get there.  ;-)


-Werner

[Werner M.]

Ok.

So I've been trying to find out more about that tpm2 protocol, and it seems the only available source of useful information is in german: http://www.ledstyles.de/index.php/Thread/22271-Jinx-LED-Matrix-Control-und-die-n%C3%A4chste-Matrix-Software
There is a post in that board by user "Seddi", who published a sample output code taken from that protocol (as far as I can tell from my rusty german, it's been set to draw into a 32x16 matrix, all LEDs in red, with a R-G-B bit order. From the source code posted, it looks like the first 4 bytes (C9 DA 06 00) are some sort of control (or header) for that protocol, as well as the last byte (36).

So I modified my listener to try and skip these 4 bytes and go straight to the color data, like so:

#include "beta-cube-library-v3.h"

Cube cube = Cube();

// UDP Port used for UDP communication
unsigned int localPort = 65506;

// An UDP instance to let us receive packets over UDP
UDP Udp;

// This stores how many bytes we've received via UDP
int32_t bytesrecv;

void setup() {
    cube.begin();
    cube.background(black);
    cube.show();

    // start the UDP
    if(Udp.setBuffer(PIXEL_COUNT + 4))
        Udp.begin(localPort);

}

void loop() {
    bytesrecv = Udp.parsePacket();
    if (bytesrecv > 0) {

        if(bytesrecv >= PIXEL_COUNT) {
            char data[PIXEL_COUNT + 4];
            // Read first 516 chars of data received
            Udp.read(data, PIXEL_COUNT + 4);

            // Ignore all other chars
            Udp.flush();

            int index = 4;  // We're skipping the first 4 tpm2 protocol bytes

            // Start painting the cube with the data received

            //for(int z = cube.size-1; z >= 0; z--)
            for(int x = cube.size - 1; x >= 0; x--) {      // Linewise, starting from leftmost index
                for(int y = cube.size - 1; y >= 0; y--) {  // Columnwise, starting from bottommost index
                    //int index = x + y + (cube.size-1-z);
                    //int index = z*cube.size + y*cube.size + x;
                    Color pixelColor = Color(data[index], data[index+1], data[index+2]);  // Take 3 bytes from the array
                    cube.setVoxel(x, y, cube.size - 1, pixelColor); // We're only drawing 2 dimensions (width & height)
                }
                index+=3; // Increment the array index by 3 bytes
            }
            // Display!!
            cube.show();
        }
       
    }
}

By using the trial-and-error process, I've been able to determine the correct color order to at least light up the voxels in the correct colors (using the "Simple Color" effect to check).
Then I started trying out the different selections in the "Fast Patch" options window, but the closest I got to what was being shown in the preview window was the option to draw "Linewise, starting Top-right", which makes absolutely no sense whatsoever to me. And still, it's not perfect. There are visible gaps occurring (sometimes the 8th column isn't drawn at all), and when changing to a more definite effect (e.g., "Falling Rain"), it shows me vertical bars being drawn randomly instead of the nice trailing "raindrops". At least, they are in the correct colors..  ;-/

I even tried changing the order in which I would index the voxels in the for() loops in my code. No avail.
So my current issue is figuring out how to index the voxels according to that tpm2 protocol and understand in which order I need to map each voxel in the patch window, to correctly set the voxels in the cube.

I would ask the author directly in the forums, but I do not feel enough confidence in my german to do it. Perhaps one of our german-speaking members here would take a chance? If so, then it would be nice to also ask the author for implementing the 3rd dimension (depth) into his code, so we would be able to fully address the 8x8x8 layers of the cube.

Anyone?? Bueller? Anyone??

[Werner M.]

In my last post I forgot to include the screenshot of the Fast Patch window with the options I've set.

[Werner M.]

And another thing, I've changed the display dimensions to: 8x8 for the sake of experimenting with the first face (z = 7) of the cube only.

[Dataway]

Ugh..this is a windows only application ... have to dust off my windows laptop..thanks for finding this Werner...

[Werner M.]

(Well, can't make everyone happy, can ya??)

So there's this other app, GLEDiaTor. It's written in Java. Runs in any computer. It claims to support the tpm2.net, so when I'm done making my listener for the cube, it should work in this app too.
But I have tried it a bit today and couldn't get much further - it ended up crashing on me.

So, I found some specs on the tpm2.net protocol (in german) - I'm going to focus my efforts on making the cube work with the tpm2.net protocol and forget about the rest. I've got too much in my hands already (it looks like I'm pretty much on my own in this one).
After that, everyone will be able to play with the listener and use whatever app they like.

[Shawn Frayne]

Hi Ben and Werner and all!

Alex and I and the Looking Glass team are emerging from our cave of building and shipping the Big Cubes and CubeWalls,  Just wanted to say, you're way ahead of us on this WYSIWYG and advanced streaming work -- which is ridiculously cool!  We've some catching up to do and then will aim to contribute.

-Shawn, Looking Glass

[Dataway]

Hi Werner....I am just not to fond of Windows but I got my laptop out and am loading it up and will try and help out if I can...this darn work thing gets in the way of having fun with the cube...

[Dirk S.]

Hey Werner and all the other Specialists ,
you are such incredible!!!
Thanks again for your big efforts. I'm really curious about your progress and how it works
with the great cube!

[Werner M.]

Ok, well. I was up until 4am last night because I couldn't sleep with this damn thing in my head.

I am still not getting the frames to reassemble together correctly in the cube, but I can say I must be getting pretty darn close.

The protocol is not too complicated but the lack of information about setting up the LED matrices on the software documentation plus the fact that the "official" protocol specs are all in german turned this into a huge challenge.

In the next days I am going to experiment some more by adjusting my existing code according to some examples scattered on the net - maybe this will speed up things a little.

Ta.

-Werner

 "C makes it easy to shoot yourself in the foot; C++ makes it harder, but when you do it blows your whole leg off" - Bjarne Stroustrup 

--
You received this message because you are subscribed to a topic in the Google Groups "cubetalk" group.
To unsubscribe from this topic, visit https://groups.google.com/d/topic/cubetalk/w2NAQsHQlIw/unsubscribe.
To unsubscribe from this group and all its topics, send an email to cubetalk+u...@googlegroups.com.
To post to this group, send email to cube...@googlegroups.com.

To view this discussion on the web visit https://groups.google.com/d/msgid/cubetalk/8e13a5f2-b7ee-474a-8c98-3bbfb704adcb%40googlegroups.com.

[Joep Schipper]

Werner,

I believe that when you ask something in English on the German forum "Ledstyles.de" they will surely respond in English. Young Germans speak rather well English and  above all are very polite!

I live very near the Dutch / German border.

Joep

Op maandag 7 september 2015 23:48:48 UTC+2 schreef Dirk S.:

[Dirk S.]

Dear Werner,

sorry for being the "stupid guy" who started the request for those kind of tool!! ;)

Anyway, I´m always happy when I read a new post from you, because then I´m sure that the WYSIWYG editor is growing and will be great at the end!  

As you maybe (already) noticed due to my disgusting english, I´m from Germany.

But here is my offer: I would be glad, if you send me the german sentence you are struggling with and I try to translate it into german, as good as I can!

What do you think?

Best regards, Dirk

[Werner M.]

Excelsior!!

https://youtu.be/5dao7m67Og0

[Dirk S.]

I can´t believe it!!!

You did it!!! This is so cool!!!

CONGRATULATION !!!!

Are those results based on that new protocol that you have written for the cube?

What steps are necessary to get this protocol running either on my cube?

Am Freitag, 18. September 2015 20:16:02 UTC+2 schrieb Werner M.:

Excelsior!!

https://youtu.be/5dao7m67Og0

[Werner M.]

Yes, it works in the Cube. On both "Glediator" and "Jinx!", and using the TPM2.net protocol over a UDP connection on your LAN.

I apologize for the video, I wanted to edit it more in order to rotate the frame at around 0:48, but YouTube decided it was enough editing for me so i gave in. Apologies once again, for any neck injuries caused by my video.  ;-)
The "steps necessary" to get this running in your cubes, are simple:

• Download and run either Glediator or Jinx!, from the links I've provided both here and in the video description.
• Get on your knees, and beg me for the sketch. I might consider giving it to you.  ;-D

(Just kidding!! I am finalizing some "polishing up" in the code and I shall be back later with the source code for everyone to try.

One thing to note though, I published the sketch earlier in cubetube - but when I downloaded it to my cube it would not work!

This only confirms my suspicion that there is an issue in cubetube, which is stopping cubes from openig UDP sockets (as discussed on another topic). Henceforth, no one's getting the interactive demos to stream. Since the cube library is unlikely to be the culprit (I use virtually the same code with some additions to it in my v3 library on Particle Web IDE), there must be some other library being loaded behind the curtain that is responsible for this malfunction.
So I must regretfully say that until this issue is discovered and fixed, my code won't be available through that channel. I will post it here though, for those who want to paste it to the Web IDE and compile via the Particle Web app.

[Alvin Lee]

Great Work! 

Certainly worth all the neck twisting : p

[Werner M.]

Right! All ready to be blown away??

(That is, those who survive through the next steps I'm about to describe).

So you all need to download the program. It's going to be either jinx! or Glediator (links on my earlier post). Windows users can choose either, Linux/Mac users will have to go with Glediator (actually much fancier, but both are extremely similar and provide astounding effects - so if you're a Windows user, I suggest you go for both, to see what little differences are between the two, and pick which one delights you most).

Configuration steps below are for Glediator. For those who will try jinx! a little bit of fiddling will reveal it's pretty much the same stuff located in different places.

Let's go!

First, download the sketch. Copy the content and paste it in a new App that you will create on Particle Web.
And don't forget to include the "beta-cube-library-v3.1" that I've published there - check my post on the topic about Hape's Text Library here on the forums for step-by-step instructions on both procedures.

In addition to having the cube running the attached sketch, there's a few settings in the program, that you need to make sure are correctly done - here's a quick run-down for GLEDiator:

Options menu > Matrix Size:


Options menu > Output:

Options menu > Output > Patch Artnet/TPM2.Net:

This is the tricky part. It is critical that you do this correctly, or else your cube will display gibberish instead of nice graphics.

Start on the right panel, add the IP address of your cube, max. channel is 192 (64 * 3 if your cube is an 8x8x8 type; otherwise, double the values except the 3), leave remaining fields unaltered.

Make sure parameters CH-R / CH-G / CH-B are set respectively, at 0 / 1 / 2. Then select the patch order (the correct patch order should be set to "vertical line wise - starting bottom right), then check the Auto Inc. box.
Then, on the left panel, starting from cell 1.1, drag the mouse all the way down to cell 8.8 (make sure every cell has been selected). Click Patch Selection.

To confirm that the patch is done correctly, check the left panel boxes: starting from cell 8.8, the R: /G: /B: values should increment from bottom to top, then continue on to the bottom on left neighbour column, like so:
Cell 1.1: R:189/G:190/B:191 | Cell 1.2: R:165/G:166/B:167 | Cell 1.3: R:141/G:142/B:143 | Cell 1.4: R:117/G:118/B:119 | Cell 1.5: R:93/G:94/B:95 | Cell 1.6: R:69/G:70/B:71 | Cell 1.7: R:45/G:46/B:47 | Cell 1.8: R:21/G:22/B:23
Cell 2.1: R:186/G:187/B:188 | Cell 2.2: R:162/G:163/B:164 | Cell 2.3: R:138/G:139/B:140 | Cell 2.4: R:114/G:115/B:116 | Cell 2.5: R:90/G:91/B:92 | Cell 2.6: R:66/G:67/B:68 | Cell 2.7: R:42/G:43/B:44 | Cell 2.8: R:18/G:19/B:20
Cell 3.1: R:183/G:184/B:185 | Cell 3.2: R:159/G:160/B:161 | Cell 3.3: R:135/G:136/B:137 | Cell 3.4: R:111/G:112/B:113 | Cell 3.5: R:87/G:88/B:89 | Cell 3.6: R:63/G:64/B:65 | Cell 3.7: R:39/G:40/B:41 | Cell 3.8: R:15/G:16/B:17
Cell 4.1: R:180/G:181/B:182 | Cell 4.2: R:156/G:157/B:158 | Cell 4.3: R:132/G:133/B:134 | Cell 4.4: R:108/G:109/B:110 | Cell 4.5: R:84/G:85/B:86 | Cell 4.6: R:60/G:61/B:62 | Cell 4.7: R:36/G:37/B:38 | Cell 4.8: R:12/G:13/B:14
Cell 5.1: R:177/G:178/B:179 | Cell 5.2: R:153/G:154/B:155 | Cell 5.3: R:129/G:130/B:131 | Cell 5.4: R:105/G:106/B:107 | Cell 5.5: R:81/G:82/B:83 | Cell 5.6: R:57/G:58/B:59 | Cell 5.7: R:33/G:34/B:35 | Cell 5.8: R:9 /G:10/B:11
Cell 6.1: R:174/G:175/B:176 | Cell 6.2: R:150/G:151/B:152 | Cell 6.3: R:126/G:127/B:128 | Cell 6.4: R:102/G:103/B:104 | Cell 6.5: R:78/G:79/B:80 | Cell 6.6: R:54/G:55/B:56 | Cell 6.7: R:30/G:31/B:32 | Cell 6.8: R:6 /G:7 /B:8
Cell 7.1: R:171/G:172/B:173 | Cell 7.2: R:147/G:148/B:149 | Cell 7.3: R:123/G:124/B:125 | Cell 7.4: R:99/G:100/B:101  | Cell 7.5: R:75/G:76/B:77 | Cell 7.6: R:51/G:52/B:53 | Cell 7.7: R:27/G:28/B:29 | Cell 7.8: R:3 /G:4 /B:5
Cell 8.1: R:168/G:169/B:170 | Cell 8.2: R:144/G:145/B:146 | Cell 8.3: R:120/G:121/B:122 | Cell 8.4: R:96/G:97/B:98    | Cell 8.5: R:72/G:73/B:74 | Cell 8.6: R:48/G:49/B:50 | Cell 8.7: R:24/G:25/B:26 | Cell 8.8: R:0 /G:1 /B:2

Click Done.

Then, if everything's done right, your target cube should be already playing back random animations streamed by the program (they should be on par with what the main screen is showing). Otherwise, go back to the Output options screen, click Open Socket (btw, you will need to do this every time you restart the program).

Usage - Main screen:

There are 3 main channels - think of this screen as a mixing console for audio. Left is left playback, right is right playback. Center is mixed (left + right) playback. It's what you'll actually see on the cube.

Apart from that, each channel has 5 buttons numbered 1-2-3-4-5. Each can be assigned a different animation , and these will mix together and play simultaneously, so the combinations are virtually infinite. At the leftmost panel, you can see examples of that. The effects on these panels were created by mixing different effect types. You choose one by clicking it. Then load it by clicking the Set L or Set R button. Way cool!!

Even cooler is the rightmost panel: It runs preset sequences of animations. Click Start Playing and lean back on your chair in awe!! 😱

Careful with the brightness levels - don't fry your cube!! the Level and Master sliders act as a fader (in this case it'll control the brightness of the LEDs. So before doing anything, make sure these are adjusted within the left-middle range (unless you've got a beefy PSU feeding your cube externally).

Alright, so get going. There isn't going to be any "hand-holding" - questions will be answered only if they haven't been covered here. I shall remind everyone I slaved over this for the past days. I'm giving it to you for free. Least you can do is try to get it going on your own.

Enjoy, and post back your impressions, if you get it running on your cubes.

[Werner M.]

I just made myself a freakin' lava lamp in just 5 minutes!
https://youtu.be/3qh64V95gAk

That is way cool.

[Dirk S.]

Hey Werner,

first of all a huge thanks for that great tutorial!!

I´ve followed your instruction step by step and everything seems great so far. Uploading the TPM2_Net listener were no problem!

But when I finished the configuration of GLEdiator, the system stated: Failed to open TPM2.Net socket!!

Solution how I get rid of this issue (I hope this was the reason ;) ) -> I´ve set a UDP Port 8080 forwarding rule in my Wireless router.

Since that time, the Cube startet to fire up all the great animations from GLEdiator!!!

Again a big thanks for your time and effort to get this thing working!

BR Dirk

[cube...@gmail.com]

hi Werner

thats very impressive. I have not tried this one but thats what all of us wanted to have. I will give this a try and tell  if i get managed it to work.

thx

hape

[Joep Schipper]

Werner, indeed impressive!

Dumb question:  how do i find the IP adress of my cube?

Joep

Op maandag 7 september 2015 23:48:48 UTC+2 schreef Dirk S.:

[Werner M.]

Ok Joep, that's in your wireless router DHCP settings. Usually there's a section in your router's web admin panel that tells you which clients are currently connected and what IP was assigned to them. You identify your photon by its MAC address.

Unfortunately, there's a part of the whole config process (as Dirk correctly pointed out) that depends on your router being configured to allow data transmission within your internal network. I cannot help you in this area, as it depends on your router's make and model, as well as the internal capabilities. So I suggest you refer to your router's manual and/or your internet service provider's customer helpline.

One thing I suggest to all is that you make the cube's internal IP permanent (usually routers default to DHCP assigning a "randomly-chosen" IP within the range of IPs specified in the settings), so you won't have any "surprises" (e.g., one day you'll try to connect and nothing will happen due to the router's DHCP changing your photon's IP address).

[Werner M.]

I also feel the need to say a huge thank you to the developers of Glediator and Jinx, without whom, none of this would ever be possible.
Not only they did a great job, but they also made their work available to all for free.

So endlich, muss Ich wärmliche Bedanke an Seddi und Pepe_1981 hier lassen.  ;-D
(I hope I was able to convey the message despite my crappy german).


-Werner

[Werner M.]

OK. now here's another goodie I was saving for sharing with all.

Want to turn your Cube into a groovy "moodlight" and control it directly from your Android phone?
You can. Now.

Follow these steps:

1. Install the Android app on your phone from here
2. Flash the attached "SparkPixels" sketch on your Cube (see "Flashing the Firmware" below)
   
3. Launch the app and login to your Particle.io account
4. You should see a list of your Particle devices, select your Core/Photon from the list
5. Bring up the settings page (sliding your finger from the bottom of your phone's screen should bring up the menu)

Important: Tap Spark Core Neopixel Driver from the settings page and select your Photon/Core. The app won't be able to communicate with your device if you skip this step

Flashing the Firmware

1. Go to the Particle Web IDE (https://build.particle.io/build/)
2. Click on CREATE NEW APP and name it what you wish.
   
3. Add the NEOPIXEL library - Click on the libraries icon and select NEOPIXEL (it should be at the top of the list). Then click on INCLUDE IN APP. Select the app you just created from the list. Then click on ADD TO THIS APP.
4. Copy and paste the SparkPixels.ino code into the app, replacing any existing text.
5. Update the PIXEL_CNT and PIXEL_PIN (near the top of the code) for your setup (in case your cube is greater than a 8x8x8, otherwise you do not need to change anything)
6. Update the TIME_ZONE_OFFSET (around line #130 in the code) to match your timezone's offset, with respect to UTC (I defaulted it to -3, as it's the correct one for my country)
   

Important: You do not need to add the beta-cube-library-v3.1 library! - This sketch will drive the pixel strips directly, using NEOPIXEL.

I already got a few ideas in mind, like integrating the code from cubetube's visualizations into it and control them via the app. That would be the ultimate in controlling your cube! And I definately would throw away my initial idea to control the cube via an IR remote.. Stay tuned folks.


Ta,
-Werner
(BTW, this one was done by this guy, not me. I've just made a few adjustments in the code to make it suit in the L3D Cube. So take some time to give him kudos and perhaps bump up his rank on Google Play Store. He deserves it.)

[Dirk S.]

Unfortunately not available for iOS user!

Or is there an alternative app for iOS downloadable?

[Werner M.]

I don't think so, Dirk.
Maybe buying a 'cheapo' android phone, just to use the app as a remote control for the Cube, would be an option?

--
You received this message because you are subscribed to a topic in the Google Groups "cubetalk" group.
To unsubscribe from this topic, visit https://groups.google.com/d/topic/cubetalk/w2NAQsHQlIw/unsubscribe.
To unsubscribe from this group and all its topics, send an email to cubetalk+u...@googlegroups.com.
To post to this group, send email to cube...@googlegroups.com.

To view this discussion on the web visit https://groups.google.com/d/msgid/cubetalk/40698f37-aa6c-45d5-ba83-e41bca567091%40googlegroups.com.

[Dave Morgan]

This is great Werner!  I can hardly keep up with all the fun stuff you keep posting. ;-)

Just a quick note though for others who may try this - I got this to work on my 16x16x16 cube, but it only controls the rear two planes.  I'm fairly certain that the big cube is driven as eight separate strips of 512 pixels (using multiple pins) so that is probably why.  It might be possible to modify this using code from the big cube demo but that's beyond my current ability in coding.  This will be really nice on my 8x8x8 cube though!

[cube...@gmail.com]

hi @Werner

did the Cube/Photon knows his own ip-address? It would be easy to show the address with the Text feature.

hape

[Werner M.]

Ok, answering one question at a time.

There is a way for the photon to retrieve its own local address. The Particle docs' reference tells you how. Then you only need to use one of the text functions in the beta-cube-library-v3.1 to display it as a string (have a look at the example TEXT.CPP on ways to do it). But as I said before, if your router is set to DHCP automatically assigning IPs to the devices that connect to it, then you may not have a consistent result. The safest way would be to obtain the cube's MAC address (also available as a function in particle's library).

But to be honest, for you to go through all that (coding, compiling, displaying in the cube, etc) just to get that info, which is easily accessible through your router's Web Admin panel... I think it's kind of overkill. Anyway.

For the cube size issue: The sketch I provided as a default initializes the Cube class with the standard values (size = 8), so in order for you to make it suit your cube, you'll need to do two things:
Modify the sketch - remove this line:

Cube cube = Cube();

And replace it by this line:

Cube cube = Cube(16, 50);

16 is your cube's size, 50 is the maxBrightness value (must be supplied).

You also need to change this code:

#define PIXELS_PER_PANEL        (PIXEL_COUNT / NR_OF_PANELS)

By this:

#define PIXELS_PER_PANEL        ((cube.size * cube.size * cube.size) / NR_OF_PANELS)

In Glediator, you will also need to change the options:

Options menu > Matrix Size: Both Size_X and Size_Y must be set to 16.
Options menu > Output > Patch Artnet/TPM2.Net: You will need to re-patch the whole matrix. As you will notice, it has doubled in height and width. Max channel is 768 now. Then follow the rest of the tutorial on how to select and patch the matrix cells.

This should cover the 16x16x16 cubes, as these changes are not done 'automagically' by the library (as Alex pointed out in another topic, there would be the need for the hardware to somehow provide an external means for the code to 'detect' whether it's a 8x8x8 or 16x16x16 baseboard.

Let me know how that goes.

-Werner

[Dave Morgan]

I should have been more specific Werner.  My comments regarding the size were for the SparkPixels Android app.  Having said that, I have been wanting to play with Glediator as well so your instructions for that are also appreciated.  I will be trying that in a few minutes. :-)

[Werner M.]

I have just taken a peek at the schematic diagram of the 16x16x16 cube, there are significant hardware differences.
Each of the 16 16x16 layers of the cube is made of 8 groups of 32 voxels, each being driven by one of 4 data output pins.
The schematic I have makes no reference to how the other layers are connected, I suppose there is some sort of multiplexing going on, or maybe there is more daisy-chaining - that's not clear in the schematic.

I'm assuming the firmware takes care of that, and if this is true, then there must be a 16x16x16 version of the cube library with the cube.show() function doing the actual multiplexing. I haven't seen it so I trust that the library wrapper is transparent to the users (hopefully).

If all of this checks out, the changes I mentioned in my post above should take care of the 16x16x16 cubes for my UDP listener sketch.
As for the other sketch, it's a different story, as I need to know first and foremost, how to drive the pins in order to make a complete 256-byte frame.

-Werner

[Dirk S.]

Hi Werner,

tried something else instead of buying a cheap android device!

I´ve installed an emulator on my macbook, called "Andy" ... and what should I say: It´s running like crazy!!! :D

Your tutorial works again without any issues!! You´re really a genius!!! ;) I love those apps to control our beloved Cube!! 

Br Dirk

[Werner M.]

Yep, that or BlueStacks, they emulate an Android phone on your PC.

But I did not suggest you do that, as I thought it would defeat the purpose of portability of the app. But of course, it will work.

I'm no genius, I'm just passionate. And the idea belongs to somebody else, they deserve all credit.

:-)

[Werner M.]

Errata: when I said "portability" what I meant was "mobility". Portability refers to code being 'portable'. Sorry, false cognat between languages.

[Werner M.]

My cube spent the day playing back a mix of a jinx script that converts sound into 'waves' and a color fading background. Fantastic.
Now it's late evening and I loaded the SparkPixels sketch into it and turned on the moodlight. How about that?

My favorite mode so far has to be the "RAINBOW" one, on the "Cheetah" speed setting. How mesmerizing. I am happy.

It inspires me to do more. In the next weeks I plan to incorporate visualizations from cubetube into the sketch - if I succeed, these visualizations will be selectable from the app.
In between this and that (and the occasional work), I'm going to try and squeeze in a fix to include the 16x16x16 cubes into it.

[Werner M.]

Hi Dave,

As I pointed out before, looking at the schematic told me that the 16x16x16 cube is a different beast. So I looked into the subject and found that according to information Alex posted on this forum topic, there isn't a library for the 16^3 cubes yet. He's currently working on that, and furthermore I found this code from the 16^3 demos being currently shipped.

Looking at the void show() function reveals how enormous of a beast this is. It confirms the suspicions I had after having looked at the schematics: the way the neopixel stripes in the 16^3 cubes are addressed is completely independent from the neopixel library - even more - Alex has devised his very own custom multiplexing scheme, which employs the D0-D4 lines to address the power distribution to each cluster of strips (via MOSFET transistors), in combination with the A3-A5 lines for 8-bit addressing plus A2 for strobing (or write enable - my guesses).

The code is far more complex than I'd have imagined. It's addressing the pins via GPIO low-level code and I am nuts if I'm going to touch that work. Sometimes two cooks in the kitchen is already one too many. I'll bail out on this one and let Alex finish his work.

So please bear with this as the changes I've suggested in my earlier post won't yield any positive results to the 16^3 cubes. Neither my own spin-out of the beta-cube-library nor NeoPixel library itself will help.

Sorry to be the bearer of bad news. But considering that these big cubes are even newer than the 8^3 ones (and look how beautiful they turned out), I am confident that it's just a matter of time to have their 'big brothers' 'speaking Cube()' too.


Ta,
-Werner

[Dave Morgan]

No problem Werner - thanks for looking.  Oddly enough, I was sure I posted something after your initial query about that schematics, that contained a link to the demo code.  Now I see that it's not in the thread, but there is a "This message has been deleted" showing instead, in the slot where I thought I posted.  Weird.

Even without support for the big cubes, I'm still very excited with everything you are doing.  I'll have fun playing with my 8x8x8 cube in the meantime. :-)

[Werner M.]

Dave, I don't like Google forums. Have posted a reply to all through my email digest and it created a new topic. There are better platforms out there and I wonder why the choice for this one was made. Just thinking that it's coming from Google, they could've developed a better platform.

 "C makes it easy to shoot yourself in the foot; C++ makes it harder, but when you do it blows your whole leg off" - Bjarne Stroustrup 

2015-09-21 12:58 GMT-03:00 Dave Morgan <da...@davemorgan.org>:

No problem Werner - thanks for looking.  Oddly enough, I was sure I posted something after your initial query about that schematics, that contained a link to the demo code.  Now I see that it's not in the thread, but there is a "This message has been deleted" showing instead, in the slot where I thought I posted.  Weird.

Even without support for the big cubes, I'm still very excited with everything you are doing.  I'll have fun playing with my 8x8x8 cube in the meantime. :-)

--
You received this message because you are subscribed to a topic in the Google Groups "cubetalk" group.
To unsubscribe from this topic, visit https://groups.google.com/d/topic/cubetalk/w2NAQsHQlIw/unsubscribe.
To unsubscribe from this group and all its topics, send an email to cubetalk+u...@googlegroups.com.
To post to this group, send email to cube...@googlegroups.com.

To view this discussion on the web visit https://groups.google.com/d/msgid/cubetalk/75d68c89-5636-4eba-ab38-fce7549d51be%40googlegroups.com.

[Dirk S.]

Hi Werner,

now I'm portable with SparkPixels. ;)

With some small modifications it's possible to install Android Apps even on a Blackberry Z10 and
that is what I did!
Works Great!

Br Dirk

Am Sonntag, 20. September 2015 23:33:24 UTC+2 schrieb Werner M.:
> Yep, that or BlueStacks, they emulate an Android phone on your PC.
>
> But I did not suggest you do that, as I thought it would defeat the purpose of portability of the app. But of course, it will work.
>
> I'm no genius, I'm just passionate. And the idea belongs to somebody else, they deserve all credit.
>
> :-)
>
> Em domingo, 20 de setembro de 2015 18:28:29 UTC-3, Dirk S. escreveu:
> Hi Werner,
>
>
> tried something else instead of buying a cheap android device!
>
>
> I´ve installed an emulator on my macbook, called "Andy" ... and what should I say: It´s running like crazy!!! :D
> Your tutorial works again without any issues!! You´re really a genius!!! ;) I love those apps to control our beloved Cube!! 
>
>
> Br Dirk
>
> Am Sonntag, 20. September 2015 16:24:11 UTC+2 schrieb Werner M.:
> I don't think so, Dirk.
>
> Maybe buying a 'cheapo' android phone, just to use the app as a remote control for the Cube, would be an option?
>
> Em 20/09/2015 08:09, "Dirk S." <dschrec...@web.de> escreveu:
>
> Unfortunately not available for iOS user!
>
>
> Or is there an alternative app for iOS downloadable?
>
>
>
>
> Am Sonntag, 20. September 2015 00:36:37 UTC+2 schrieb Werner M.:
> OK. now here's another goodie I was saving for sharing with all.
>
> Want to turn your Cube into a groovy "moodlight" and control it directly from your Android phone?
> You can. Now.
>
> Follow these steps:

> Install the Android app on your phone from hereFlash the attached "SparkPixels" sketch on your Cube (see "Flashing the Firmware" below)
> Launch the app and login to your Particle.io accountYou should see a list of your Particle devices, select your Core/Photon from the listBring up the settings page (sliding your finger from the bottom of your phone's screen should bring up the menu)Important: Tap Spark Core Neopixel Driver

> from the settings page and select your Photon/Core. The app won't be
> able to communicate with your device if you skip this step
>
> Flashing the Firmware
>
> Go to the Particle Web IDE (https://build.particle.io/build/) Click on CREATE NEW APP and name it what you wish.

> Add the NEOPIXEL library - Click on the libraries icon and select NEOPIXEL (it should be at the top of the list). Then click on INCLUDE IN APP. Select the app you just created from the list. Then click on ADD TO THIS APP.Copy and paste the SparkPixels.ino code into the app, replacing any existing text.Update the PIXEL_CNT and PIXEL_PIN (near the top of the code) for your setup (in case your cube is greater than a 8x8x8, otherwise you do not need to change anything)Update the TIME_ZONE_OFFSET (around line #130 in the code) to match your timezone's offset, with respect to UTC (I defaulted it to -3, as it's the correct one for my country)

[Werner M.]

Dirk,

That's interesting! Would you mind sharing what you did to accomplish that? I'm certain there must be other users eager to try that app on their non-android phones.

-Werner

[Alex Hornstein]

Just to chime in here about the 16x cube — the big challenge with the 16x cube was to be able to refresh the cube at a high framerate (45-60fps).  The limiting factor in the refresh rate is the time it takes to send the digital data to the LEDs.  In the 8x cube, all the 512 LEDs are in series, and it takes (512 LEDs * 24 bits/LED / 800000 bits/sec transmission speed) = 15ms to send all that data, limiting the refresh rate to a max of 65fps.  With the 16x cube, there are eight times more LEDs (4096 LEDs), and if we put all those LEDs in one long string, it would take eight times longer to send out data, and the refresh rate would drop to about 8 fps.  

To get around this issue, we arranged the LEDs in the 16x cube into eight strings, and we update them in parallel.  Unfortunately, the neopixel library we used in the 8x cube doesn’t support parallel strips, and the only library that does, fastLED, isn’t available yet for the photon.  So we built our own low-level code to clock that data out in parallel.  That works well, and we’re able to run the big cube at a full frame rate.  I’m still working on integrating it into the cubetube library, and I’m planning to roll out early support this week.  

—alex

On Sep 20, 2015, at 4:48 PM, Dave Morgan <da...@davemorgan.org> wrote:

The demo reel code for the 16x16x16 cube is available here.  It does indeed have more pins, and a different show method.  In the meantime, I now have the Android app working on my 8x8x8 cube. :-)

-- Dave

--
You received this message because you are subscribed to the Google Groups "cubetalk" group.
To unsubscribe from this group and stop receiving emails from it, send an email to cubetalk+u...@googlegroups.com.

To post to this group, send email to cube...@googlegroups.com.

To view this discussion on the web visit https://groups.google.com/d/msgid/cubetalk/4e70f71b-10ad-406d-9155-4fe722b60159%40googlegroups.com.

[Dave Morgan]

Thanks for the update Alex.  I've done a number of projects using FastLED, so I'm really looking forward to the Photon support. I know the FastLED guys are working on it, so it may not be too far out.

[Werner M.]

Really dumb thought: In my mind, I had pictured instantiating 8 neopixel strip objects, like e.g.:

#include "neopixel/neopixel.h"

//NEOPIXEL Defines
#define PIXELS_PER_CLUSTER 512
#define PIXEL_TYPE WS2812B
#define PIXEL_PIN1 D0
#define PIXEL_PIN2 D1
#define PIXEL_PIN3 D2
#define PIXEL_PIN4 D3
#define PIXEL_PIN5 D4
#define PIXEL_PIN6 D5
#define PIXEL_PIN7 D6
#define PIXEL_PIN8 D7

Adafruit_NeoPixel stripCluster1 = Adafruit_NeoPixel(PIXELS_PER_CLUSTER, PIXEL_PIN1, PIXEL_TYPE);
Adafruit_NeoPixel stripCluster2 = Adafruit_NeoPixel(PIXELS_PER_CLUSTER, PIXEL_PIN2, PIXEL_TYPE);
Adafruit_NeoPixel stripCluster3 = Adafruit_NeoPixel(PIXELS_PER_CLUSTER, PIXEL_PIN3, PIXEL_TYPE);
Adafruit_NeoPixel stripCluster4 = Adafruit_NeoPixel(PIXELS_PER_CLUSTER, PIXEL_PIN4, PIXEL_TYPE);
Adafruit_NeoPixel stripCluster5 = Adafruit_NeoPixel(PIXELS_PER_CLUSTER, PIXEL_PIN5, PIXEL_TYPE);
Adafruit_NeoPixel stripCluster6 = Adafruit_NeoPixel(PIXELS_PER_CLUSTER, PIXEL_PIN6, PIXEL_TYPE);
Adafruit_NeoPixel stripCluster7 = Adafruit_NeoPixel(PIXELS_PER_CLUSTER, PIXEL_PIN7, PIXEL_TYPE);
Adafruit_NeoPixel stripCluster8 = Adafruit_NeoPixel(PIXELS_PER_CLUSTER, PIXEL_PIN8, PIXEL_TYPE);

(...)


Wouldn't be a practical workaround - I'm already considering that this code presents obvious pin (and possibly memory) allocation issues.
Even knowing in advance that this code is not as resource-efficient as yours, I had to get it out of my system.

-Werner

[Dirk S.]

It would be a pleasure ... so here it comes:

Example BlackBerry Z10 

1. Check your OS. Need to be > 10.2.1. I´ve actually OS 10.3.2.2474 running.

2. Open SETTINGS - APP MANAGER - and ENABLE the new function - APP INSTALLATION from VARIOUS (non Google) SOURCES. !! Careful! This step is done on your own risk !!

3. Now search for the app-name with APK extension as a free download version and get it on your phone.

4. Check your FILE MANAGER - DOWNLOADS and hold the desired file pressed for some seconds. This will open a window with an option to INSTALL.

5. Start the app as usual!

One other method is to install some kind of a download manager for APK files, like SNAP or apktrain.com or install Amazon Appstore on your BB10 device, visit http://www.amazon.com/getappstore.

Br Dirk

[cube...@gmail.com]

hi @Dirk

i'm also stopped by the message "Failed to open TPM2.Net socket".

And unfortunately i have no knowledge about udp forwarding and so on. Would please be so kind to explain on which way the data bridge should happen.

I have made a static forward from my computer to my Photon with udp Port 8080 but nothing happens (same message again)

thx in advance 

hape

PS i know that Werner says not to ask this but i want this Glediator running and don't know what to do (or is it impossible with the router Fritz Cable 6490?)

[Dirk S.]

Hape,

even on the risk to disappoint you, but it seems that to open the UDP port in my wifi router was a dead end. Still after I were able to stream all the great pattern directly from GLEdiator or Jinx to the Cube,

I were not convinced by that action and so I started to remove the UDP rule from my router ... and ... it still worked.

But what I´ve done either before I started the successful attempt was to repeat the Tutorial from Werner regarding building the "TPM2.net" listener step-by-step and quite carefully. 

After uploading the listener to the cube again, I was able to open the TMP2.net without error.

Please note: When you start to open the link between Cube and GLEdiator/Jinx make sure, that the MASTER slider for Volume/Brightness is at its minimum. 

If not, then you maybe notice a direct reset on your cube by the high current due to the bright LEDs. And if you have connected you're Cube to a weak USB power source, this will happen immediately.

Consider this fact either, when playing with the App "SparkPixels" !!! 

Br Dirk

[Alex Hornstein]

That does work — that’s how we did the first tests of the big cube.  The problem is that neopixel doesn’t have a way to drive those outputs in parallel — When you output the data, you have to do something like:

stripCluster1.show();

stripCluster2.show();

…

and that ends up dividing the update rate by 8.

—me

To view this discussion on the web visit https://groups.google.com/d/msgid/cubetalk/de3ff82a-3947-45d3-98a1-e22937a9ba6f%40googlegroups.com.

[Werner M.]

Hape & Dirk,

I have the unique privilege of being able to run both Glediator and Jinx in the same machine (Windows 7). And I have seen this issue with the sockets error message happen to me once.
I closed Glediator, opened Jinx, clicked on "Start Output" (which does the same as Glediator "Open Socket" is supposed to do), and bam, I could see it work straight away.
I opened Glediator again, clicked "Open Socket", and it worked again.
This is an issue with Glediator and somehow the way it manages opening and closing sockets on UDP doesn't seem to be done right and hence these issues you're having. It's got nothing to do with router settings.
If you want to certify what I'm saying, just test it this way: with Glediator working (cube showing animations from Glediator) click "Close Socket". Glediator will report that the socket was closed successfully, even though the cube will continue showing the animation. So it has not closed the connection.

IMO, this is an issue that needs to be reported to the authors of Glediator. Even though it doesn't happen too often (at least not with me).

-Werner

Em segunda-feira, 7 de setembro de 2015 18:48:48 UTC-3, Dirk S. escreveu:

I´m a real noob regarding programming code line by line for the L3D cube in the small online editor.

Therefore I would like to know if Lookingglass is working on an WYSIWYG editor to design colourful pattern for the L3D cube quite fast and simple, either for a noob like me?

I have already installed the Processing prog including the L3D cube library, but it´s still not as easy as I would like to have it - but I love the cube! 

Can I expect such a tool in the near future?

[Werner M.]

[EDIT]:
With Glediator working (cube showing animations from Glediator) click "Close Socket". Glediator will not give any feedback (assuming it shoul've closed the connection), even though the cube will continue showing the animation. So it has not closed the connection. Then click again in Open Socket, and you get the error message. Restart Glediator, click Open Socket. It works again.

[cube...@gmail.com]

hi @Werner and @Dirk

for the Listener program should the library V3 used? (which is in the code if you download it here) or the newer v3.1 (yesterday i tried the V3.1). I think i understood how to do it because the Text feature did work. So i give it a new try at home with your tips.

thx for doing and sharing all these nice things :-)

hape

PS if someone is interested i have found an easy way to get the ip-address without looking into the router

[Joep Schipper]

I too have difficulty to stream the TPM2.net listener to my cube.   And "cube" i am interessed in your simple? solution to discover the IP address of my photon.

thanks   Joep

Op maandag 7 september 2015 23:48:48 UTC+2 schreef Dirk S.:

[cube...@gmail.com]

hi Joep

i think you talk to me as cube :-). So this is the code you have to flash to your cube from the Particle build website:

https://build.particle.io

this is the code:

char myIpString[24];

void setup() {

    IPAddress myIp = WiFi.localIP();

    sprintf(myIpString, "%d.%d.%d.%d", myIp[0], myIp[1], myIp[2], myIp[3]);

    Spark.variable("ipAddress", myIpString, STRING);

}

Now you go to the bottom left and click on "Settings". On this Settings panel you see an Access Token. Copy this token.

Now you can list your devices with (put this simply in a browser)  https://api.particle.io/v1/devices/?access_token=here you paste your token

Unfortunately the ip-addresses i see in the field last_ip_address has nothing to do with the ip-address of my devices - so this is really to list only the devices to know that your device/s are registered and off- or online.

But with https://api.particle.io/v1/devices/your_device/ipAddress?access_token=here you paste your token - and replace your_device with the name of your device

this api request in your browser you see the Photon ip-Address

I think its simple and can be done by everybody who has managed to register the Photon.

hape

[cube...@gmail.com]

hi @Werner

i'm so frustrated. I got on the open socket the message that the socket was opened. But nothing happens. I have done all the steps 3 times but it didn't work. If its ok for you i see the only chance in posting my Glediator screens and you take a look (if this is ok for you?).

I feel so near on this fantastic tool but it didn't work and i also didn't know how to test any of these (Do you have an idea of a small test programm to see if the TPM2_NET did really work?).

Thats in my mind allways the thing with the wifi: if it doesn't work its so hard to find the error.

pls be so kind to help me out

hape

[Werner M.]

Hape,

I'm sorry, but apart from the tests I've described in my earlier posts, all I can say is that you could try running Jinx! and see if your cube responds.

If it responds to Jinx, then - again - I say it is Glediator. But even Glediator should work almost all the time. So if it never worked with you, then you may have another issue going on.

-Werner

 "C makes it easy to shoot yourself in the foot; C++ makes it harder, but when you do it blows your whole leg off" - Bjarne Stroustrup 

--
You received this message because you are subscribed to a topic in the Google Groups "cubetalk" group.
To unsubscribe from this topic, visit https://groups.google.com/d/topic/cubetalk/w2NAQsHQlIw/unsubscribe.
To unsubscribe from this group and all its topics, send an email to cubetalk+u...@googlegroups.com.

To post to this group, send email to cube...@googlegroups.com.

To view this discussion on the web visit https://groups.google.com/d/msgid/cubetalk/de292921-fba8-417a-b644-376f648af2fc%40googlegroups.com.

[Todd S]

Hi Hape similar situ here,I am on Yosemite iMac, have started from beginning of Werners instructs a few times and cant get working, but have a virtual machine running with Jinx as per Werners instructs and all works good to port 65506, I have attempted to clear all ports , port forwarded on router etc. and no dice for Glediator. So your not alone..find Jinx quite comprehensive and as its working from a virtual machine know its not the router or any other port specific factor it seems. Have sort of runout of isolating on that basis as if Jinx works so should Glediator, perhaps a driver issue. Thanks for the great instructions Werner have quadrupled the extent of what I am doing with this Cube since following your posts
Todd

[Todd S]

[Werner M.]

Hi Todd,

Thanks, I'm happy it works for you. My last advice regarding this uniquely strange issue with Glediator is that you guys wo aren't getting it to work on your machines work it out between you and the developer. In my machine with only Windows 7 OS installed, both Jinx and Glediator work. So it would be interesting if you guys could isolate the cause of this issue for other users to be able to work it out on their systems as well.

-Werner

[Todd S]

Hi Werner have emailed Solarlab, lets see what they have to say

[cube...@gmail.com]

hi

so after frustrated about the Glediator i have also tested Jinx and this runs fine. So there have to be strange things with the net code in Glediator. 

Everyone who has tested and Jinx did run and Glediator did not run pls poste your environment

So mine is Win7 64 with a router and a wireless Access Point.

I hope to determine what constellation did not work and to come to the point of Working/not working closer

hape

[Todd S]

Hi hape I am on an iMac, El CApitan beta, wireless access , and AT&T router and Jinx runs fine

[Todd S]

[Dirk S.]

Hi,

I´m running an MacBook Yosemite with Parallel Desktop WIN10.

As already mentioned in one of my earlier post, I´m one of the privileged persons who is able to play with both Programs, so Jinx! and even GLEdiator is working fine under WIN10.

But I also noticed that sometimes GLEdiator won´t open the TPM2.net socket. With Jinx! - always successful connection!

Br Dirk

[Werner M.]

Exactly, Dirk. That's what I'v determined after running my tests with Glediator on WIN7. It seems that Glediator fails on managing port 65506 sometimes. Apparently, it's possible to get it working again just by restarting the program.
It seems other people cannot even get it started in the first place. My first suspicion, these are Mac users. Second suspicion, MacOS might have some firewall or some other security protection that is not allowing outbound traffic over UDP on this port. But I cannot test any of that. Unless someone wants to send me a Mac as a gift.  :-)

Anyway, news!!
New and updated SparkPixels script for the Android app - 3 new modes:

1. ColorPulse: IT'S ALIVE!! IT'S ALIIIIIIIIIIIIVEEE!!!
2. AcidDreams: Lucy in the Sky with Diamonds...  ;-)
3. ColorStripes: For the lack of a better name...

Script attached. No need to do anything on your phone! Just load the script to your cube and enjoy. New modes will be automagically picked up by your app.


-Werner
(P.S.: More to come.)

[Werner M.]

Hey everyone,

Was a little unsure whether or not to post this (since there was no response from my last post, assumed no one cared to update their cubes), but I figured what the heck; I have done some heavy mods to the script. Completely revamped almost all of the existing modes (those who will load this one will notice right away that there is more 'smoothness' added to most of the animations), and added an extra few modes on my own (now with 20 modes altogether):

1. "STANDBY",            
2. "INCANDESCENT",       
3. "ACID DREAM",         
4. "COLLIDE",            
5. "COLOR BREATHE",      
6. "COLOR PULSE",        
7. "COLOR STRIPES",      
8. "COLOR TRANSITION",   
9. "COLOR WIPE",         
10. "CHASER",             
11. "COLOR ALL",          
12. "FLICKER",            
13. "STROBE",             
14. "FROZEN",             
15. "POLICE LIGHTS",      
16. "POLICE LIGHTS CHASER",
17. "POLICE LIGHTS WIPE", 
18. "RAINBOW",            
19. "RAINBOW BURST",
    
20. "THEATER CHASE",      
21. "ZONE"

The key for above is: Existing modes that I've revamped; All new modes.

Load. Flash. Enjoy.


Ta,
-Werner
(P.S.: Did I mention there's no need to change or reinstall the Android app? No? Ok then: there's no need to change or reinstall the Android app).

[cube...@gmail.com]

hi Werner

thx for this. I have updated my cube after your last post but not written that i have done that :-). So i'm the one who was looking on your code and have downloaded the android app too. So it was a nice feature to get the cube working this way.

thx a lot for your work

hape

[Dirk Schreckenbach]

Hi Werner,

I appreciate your efforts too and were really impressed about the new pattern you've implemented during the last update.

As soon as I'm back at home (Business trip), I'll install your latest 'gift' and check how it's work.

BR Dirk

Gruß Dirk

--

You received this message because you are subscribed to a topic in the Google Groups "cubetalk" group.
To unsubscribe from this topic, visit https://groups.google.com/d/topic/cubetalk/w2NAQsHQlIw/unsubscribe.
To unsubscribe from this group and all its topics, send an email to cubetalk+u...@googlegroups.com.
To post to this group, send email to cube...@googlegroups.com.

To view this discussion on the web visit https://groups.google.com/d/msgid/cubetalk/86dbde9a-e5ea-4969-86f2-c5bfdb8d9595%40googlegroups.com.

For more options, visit https://groups.google.com/d/optout.

<SparkPixels.ino>

[Joep Schipper]

 Dear Werner,

By now i am looking to a briljant "ACID DREAM"  The cube and your applications are marvelous, very much appreciated! I am eagerly awaiting  my 16 cube! I hope it will be possible to play then your designs.

Thanks for everything

Joep

Op donderdag 1 oktober 2015 10:17:05 UTC+2 schreef Dirk S.:

[Werner M.]

Hi Joep,

With regards to playing this app with the 16^3 cubes, I advise you not to hold any high hopes - the architecture of these big cubes is very much different, as they don't use the Adafruit Neopixel library to update the strips. I'm afraid it's gonna be a no-no.

-Werner

[Werner M.]

Before anyone loads my sketch for the Android app, I need to advise all:

Particle has once again, published changes in the cloud without prior notice, which directly affect the code in that sketch. As of today, it won't compile.

I found out about this the usual way - the hard way (which seems to be the norm at Particle now - let users figure out themselves whatever problems WE cause to them).
It was only after my ranting at their forums this afternoon, that someone stepped up and admitted they had changed certain things that would cause that error.

I have a correction in place, as soon as I can finish testing every mode in my sketch I will repost it here.

For the time being, DO NOT LOAD that code - it won't damage your cubes as it will never be allowed to flash by the compiler. But if you had tried to flash it and are wondering what those weird error messages are about, that's the explanation.

-Werner

[Werner M.]

Before anyone else gets confused.

This error I'm talking about refers to my sketch only - it has no connection to the android app or its use.

If you are having problems using the android app, I suggest you read my guidelines posted way back in this topic and try to follow all the steps, all the way through. The app works, provided the cube is running the provided sketch.

-Werner

 "C makes it easy to shoot yourself in the foot; C++ makes it harder, but when you do it blows your whole leg off" - Bjarne Stroustrup 

 "C makes it easy to shoot yourself in the foot; C++ makes it harder, but when you do it blows your whole leg off" - Bjarne Stroustrup 

2015-10-01 21:56 GMT-03:00 Todd Stiles <todds...@googlemail.com>:

Ok Thanks Werner, did try it and did not get anywhere I am running a android simulator "Andy" that Dirk suggested, and thought it was something to do with that

--

You received this message because you are subscribed to a topic in the Google Groups "cubetalk" group.
To unsubscribe from this topic, visit https://groups.google.com/d/topic/cubetalk/w2NAQsHQlIw/unsubscribe.
To unsubscribe from this group and all its topics, send an email to cubetalk+u...@googlegroups.com.
To post to this group, send email to cube...@googlegroups.com.

To view this discussion on the web visit https://groups.google.com/d/msgid/cubetalk/c2e1b10b-bf8d-4434-a302-e3e12846223a%40googlegroups.com.

[Werner M.]

I am done verifying my sketch. Attached is the updates, revised and tested version (as of this date).

I already explained the reason I had to pull off the previous release; furthermore, I had a heated argument with Particle's engineers about their practices.
To me, when you release a product and have grown a considerable user-base that is dependent entirely on your framework being reliable and consistent, and you do not deliver on that, it means you are betraying your loyal customers.

It's like selling drugs to a child; watching them grow as a drug-addicted teenager, and then turning your back when things fall apart on them and they turn to you for help.

After all, what's the point in coding a cool app that relies on their cloud-based framework to function, when they keep changing their framework without proper notice and without a good reason for doing that, every time the wind blows a different direction?

Selling a product and then simply telling users "our product is still under development" when things don't work as expected after that is unacceptable to me.
You don't release a product to the market and put a price tag on it if you've not done 100% of testing and quality assurance and are not confident that it will be reliable for at least the next 10 years. At least, that's what big manufacturers (e.g., TI, HP, Motorola, ZILOG, MOSTEK, FAIRCHILD, et-cetera) always did and do.
If your prerogative is to release something to public attention for gathering user feedback to work on improvements, then you shouldn't charge for it in the first place. These are not customers. They're beta-testers. So they know not to expect things to be perfect.

Particle has ticked me off. Their engineers are adamant in maintaining their position as "we know better; we do stuff like this to protect you from yourselves". This patronizing attitude was the drop that filled my bucket.
So as of now, I'm done supporting them. I will keep the photon, but for new developments on my Cube, I'll be using Arduino + ESP8266.

To top it off, I've tried to add the UDP listener to the sketch as a new mode for the Android app to control it. Guess what, my listener simply doesn't work when included in that code. I've tracked the problem down to it being a bug in the UDP.ParsePacket() function and I opened a topic on Particle's forums for letting them know and guess what? Got a couple replies from some cocky engineer telling me my code was wrong (not at all) - he simply did not care to read my code properly before issuing some puffed-up comment.
So there's not going to be a "LISTENER" mode in the Android remote control app. Give your praise to Particle's engineers for that.

So this is my last post regarding these cool apps. If anyone still has any questions or problems getting them going, I suggest re-reading my earlier posts. Everything discussed so far should cover any issues.


Ta,
-Werner

[Dirk Schreckenbach]

Dear Werner,

I'm really sorry to read that!

It's a shame, how some Supplier treat their Customer!

Anyway I'm a great admirer of you programming skill and hope to read from you in the future, when playing with my cube and browse through the forum.

Best regards und viele Grüße,

Dirk 

--

You received this message because you are subscribed to a topic in the Google Groups "cubetalk" group.
To unsubscribe from this topic, visit https://groups.google.com/d/topic/cubetalk/w2NAQsHQlIw/unsubscribe.
To unsubscribe from this group and all its topics, send an email to cubetalk+u...@googlegroups.com.
To post to this group, send email to cube...@googlegroups.com.

To view this discussion on the web visit https://groups.google.com/d/msgid/cubetalk/6b88e425-6e8b-45a6-ac1d-f366f50f78c5%40googlegroups.com.

For more options, visit https://groups.google.com/d/optout.

<SparkPixels.ino>

[Werner M.]

To be honest, I'm planning on just enjoying a little bit of the work I've done so far. I actually ended up spending way more time refining and improving my code than actually enjoying the apps in my cube.

Right now I have my cube playing a few animated gifs loaded onto it by the Jinx! image loader. Quite amazing.

You can even put photos of your loved ones in your cube - obviously, with an 8x8 pixel resolution limitation, don't expect to see the glow in their eyes  :)

 "C makes it easy to shoot yourself in the foot; C++ makes it harder, but when you do it blows your whole leg off" - Bjarne Stroustrup 

[Dirk Schreckenbach]

DAMN....this is so cool...!

Absolute great job!

Your pattern are mind blowing!!


Gruß Dirk

To view this discussion on the web visit https://groups.google.com/d/msgid/cubetalk/CANpWphicSO0P8RETtvTOJ1va%2BLTZT9ruz_pv60koRq6kYdtkGA%40mail.gmail.com.

[Dave Morgan]

This is very cool indeed! I am anxious to try the updated version when I get home from work tonight.  Thanks for sharing all your hard work on this!! :-)

[Werner M.]

:-)

The rainbow one was done by the original author. On top of it I made Acid Dream and also Rainbow Burst.

The jinx! file loader even plays ANIMATED GIFS!! so amazing!!

If I had 4 8x8x8 cubes I would cluster them together with the jinx! matrix patcher, then have these animated gifs played back - it would be a true light show in my room!

I am stoked; amazed; in awe.

 "C makes it easy to shoot yourself in the foot; C++ makes it harder, but when you do it blows your whole leg off" - Bjarne Stroustrup 

[Werner M.]

I've also spent a great deal of time reworking the Frozen mode. The original author just made it display random flakes then wipe them off after a random amount of time.

I have made them slowly "melt away" by dimming each one then when another batch is due, it "fades in".

But due to certain  constraints, I could not make it look good through all the speed setting values, so I recommend not going faster than Jimmy Johns neither slower than Turtle. Best viewing speed settings are between the Rabbit and Ricky Bobby setting.

 "C makes it easy to shoot yourself in the foot; C++ makes it harder, but when you do it blows your whole leg off" - Bjarne Stroustrup 

[Dave Morgan]

Now I really need to make time to play with Jinx, as it happens that I do have 4 8x8x8 cubes, and this sounds like a great idea!

[Werner M.]

If I were as lucky as you I would've done it 10 times over by now.
This is a must do.

[Dave Morgan]

It's mainly an issue of too many projects in process at one time.  I have the 8x8x8 cubes and my 16x16x16 cube, and I also have an LED table that I just finished (this has been getting most of my spare time).  

On a related note, earlier this year I bought a copy of Madrix to use on my PixelBrites.  Madrix supports matrices and cubes!  It supports Art-Net, but not TPM2.net.   I just logged a wish request on their support forum to see if they could add TPM2.net support.  That software (which is similar to Jinx, but more elaborate) combined with your listener would be absolutely amazing!  Thanks again for your work on this.  :-)

[Werner M.]

OMG.

O-M-G.

This thing works in all 3 axes!

You can patch an 8x8x8 matrix with it. It's unbelievable.

Two things they need to support:

1. NeoPixel WS2812 strips
2. TPM2.net protocol

If they ever do that, I'm sold.

[Werner M.]

Oh. But wait.

Problem: 250 euros for the start version?

I'd rather save my hard-earned money to buy perhaps a new 8x8x8 cube from Alex and Shawn.

Too bad. Poor man's joy doesn't last long.

[Dave Morgan]

Yeah - it's targeted at commercial users, so it's definitely on the expensive side.  It's really fun to play with though.  There are all kinds of really creative things you can do without needing to write a single bit of code.

[Werner M.]

I believe you - but apart from the fancy stuff in there and the x/y/z patching, I can say that Jinx! and GLEDiator can unleash the same power - the more I tinker with all of the features + effects + plug-ins, the more I realize that this is just the thing Alex and Shawn were looking for. Just the fact you no longer need to wire the cubes together to form clusters is a huge $$ and time saver.

I've just loaded another batch of animated gifs onto my cube and am watching it run in awe.

[Werner M.]

...AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANNNNNNNNNNND,
(I like to talk like Alex when he's got a major breakthrough announcement to make)

Before y'all load the updated sketch I've posted today - STOP STOP STOP!!

Got a last trinket to leave for you guys, before I go. The LISTENER mode is here!
The issue I was having was due to the photon SYSTEM_MODE being set to SEMI_AUTOMATIC by the original author; it seems that it interferes with the UDP listener, for some (undocumented - what a surprise..) reason.
Since the sketch I wrote for the listener does not toucht the SYSTEM_MODE (which in this case, defaults to AUTOMATIC), I've commented out the line that sets the SYSTEM_MODE and got UDP packets flowing in. Simple.

A couple things to notice:

1. During the LISTENER mode, I've disabled both the brightness and speed setting. You will realize that sliding either of these controls in your app won't change anything (again, only in LISTENER mode). That's done on purpose, since both Jinx! and GLEDiator have their own dimming controls, I want to make sure people won't mess with the brightness and then when changing modes, have a nasty surprise (like forgetting you had the brightness pumped all the way up in LISTENER mode, then changing back to some other mode which could end up frying your strips).
2. I've taken care to make sure when exiting LISTENER mode, the brightness and speed settings would be restored to their values last set before entering LISTENER mode. So no concerns there.

Enjoy the new sketch for the android app. Now you have the power of L3D on the palm of your hands.

Ah yes, of course! There's no need to change or reinstall the android app.  ;-)

Ta (for good),

-Werner

[Dirk Schreckenbach]

Why do you have in total 4 (!!!!) L3D cubes? That must be a huge light show in your room! ;)

Gruß Dirk

--
You received this message because you are subscribed to a topic in the Google Groups "cubetalk" group.
To unsubscribe from this topic, visit https://groups.google.com/d/topic/cubetalk/w2NAQsHQlIw/unsubscribe.
To unsubscribe from this group and all its topics, send an email to cubetalk+u...@googlegroups.com.
To post to this group, send email to cube...@googlegroups.com.

To view this discussion on the web visit https://groups.google.com/d/msgid/cubetalk/728acdd2-0c2a-4f24-9024-2fdfa6e5a3f5%40googlegroups.com.