Allgemein – texelography

Convert a Discman D-10/100 to Li-ion Battery

2023-10-19
by Clemens

In 2023, Japanese textbooks still come with Audio CDs. If you want to listen to them during your commute, you’ll have to go through the hassle to convert them to MP3 and store on your phone.

Or, you could get yourself a vintage Sony Discman portable CD player from 1988, with a heavy lead-acid battery pack, and use that instead. At least for me, the decision was easy.

The Sony Discman D-100 I bought second-hand from yahoo auctions of course didn’t work: it required a new plastic gear, a new laser, and voltage, PLL and laser focus bias adjustment. After that, I got myself a working vintage portable CD player.

These Discmans didn’t use AA batteries, instead, they came with a flat battery pack that gets sandwiched underneath the CD player. It is called BP-100, uses lead-acid cells, and is, as expected, quite heavy. It comes with two metal hooks to be able to strap it around your neck. The pack is rated at 6V/1000mAh.

After 30 years, the lead-acid cells were completely dead. Removing a few screws reveals three Lead-acid battery cells.

Initially I considered to replace the cells with LiFePO4 cells due to the similar voltage: using two LiFePO4 cells would result in about 6.6V. With a small BMS, that would be a nice drop-in replacement for the lead acid cells. After a long search, I struggled to find suitable sized flat LiFePO4 cells with satisfying capacity that would fit into the case, and investigated into standard Li-ion cells.

The first place to check was the manual of the D-100, which comes with complete schematics and layout.

The area circled in green is the charging connector. A mechanical switch within this connector switches the main supply voltage for the CD player from the power supply to the battery, if the charger is disconnected. That is why even with a battery pack connected, the CD player won’t power on if you have the charger connected to the charging connector, but not plugged into a power outlet.

Since every part of the CD player can also work with the 9V provided by the charger, it is safe to assume that it will also work with the 7.6V of two Li-ion battery packs. The only thing that needs to be adapted is the voltage of the charging circuit. By default, it charges with 7.4V. For Li-ion, the charge voltage needs to be raised to 8.4V.

Two pouch-shaped 4000mAh Li-ion cells with 100x50x5mm dimensions were a good fit. The cells I bought came with their own battery monitoring system (BMS), but I decided to add another two-cell BMS on top of that. Never use Li-ion batteries without a BMS, as there is a high risk that the cells will be overdischarged or overcharged.

This was my first time doing a Li-ion conversion, and I decided to try a cheap two-cell Chinese BMS rated at 2A.

VHB (Very High Boding) tape is used to keep the cells in place.

The cells connected to the BMS (wrapped in isolation tape) installed in the battery case. It was a little bit difficult to close the lid, as the cells are a tiny bit thicker than the original cells. If possible, try to use cells with 4.7mm thickness, or use thinner tape.

A quick test indicated that the new cells are working fine, and the Discman can now run on Li-Ion cells, providing more than 4x the power than the original pack!

While we can discharge the cells, we can’t recharge then at the moment. The charging circuit on the D-100 only charges up to 7.4V, which won’t be sufficient. This charge voltage needs to be adapted to about 8.3-8.4V.

A closer look at the schematics reveals how the charging circuit works. A PWM controls Q411, which, via coil L406, charges the capacitor C421, which maintains the charge voltage. Depending on the PWM duty cycle, the transistor will pump less or more charge into the output, thereby adjusting the output voltage.

The voltage is controlled using the resistors R439 and R434, which divide the output voltage into a lower voltage, suitable for the comparison logic inside the regulator block in green. The resistors R435 and R436 are used for manual adjustment of the output voltage, and by closing soldering bridges, the output voltage can be adjusted.

To raise the voltage, I decided to replace R439 by a different value, so that the regulator adjusts the output voltage to 8.3V. I decided to add 0.1V buffer to ensure to not overcharge the cells.

With that modification completed, the Discman Li-Ion conversion was completed. The battery can be charged using the factory charger, everything looks completely factory, but the newer cell chemistry allows for over 5 hours of runtime. With the charge logic, charging takes several hours. A smarter charging circuit designed for Li-Ion cells would be able to charge the cells much faster and more reliable, but I am very happy with my solution.

Reviving the Battery of a IBM Thinkpad 240

2023-07-01
by Clemens

A while ago, I purchased a Thinkpad 240 online, and upon receiving it, my excitement grew as I discovered its almost pristine condition. The keyboard displayed only minimal signs of wear, and the Intel Celeron and Windows 98 stickers on the keyboard bezel appeared almost as they did in 1999.

