Spent some time studying the PCF8576 LCD driver chip and decided I would try some code:

1. Set up the Arduino as a slave receiver at I2C address 57,
2. Pulse a spare output pin when that address was hit,
3. Print a “* to the LCD each time the address was hit

I then wired the Arduino to the radio front panel, like this:

Originally I was going to power the Arduino from a nearby computer, but then decided I would just power it from the radio +5 regulated supply.  For those looking carefully you would see I only have three wires in the photo, the black one connected to the ground pin on the Arduino and the two I2C lines (SCL and SDA).  I added the fourth wire after this photo.

Before I did I wanted to double check the +5 supply pin I had previously located and to my dismay the radio was dead.  This happened before and I thought I had fixed it by resoldering the flex cable that goes from the side interconnect board to the front boards.  But the same problem had me tracing what I had learned about the power supplies in the radio and found that pin 40 of that cable was open.  It takes a pull-down from the front panel switch to turn on the main supply and with that open obviously the radio wouldn’t work.  So I put a fine flexible wire jumper in and the radio came right up.

So I turned the radio on, and got four asterisks on the LCD.  What that told me was that the I2C receiver in the Arduino was likely working and that four sequences were detected as being sent.  I changed channel and each time I did that I got another asterisk.

So now I got bold and instead of the asterisk I changed the code to print the number of bytes received, brought it back to my bench, turned it on and got “16.”  I changed radio channel and 16 came up again.  Well, well.  What that seems to indicate is that each time the radio wants to modify the display it writes the entire block of data representing the entire display.  Here is what it looked like:

So now I will set the LCD to display the data bytes received in hex.  There’s a hitch in that it’s a little of a pain to buffer and stop the display to read the initial 4 writes.  I am not sure what those 4 are, but I know that one is a LCD test, turning on all segments, and another is to make the regular display.  Perhaps there are a couple of clear displays in there, or there is a control chip initialization then self test then clear then normal?  Who knows, but to some degree it doesn’t matter, all I really want is to read the normal display as I will do self test of the new display myself.

The LCD above is 16 characters by 2 lines.  That will just fit a hexadecimal display of 16 bytes, two characters per byte.

What happens will be the subject of my next post!

One of the steps I described earlier was to map the LCD segments to the LCD driver chip pins and then to the internal memory of those chips.  This is because when I receive that data in my microprocessor I will have to be able to interpret it.

I first examined the LCD display itself and carefully followed each pin to a segment.  I ended up with this sketch:

Then I used a special set of HP probes on the DMM in continuity mode.  The probes are super tiny and have spring probe tips like used for PCB test probing.  I followed each LCD pin back to the driver chips.  That led to this:

1S and 2S represent the two LCD driver chips.  It turns out 2 is the low order and 1 is the high order addressed chip but that doesn’t matter.  The S number is the segment output number of the chips.  The 7 segment below has the standard segment labeling.  Still looks confusing?  Patience…  Now I put the segment outputs in order and get:

LCD Driver 0 segment outputs
S0      10 MHz A
S1      10 MHz B
S2      10 MHz C
S3      10 MHz D
S4      10 MHz E
S5      10 MHz F
S6      10 MHz G
S7      Decimal point
S8      1 MHz A
S9      1 MHz B
S10      1 MHz C
S11     1 MHz D
S12      1 MHz E
S13      1 MHz F
S14      1 MHz G
S15      PROG
S16      100 kHz A
S17      100 kHz B
S18      100 kHz C
S19      100 kHz D
S20      100 kHz E
S21      100 kHz F
S22      100 kHz G
S23      RX
S24      10 kHz A
S25      10 kHz B
S26      10 kHz C
S27      10 kHz D
S28      10 kHz E
S29      10 kHz F
S30      10 kHz G
S31      EXTERNAL
S32      1 kHz A
S33      1 kHz B
S34      1 kHz C
S35      1 kHz D
S36      1 kHz E
S37      1 kHz F
S38      1 kHz G
S39      CH

LCD Driver 1 segment outputs
S0     100 Hz A
S1      100 Hz B
S2      100 Hz C
S3      100 Hz D
S4      100 Hz E
S5      100 Hz F
S6      100 Hz G
S7      MHz
S8      10 Channel A
S9      10 Channel B
S10     10 Channel C
S11     10 Channel D
S12     10 Channel E
S13     10 Channel F
S14     10 Channel G
S15     Right arrow
S16     1 Channel A
S17     1 Channel B
S18     1 Channel C
S19     1 Channel D
S20     1 Channel E
S21     1 Channel F
S22     1 Channel G
S23     Left arrow
S24     HI
S25     M
S26     LO
S27     F
S28     K
S29
S30
S31
S32     Bar graph L
S33     Bar graph M
S34     Bar graph H
S35
S36
S37
S38
S39

