So I finally have finished the refurbishment of the Kepco JQE75-1.5M PSU.
I forgot to upload this post so it is about a week late unfortunately, but better late than never.
In this final instalment I have already finished the first PSU, then I do the entire 2nd PSU the same way as the first to show you what I went through to get the finished product.
The total cost of this project was around $35
$10 each for the PSU’s
$9.74 for a pair of screens
couple of dollars worth of resistors and diodes
few cents worth of solder and heatshrink
It took a good few hours to do each modification, the longest part was grinding down the metal to fit the IEC connector. This would have been seconds with the proper tools but I didn’t have them 😛
The PSU’s appear to be working fine, though I need to do a proper burn-in test to be 100% certain of their stability.
So I continue my refurbishment of the Kepco JQE75-1.5M PSU.
My LED displays arrived from Ebay so I decided it’s time to fit them, and time to replaced the neon power indicator with an LED.
I could not find a stable voltage (as in, not changing when adjusting the current/voltage pot) so I opted to find an AC voltage either on the board or on the transformer itself.
After 2 attempts I found an unused 24Vac winding on the transformer and hooked up the following circuit to the LED display and power LED which replaces the neon bulb.
(Note: there is a 330uF 50V electrolytic reservoir cap across the DC output voltage I forgot to draw in)
This seems to work fine, now I just need to fit an IEC connector and a bezel for the LED display on the front panel.
It’s been a while since I’ve posted to my blog, but here is a video I just uploaded showing how I reverse engineer digital circuits.
I’ve been doing this sort of thing for as long as I can remember and I find it very relaxing at times. Nothing better than throwing some nice music on and doing a bit of reverse engineering.
I was recently given a dot matrix LED display by a friend and decided to reverse engineer it so we both can run them, he still has one of his own.
There is a damaged chip on the board which meant that some of the displays didn’t display their 2 bottom rows but I will be tackling this issue in a later video. I will also be transferring the control to a PIC instead of the Arduino as it was not fast enough to get a good refresh rate, and this is without any external communication facilities being addressed.
I found myself some PSU’s at a flee market a few weeks back and decided to pull out the matching pair of 75V PSU’s for some inspection. Much to my delight, they both appear to work fine.
The only issues with them is the neon power indicators are not working (or barely working), and the voltage/current multiply switches for the analogue movements are crusty. And not to mention a non-standard power connector on the rear. These will all be replaced and updated in future videos.
I have decided to replace the analogue meters with LED modules (just waiting for them to be shipped from China on the slow boat) then I will hook them into to sense the output terminals and find a way to recess it in places of the old meters.
For the power indicator, I will find a voltage rail inside the PSU (most likely an opamp rail) and fit an LED in place of the neon lamp.
Please keep tuned for more!
You can subscribe to my YouTube channel to get updates on my progress too.
It’s been a while since I’ve released a video for this series, but I have been doing final tests for the term at college and was a little overwhelmed. But I did my last test yesterday and decided it was time to do an update.
As promised in the video, here is a flowchart showing how the software currently works. This is the basic idea of what goes on.
Do note that the Volts and Current pots on the front of the case do not directly set the current and voltage limits, rather they are read by the Arduino via the ADC and scaled and then that is outputted via the DAC to the actually regulation circuitry. This leaves the possibility of having the push-buttons setting the Voltage and Current instead.
Here is the Arduino code used in this episode, I will be cleaning it up for the final version:
// disable all devices to start with
digitalWrite(ADC_CS, HIGH);
digitalWrite(DAC_CS, HIGH);
SPI.begin();
Serial.begin(115200);
Serial.println("Ready.");
// set up the LCD's number of columns and rows:
lcd.begin(16, 2);
// Print a message to the LCD.
//lcd.print("hello, world!");
}
void set_dac(byte chan, unsigned int value,byte ga, byte shdn)
{
byte b,c,conf;
// ga : 0=2x (0-4096v), 1=1x (0-2.048v)
// shdn : 0 = shutdown DAC channel, 1 = output available
// [ A'/B , x , GA', SHDN', D11, D10, D9, D8 ]
conf=(chan&0x01)<<7; // mask out channel number and shift it to bit 7
conf=conf|(ga&0x01)<<5; // mask out gain select and shift it to bit 5 and or it to conf
conf=conf|(shdn&0x01)<<4; // mask out shutdown select and shift it to bit 4 and or it to conf
conf=conf|(value>>8); // or in the top nibble of value left in conf
b = value; // bottom byte of value
SPI.beginTransaction(SPISettings(15000000, MSBFIRST, SPI_MODE0));
digitalWrite (DAC_CS, LOW); // enable DAC
SPI.transfer(conf); // send configuration and top nibble of value
SPI.transfer(b); // send bottom byte
digitalWrite (DAC_CS, HIGH); // disable DAC
SPI.endTransaction();
}
unsigned int get_adc(byte chan)
{
unsigned int a,b,c,conf;
conf=conf=((chan&0b00000111)<<1)|0b00110000; // create configuration byte
SPI.beginTransaction(SPISettings(8000000, MSBFIRST, SPI_MODE0));
digitalWrite (ADC_CS, LOW); // enable ADC
SPI.transfer(conf); // send configuration byte
b = SPI.transfer(0x00); // receive sign bit & top 4 bits
c = SPI.transfer(0x00); // receive lower 8 bits
digitalWrite (ADC_CS, HIGH); // disable ADC
SPI.endTransaction();
b = b&0b00011111; // filter out unwanted stuff from high byte
a = (b*0x100)+c; // convert 2 8-bit numbers into a single 16-bit number
return(a);
}
unsigned int get_adc_avg(byte chan)
{
long tempx = 0;
byte ax = 0;
for (ax=0;ax<20;ax++)
{
tempx+=get_adc(chan);
}
tempx/=20;
return (tempx);
}
In this video I will go over techniques of sensing current in the PSU circuit as well as explore the regulation of the current.
It’s been a while since my last episode, I have been busy with school work and I also needed to construct a variable dummy load in order to get this working.
We are nearing the end of the series. In the next video we will be putting the analogue side and the digital side together and having a look at it being completely driven from the DAC.
In this video I do the actually capturing of some buttons on the IR receiver. We also analyze the LED data train and decode the way the screen is driven.
So I got another satellite receiver to tear down. This one is similar to the Viewsat VS2000 one I tore down previously, check the video
Just like the previous one I will be decoding the LED display driver, but unlike the previous one, I will be capturing the IR receiver data in hopes of using the remote control in a future project.
sorry for the delay adding this to my website, I’ve been busy with college. I’ve just uploaded part 10 and realized that I didn’t update the webpage for 9, so here it is.
In this episode I will be briefly covering using the button inputs on the Arduino. I briefly go over debouncing and then I introduce using a matrix keypad to allow more buttons to be used.
Arduino code for debounced button input:
#include <LiquidCrystal.h>
#define button_5 6
#define button_4 7
#define button_3 8
#define button_2 9
#define button_1 10
#define hold_limit 15000
int temp=0,tempold=1;
int b1=0,b2=0,b3=0,b4=0,b5=0;
int bs1=0,bs2=0,bs3=0,bs4=0,bs5=0;
int bc1=0,bc2=0,bc3=0,bc4=0,bc5=0;
// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
void setup() {
// set up the LCD's number of columns and rows:
lcd.begin(16, 2);
// Print a message to the LCD.
lcd.print("hello, world!");
}
void loop() {
// set the cursor to column 0, line 1
// (note: line 1 is the second row, since counting begins with 0):
The expansion module finally arrived this morning 🙂 and the glue seems to be mostly set.
Here is the expansion module lined up next to the OWLS board, now to fit the headers and find a cable.
Luckily I had an old short IDE cable around that works. It over hangs 4 pins either side but it works.
Here is both board in place in their respective connectors.
this is it with the case fully done up, the board sits on a slight angle but it is all nice and snug.
Now all left to do is hook up the cables and give it a test.
Here is it hooked up doing some reading of SPI traffic on the Arduino, note that 3 switches have been set on the panel, this is grounding the un-used pins to avoid phantom signals due to floating lines.
I had to mess around and update the firmware to make it recognize the extra 16 channels, the bootloader didn’t work so I had to use a PICKit3 to flash the OWLS’ PIC directly.
Below are a couple of captures from the SPI bus reading channel 0 of a MCP3304 with a potentiometer on it.
Set to 5V in
Set to 0V in
That concludes the case project for the logic analyzer, I would say that it was successful and I feel much better using it without having to worry about shorting the board PCB.