However, the notebook did have three minor drawbacks:

The TFT polarizer started to disintegrate, which is a common issue with older notebooks in Japan. The high humidity in summer causes the film to dissolve.
The system was bricked due to a BIOS password.
The battery was not functional.

To tackle the BIOS password, I soldering a few cables to the EEPROM, extracting its data, and utilizing some shady tools to retrieve the password from the dump. With that hurdle overcome, my attention shifted to resolving the battery problem, and I am eager to share my experience in this article.

Since there are no new batteries available for the Thinkpad 240 series, there is no other way than to repair the original battery. As such, my initial step was to open the existing battery case and examine its internals.

The original cells of the Thinkpad 240 battery.

Fortunately, the Thinkpad 240 already utilized Li-Ion batteries, sparing us the hassle of dealing with outdated NiMh or NiCd batteries. The battery pack consisted of three “pouch-shaped” cells and a battery monitoring system (BMS).

Here are the specifications of the components:

FRU: 02K6606
Battery Controller: bq2040
Battery EEPROM: 24C01

A fellow Thinkpad 240 enthusiast had already undertaken the task of debugging the BMS and EEPROM, but in my case, such measures were not required.

The dimensions of the cells are as follows:

Width: 34mm
Length: 48mm
Thickness: 10mm

Although I couldn’t find specific information about the original cells online, I managed to source similar-shaped cells with matching chemistry. I opted for the Sanyo Li-Ion cells 3.7V / 2000mAh / 103450, which proved to be a suitable replacement. I purchased them from AliExpress, although I cannot verify their authenticity, they have functioned flawlessly so far.

Based on my experience working with other notebook batteries, I learned a crucial rule: never disconnect the BMS from the cells. Even a momentary power loss results in the BMS locking itself, effectively rendering it useless. Without access to the BMS EEPROM or expensive tooling and software, reviving the BMS becomes an insurmountable challenge.

To revitalize the battery cells, I “hot-swapping” the cells. I soldered the new cells onto the circuit first, then disconnected the old cells, all without ever interrupting power to the BMS.

The battery pack after “hot-swapping” the new cells in.

On the picture above, you can see some white blob between the right-most cell and the PCB. This is likely heat-conducting material used by the BCM to identify if the cells are heating up. Before putting the battery back into the notebook, ensure that you have sandwiched the white blob between the cells and the PCB.

There was no need to reprogram the BCM. After plugging the repaired battery back to the notebook, the Windows battery gauge indicated “0%, charging”. I let the battery charge for a few hours, and could then use it without any issues.

Use glue that is suitable for ABS when reassembling the case. In my initial attempt, I used the wrong glue and didn’t work very carefully, resulting in ugly glue traces on the case. So, be meticulous during this step to achieve a clean and seamless finish.

The battery lasts approximately one hour while running 90s software developer tools and occasionally compiling with Visual Studio 6. Although this may not be impressive compared to today’s standards, it’s important to remember that even during its introduction, the Thinkpad 240’s battery life was considered short, and larger batteries were available.

The Thinkpad 240 running Visual Studio 6.

In the next blog post, I will address the polarizer film issue on the TFT.

Protected: Mein Honda Insight ZE1

2023-01-222023-02-16
by Clemens

Nissan Sunny Rz1 Digital Cluster Adapter Schematics and CAD

2022-10-23
by Clemens

I would like to make the Nissan Sunny Rz1 Digital Cluster Adapter open-source and allow DIYers to build the project themselves.

To build the adapter yourself, you will need to:

Have the adapter PCB manufactured, solder all components, and program it
Setup the correct dataset and configuration for your Rz1
3D-print the wiring harness connector adapters
Have the PCBs that are part of the connector manufactured
Build the wiring harness

Build the Adapter ECU

First, you need to order the manufacturing of the PCB. You can download the schematics and layout file below.

AdapterPCB The schematics to build the PCB

It is probably best to directly order them from a company which directly does SMD assembly to reduce the effort.

The firmware that you need to flash can be found here: https://github.com/Danaozhong/Nissan-Sunny-B12-Rz1-Digital-Cluster-Conversion-ECU-Firmware

You will need to clone the repository, build the firmware, and flash it to the STM32 located on the PCB board.

After assembly and flashing, you should be able to see a command prompt via the UART.

Build the Adapter Harness

To build the adapter harness, you will need the following parts:

