Marc's Public Blog - Electronics Hacking

Thinkpad P73 vs P70, not a win all around: only one 2.5" drive instead of 2, and a badly designed power system

P70 vs P73, they look pretty similar

*Update*: it seems if that if you get a cheaper nvidia chip with the P73, it is then configured to accept 135W power supplies as the minimum required. That said, it will still refuse to work with any regular 90W power supply or external battery back, unless you force it with the center pin resistor swap.

While I have no plans to use windows on that machine, I thought I'd just try it out to see how it does on power. This is where I was impressed, windows can idle at less than 10W for more than 11H runtime, while I'm lucky if I can get linux at 15W. This is definitely a place where linux should do better, of course, it's not as if Lenovo put any work into making linux more efficient on their hardware either:

*Update* : with tlp and using the nouveau driver just enough to turn off the nvidia chip, I'm now able to tune the laptop down to 10W, almost matching windows.
See tlp issue 494 for details on how to setup tlp to run in low power mode when power is plugged in.

Another disappointment is that the P73 is mostly the same size and weight than the P70, but it has less room for storage. It has a bunch of empty spaces that aren't used for anything, and it can't use two 2.5" SATA drives anymore, like the P70 could. Worse, the now single 2.5" slot uses a lenovo only ribbon cable that does not ship with the laptop and basically means you cannot even add a 2.5" drive without that special ribbon cable, which isn't in stock yet. Well done... Ah yes, the battery is also not hot swappable, even if it is replaceable (unlike a Mac laptop where everything is sealed shut).

this shows the unobtanium lenovo cable for the now only single drive that fits, along the unused space

Ok, stop complaining, just buy a bunch of 170w or 230W power supplies and move on with your life

Tricking the P70 and P73 into accepting a power supply it wouldn't otherwise use

For the P70, I built this power supply adapter with a resistor bridge to tell the laptop how big it should think the power supply, is:

It's basically a configurable version of this. Yes, lenovo, I thank you for the hours I wasted opening up power supply plugs and replacing the center pin resistors:

Here's how the P73 responds:

- 230W works fine   4.6k => I have seen power supplies work with 170W but fail at 230W, so the laptop does draw more
- 170W works ok     1.9k (1.8k also ok)
- 130W rejected     1k
- 90W  rejected     550 

The rejected power supplies will be used to charge the laptop if it is shutdown, but they will not be used in any way otherwise. On the P70 the laptop would at least use the power supply to keep the laptop alive, and use half battery half external power supply. Not so with the P73, it just ignores it entirely.
This is utter bullshit as I have plenty of 90W power supplies, including 12V car converters, or a 90W external 20V battery pack I can't use anymore.

You can go read my Hacking a thinkpad slim tip adapter to output more than 90W (required to charge a Thinkpad P70) page for details, including this nice battery pack I couldn't use anymore:

