@MKR: Maybe next week? :-)

@Rene: No worries -- it's great to see you here -- and we look forward to seeing you next week

Sorry for missing today's chat, I hope to participate more actively next week,

bah, late again :)

Enjoyed while I was multitasking, I may get more engaged and pick up some work.

I am very much interested in participating actively.

Thanks for the warm of the group, and adios til next week.

See you!

Thansk to Duane for co-hosting while I was doing the other "stuff"

OK -- bye to all for now

C U next week (plus C U in blogs and comments on the site)

@Kenwick: The "Beginner" thing is just based on the number of posts people make -- in a few years time you will have passed through "Smarty Pants" and be approaching "Clever Clogs" :-)

Bye all.

Is it just me or did only "BEGINNER"s sign up to work? I'll be in touch, Max.  Bye y'all.

OK -- I have to go now -- I'm working on an article about the current state of the art in 3D ICs for APP -- I'll be posting it later thsi afternoon so keep your eyes open

Thanks EVERYONE for making APP such a success!!!

Thanks, Max

Alvie, I just checked your site - you'll do just fine. Thanks.

@Rene -- that's a good idea to monitor ambient lighting conditions and use that to tone down the display -- it could be a lot less bright in the evening than in the middle of the day...

@KenwickVS: anything you might need just tell, I'll be glad to help :) You can reach me at alvieboy@alvie.com.

@Alvieboy and Rene @Myplanet and John and others -- it's great to see newcommenrs in this chat -- we do thsi at the same time every week -- keep your eyes on the weekly newsletter and suchlike for details of each forthcoming chat

@KenwickVS: Maybe you and I can link up by phone and sort out the next move -- email me at max.maxfield@ubm.com with a time and number and I'll call you (i'm in USA Central Time)

alvieboy - We'll probably have to volunteer you.

Yeap, using 20mA LEDs it may peak at 2KW !!! , for an all white screen.

So may I suggest to planning not only PWM for duty cycle adjustment, but also room ligthing or display environment conditions to adjust the required level.

No need to blast a small room if not necessary

@All: A couple of things while I think about it

1) if you haven't already done so, please take the Flash Poll (scroll down the right-hand-side of the page)

2) Please do your best to spread the word about All Programmable Planet -- anything you can do will be much appreciated -- one idea is for you to "Follow" us on the All Programmable Planet Twitter and LinkedIn and Facebook feeds, and whenever we post an article, for you to re-Tweet/whatever it to your followers...

The LED stripes we used with SoundPuddle have some interesting latch/update system: you first latch the RGB values (7-bit) sending 0rrrrrrr, 0ggggggg, 0bbbbbbb (which will latch) and then apply them with a 1-------- signal. This at least avoids color artifacts.

I mean SourceForge or some other entity- or does APP have a method?

OK, I've sat on enough tech committees to know the ropes, so I'll pen something up.  However, any suggestions on how to collaborate on line?

@KenwickVS: Re the spec -- Duane already has his hands full with the Robot Avatar project ... and I am famous for having ideas without a clue how to implement them...

Alivieboy - That's an interesting though - using PWM to reduce power and acdjust for the extra light with larger displays.

@KenwickVS: "What we need is a draft technical document (any volunteers?)"

I was just waiting for someone to suggest this ... "you touched it last" (grin)

Max - Life is rough on the West coast. :-)

@Max: at 20mA you need almost 10KW of power. That is massive, and requires not only proper dissipation but good power distribution - and note the huge amount of light you'll see. Unless you somehow decide to do some sort of PWM (like 10%) and then you can get below 1KW. Even like this, it's not easy to dissipate and distribute.

@Duane: "How time flies - It's now 11:00 here"

I know, I hated that you had to get up early for this (grin)

What we need is a draft technical document (any volunteers?) that we can interactively massage into a working document - and then get started on the real work.

@Alvieboy: "How are you planning to update *all* led at same time ?"

That's a good question -- I haven;t tied thsi down yet, but my thought is that if the array determines it's own size -- and each module (4x4 board) in the array understands it's X/Y location in the array, then it shoudl be possible for the master controller to say "here's the new frame" and for all the sub boards to buffer/delay the signal until they are all ready to update at the same time...

alvieboy, we havn't gotten that far just yet and welcome any input.

Re power -- one thing I've done before is use old PC power supplies -- you can pick them up from a technology recycling center for about $5 each -- they output 20A on the 5V line easily...

I did a quick power calculation and assuming 20mA LEDs, it's massive for an 800 x 600 array.

I'm back :-)

How are you planning to update *all* led at same time ?

How time flies - It's now 11:00 here

Duane, 

I like the idea of expansion, starting small and allow for growth.

However, I have noted that the power issue has not been touched, lets not neglect the fact there is some heat also that needs to be controlled, otherwise you have thermal run away and lots $ ruinned