3D-printed connector cases for the female plugs to connect to your vehicle harness. You can download the CAD drawings and STL files below.
The printed PCBs that are installed inside the 3D-printed connector cases (in total, 4 PCBs are needed).
The cluster connector salvaged from a wrecked Nissan Sunny B12
TE Connectivity connector 175964-2 to connect to the adapter ECU
TE Connectivity connector 172021-2 to connect to the digital cluster
Lots of automotive grade cables, crimp equipment, soldering equipment
Firewall grommet 38mm diameter

The instructions on how to build the adapter harness can be found in the Excel document below.

Harness_Pinout Download

CADDrawingsConnector Download

ConnectorPCBs Download

Presse-Information Honda Insight

2021-09-222021-09-22
by Clemens

Ich hatte das Glück, eine originale Presse-Informationsmappe über den Honda Insight aus dem Jahr 2000 zu bekommen. Hier möchte ich gerne die Scans und den Inhalt der CD allen Enthusiasten zur Verfügung stellen.

Bilder und Umschlag Scan Download

Test Scan Download

Download ISO Image

Digital Cluster Conversion Kit Launch

2021-03-112023-07-01
by Clemens

I am pleased to announce that for the Nissan Rz1 digital cluster conversion kit project, all development and testing steps are complete. The product will be launched in April 2021.

To put it simply, this kit allows you to put the JDM digital cluster into your US/European Nissan Rz1, without having to cut any cables or complex rewiring. No hard-to-find special speed sensor or fuel sensor are required.

JDM digital cluster: Not included in the kit

For DIY enthusiasts, all technical documents, PCB layouts, part lists and 3D printing components will be made available soon. The firmware of the conversion ECU is already open source.

It will contain the following parts:

The adapter harness plugs into factory wiring, and converts it to the digital cluster wiring

The Digital Cluster Conversion ECU converts the speed and fuel signals, so that the correct values are indicated.

A simple and easily-available electronic speed sensor is used to measure the vehicle speed. It replaces the older speedometer cable used for the analogue cluster.

As you can see from the pictures, it is a complete plug&play solution, which can be installed without having to cut connectors, or rewire your vehicle cable loom. The adapter can be fully removed; and the factory cluster reinstalled.

Basically, the only wiring step necessary is to connect battery supply, ground, and accessories.

The kit will only work on specific left-hand driven Nissan Rz1 models.

My Fuel Saver Car: Honda Insight ZE1

2020-12-082021-05-28
by Clemens

After driving my Nissan Sunny B12 Coupés for a while, I felt I needed something more environment-friendly, and a bit safer. From my work, I had the opportunity to drive the latest-model Toyota Prius as a test car. Most car enthusiasts would consider it boring. I, however, loved the technical details this car had to offer. Driven properly, you could easily reduce your fuel consumption to 3.3l/100km. An impressive value for a sedan!

Hence, I decided I need a similar fuel efficient vehicle myself. My search started right at spritmonitor.de, a German platform where users document their fuel consumption records. The website allows filtering the fuel consumption records by the most fuel efficient vehicles, and the first entry in the list surprised me. It was not a Toyota Prius, as I would have thought. It was a car that so far has completely evaded my attention. A Honda Insight.

The record displayed a fuel consumption of less than 3l/100km, a value which I considered to be almost unobtainable without a plug-in possibility. Even stranger, it was a car built in 2000! How can such an old car achieve such numbers? Read on.

Doing my research, I learned that in the early 2000, under pressure from threatening US enivornmental laws, Honda built a car with the goal of reducing emissions as much as possible. That car was not designed by the marketing department. It was a product made by engineers, without compromises, or cutting corners to reduce costs. Just looking at it in detail, you could feel how the hard-working Japanese engineers in the late 90ies did everything possible to build a revolutionary car. Below is a list of features that the little Insight has to offer:

full aluminium monocoque, total weight of the complete car of just about 850kg
3cylinder 1L engine
lean-burn operation
NOx-trap type catalysator
super-lightweight aluminium wheels
144V NiMh battery pack with battery management system, thermal monitoring, over/undercharge protection
A ultra-slim 10kW brushless DC motor, mounted on the crankshaft

You really have to give Honda credit for investing so much R&D effort into building this car. I mean, how was this possible back in the late 90ies? People were still struggling with Windows 95 bluescreens every day, and, unlike today, electric drivedrains were neither famous nor popular.

Long story short, these technical details fully convinced me, and I had to get one of these fascinating two-seaters. Unfortunately, Honda did not sell many of these in the old country, especially not in Germany, where at bak in the early 2000s clean Diesel engines were regarded the future of Automotive. Only about 100 of these little cars made their way to customers here.