*Update* : so, actually with some serious tlp hacking (basically I told it to force battery mode even if a power supply is plugged in), I've managed to throttle the laptop enough, even when plugged in, so that it only uses 20W. At that point, I'm actually able to use my old external battery pack, as well as a 90W power supply, as long as I lie to the laptop and pretend they are 230W power supplies with the resistor trick. In my tests with windows, it was not possible to throttle the laptop enough when plugged in, not to have it overwhelm a smaller power supply (not that 90W is small for a laptop that normally uses 20-30W when it's not charging batteries).
If you scroll to the bottom of the page, you'll also see a terrible buffer lipo hardware hack I did that allows to use the battery pack with higher amp draws, but it's a bit ridiculous (and bulky).
See tlp issue 494 for details on how to setup tlp to run in low power mode when power is plugged in.

Without the tlp hack or the buffer lipo hack, when I lie to the laptop and tell it is connected to a a bigger power supply, manage power draw with what I run, and disable battery charging in software, but the laptop will still draw the power supply for over 100W when you plug it in for a fraction of a second, and refuse it if the voltage drops.
Obviously this would not be a problem if the laptop simply had a 90W power supply mode where it throttle things down and turned off battery charging. This is mostly what the P70 does.

In the meantme, on top of hacking my power supplies, I also made this for my laptop, it looks silly and makes the thinkpad not look like a professional laptop, but well, that's lenovo's fault:

this takes any power supply and replaces the center tip resistor with a 1.9k one to emulate a 170W power supply

From talking to Lenovo, they don't think that this is really a problem, so since I'm an engineer, I made my own external battery pack, but I otherwise recommend to road warriors to avoid thinkpads from now on, given the backward power design in this one.

Making a Thinkpad P73 compatible external battery pack

Prototype with 150W step up converter which takes my 16V lipo to 20V while delivering enough amps to make the laptop happy:

it works, and the laptop thinks it's connected to a 230W power supply thanks to the center pin resistor.

Here's a quick demo:

Version 2 was to have a way to recharge the battery pack while it's being used. I've used this to use the battery pack as a buffer to absorb peaks from the laptop without tripping an external power supply, including in a car limited to 100W or a plane power supply limited to even less:

this works in theory, but the lipo charger is quite slow and wouldn't keep up for long, but I made a better version shown lower down

Lenovo's P73 airplane mode simply stops using the external power supply and reverts to batteries. Sigh...

Making a battery pack to act both as buffer for a smaller power supply, and as emergency external power (even power the laptop from 12v)

version 1 was a bit bigger than I wanted, 90W power supply shown for scale

here, the 90W power supply is recharging the battery at 2.5A while it's being discharged at 3A on the output side, using the battery as buffer

I made version 3 a bit smaller, with a built in 12V lipo to act as buffer for a smaller power supply. Yes, it's a beautiful piece of art, I know :)

Pushed to the extreme, I can now use my original external battery pack again by having it recharge my lipo+150W step up that can output more amps than the ravpower pack can. Of couse, it's inefficient, the ravpower pack outputs 20V that gets down converted to 12V by the H605 Air lipo charger, which charges the built in 3S lipo in the box, and then gets up converted back to 20V without the amp limitation (the phone used to control the lipo charger also inside the box):

The really cool thing is that by using tlp, it's actually possible to tune the laptop down to very low power use, even when plugged in, something that windows probably can't do:

7.3W with the screen off (and around 10W with wifi off and the screen on low dim) is not bad for a laptop that big

4S Lipo vs 4x 18650 or 26650 batteries

That said, as I recently found out that 16650 (or better 26650) batteries are both lighter and smaller. The only thing the lipos do, is offer a better discharge rate, but while that's useful for a high power RC plane motor that can empty the batteries in 10mn, it's not needed for a laptop:

26650s are 195 Wh/kg while the lipo I gave was 184Wh/kg. The 3rd battery listed is supposed to be 260Wh/kg which is much nicer, that said, it looks like those samsung batteries are actually smaller than 26650s, lighter, and yet offer the same 5Ah at 3.6V. If so, that's very impressive.

As of this writing, I have however not found 26650 battery holders that hold 26650 protected cells that are a bit longer. This seems to the be only one available, and it's too short to hold the batteries: https://www.amazon.com/gp/product/B074GVPWSH

A few months later, I ended up cutting them and taping them to make them longer. It doesn't work great, but it was enough for a few tests. In the end, I found that somehow I wasn't getting enough amps out of them, which surprised me, so they didn't work that well compared to a lipo:

Conclusion

Jon, presenting the miniconf as per how many

Raspberry Pi running the car

This year's dingo car, controlled by the rPi

All done

Andy presenting the software side of the car

We then trained our cars' neural network by manually driving them arount the track:

and before long, I got my car to drive around on its own

Here is a video of my car driving on its own, including how it learned to drive:

During the miniconf, I also gave a talk on my recent LED panel/ESP32 work and brought my recent RGBPanels:

I knew that this could void the warranty on some parts of the car. I was ok with that. Tesla wants me to buy a powerwall, but I think powerwalls are stupid.

I'd need to spend $30 to $40K in powerwalls to get the same amount of energy I already have in my car and I already paid for. Sorry, but I'm not spending that much for something I may need once every few years. Load shifting my solar in california is otherwise a straight loss, and PG&E forces some silly rules about not allow using powerwalls for time of use power arbitration if you accept the buying credit for them. You get penalized for helping take the peaks off the grid, yeah bureaucracy!
If tesla sold a powerwall that would allow using your car as a battery source for emergencies only (car batteries are not designed for daily cycling like powerwalls), I'd be super interested, but they do not, so I decided to make my own answer.

I knew that I could probably only get 2-3000W out of my car, honestly for emergency use (a couple of fridges and essential equipment), that's good enough. Sure, it wouldn't power all my house lights, or even my furnace for heating (which happens to use over 1000W just to run the fans), but eh, it's for emergency use only, so good enough.

Plugging into the standby 12V battery

My plan was to connect a big GLA 12V battery in parallel with the car's battery, so that it could absorb big peaks and buffer a it longer in case the car's battery recharge didn't kick in quickly enough. I did however confirm that the car's DC-DC system only recharges the standby battery at a slow rate, so it was not adequate for my need.

Plugging into the cigarette lighter adapter

Tapping into the car's DC-DC system

The 2 white holes are where the clips that you need to release. are located. You can also see the black and red tap points:

The Nut on top of the positive bolt under the seat

Building it up without resistor and protection relay

If you do not see a spark, you may just be able to connect the inverter dirctly to your car with just wires (although if that doesn't work, it will trip the DC-DC converter in the car, and require a full car reset to bring it back online).

Building it up

Originally I tried those:

What happens is:

This shows the current meter shunt connected to the bypass relay (which is powered by the connectors on the inverter side). You then see the thick 100W resistor connected in parallel with the relay. This allows current to flow more slowly and ramp up the connection:

I tested a 1300W microwave which worked without issues, so did my fridge and other devices. The pure sine wave inverter is very important for a microwave, but a cheaper inverter worked well enough for my fridge and basic loads.

Since we're talking about currents of 100A or more, we need to talk about wire gauge. The inverter I got came with 10AWG cables of about 1m. These cables are insufficient for 100A (never mind 200A), but in real life will mostly work for short distances and as long as you don't use the full power continuously (which could technically heat up the cable enough to melt its insulation and cause a short eventually). In my tests with 100A, I lost 0.7V due to inadequate wiring:

Given that the car outputs 13.5 to 14V, this drop is not big enough to matter since the inverter works all the way down to 10V or so, but be mindful of potential heat. Here is the end result:

Keeping the DC-DC system awake

Backfeeding your house

Discussion Threads

The diffuser however had to be:

After getting recommendations on the FastLED group and SmartMatrix group, I ended up getting two things:

The Frosted Clear Plastic Cutting Mat was good for protection, but didn't offer too much diffusion. Still, it was better than nothing, and that's what I ended up using in the front of my shirt.
The Serenity Foam Underlayment for Laminate Flooring offered better diffusion, but no protection at all. However, I figured out that if I used that, plus the cutting mat on top, I got extra diffusion and protection.

If you wonder, the demos below can be had from:

Here are pictures of what it looks like with one and both layers:

The cutting mat only still provides some diffusion, just not as much:

Here is what it looks like with both layers and very small wires to hold the mat on top of the 3 32x64 RGBPanels attached together:

Here is what it looks like side by side, with both, and without any:

This works pretty well, thank to the people who provided suggestions and help

you can find the talk pdf here: http://marc.merlins.org/linux/talks/Using_Open_Hardware/Using_Open_Hardware.pdf (you'll want this one to get all the clickable links in the slides)
you can view the talk slides in html here or below:

Talk video below:

I arrived the sunday before the conference and helped out the open hardware organizers with a bit of last minute setup. I also got to do some last minute testing and tuning of my panels:

hacked up ESP32 with level converters on breadboard to run 3x 64x32 SmartMatrix panels with SmartMatrix::GFX

64x64 P3.8 SmartMatrix::GFX panel vs 3x 64x32 SmartMatrix::GFX P4 flexible panels vs 4x 16x16 FastLED::NeoMatrix P10 panels

After finishing the code tuning and demos just in time, gave a 20mn miniconf talk on the history of linux.conf.au hardware miniconf. I went through how much I learned from those confs and what I was able to achieve as a result. I sure got to learn a lot about microcontroller and driver programming:

I wasn't able to bring my burning man 4096 neopixel matrix, it doesn't even fit in my car, but the irony is that my small 64x64 rgbpanel has the same resolution and fits easily in my backpack

The 64x64 compact display is showing the hand X-ray here

A few days later, I gave the longer version of my talk at the main conference. By then it had grown to over 160 slides in a 45mn slot, or 16 seconds per slide. Ooops...

http://marc.merlins.org/perso/arduino/post_2015-01-06_Driver-for-direct-driving-single-to-3-color-LED-Matrices-with-software-PWM.html

http://marc.merlins.org/perso/arduino/post_2017-04-03_Arduino-328P-Uno-Teensy3_1-ESP8266-ESP32-IR-and-Neopixels.html

http://marc.merlins.org/perso/arduino/post_2017-04-24_Adafruit-GFX-on-NeoMatrix-and-RGB-Matrix-Panel-Demo.html

http://marc.merlins.org/perso/arduino/post_2017-06-02_LED-Pants-and-Shirt-Programmed-With-Arduino-on-ESP8266.html

http://marc.merlins.org/perso/arduino/post_2018-04-23_FastLED_NeoMatrix-library_-how-to-do-Matrices-with-FastLED-and-Adafruit_GFX.html

http://marc.merlins.org/perso/arduino/post_2018-05-29_EDM-Party-Shirt-powered-with-FastLED_NeoMatrix-and-Adafruit_GFX_-plus-160Wh-_10Ah-4S_-worth-of-lipos.html

http://marc.merlins.org/perso/arduino/post_2018-07-13_AnimatedGIFs-for-SmartMatrix-or-NeoMatrix-_Neopixel-WS2812B_-from-SDcard-or-SPIFFS_-on-Teensy-3_x_-ESP8266_-or-ESP32.html

http://marc.merlins.org/perso/arduino/post_2018-07-30_Building-a-64x64-Neopixel-Neomatrix-_4096-pixels_-running-NeoMatrix-FastLED-IR.html

https://github.com/marcmerlin/SmartMatrix_GFX

Hopefully the talk and/or slides are useful to you. Links:

The ideal solution is batteries only if your event isn't too long and you've done the math that the batteries have enough Wh for your needs
Next, is usually batteries + generator that you start as needed. Solar is really the best solution, but it requires more complicated hardware and setup (charge controller, MPPT charger, etc...), but more importantly for any non trivial power need you actually need pretty bulky and heavy panels to handle the load (of course this also relies on you being able to count on enough sun during your event at that location, not an issue for burning man, but potentially an issue for a spring festival in some place that could be overcast or maybe even rainy).

12V Charging

Plenty of chargers work off 12V, you may just need to use some barrel adapters:

20V and other higher voltage high amp charging

this battery pack can output 9, 12, 16, 19, or 20V

You can see the 12V being split and going into the little white box with the step up boost converter. It shows that it's taking 3.5A at 12V and the red display next to the laptop shows it's turned into 1.7A at 20V which goes both into the already charged laptop and the almost charged ravpower battery pack:

it might not look like much, but this is my new 160W laptop power supply :)

5V USB charging

you can see the anker 14 port USB hub next to the powerex battery charger for scale

Then, I personally use this for my trips when I want a lot of USB (5V) power:

And here is the end result, lots of different chargers all from that same 12V source (including all the adapter tips in the upper left)

After I figured that my previous shirt was getting a bit stale, I wanted to design EDM Party Shirt v2, which both had to be easier to wash (the previous one had LED strips all over it that were too much work to remove, making the shirt not really washable), and I also wanted it to be more special.
I had been playing with Adafruit::NeoMatrix and figured it would be cool to have a NeoMatrix on my shirt (also it would be easier to remove a whole panel to wash the shirt).

So, in the great tradition of yak shaving, I first decided that I should be able to use FastLED instead of Adafruit::Neopixel. This was mainly at the time because FastLED allows parallel output and therefore allows updating a screen by segmenting it in smaller pieces that are updated in parallel. With Adafruit::NeoMatrix, my 768 pixel panel would have taken about 30ms to refresh, or only 33 frames per second, which is not a lot. With FastLED, I was able to trivially segment it in 3 and get 10ms/100fps, which is a whole lot better for animations.
Turns out, switching to FastLED also gave me access to LEDMatrix, an alternate library which while lacking Adafruit::GFX primitives, offers another nice API including better text and basic sprite support.

So, I started a port of Adafruit::NeoMatrix to FastLED and wrote FastLED::NeoMatrix. It was actually a non trivial port, which took much longer than I thought, but I got it working in the end:

by then I was already able to display with 3 data lines, one for each 32x8 panel

In the process, I managed to plug the wrong power into the panel and blew a pixel. Thankfully I was able to borrow another pixel from a strip and soldering it in place to fix it:

Once the port was done, came time to get the panels together. Wiring was a bit challenging because I had to ensure that power was injected at a mostly equal value in 9 different points (3 per panel) due to voltage sag at higher amps. I then quickly found out that with 3 data lines at high frequency, there is cross talk between the wires, so I switched to a CAT-5e cable where each data line is twisted with its ground and the remaining 2 wires are used to bring VCC (5V). Technically my 3 panels can use up to 60A at 5V at full power. Obviously many things will melt before that, and I'm using a power converter that tops out at 10A. Even 10A is too much for the wiring, but thankfully my displays don't use that much brightness (it would be blinding to people):

two 5Ah 16V lipos give about 160Wh, just enough to run 2 panels 10 to 12H

the fancy energy meter keeps track of how much time I used and how many Ah came out of the batteries. Useful to know how much time I have left. The blue meter is amps at 5V (after the power converter) and the red one amps at 16V (straight from the battery)

on the right, I have a backup ESP8266 if the main one fails, a backup BEC (5V converter) that's technically 10A capable but not meant to do more than 5A continous, and bottom right is my older 3A BEC with in line amp meter

the new tobsun 5V converter is bulky but does 10A without issues

For the back of the shirt, I got some fabric and created an inside pocket to hold the panel:

it then mirrors the front

All this crap goes into a fanny pack, and gets wired to my shirt, pants, and glasses:

the cool part is that my back also has a panel inside the shirt that uses the shirt as a diffuser

You can get the code I wrote for the shirt here: https://github.com/marcmerlin/NeoMatrix-FastLED-IR

This video shows an early version of the code working on a desk:

This video shows the animations:

While this video shows the tech a bit more:

So, this all started with some LED shoes I hacked to last 12H instead of 4, and it ended with me learning how to program arduino like microcontrollers to control neopixels (aka WS2811/WS2812/WS2812B) while being able to receive Infrared/IR commands. The latter is actually difficult but you go read that page to learn why

Since I've met plenty of people who complimented for my neopixel shirt and pants combo, and some who asked questions about them, I thought I'd write some quick page to explain how it all works and how you can do similar things, since it's more fun if I'm not the only one lit up at Dreamstate (which has been less of a problem at burning man).

Here is a video summary:

Show me the code!

So, I have 3 versions of the shirt, let's go through them depending on how complex you'd like to go:

Multi Color LED strip, non controllable

It used a 12V controllable dimmer: https://www.amazon.com/gp/product/B00MHKCTLE which can simply change the brightness of the LEDs, which are of a set color. I bought the LED strip in Akihabara Japan, but I'm guessing something similar can be found elsewhere.

Tri Color Controllable LED strip

This version is better in that the LED strip has 3 channels, one for reach of Red, Green, and Blue. I uses a tri color controller like this one: https://www.amazon.com/gp/product/B01410R4KS or remote controlled: https://www.amazon.com/gp/product/B00PBOJNZS
Those controllers can create any color and flash it at any interval, however:

ESP8266/Arduino Controlled Neopixels

To fix the issue of not being able to have custom multi color LED patterns, where each LED/pixel can be controlled separately, the solution is neopixels (aka WS2811/WS2812/WS2812B). Each LED/pixel is controllable separately, which is done by a computer, in this case the ESP8266 can run my own programs to control all the LEDs.
The ESP8266 is a 3.3V based microcontroller for low power use (good when battery powered) while the neopixels are 5V powered, but thankfully the neopixels can use 3.3V signalling from the ESP8266 while being 5V powered to light up properly. The one thing to keep in mind is that neopixels use some power even if they are not lit. In my case 200 neopixels, take about 120mA when they are off, and 4.5A when they are all lit in white on full brightness.

Neopixels are almost infinitely versatile, instead of having them in single line strips like on my shirt and pants, you can also make display matrices out of them:

I've then written code that receive the IR commands from the remote and execute different code that creates different light patterns, which is explained in more details and available on this page and you can get the code from github.

Here is a video that shows all 3 modes, jump to 3:50 for the neopixel bit:

Show me the code!

See also the newer https://github.com/marcmerlin/NeoMatrix-FastLED-IR (from http://marc.merlins.org/perso/arduino/post_2018-07-30_Building-a-64x64-Neopixel-Neomatrix-_4096-pixels_-running-NeoMatrix-FastLED-IR.html )

Why my pants needed IR controlled neopixels :)

