Search results for:

Ouch :D
What about if every panel (16x16) which is 15A or 75W would run from individial power supply (for each panel own one)? It obviously a bit more expensive, but easy solution here?
Something like this: http://www.ebay.co.uk/itm/UK-Stock-DC-5V-12V-Universal-Regulated-Switching-Power-Supply-for-LED-Strip-CCTV-/400671565030?pt=UK_BOI_Electrical_Test_Measurement_Equipment_ET&var=&hash=item5d49e2e4e6
Which is £12, not that bad imho. There is 200W option as well, which is enough for 2 panels. Throwing more Amps on panels - is not bad, right? As I would plug Espruino it self to same power source, and board needs very little energy (Espruino + WiFi/Ethernet).
It just have to be 5V and enough of Amps?

1.35 KW LED array, lol, that will cost a bit of energy :)

That is a great explanation!

I've looked into external power supply options, they look rather serious :) But If I want to have 18 in total of those panels, then it will be up to 600W (5v 270A), that is like a good PC with next-get GPU card.

I will go for an external power supply option. Will let you know how it will perform.

Those little caps - are capacitors. Your problem is different.
All LED strips already have individual capacitor nearby Each LED.

I've got slightly other problem now.
Got 256 RGB LEDs soldered, in 16x16 array.
My problem is that at the end of chain, LEDs start looking dimmed (they become orange, like loose blue and some green), like not much power left, especially if they all white.

It is plugged to espruino (power, data, ground).
As I understand I should move power and ground to external source?

Indeed!

WebSockets has extra framing around each message, on top of pure TCP sockets including handshaking - which is string based message (HTTP headers).
Framing contain some data about type of message, its length and masking. That pretty much it.
I have implemented this protocol in C# .Net long time ago (when there was no SignalR and .Net 4.5).
Those guys have it, but their implementation is a bit surplus: https://github.com/einaros/ws
Here is some code for send/receive in .Net with dataframing I've made some time ago: http://moka.me.uk/files/wsreadwrite.txt

UDP is unreliable especially on embedded systems. What about just streamed TCP? Pure binary TCP stream? As starting point I believe is a good thing, will allow other developers to implement their data protocols on top of it.

You might ask Hackspace London guys on mailing list, seen someone were playing with lasers there: https://groups.google.com/forum/#!forum/london-hack-space

If streams will come, will they be compatible with any socket? As if it will allow stream over TCP socket, that would be "mindblowingly" amazing :)

Could you please modify your post, as it looks broken :)

You can extract colour data from bmp into Uint8Array on desktop computer, then using atob convert into binary string, and save into a file.
Then it will be much easier and faster to load it from SD card on Espruino from that file (binary string) using atob, speed should spike dramatically.

Just unrelated tip, but will reduce size of emptiness in your code :)
Replace linea function with this:

function linea(y) {
  return (y - 1) * 128;
}

For atob and btoa thanks a lot!
Mainly it is an idea. I were looking into networking solutions, atm there is http, but of course overhead due to http, as well as the fact that for each request it open/close of a socket - is waste of performance.
So looking into more low-level communications. WebSockets - is a great alternative, but there is no support for them so far.
http over ethernet? Maybe.

We will have many of panels, each 16x16 (256) leds.
Each will have own board, and most likely ethernet connection, wifi would be great, if we will have WS that might work! Need to figure out how to get rid of problems I have when connect LEDs at same time as WiFi, looks like some capacitors are required (just a guess, as I am newbie in electronics).

Then software on laptop will do rendering and send data. WS - would be the best of course. Idea is to make modular node-webkit app, so people will be able to write own WebGL renderers and UI plugins to control panels.

We already have some soldered and tested, some tests on boards, and already printed parts to match them properly.
Here is WIP prototype model of a panel. We targeting to around 18 (6x3) of them with 30mm distance between each LED. That is amazing 4608 of individually addressable LEDs! :)

+1 for WebSockets!
This node.js ws repo might be helpful: https://github.com/einaros/ws

But for real-time renderer from software, and pretty visualisation, is what we want to achieve, is new buffer every ~16 ms (60Hz). Just for the beauty and experience of the picture.

My idea is to create a remotely controlled controllers. So the idea that espruino will only get binary data from wireless or through some other wired method from laptop, and will render it on led arrays.
While visuals will be all product of software I'm writing. There are few ideas but generally it will be OpenGL (for prototype I'm using WebGL), that renders some 3D stuff, then I get pixel buffers, send them using WebSockets to node.js, and then from there I will have more ways to send to espruino board, as node.js has some cool low enough level of networking solutions. If will be able to get wireless working without big delays - that will be mind blowing.
I got wireless module as I had backed it on kickstarter, where got 4 boards, 1 wifi and few others (RS, Bluetooth).
Targeting to less than 30ms delay between renderer in software, and render on LEDs.

Then after this base is done, will look into Web Audio API in Chrome of FF, so I can extract frequency spectrum data, and them do some real-time rendering based on ranges of frequencies.
I did software very similar thing previously in .Net and Blitz3D before that (long time ago though) using BASS (library) and FMOD.
It's exciting project doing with my friend.

Thanks a lot. This is awesome, enjoying how easy is to put them together and here we go.
Another question:
If I want to have 8x8=64 LEDs and one Espruino, with 60 frames a seconds, it will be about ~10kbps (64leds * 60fps * 24bits), which as I understand is fine capacity for one board right?

Thanks for helping out :)

So that will help it to be OK through USB?
I will try, thanks a lot!

Trying to connect single individual WS2812B, and control using this code:

SPI2.setup({
  baud: 3200000,
  mosi: B15
});

var rgb = new Uint8Array(3);

setInterval(function() {
  // get milliseconds
  var ms = Math.floor(getTime() * 1000);
  // make 0..255 value based on time
  var r = Math.floor((Math.sin(ms / 1000) / 2 + 0.5) * 255);
  // send data
  SPI2.send4bit([ r, 0, 0 ], 0b0001, 0b0011);
}, 1000 / 60);

So it suppose to fade one color from 0 to 255, from dark to bright.
But what it does it kinda starts from blue (0-16) and then starts blinking and shifts to red and blinking there as well.
So looks like something wrong with bits, is it baud rate, or is it different format of data?

Any assist would be great.
Wiring is simple, B15 goes to data, power to power, and ground to ground. Nothing more or less.
Is capacitor here essential, or it is not related?

EDIT:
When connecting using battery (without USB) then it's OK!
So what am I missing here?

SOLUTION [ DrAzzy ]:
Put 0.1uf capacitor between ground and power right next to each LED.
Or consider already soldered solutions.