Now, I have to say that an ecologial lifestyle is very important for me. I value it much higher if someone fixes something that breaks, instead of just buying new. I apply the same principle to cars, and tend to buy the kind of cars that other people would simply scrap, and then invest tons of effort to bring them to life again.

That’s what happened here as well. It looked bad.

It’s hard to see, but that car was in a front crash. The bonnet, bumpers and radiator and support are all bent. The headlight was cracked. It was leaking coolant.

Very bad.

The interor shows signs of 340 000 km driven.

Noone with a clear mind would have brought that car back to life.

A “mouse dead” IMA battery, as we like to say in German

My appologies for the pictures. As a student, I only had a very basic smartphone, with a pretty bad camera.
How did I bring that car back on the road? You’ll read this in part two of this article (coming up)!

How to Implement 3D Object Triangle Selection?

2020-09-11
by Clemens

keywords: 3D geometry; triangle selection; vertex selection;

When developing 3D software, you might want to allow the user to select specific polygons or vertices from your 3D model. Different parts of the geometry, such as corner points (vertices), triangles or surface normals must be selectable just by clicking on them. The complicated part is not only to calculate the right geometry entity which is currently selected by the mouse cursor, but also to do it fast enough. It must be possible to find the selected object in real-time to allow hovering. If the mouse is moved over the object, the software should give a visual feedback to the user by highlighting the currently hovered entity.

With the method presented here, you can implement a selection algorithm for the following 3D geometry entitites:

Surface point
Surface normal
Vertices
Edges
Triangles
Whole entities

One possibility to solve this issue is to calculate the solution manually using mathematics. By taking the current mouse cursor position and unprojecting it in 3D space using the inverse of the projection matrix and calculating the first intersection with a geometric entity, the solution can be found. However, this method is computation intensive, slow and cumbersome.

Off-screen rendering of a 3D CAD model for selection purpose. In this image, each triangle of the CAD model is rendered in a unique color. From the color information, the selected triangle can be found using a look-up table. These renderings are done by OpenGL in the back buffer so they are not visible to the user.

Luckily, it is not necessary to reinvent the wheel as already existing technologies can be used for this purpose. The OpenGL library supports rendering into back buffers, which means that the results are not visible to the user (off-screen rendering). To solve the problem of selection, the current view of the object is rendered into a back buffer using a special color coding method. In this selection rendering mode, lighting and geometry shading is disabled and the colors of the objects are defined by the programmer. Selectable objects are displayed in unique colors, while the background and non-selectable geometries are rendered in black. To find the geometric entity which is currently selected, a small part of the back buffer around the mouse cursor position is copied and the closest non-black color value is searched. The correspondence between the color code and the information of the selected element is determined by a lookup table. With this method, a hardware accelerated selection mechanism can be easily implemented. The picture above shows an image of this off-screen selection rendering. This method is sufficient for most geometric entities; however, some minor problems must be tackled with. If a vertex (a corner point of a triangle) is to be selected, it must be ensured that all vertices which are not visible due to occlusion, such as points on the backside of the object, are hidden. This is done by not only rendering the vertices with their unique color value, but also by rendering the whole geometry in the back buffer using black color. The depth-test of the video cards depth buffer will then automatically discard hidden points, making their selection impossible.

Another problem is to find the surface point on the geometry. In this selection mode, not the vertices of the triangle are to be selected, but the exact coordinates that are currently hovered by the mouse need to be known. While this case is less relevant for geometries with a dense triangle mesh, it becomes more important if the mesh is very sparse and only consists a few triangles. A large cube is an example of such geometry – due to the planarity of the surfaces, only very few triangles are necessary to generate the surface. To calculate the exact coordinates of the surface point currently hovered by the mouse, the color-keying method cannot be used. For this method, the solution is to render the geometry in the back buffer and then read the value of the depth buffer (z buffer) of the video card at the current mouse cursor position. This depth value can then be used to unproject the current surface point by inverse-multiplying the projection matrix and the extrinsic transformation to receive the coordinates of this point in the CAD model frame.

Honda CRZ ZE2 CAN Bit Assignment Sheet

2020-05-202021-03-13
by Clemens

A while ago I hooked a CAN logger to a friends CRZ, and reverse-engineered it a bit. Hope it helps for your projects 😉

Vehicle CAN