Now it makes sense, doesn’t it?  So now I can decode the binary data sent to the LCD drivers.

I looked at the LCD driver chip data sheet (PCF8576) and see that there are both command and data words.  Most of the command words have to do with LCD configuration and I can ignore them; I will have to pay attention to the cursor index set command but that is trivial.

To be continued…

I had less time to play than I thought I would have this Thanksgiving weekend, but I did make a little progress.  I started the actual code, included libraries, did some reading up on how to use them.

I also hooked up a simple LCD display.  Here it is:

My plan is to use this setup to develop code to read the data from the Syncal, piece by piece.  This alphanumeric display is extremely simple to use so I can concentrate on the radio interface and not have to develop and debug both the radio interface and the graphic display at the same time.  I can decode what I get from the radio and display as text, each element of the display one by one, this way.  Once I know I have all the data received properly I can replace the display with the actual graphic one I will use and concentrate on the graphical layout of the data I have.

My next step will be to finalize my understanding of the Syncal display mapping, then how the two LCD chips are addressed, then lift their response pins on the I2C bus, wire up the I2C ground and power and route them out of the radio with a small connector to tie to my little Arduino test board.

Then it’s just a matter of slogging through the different segment mappings.

After posting about my Syncal display project I was asked if there was space in the radio for the Arduino board:

There isn’t, but fortunately it doesn’t need to be installed into the radio.  The board is to make it easy to develop projects and also program the microprocessor chip.  The chip is the socketed DIP below the green LED.  The rest of the board is for power supplies, USB interface etc.

So what will happen is that I will get the code working then take the CPU chip out and mount it on a small perfboard with RC (no need for crystal accuracy in this application).  It will run right off the radio +5 volt logic supply.  This goes right between the OLED graphic display and the existing display board.

Then I buy another Atmega 328P chip to put on the development board for my next project.  Of course, I could be lazy and load my completed program onto one of these:

https://www.adafruit.com/products/2590

That’s a surface mount version which is 0.7″ x 1.7″ and only 0.2″ thick.  Then there’s only the need for 5 wires to the radio and 5 wires to the graphic display, no discretes.

The Racal Syncal 2000 is an amazing “pack” set for amateur use.

1.  It is built to British military specifications,
2. Designed for outdoor use in the field,
3. One of the lightest of its type,
4. Built in fast auto-tuner,
5. VFO knob (VERY rare in a military set!)

Unfortunately these are very hard to find, and when they are, they can be extremely expensive.  Not wanting to get a second mortgage, but really wanting one, I was able to get one for a very attractive price.  The hitch was that the LCD display had some bad segments.

I thought there was a small chance the problem was board corrosion and the LCD itself was ok, but that was not to be.  The problem is actually with the LCD display itself, and it is a custom part, and of course no longer made.

When I opened the unit I discovered a couple of design weaknesses.  The seal around the LCD is poor, and the mic connectors are not nearly as robust as the US type, and both of mine had cracked, letting in water.  This water caused corrosion of the LCD contacts.

First I addressed these concerns.  I was lucky to find replacement connectors, for way less than list price, via a surplus seller in the UK.  I then siliconed in a piece of actual glass in the front panel, which completely solved water ingress.

Now, as to the display, I decided I would see if I could find a graphic OLED display which would fit in the existing space.  Although limited due to several mechanical constraints, I found several in stock at Digikey.  I need to re-verify the mechanicals then I will order one, although I’ll probably wait until I need parts for another project since the cost is low enough that I’d like to share the shipping cost among more parts.

The schematics are so far not available for this radio.  However, the LCD driver chips are well documented PCF8576T devices which have a I2C interface.  My plan is to use an Arduino chip with the “wire.h” library which can emulate a I2C device, then a standard library to talk to the SPI interface in the OLED display.  Besides a filter cap or two and maybe a few resistors there won’t be much else in the circuit.

I’ve never used an Arduino before so I bought one from Adafruit and downloaded the development environment.  I bought a relatively simple one called Arduino Uno.  It looks like this:

It attaches to your computer via the USB port.  I loaded the dev environment and it came up incredibly easily.  All I needed to do after installation was to change the default port from Com 1 to Com 7.  I was able to open a sample program and upload it to the board, and it ran just fine.  Here is the board connected to my computer:

