Progress
Here I try to document how the project is going along, because not everything that happens is transparent via the commit log. Newest entries are always on top.
I've worked continuously on improving the five PCBs and a dozen enclosure parts (not yet online).
For the PCBs, it has mostly been micro-optimizations of traces to improve return current loops and thus EMI/EMV. Especially the Controller module changed a lot, so that it will support a larger number of ("Feather") microcontrollers, and many kinds of presence sensors.
All five PCBs are now ready for an external review that will commence soon. As a preparation for this, they have been moved into the hardware/abl directory, named more consistently, and their README files have been improved a lot (or created from scratch, in most cases). The schematics have also been cleaned up.
I've also ordered a few hardware components:
- Four kinds of Feather
- 3 different ESP32-C6
- A RP2350 to have an alternative without any Wireless protocols
- Two new kinds of presence sensor (so I have 5 different ones in total)
Since the enclosure source files are not yet ready to be published, here's a current WIP picture of it:
There have not been many updates to the PCBs and software for a while, as I have been working on the enclosure of the ABL (outdoor version of the lamp). In the past week, enclosure and PCBs have been refined in close alignment, to make sure that everything fits.
The design now consists of three major PCBs: power, controller and LED. There are two more PCBs without components on them that just act as connectors (one rigid, one flexible).
This basically separates the lamp into two big modules: Wall mount including 230 AC connections and transformation, and all the rest that runs at 5V DC.
To keep moving forward quickly, I currently need to work with a lot of file formats that are not ideal for open source / git version control. I'll need to take some time to convert / recreate those into open formats later. So there's a lot happening behind the scenes that will not (yet) be visible in this git repository.
The five PCBs are now 99% ready for ordering the next prototypes (already in my shopping cart, but need a final check before ordering). The design of most mechanical parts is between 60% and 90% done.
So here's a look inside the current CAD model with all PCBs exposed, but many mechanical parts hidden:
Talking prices:
Custom PCBs including parts and assembly will be around 50€ total per lamp. This does not yet include taxes, customs and shipping, but also does not account for the complete bulk discount (I'm currently doing orders for 5 to 10 items each, and I can see how prices go down when ordering 30 or 50 items. The actual price for each of 160 items will be lower, but can't be displayed right now.)
The metal enclosure parts are pleasingly cheap to manufacture in batches of 160, but dauntingly expensive if I order just 1 or 5 pieces. For plastic parts, prices per item are basically constant, which makes it easier to do iterative prototypes.
The day before, I didn't get out any light from the single LED I had soldered on. After some more experiments, I'm very sure that there is no design error in the PCB, just an assembly problem. It looks as if some LEDs have too little solder and don't make contact at all, one might have too much so there's something shorted, but the rest works just fine.
It's hard to get the right amount of solder onto the LED pads on the first try, and it's even harder to fix it afterwards, when I can't use the stencil and have to do it free-handed. The thermal pad is 1.27mm by 1.4mm which might seem small, but actually has 10 times the surface of the electrical pads (and for the stencil openings, it's even 16.7 times bigger). I managed to do this correctly on LED Module D, and this is the single part of the design that has not changed at all in Module E, so it has to be ok.
I got a hint on how to fix the temperature sensor issue from yesterday, but I'll need to get some kapton tape for that.
My first impression of the thermal conductivity: it seems quite good, but having the temperature sensor working would be a huge help to actually verify that.
And in other news, I started another CAD / light simulation experiment, to quickly iterate on diffusor lenses virtually, but using a model format that is also suited for CNC or SLS manufacturing. My actual model is total crap right now, but the workflow is going in the right direction.
I couldn't test a lot during this weekend, because temperatures in my "lab" were between 32°C and 34°C. Anyway, I managed to solder one of the boards, which is much easier than Module D because I used larger SMD resistors.
I could also do a little bit of testing. First, it turns out that the thermal pad of the temperature sensor TMP1075 is internally connected to ground, which is not documented in the datasheet. I had connected the thermal pad to V_LED on the PCB, which means that I would need to electrically insulate the thermal pad to make it usable. I'm not sure if this is possible without ordering new PCBs.
I had to cancel my tests due to the overall heat in the room and will continue after the weather changes...
There was an error with customs processing, which delayed the delivery by two weeks. But now the modules finally arrived!
In the past weeks, I've had some issues getting LuxCoreRender to work, though it was actually very easy in the end. LuxCoreRender is a physically correct renderer which can accurately simulate caustics, which is needed to simulate light fixtures.
Finally I could set up a simulation of LED Module D/E and my first reflector in Blender. I could (qualitatively) compare the result to the real-world test of the hardware, and it looks very similar.
In the simulation, the lamp sits in the center of a half-sphere and iluminates its inside. A special camera (which could not be built in rehl live) takes a warp-free HDR image of the half-sphere which is saved to an EXR image file.
Looking for a tool that converts EXR images to IES light profiles, I found no solution. Only some others who had asked the same, and got answers like "such a tool does not exist, and cannot exist, because IES profiles are very complex."
Turns out: they aren't. I coded a simple tool in Rust that does the conversion just fine. With this, I can put the lamp - or hundreds of them - into a larger scene and render it without LuxCoreRender and without the computational overhead of the caustics within the reflectors and diffusors but with practically the same result. That's needed to validate the overall lighting of larger building complexes, where the illuminated areas of multiple lamps overlap.
The PCB files for Module E and it's adaptor are now in the repository, along with updated README files.
The README texts could definitely need a few pictures, but I'm too sleepy to properly add them to the repo now.
Hey, it's easier to add them to this wiki page:
PS: I just uploaded an improved E Adaptor v1.1 with better GND return path. The ones in v1.0 were pretty bad, I guess. In other news, the production of the v1.0 adaptor was just completed 30 minuted ago 🙃
With the modded Module D it was finally possible to test the reflector prototype from 2.5 month ago. The overall light distribution is very nice: very focused in one direction, and full 180° in the other direction.
The surface of my first reflector was somewhat uneven, which resulted in caustic lines around the borders, which were aligned differently for each LED color. This makes the small shortcomings of the color mixing overly visible. To fix this, I tested a structured diffusor sheet, but it altered the overall distribution a but too much. Fun fact: the diffusor came with a protective film, which can also be used as a diffusor, and works even better.
I produced a new version of the reflector with a smoother surface, by applying the plastic reflector foil to a thin stainless steel sheet that bends nicely, and glued this to the 3d-printed half-bowl. Together with a new adjustable fixture for the PCB, I could optimize the light distribution and color mixing a lot more.
So even though module D was a real pita for multiple months, the concept worked out and the effort payed off in the end! With this gained confidence, I modified the schematic and PCB layout enough to justify a new letter: LED Module E. I already ordered a bunch of those, together with an adaptor board to make it easier to connect it to an ESP.
To test some reflectors and diffusors, I need working LEDs in a line like on LED Module D. As said before, most of the circuitry is rubbish, but doing it without the Module D would be impossible. The parts and pads are much so small to hand-solder wires to them, and the thermal load cannot be handled without the optimized copper layers. I managed to separate the good parts of the PCB with a sharp knife and hook it up to the PWM channels of the ESP32-C6, bypassing the TLC59711.
Controlling 10 LEDs with just 6 LEDC-PWM-channels is tricky, but should be manageable. At the moment, it is ridiculously hard and my workaround is among the worst code things I've ever written, but when the next version of esp-idf-hal ships with this PR, it should become much easier.
Overcoming those hardware and software problems took the whole weekend, but is the ground work to finally test the reflectors, which will be pivotal for the first production run of the besteLampe later on.
Not really sick anymore, but still very few energy to work on this project :( Anyway...
Today I got an oscilloscope (and also a thermal imaging camera). With it, I could get better insights into the PWM/CCD chip that is used on Module D. Even without the specific circumstances of being on that module,the chip creates a mostly rectangular wave that can be used as a digital PWM signal - except when it doesn't. In edge cases (like very low duty cycles), the signal breaks in complex ways that are ok for directly driving an LED, but unacceptaple for amplification with a MOSFET.
So the TLC59711, and thus Module D, is a dead end. I still think I could make it work for reflector measurenments, but not relyably enough for real-world usage. Instead, I will go back to generate the PWM signal on the ESP32-C6. A new Module will be needed.
I was on a business trip for a few days, and then sick for more than a week. The only lamp-thing that happened in that long time:
LED Module D does not (yet) work reliably. Either the LEDs are on all the time at full brightness, or they can be switched but not dimmed... Lately, I got dimming to work, but some specific low-brightness-settings (e.g. 0,381%) result in full brightness anyway. Testing and fixing this is hard, because this board revision can handle full brightness only for a few seconds before the LEDs get much too hot - and de-solder themselves.
I think that I can get a few of the boards working good enough to make the reflector tests and angular measurements soon, but most probably the schematics need to be heavily reworked.
The newest PCBs just arrived, and as always, they look great. Hope that their performance will be equally well! Now that I've seen even more of the complexity of constant current drives yesterday, I'm glad that I have chosen a simple PWM-MOSFET-resistor approach for the LED Module D.
Looking at the input and output signals of the LED Driver Module A, its working principles seem to be even more complex than I anticipated. The datasheet did not prepare me for this. I thought it would be two PWM waved modulated with each other (2.4 kHz and 1 MHz). Instead, it's three different waves, none of which is at 1 MHz. The one with the highest frequency is also amplitude-modulated with a fourth signal that I could not yet characterize.
I'm still impresses that this thing works, but my hopes of understanding and improving it faded even more.
I held a one-hour talk (in German) about besteLampe! at Kamphack 2024 in Münster. Sadly, the location could not provide a recording setup for me, and of my own two recording solutions, one failed completely and the other one only recorded the first half. I got a lot of hints on how to improve things, what to look out for, etc.
There is now a very simple "robot" mostly made of trash, and two servo motors. It can measure the light emission across 180° horizontally and about 50° vertically. The 50° would be too limited for many light sources, but for the approach of LED Module D and its linear half bowl reflector, it should be just right. I took the first measurements (with a single LED, because the module is still being manufactured) but I still need to transform them from one polar coordinate system into another to make any use of them.
I was on vacation for a week, which limited my options to test existing hardware. Instead, I designed LED Module D (not yet uploaded) and ordered it. It combines a few technologies that I have tested on their own but not yet in combination: small high power LEDs as on LED Board C, but in a very compact linear arrangement, a TLC59711 for PWM generation only (constant current driving capabilities ignored), and a configuration of logic driver, MOSFET and series resistor as used on the Main Module v1 and the LED Modules A and A2.
With 10 individually dimmable LEDs with an active optical strip of 20mm by 1.3mm, it is aimed at a design with a linear half-bowl reflector. And with each LED delivering up to 10 Watts, one board should be enough to drive a complete lamp. If more LEDs per lamp are needed, it is infinitely chainable due to the TLC59711. And the whole chain only needs 2 or 3 GPIO Pins on the Microcontroller.
After more than 40.000 measurements with two different driver modules, two led modules, varying count of LEDs and almost any other parameter that can be changed, there are two interesting results:
- Driving 3 high power LEDs in series at 12V with an oversized inductor (33mH instead of the 10mH recommended by the data sheet) gives the best results compared to any other driver.
- But a simple series resistor is more efficient than the constant current driver in many cases.
There are some other advantages and disadvantages of CCDs (constant current drivers). In the context of besteLampe!, those advantages become less relevant, e.g. the ESP32 can monitor the voltage, current and temperature anyway, and with that information adjust the PWM duty cycle in software to keep the brightness constant under changing circumstances. Fun fact: all CCDs that I tested make the relationship between PWM duty cycle and resulting brightness much less proportional, so that adding a CCDs actually increments the needed computations on the ESP to get a specific amount of light.
Another interesting find: CREE publishes the efficiency for most of their white LEDs in "lumens per watt", but not for the XLamp Element G which I currently use on the LED Module C. But they seem to be about 33% less efficient than their mid-power LEDs which I used in the LED modules A and A2.
I still need to test the high-efficiency LED in combination with a CCD for a definitive verdict.
I got the INA219 power sensor working, but have some problems with the TMP1075 temperature sensor. On the other hand, neither the LEDs (with heatsink) nor the driver board (without heatsink) get warm, so that's ok. My current bottleneck is the 15W power supply, because both the driver board and the 3 LEDs can take more than that.
The PCBs for Driver Module A arrived today, four days earlier than announced! And the parts also arrived. I assembled the first one and just tested it. It works great, better than the 60€ evaluation board that I bought earlier. Even though my board is 8 times smaller, at least 10 times less expensive, and this was my first try ever :D
Computing the perfect values in advance is extremely hard, so I want to build and test multiple variants:
- four different inductor values from 10µH to 33µH (tested with 10µH today, other parts are here)
- four different maximum currents from 1A to 3A (tested with 1.5A today, other parts are here)
- different switching frequencies (tested with 1 MHz today, need to order resistors) I only have 20 boards now, so I can't build every possible combination. Or I need to exchange some parts on the boards between tests.
For a given board, my test setup currently goes through more than 400 combinations of duty cycles and PWM frequencies and measures the emitted brightness. I will soon be able to measure the power consumtion, LED temperature and driver board temperature as well.
When I have those detailed measurements, I can select the perfect driver configuration for each color channel, and calculate the resulting material cost, power consumption and brightness.
I made a quick prototype to confirm an important idea: if you have a linear light source, it's easy to make a reflector that projects is as a thin line, keeping it focused in one direction and blurring it in the other. This should make it easy to mix colors from individual LEDs on that line.
I only tested this with a monochrome LED strip yet, and I guess for actual color mixing I will need to add some more diffusion or scattering, either before or after the reflector.
In any case, this could become a very elegant solution to light a linear area like a straight footway.
Oh, and I also bought some Musou Black to eliminate unwanted reflections and scattering. It's very black, though not nearly as black as I thought it might be. But it will be fine: it's absolutely matte, so no matter if it absorbs 97% or 99.4% of the light, there is 0% glossy reflection.
I ordered a little over 500 parts for various hardware tasks - assembly of the first Driver Modules, adapting the LED Modules A and A2 to be driven without series resistor, alternative presence sensors, etc.
But the PCBs will not arrive before the weekend, so I will use the coming days for theoretical work: cost and efficiency calculations, compare the existing design options and the new ones from two days ago, maybe first light simulations with LuxCoreRenderer...
Regarding efficiency calculations... my first back-of-the-envelope calculations show that hardware cost is minimal compared to the electricity that is used. It will almost always pay off to invest in improved efficiency. More on that later...
Fixed the configuration of the software, so that it compiles again. It involved changes to versioned files as well as files outside the repo on my computer. This time I documented it in the Wiki in case it breaks again.
Also had a very constructive discussion about design near-future decisions. It turns out that it's not either "diffuse light by many mid-power LEDs with simple MOSFETs and series resistors" or "directed light by a few high-power LEDs with CCD". There are many in-between solutions that might also make sense.
And I became aware of supply-chain issues with CREE LEDs: I might need amounts of each color that are bigger than what distributors have in stock (often: several hundreds) but much lower that the minimum order quantity (1500 or 3000) needed for those which are not in stock.
During the last days, I designed LED Driver Module A, based on the A6211 Constant-Current-Driver IC. This has been the hardest part of the development until now, because choosing analog components that need to handle high power under non-trivial circumstances is new to me.
I might need to derive improved versions of this if I made a mistake, and/or I might create more modules like this to test other constant current drivers. The plan is to use the same form factor and pin layout, so that the driver modules are drop-in replacements of each other.
The driver module and the adaptor were ordered today and should arrive in about 8 to 10 days.
The first LED Module that I ordered 8 weeks ago arrived 2 weeks ago, and only now I found some time to test it quickly. Attached to the first prototype lamp, every color channel lights up when it should.
As I said before, it does not fit into the enclosure. I designed an adaptor, that should not only make it fit physically, but also allows a smooth transition from the old pin assignment to the newer one, which is partly implemented on the A2 board and will be fully done on the next version of the main module. The configuration via solder bridges needs some more documentation though.
The adapter has required a surprisingly large design effort. It only routes a few signals, but due to size constraints it needed four layers and I nearly switched to 6 layers.
I've attached the TLC59711 (twelve channel LED controller, but with very low power) to the LED Module C to test the mixing of 10 different LED colors. To make it easier to adjust the colors, I wrote a small adapter program, so that I can use 12 Knobs of an Arturia MiniLAB Mk II to directly control the color channels.
With this, I could roughly test the color rendition of each channel and various mixes thereof, and also fade between monochrome amber and polychrome amber. It's working as expected, but also confirms that it's good to have multiple variants of white LEDs, Amber LEDs and at least one kind of red LEDs.
I also ordered a lot of new parts for the next tests. Need to design one or two additional PCBs to test color mixing with the full power of the LEDs.
I ordered those boards 10 days ago and they already arrived. Looking very nice, the LEDiL connector fits and the lenses/reflectors also fit (but are extremely close to the pin headers).
With these boards I will finally be able to test the CREE XLamp LEDs, and with them, the Constant Current Driver(s).
I tried to reflow-solder the boards using the OpenReflow hot plate, that also arrived today. I don't have a dedicated controller board for it, not even an adjustable power source. My computations showed that a constant 12V drive could be exactly right, so I tried an old PC power supply and it worked perfectly! That's great, now I can reliably reflow-solder at home.
The LED Board C works very well, the colors of the XLamp Element G LEDs are nice, and the color mixing ranges from "wtf" to "99% perfect" depending on which lens I use. Ordering 10 different ones was a good idea!
I could only test with 3W power until now, because I did not adjust the driver board, and because I don't have the heat sink yet. But 3W without heat sink stays very cool, so 15W with heat sink will be no problem as well.
The LED Module A v1.0 finally arrived, six weeks after ordering. As described in #2, my placement of the connector was very unfortunate, and I need to make a small adapter if I want to use them in the exiting enclosure. I already started designing it, and it will also help to bridge the small differences in pin assignment between different LED Modules and different Main Modules.
Finally made an automated testing rig for the TPS92200D1EVM evaluation board. With this, I can test if / how the constant current drive handles the PWM signal it is feeding me.
First results: it's much more complicated than I thought, and the official documentation does not describe it well. I think I could work with this driver, but it would need significant effort in the software to do it correctly. Also, I can't use most external PWM generators with this, because I need to set the exact timings / frequencies and vary them from about 50 Hz for extremely dim light, through 1000 Hz for medium brightness and can only use the desired 3000 Hz above 50% brightness.
Recently I ordered an assortment of reflectors and lenses from LEDiL, and they arrived today. I will need the LED Module C to test them, which I ordered yesterday. I might try to test it with a larger LED, or using try to connect the new, small LEDs without the board, but I guess this just won't work.
The lenses look great, and I start to understand why they aren't cheaper. I couldn't make something link this at home, and I doubt that I can get something similar with professional rapid prototyping either.
I started designing LED Module C. This is going to be interesting. I try to put 25 very small high-power LEDs into a circle of just 2cm diameter, so that they can all shine through a single lens. This will definitely need more than 2 PCB layers, and the thermal management is going to be... interesting.
Today I tested one of the reflectors that I 3d-printed days or weeks ago. It works exceptionally well for the light that is actually reflected, but like every full parabolic reflector, a lot of light just comes out of the LED and goes off without ever having the chance to be reflected.
I will likely need lenses instead of reflectors, or need to test half-bowl reflector designs. My first 2d-simulations of a half-bowl reflector looks promising though.
Met some interesting / interested hackers in Münster's WarpZone. Together we could fix some minor soldering issues on my LED Module A2 prototype that I reflow-soldered in an old kitchen pan on my inductive stove. Also made progress on the software and got a lot of new ideas and feedback.
The PCBs for LED Module A2 arrived, which I ordered after Module A, but because I did not order the Assembly, I already expected them to be here earlier. I hand-placed about 150 SMD components and tested a very hacky soldering process with sand in a pan. It worked very well, though the sand was very dirty and the dirt got burned up and filled the appartment with smelly stuff. Can't recommend, won't do it again.