Message ID	Bit	Length	Description
0x13F	8	16	ThrottlePosition raw
0x13F	40	32	ThrottlePosition counter
0x164	0	8	Headlight switch
0x164	48	16	Vehicle speed
0x17C	24	16	Engine RPM
0x191	1	1	Transmission reverse SW
0x191	2	1	Transmission neutral SW
0x374	32	8	Trunk open
0x136	8	8	VTEC SW
0x136	0	8	fuel cutoff

IMA CAN

Message ID	Bit	Length	Description
0x111	8	16	IMA Motor RPM
0x169	8	16	IMA motor current (mA)
0x231	24	16	IMA SOC

“Can not find free FPB Comparator!” when using OpenOCD…

2020-02-15
by Clemens

The last two days, I had a very interesting problem that I thought is worth sharing. I am developing a project on an STM32 microcontroller. My toolchain uses Eclipse, which uses GDB, which in turn controls OpenOCD, which does all the low-level stuff so that I can flash and debug. That worked very well for a long time. Until yesterday.

What did I do? I added a new class to my project, which at some point would be dynamically allocated. I kept the method bodies all empty, so nothing should happen. But after flashing the code to the target, the debugger crashed with the message:

Can not find free FPB Comparator!
can’t add breakpoint: resource not available

This error message was already familiar to me – it usually happens when you have too many breakpoints listed in Eclipse, and when you start the debug session, it will automatically add all these breakpoints. If you have listed more breakpoints than the MCU supports (six), this message appears. But here, my breakpoint list was completely empty.

Strange! I had no idea what was going on here, so my first trial and error approach was to reduce the flash and RAM footprint of my app, but even after implementing some optimizations here and there, the problem remained the same. The fun fact was that if I commented out that class, debugging worked again! But once my class was back, even with empty function bodies, the debugger stopped working!

So I decided to have a closer look. Using the telnet interface of OpenOCD, I was able to halt and continue the MCU, so debugging in general was technically still working. Reading and writing from and to memory was also working.

After reading a lot about the FPB, I understood a bit better how this works: The Flash Patch and Breakpoint (FPB) unit is a set of registers of the ARM MCU, which consists of several comperators – one for each breakpoint. Each comperator basically stores one program ( FP_COMPx). If the currently executed address matches what is written inside this register, the execution will be stopped and you can debug.

So I decided to have a look at the hardware registers itself. Since I couldn’t use Eclipse for debugging anymore, I had to use Telnet. If you have an OpenOCD server running, it will listen on port 4444 for a telnet connection. Via this connection, I was able to read out the memory of the FPB registers, located at address 0xE0002000:

mdw 0xe0002000 20
0xe0002000: 00000261 20000000 48001239 4800164d 480019b1 480021a1 48005d0d 48006851
0xe0002020: 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
0xe0002040: 00000000 00000000 00000000 00000000

Starting from the third register (0x48001239), there is a list of six registers filled with some addresses. That explains the error that we see from OpenOCD, the questio now is, who is writing to these registers?

A lot of further research revealed me that it is possible to open OpenOCD in debug mode, by passing parameter “-d3” to it. This even works in Eclipse:

With this additional debug output, I could actually see what secretly happens after flashing. I saw about six of these blocks:

Debug: 17205 11732 gdb_server.c:3153 gdb_input_inner(): received packet: ‘m8001238,2’
Debug: 17206 11732 gdb_server.c:1438 gdb_read_memory_packet(): addr: 0x0000000008001238, len: 0x00000002
Debug: 17207 11732 target.c:2210 target_read_buffer(): reading buffer of 2 byte at 0x08001238
Debug: 17208 11732 hla_target.c:777 adapter_read_memory(): adapter_read_memory 0x08001238 2 1

This is actually the part where the breakpoints were set, and I could see the breakpoints were actually explicitly requested by someone! But why? And why on earth would Eclipse set so many breakpoints? I decided to check the addresses in the Linker file.

The locations usually looked somewhat like this:

All of these blocks somehow had a function with the string “main”, and it was the same case with my recently added C++ class, which also had a member function named “main”. That was when I understood, that Eclipse automatically sets a breakpoint at main() after startup! And for some reasons, it is setting this breakpoint also to classes that have a member function with the name main. It was just because I added one more class with a “main” function, that the number of possible breakpoints was exceeded, and the debugger wouldn’t work anymore.

You could debate if it is good style to have functions named “main” in your code. For me, it was OK because they are not only class members, but also somewhere in their own namespace, and should therefore be restricted. Turns out this was not always the case.

So if you encounter this problem, make sure to reduce the number of functions named “main” in your system!