I started with a silver shirt, I added a few LEDs, and then more I got from a swap meet, and later added some LED shoes I hacked to last 12H instead of 4

The end goal was adding neopixel strips on my shirt sleeves and pant legs:

Here is a 6mn clip showing the shoes and shirt if you'd like the details:

The problem with my shirt, though, is that the colors you see on the picture are actually due to broken traces, causing the colors you see. It's better than nothing, but not what I was trying to do, and no way to create streaming effects. This is of course where neopixels come in.

I'm not going to repeat the excellent Adafruit Neopixel Uberguide here, but I have a 3mn video clip showing a standard IR RGB LED controller, compared to a neopixel strip. It also shows how I use standard remote control servo cables to wire neopixels, and how to watch out for:

Why IR and Neopixels at the same time, is hard

It's easy to listen for IR, and then change neopixels, leave them alone, and listen for IR again. It's hard (or near impossible on some chips) to actively update neopixel strips for animations and listen for IR commands at the same time.

Why? This video explains the issue:

What's going on is on low end arduino chips (328p, leonardo, or even AT mega and all other 16 bit AVRs), neopixels are controlled by stopping chip interrupts and sending a very precisely timed signal to the neopixels. If the timing is off just a little bit, the wrong colors get sent, or nothing works at all. This is why interrupts must be disabled