So here is my plan for doing this:

1. Acquire Arduino and set up dev environment (done)
2. Get to where projects can be edited and loaded to device (done)
3. Determine radio LCD segment to driver chip mapping (25% done)
4. Determine addressing of LCD driver chips in radio, and how they are daisy chained
5. Install wire.h and configure to emulate radio configuration
6. Wire up basic LCD display to dump data to as debugging aid
7. Write code to interpret segment data and convert to numerical frequency data, then display
8. Write code to trap text messages such as Good, Pass, tune, etc
9. Acquire the chosen OLED display, wire it in
10. Write code to make nice graphical display
11. Final debug
12. Remove LCD driver chips and other associated components from radio display board
13. Package to fit onto radio display board
14. Final checkout

More as I make progress!

Syncal 2000 display project, part 2

Happy Thanksgiving!

I took off work super early, 3:15, so I would have more time in my lab and wanted to finish my battery for my PRC-70.

When I got my radio it came without a battery pack so I searched for one for a while, but without success until Jim Karlow offered to sell me a partial one which was all he had.  That was the best I could do in two months so I went for it.  It was the case itself, the outside latches, and the connectors for radio and external power.  No other hardware, no brackets, nothing inside.  On the plus side it was in excellent mechanical condition.

The positioning of the connector for the radio was a tricky thing to determine as the location would have to be calculated since it couldn’t be directly measured and there were gaskets which got compressed etc..  So the project was on the back burner.  At one point a friend loaned me his rig with battery pack and this allowed me to measure exactly the connector position they intended.  Here is a picture of the loaned pack and the one I am working on:

Note that my pack is the shorter one.  His pack is somewhat taller and was meant for some kind of wet cells and was converted to D cell nicads. I made the connector bracket from a 0.125″ thick aluminum angle bracket.  The connector is mounted with shoulder screws to allow some movement to compensate for misalignment.  The hole for it is also oversized to allow for the same movement range as the original.  You can also note the threaded brass inserts in the case.

That’s the cover plate laying there.  I determined screw locations by placing pieces of lead from a pencil on all the standoffs like this and placed the blank on top and wiggled it around.

Here it is with the fuseholder installed as well as the charging connector:

You can also see the stack of 26650 cells I glued together in the upper left.  They are old A123 cells, and after all these years were still charged at the standard 50%.  I used a 8S2P configuration which yields a fully charged voltage of 26.4 VDC.  You may note that I didn’t use a balancer.  That is because:
1)  I haven’t found one I like,
2)  I haven’t made my own yet (maybe this winter I’ll create a 12/24 volt one I like),
3)  It really isn’t necessary if the cells start out more or less balanced, at least for a couple of dozen cycles.

It could take years for me to need that functionality and without it I don’t have to worry about it draining the cells down.  I could literally leave this for 5 years and it would still be charged and ready to go.
To charge, just hook up to a bench supply at 28.8 Volts and wait until the current drops to under 50 mA.
For safety, I wired the cells together with stranded 24 AWG teflon wire.  Why so thin?  Extra safety in case of a short.  Interestingly, I accidentally did short the pack when soldering the wires on the cells and two of those links instantly opened.  It mystified me at first because there was no voltage yet everything looked fine.  What had happened was that the wire opened in the middle and the teflon didn’t show it at all.  Pulling one end and having it come out was a giveaway.  Is this too thin?  No, due to the short lengths the resistance drop is insignificant and the wires are very capable of carrying the normal operating currents.

     Here it is with the stack wired and placed in.  I used pretty dense closed cell foam to securely hold the block in place.  I don’t know what it is, it is some special acid resistant expensive specialty stuff from work.

     And here is it with the cover placed on.  I think the inserts at the end were slightly lower than the others based on how the cover is lower there but it’s not worth fixing, really.  This thing feels really solid.

And here it is on the radio:

 And it works perfectly.  Plugged in the handset and antenna, set frequency, tuned, and talked.

So, I wondered, it’s a pretty heavy radio, how do all these sets compare?  So here are the weights of my and other pack sets:

PRC-70 with tall nicad pack:    29.5 lbs
PRC-70 with short lithium ion pack:   24.0 lbs
RU-20 with lithium ion pack:     16.0 lbs
Syncal 2k with lithium ion pack:    12.5 lbs

If I had to carry a set into the field on my back I’d obviously choose the Syncal 2000.  Actually, I could carry two of those and it would weigh about what the PRC-70 does!