So, do we create some sort of Open Source collaboration somewhere on the NET?

It would add just a little more work to the design, but I would think it would be very manageble

Kenwick - I don't really see a problem splitting it into multiple channels like that.

As I indicated earlier, the screen could be split into multiple channels to reduce the bandwith requirements in apps that require video.

Rene, Kenwick - Yes, we have been talking about an RGB wall with 24 bits per pixel. Thad does give 43MHz

i will be back in 3 or 4 minutes...

MyPlanet - I think there are some PPGAs available for around $10.00 US

I think the assumption, based on the previous Blogs was an RGB wall.

Kenwick - I forgot to consider 3 LEDs per pixel. That would make it 43 MHz for 8 bit parallel data. In serial, of course, you'd be up in the hundres of MHz.

I calculated 43.2 MB/Sec for RGB pixels, or we talking discrete single color pixels?

Anyway, it seems that it would be possible, using RS485 to achieve real video.

30fps, isn't that for High Definition? Could we use a lower frame rate?

If I recall correctly, standard VGA monitors use a 25MHz pixel clock.

Each 4x4 board would have its own power connector

Each small array would have separate power terminals (I assume) so the power needed is proportional to the size of the whole wall.

Duane, inexpencive FPGA?

30 fps would need a data rate of about 14MHz

Do you have enough power to drive a 800x600 LED array ? That thing requires a lot of power.

FYI, RS485 driver/receivers are now available for speeds of 20Mb/sec and sometimes more. Can someone quickly do the math for a 800 x 600 display?

Kenwick - I think that's a great way to package it up. We could also have training materials that would allow, for example, a class to have each student build there own and then have the whole class plug them together.

MyPlanet - We've been discussing ideas around building a modular large LED array display controlled with inexpensive FPGAs

So, we have an idea: an X-by-Y array with LED's and an on board FPGA; serial data in and out, cascadable and remotely controlled {?) as a kit.

Kenwick - Good idea. The frosted ceiling lighting panel would work the same as what I was envisioning, except the ceiling panel would probabnly be less expensive, lighter and easier to find.

MyPlanet - This is it. You're in the right place.

Kenwick - Maybe someone that has good curiculum writing skills could put together a classroom program around this

max, live webinar, where is it for APP

Why not an inexpensive square frosted plexiglass panel from ceiling fixture held off the board by standoff's ?  It would just require drilling 4 holes for screws.

Talk to you later Max.

i think am 45 minutes late

I'm really sorry about this, but I've been asked to host / moderate a live webinar -- it started at the same time as our chat -- so I've been typing on one computer (this one) and talking into another -- but now I have to focus 100% on moderating the "questions and answers" part of the presentation, so I'm going to leave you in Duane's fiem (but fair) hands :-)

Hi Myplanet :-)

@Dunae: Oh, I see ... I don't know -- I STILL like the idea of a 4x4 array as a basic building block (but I can't articulate why)

Max, re cover material: Maybe some difuse white glass or plexi-glass as is used on an old 35mm photographic slide sorter.

Hi Max

Max - those 8x8 LED modules don't have any kind of controll built in, so they could just as easily be driven by our FPGA. We'd just be stuck with the LED spacing built into their module

Alternatively -- maybe we just go for a black front-panel with areas milled out for each LED

The original SparkFun boards have the tranclucent silicone rubber pad -- this is great material for displaying and diffusing the lights from the tri-color LEDs, but it has the conductive circles and stuff to make it act as an input device -- does anyone have a better suggestion for this cover material?  If we can purchase som eoff-the sheldf solution, that might dictate the size of our board

@Duane: I'm not sure what you mean

I think Max is right, it should be highly educational for some kid to assemble an array on the kitchen table, and get it to work.  Yea, the parts might have to be imported, but not the labor and the education.

Max - You could still control each one with an FPGA, but, it would elminate all flexibility in choosing the size. To make a bigger display, the LEDs would need to be spread out on a PCB as we've been discussing.

Let's see, can we get Xilinx to put up some $, and CREE and ...

@Duane: I hadn't seen those SparkFun boards with 8 x 8 arrays .. they do look tasty... but still, I like the idea of (a) building out own and (b) using FPGAs to give incredible performance and control...

Reality check, if the construction and parts of the LED modules (to be purchased in volume) for the lowest cost, then more likely these will have to come from China.   

Maybe offer fully pre-built boards -- and also boards that just have the FPGA soldered on, but leve the user to solder on everything else (that way hobbyists can say to themselves "I built this"). In this latter case, sell a kit (board+FPGA and then all the other parts and connectors), and also sell just the board FPGA and let the users source the other parts themselves...