Now, there are actually many other addressable multicolor LED types. The nice ones are 4 wire and work via SPI, which allows the CPU to control the timing and the clock, removing this exact bit banging timing issue. The cheaper 3 wire ones have a set clock and require that the CPU sends a very precisely timed signal, usually done while disabling interrupts. See https://github.com/FastLED/FastLED/wiki/Overview

But since neopixel strips (aka WS2811/WS2812/WS2812B) is what I already had, I now had to deal with this precise timing issue. As you can guess, disabling interrupts causes issues with the IRRemote library because it has its on interrupt handler timer that also requires being run at a special timing, or it doesn't capture proper IR signals.
The end result is that you cannot disable interrupts and receive IR signals, and if you don't disable interrupts, the neopixel signal is unstable and the colors flicker (demonstrated int the video above).

So, unless you use some special hardware to drive neopixels strips on an AVR chip, concurrent IR + neopixels is just not going to work.

an arduino nano v3 running neopixel strips

my 328p arduiny chip (equivalent to arduino nano) and anti plug backwards toothpicks :)

because my 328p chip was unprogrammed, I had to figure out direct ISP programming pinout for it and I flashed a bootloader on it

Concurrent IR + Neopixels solution #1: be fast (Teensy 3.1)

a few chips for comparison (uno, leostick, nano v3, arduiny, and Teensy 3.1 in green)

