 This is the title that Leon is complaining about just now. It actually shows that we can draw anything onto the wall. So I'm talking a little bit about new pixels, because this is majority part of the base of the whole project. Okay, so just in case somebody have never heard of new pixels, it all starts with a small little chip called WS2811 developed by a very small semiconductor company in Shenzhen, but with a very big name called Watt Semi. And it is kind of an LED driver in a very dull A-Ping package, and soon they release a nicer one with the pack, with our LED itself integrated with the controller and making it into a small single monopiece item. And this soon become, and the name is WS2812B, and this was picked up by Adafruit, and they renamed it to New Pixel and become very popular. And today you can buy new pixels in all kinds of formats. For example, you can buy in strips, you can buy in panels in all kinds of assorted shapes, and this has become a huge market for this single LED. And how we did this, actually we made this, this is one of the 132 PCBs we made. It actually is quite simple, we buy the new pixels in strip format and we cut into small pieces and sold it on top. And for each like this square, we put into a small little case with a poly panel in the front and some of the people from PA helped us to draw all the offensive pictures on top of it. So all together we have 11 columns with 6 rows of each side. So this is 66 pixels, 66 blocks on each side of the wall. And each side we are controlled by ESPA266, people know me, I'm kind of addicted to this microcontroller. And how does the work is actually quite simple. Zaya write the browser page and which posts the RGB data for each of the big wall and into ESPA266 and we receive this data and we just tokenize the information of RGB or this kind of information that we pump into a new pixel. It's actually very simple. So there's not too much to talk about the whole architecture of this project but I really want to share some of what we have learned from this project. So first thing is that driving a new pixel is a very simple way that you just pump all the pixel data from the first pixel and it will in turn retransfer the same to the second and the third one. What happens is, for example, we have 3 pixels here and what happens is for each pixel we need 3 bytes of data which is red, green and blue and what you need to do is just pump 9 bytes of data into the first pixel and the processor inside will chop off the first 3 bytes and use it to display a color and retransfer the remaining 6 bytes to the next pixel and hence so on and so forth and all the way you can run thousands of pixels with this kind of arrangement. And you do not really need to write all your program to transfer your data and spread into bits and bit streams and there's a huge number of libraries available. For example, if you use an Arduino platform just launch the library manager and search for new pixel or search for WS-208-12 there's a huge amount of libraries available but you do really need to look at whether this library supports the microcontroller you are using because now the Arduino platform has included so many of the microcontrollers that you better look at for certain of the libraries it doesn't support like it only supports AVR or only supports ARM it may not have other supports so this is some of the trap for some people who are not in this scene. So a little bit of internal of our new pixel is that we know that it's extremely fast because we are talking about sending 3 bytes or we say 28 bits of data into per LED that is they give a very strict timing of 1.25 microsecond per bit that makes 24 bits per LED which is 29.7 microsecond if you calculate upwards that you can if you want to animate a string of pixels in a 30 frame per second you can actually animate 10,000... sorry this is 120 new pixels that you can actually animate this in 30 frames per second so that with our project we only... for each side of the world we only use like 500 over we can actually run much, much faster than what you see at the moment this is one of the points we understand the other thing is power consumption so Adafruit has a very nice web page called the best practice of using new pixel they're talking about the power consumption of new pixels and they give a number of 60 milliamps per LED although there are some of the preconditions they say if we are running at 6 milliamps that means that you are driving full force of the 3 LEDs that will become white colour and most of the time you may not want to use white colour you use other colours then they give an assumption it's like 20 milliamp per LED then if you times this by thousands there's a huge amount of power that you require so we calculate based on our case each block has 9 pixels 20 milliamp, 180 milliamps so each panel got 66 blocks that is 11.8 amps so it's... you cannot expect that you have... like when we use a 100 water power supply you have 20 amps of power you cannot just feed this power into one end of new pixel and expect to power the whole chain because the kind of 20 amps of power at this kind of current all the contacts, all the connectors you use have to be specially made otherwise the loss is tremendous and the heat and the loss is tremendous so very luckily we actually found this something like this it's a power distribution block that is split your white input to the output and we actually use 4 of those so that for each of the... and we divide each string into... we actually parallel the power supply for each string although the signal is in zero but the power supply is in parallel so we use this kind of block to power them in parallel so in the end we can still measure about 5 volt in the last pixel so this is some of the taking homes for our project and I want to share, that's it, thank you okay, I have this body if somebody interested can take a look and thanks for all the people helping us to solder this up so the blocks have 3 pins so that's why you ended up with 6 by 11 in the panel per panel we have 2 of these blocks so we have 6 rows in parallel and you have an ESP in every block? we have a 1 ESP in every block sorry, every panel every big panel, so there's only 2 ESP there one thing to share 5 meters of NeoPixel if you power them from one side the last meter of the pixels doesn't work anymore properly so what worked out then was connect the power on one end and the ground on the other end so the distance between power and ground was the same for each pixel then it worked nicely that's interesting