There are also little LED squares, already packaged in a matrix (http://www.sparkfun.com/products/683). That would reduxce the flexibility in sizing, but might be an option too.

Maybe, if funding could be found to build such a neat LED wall, it should have other interfaces, tactile perhaps, and loaned out to various children's public art galleries so that they can determine what get's displayed.

@KenwickVS: "Add a barometer, temperature sensor,..."

YES!!! Very Cool idea

Don't get me started about China.

I also like the idea of having a Turing Machine meandering its way around the wall -- reading the contends of a cell (stored in the master controller) and then deciding what to do and which duirection to move in next. And you coudl have multiple Turing machines running simultaneously...   maybe even use Genetic Algorithms here to get them to evolve to cooperate or whatever...

Add a barometer, temperature sensor, etc. and as long as you're not color blind, you'll always know what's going on around you.

BlinkM has been developing in a similar direction for a while. Their stuff has always been expensive to implement large arrays with.
Honestly, the main reason I've been doing a lot with strips is the price. You can get the LPD8806 strips from china for ~$14 / meter now, which comes out to $0.43 per RGB LED and driver

Is my math right? Assuming 20mA LEDs: 480,000 X 3 X .02 = 28,000 Amps for a worst case, all white display. That seems way high.

I'm imagining a wall-size Wall-of-Light in my office running the Game of Life -- different colors for different types of cells -- using Genetic Algorithms so the cells can evolve -- it would look SPECTACULAR!!!

Man, I should have invested in CREE a long time ago.

I stand corrected after looking back, it's 800 x 600.

@KenwickVS: "I think the important thing about reinventing the wheel is to keep it round."

Luddite!

@John: I REALLY want to end up with a mega-cheap board so that anyone can afford it. With the modular approach you could start with just one board, then start adding more

800 x 800 - Blame MAX.

800 x 800 = 640,000 pixels! That's a lot of LEDs!

I think the important thing about reinventing the wheel is to keep it round.

re videos - Yes. Those were very impressive

I'll bet we could get "real video" at 800 x 800 or less via DMX by paralleling DMX channels at the host controller and splitting the panels.

@Max, I think there are up sides to either approach. A nice thing about the LED strip method is that you can very quickly set it up, and with an FPGA you can run a bunch in parallel. The problem I've run into sometimes is that the SPI signals (unsurpsingly) often have noise problems across cable runs

With the 4x4 modular boards (if I'm following the idea correctly), you can implement a much more robust comm protocol. That should aleviate noise issues, the relevative benefits between the two approaches would depend on exactly how the comm is implented (e.g. how fast is it), and how expensive the boards are to produce

Did everyone look at those videos people suggested in the comments at the bottom of my original blog?

Whatever method might be used, I would just envision an individual address mode and a sequentially addressed mode.

@Duane: "I do tend to reinvent the wheel from time to time."

The important thing about reinventing the wheel is deciding what color we should paint it!

Kenwick - I do tend to reinvent the wheel from time to time.

Max - that could work too.

@Duane: re backpack - something that mounts on the back of one of the display squares. :-)

But since each 4x4 board has 2 input connectors and 2 output connevtors, one edge of the array will present one of the input connectors associated with each board on that edge -- why not simply have the master controller plug into one of these?

Duane, Good idea, but you're re-inventing the wheel.

I think we should put the prototype on Max's office wall, point a webcam toward it, and control it from APP.

Maybe there could be two addressing modes: One with each data packe being addressed to a specific display square and LED, and a nother mode where the data is sent serially to all squares. The first one starts in receive mode while the others are in ignore mode.

When the first packed goes out, the first display square takes it and triggers into ignore mode and does something to trigger the next in line into receive mode.

This would allow data to be sent out in much the same way it is on any display

@John: Since you built the SoundPuddle -- and you also understand what we are trying to do here -- if you were doing what we are talking about, woudl you go for the LED strips of our 4x4 modular board approach?

With RS485, it is multidrop, so the Master Controller can be anywhere.  It could be controlled via a USB-to-485 adapter from a PC, or the EtherNet.

That way you linearly reduce your refresh rate as your add more SPI interfaces. The only limit is IO pins and cabling

I'd like to do this as an open source project -- including schematics and board layouts and FPGA code -- so anyone could build the boards / controllers themselves -- but also members of All Programmable Planet could build them and sell them...

I implemented it by running many SPI LED strips in parallel, with 10 SPI controllers on the FPGA

re backpack - something that mounts on the back of one of the display squares. :-)

It is possible to use multiple DMX "Channels" to give more pixel resolution.  I don't know that it's fast enough for "real video", though.

I not sure that DMX protocol has the BW for video of any refresh rate required for actual TV. What size is under consideration as the limit?

@Duane -- what do you mean by "backpack main controller" ... do I have to carry this around in my backpack?

If we're getting up to the 800x600 size range, power might be one of the bigger issues.

If you look at the SDparkFun board, it has two input connectors (on the top and right edges, let's say) and two output connectors (on the bottom and left edges) -- making them easy to connect together

DMX is usally limited in the number of pixels you can run, often at 512 IIRC

@Duane: as per my earlier message -- I think we shoudl have a seperate controller (could be a PC or a MCU board) that connects into one of the sub-boards in the array

If we did have a backpack main controller, there could be a variey of ways to control it, based on what's in the bcakpack. You could create one for RS-485, WiFi, Blue-tooth, etc.

Max, DMX fills the bill, plus you can control hundreds of other things like smoke machines, lasers, etc.

My original desire is to have a display I can use to implement 2D Turing machines, the Game of Life, and also create swirling color displays to go with music. But I'm now starting to wonder if -- say you build an 800 x 600 resolution display -- you could display video?  Could we achieve this speed?

Would we want one of the boards to act as the master controller, or should the system have a separate main control board - maybe in a back-pack form factor?

I agree that we should use some sort of generic communications protocol. Also I think the user should be able to control the multi-board array using anything he/she wants, like an MCU board or an FPGA-based controller. Maybe also have an interface board that would connect to a PC via USB and allow the display to be driven from a PC.

We should consider RS-485 as the serial interface.

I like the idea of the boards automatically identifying themselves to each other. Then we coudl have a "master controller' to drive the array -- thsi coudl be connevted into any board in the array -- the array woudl tell the master controller "I am a xx by yy array, and you are talking to elemend i,j in the array"

I've got some posted on the technical information of the project: http://soundpuddle.org/zpuino

We might want to look at something like the PicoBlaze soft-core to perform the addressing and other start-up activities.

I recently built a large FPGA controlled RGB LED array, using a Papilio with the Zpuino framework, and LPD8806 strips.

http://soundpuddle.org/media

DMX, an ANSII standard, is a very simple "Packet Protocol" specifically for controlling lighting and has become the standard for theatrical control and would work well in an FPGA in each square.

Not sure whether to use an SRAM-based FPGA (easy to reprogram but requires a 2-chip solution) or a Flash-based FPGA -- one big thing for me is to make this as cheap as possible so that lots of people can afford to play with them

I think we could come up with a way to have the boards each auto-ID temselves at start-up. That way each LED could be invidicually addressed on each board and each board could be individually addressed.

@Duane: I agree -- I'm thinking that  each board should have a low-cost FPGA. The FPGA could be in charge of board-to-board communications and also controlling the LEDs -- the FPGA could easily implement 16 x 3 = 48 pulse-width modulators (PWMs).

I like the idea of having a small, low-cost board with a 4 x 4 LED array. Like the SparkFun board, it should be possible to connect lots of them together to form any size array you like.

Each LED would be individually addressed - possibly via an inexpensive FPGA on each square.

The SparkFun pad can be used for both input (vie its 16 pushbuttons) and output (via its 16 tri-colored LEDs). This is great for things like their Trtris game, but I think I just want mine to be an output device, which makes it a lot simpler and a lot cheaper.

@Dunae: Good point about no single point of failure

We'd like this system to not have such a single point of failure

I'm back....

Max will be a few minutes late this morning, so we're starting without him. I'm not familiar with that particular product, but we have looked at one from SparkFun

That happened to my Christmas lights.

Max have you guys worked with the SPI RGB modules from APA electronics. See link

http://www.neon-world.com/.  I am thinkering with some ideas myself, but found that module to have the weakness of single point of failure.  One bad led in a serial string takes the whole thing down.

Although it is a pretty cool module, there has to be a more liable way to separate the serial data stream from video driver to create an improved reliability.

Large displays could be created by connecting multiple squares.

I've been doing some thinking about it and, regardless of the array, we should consider controlling it with DMX512 protocol, which would make a really neat FPGA project on it's own.

The basic idea is to cread a modular display system with the modulues being square grids of 16 RGB LEDS.

Hi there. This morning we'll be discussing Max's wall of light, as describbed in this post: http://www.programmableplanet.com/author.asp?section_id=1925&doc_id=247571

Hi Y'all.

I'm about to launch a live webinar -- this will take me just 3 minutes -- then I'll be back -- so Duane will be handling things for the next 3 minutes...

Hi Myplanet -- you are still 2 minutes early

Good morning (or afternoon)

Still Nobody

Goodmorning everybody

Our weekly chat will commence at 12:00 noon my time (Central Time), which is 1:00pm Eastern Time, 10:00am Pacific Time, and 6:00pm UTC/GMT in Sheffield, England, where my dear old mom lives.

As usual, we will follow our usual practice of leaping from topic to topic with the agility of young, fearless mountain goats. One topic on my personal agenda is my "Wall of Light" project...