Thanks to better FastLED hardware support, when I moved my code to a Teensy 3.1 32 bit ARM CPU, the CPU was fast enough that it had time to re-enable interrupts in the middle of updating neopixels. This in turns allowed the IR Remote interrupt handler to just barely run in between pixel updates, and capture IR codes. Success!

See this video for details:

The magic code that makes this work, is here: https://github.com/FastLED/FastLED/blob/master/platforms/arm/k20/clockless_arm_k20.h#L34
sei(); delayMicroseconds(WAIT_TIME); cli();

Thanks to this re-enabling of interrupts, things work.

So at this point, someone sensible would have declared victory. However, I felt bad wasting a Teensy 3.1 on something as simple as driving a single neopixel strip (it can drive 8 in parallel) and reading from an IR receiver, when it has around 32 I/O ports. This is why I checked if I could get this to work on ESP8266 chips which are even cheaper and have much fewer I/O pins (but add Wifi)

Concurrent IR + Neopixels solution #2: don't use the CPU for neopixels (ESP8266 (I2S) and ESP32 (RMT))

I had more 32bit chips, so I thought I would give them a try. I tried the ESP8266 and ESP32:

First, the ESP8266 mostly worked with FastLED + IRRemote, but not quite. The FastLed code, just like on Teensy, is nice enough to re-enable interrupts for a short while: https://github.com/FastLED/FastLED/blob/master/platforms/esp/8266/clockless_esp8266.h#L45

os_intr_unlock();
delayMicroseconds(WAIT_TIME);
os_intr_lock();

However in my tests, the IRremoteESP8266 library was maybe a little bit too slow and caused occasional visible neopixel glitching (this has been fixed in FastLED since I originally wrote this). This is where I found this interesting library: https://github.com/JoDaNl/esp8266_ws2812_i2s/ which manages to drive the neopixels without doing bit banging with interrupts disabled ((ab)-using the I2S hardware support). It's not a very fancy library in what it offers, but it works perfectly with interrupts enabled.

There is another DMA library using the UART instead of I2S interface, that also works without affecting interrupts: https://github.com/Makuna/NeoPixelBus
Same thing for ESP32. Actually ESP32 is even more difficult to get a perfect timing out of using bit-banging given that it's a dual core CPU running on top of an RTOS, and no matter how precise your code is, you just cannot guarantee that it'll run perfectly at the timing you need all the time. I did add ESP32 support to the Adafruit Neopixel library, but it only works most of the time, which isn't really good enough.
This where its built in RMT support comes in. It can generate 8 precise signal waves, which are perfect for neopixels, so this is the way to go to animate neopixels without disabling interrupts (making IR receiving trivial). IRremote was missing ESP32 receive support, but I added it recently, so it's all working.

FastLED now supports RMT on ESP32, so you can run interrupts while talking to Neopixels.

Here's a video summary of ESP8266 and ESP32:

Software and Libraries

And here is my code again: https://github.com/marcmerlin/Neopixel-IR

The big plus from that example code is that it supports 4 different Neopixel backends and abstracts them so that the adafruit (and other) demos can run on all 4 libs. See how it does it here: https://github.com/marcmerlin/Neopixel-IR/blob/v1.0/Neopixel-IR.ino#L275

New ESP32 FastLED drivers

Video with the whole story and details

I also have a video showing the evolution of lights on my shirt from v1 (single non controllable color) to v2 (tri color, but not pixel addressable), to neopixels with cool patterns (jump to 3:50 if you'd like that):

While those shoes are quite cool when they work, and getting them for $50 or less on amazon is quite cheap. Sadly the build is a bit cheap and the hardware could be improved. So I went ahead and did it.

the lit shoe laces are separate

This is what you find under the sole: everything is inside a resin and the built it lipo is too small (only 4H runtime). Two sets of 4 wires come out: one is to control the LEDs and the other one has 2 wires for the switch built in the shoe, and 2 wires for the USB power charging (which charges super slowly, about 4X slower than the speed the lipo can charge at):

The first thing to do is to open the side of the shoe to get to the switch, take it out, and turn it around so that it points away from your foot. Otherwise it's way too easy to trigger. I've also cut the yellow wire and added a small slider switch. This allows me to disable the push switch if I want the shoes to stay off, or not rotate between color patterns each time the switch gets bumped:

The lipo is totally built in and too small. Adding a second lipo in parallel is a bit difficult, I had to burn off the resin to access the lipo terminals:

it claimes 450mAh, but I think it's smaller

it's a bit difficult to solder wires on top of the lipo wires without shorting it

I then added a female connector to allow use of bigger lipos from a mobius I wasn't using

I had a few lipos to choose from, but the mobius one was the best fit for the hole in the shoe

I had to cut off a bit of plastic fit the battery

still a bit of a tight fit

My shoes now work a bit over 12H, do not turn on or off without my wanting them to, and they come with a real off switch. I did put a very solid sole insert on top though to protect the electronics and the new bigger lipo underneath. There is also a worst case scenario where it could catch fire :)

I later got another pair of shoes with dual LED pattern, the battery is still quite small (450mA), and on top of that the shoes shut off on their own every 2H. Sigh...

getting to the battery contacts is still hard

I added a direct port to the lipo for optional faster charging and charge status check

Also, the charging function is slow as crap, but the direct lipo access charging port I added lets me recharge the batteries directly in one 1h by connecting directly to a proper lipo charger. They do suck in several ways, but in the meantime, finding dual pattern LED shoes with LED strips that flex instead of breaking, wasn't trivial either...

Years later (2021), I'm still using this type of shoe, but don't love them as the LED strips keep breaking, if it's not the control module itself on occasion. I tried to find other options, but have not yet. I had a look at LED laces, and those are not very reliable either (or very bright). I tried to hack these to power from the power supply I added and upgraded in the shoes, but it was probably not the best idea: