Hipstreet Phoenix tablet to TV box conversion

Published by:

Ok, so the Hipstreet Phoenix tablet that I repaired the power button on a few months back got knelt on. The screen didn’t like it very much and refuses to work now due to a crack.

Looking at the bottom edge of the tablet you notice there is a nice selection of features.

From left to right: Headphone/Headset (Covered by my thumb), Mic, Micro USB, Mini HDMI, A 5V charging port, reset button, microSD card socket.

I decided to order some items in to see if I could use these ports instead of relying on the LCD/touchscreen interface.

Here is the board in all it’s glory. a fraction of the size of the case it is in.

Firstly I have already ordered in some USB OTG cables. (Actually ordered a set 4 months ago on ebay and not seen any, and ordered a set 2 months ago and still waiting for both). They haven’t arrived so I did a quick bodge to use USB OTG without the proper cable as you will see in the picture below. I’ll detail that soon.

Next I got a HDMI cable, turns out I purchased a MicroHDMI cable 😛 but I went out today and got the MiniHDMI cable and plugged it into the tablet and switched it on. Nothing appeared on the screen until it was a good minute into the booting but it worked ok, it was a little too large for my screen but I have an old TV so I found that with a lot of things, but the main point is that it works on HDMI!

I found that I could use the tablet by pressing on the touchscreen but it’s somewhat hard to know where your touching when the LCD is broken and your watching it on a TV.

Next I turn my attention to the USB OTG situation. I heard that you can plug in a mouse and/or a keyboard and use them with Android based devices, I have never seen this before myself so I was curious. The only spare keyboard I have is an old PS/2 Style keyboard so I plugged in my PS/2 to USB adaptor, the keyboard initialised (as noticed by the lights coming on for a second) but I did notice the display flickered while doing so but it didn’t seem to do any kind of input. Maybe it was drawing too much current and was disconnected by the tablet after initialising, I will find a USB keyboard and try again later.

Next I try a USB mouse, the only one I have at hand is a cheapo wireless once from Dollarama, this appeared to work fine, I tested it and had a quick game of solitaire to test it.

Ok, so the bodge that I did to get USB OTG up and running is based on instructions I found here:

Image from: http://tech.firstpost.com/news-analysis/how-to-make-your-own-usb-otg-cable-for-an-android-smartphone-29503.html

What I did was locate pin 4 on the microUSB socket on the PCB and trace it to a point where I could solder on a wire, luckily I found a test point and used that, I also attached a 2nd wire to GND and brought them both out (The orange and white wires). In order to use USB OTG I just short them together. Now I needed a microUSB to Female USB-A connection, I simply took an old dual USB socket and bridged the 2 connections together at it’s cable header, turning it effectively into a crude gender changer for USB-A then used a normal microUSB-USB-A cable to connect it to the table. voila!

This is only a temporary solution until my proper cable arrives.

This is the current state of the device.

Plans for the future:

  • Put the PCB in a small plastic box make new buttons on the front
  • use external power into the 5V charger port
  • Use a small USB hub (preferably powered) with a proper USB OTG cable to allow keyboard, mouse, and other USB devices
  • Modify the Android OS on the device to allow me to use it for something useful

That’s all for now, hopefully more to come soon.


Quick update:

I made a proper USB OTG cable (Using the website mentioned above) and found a USB keyboard, this worked great 🙂 I then found a small USB hub, this one is a 4-port USB 1.1 hub unfortunately but it’s good enough for mouse and keyboard use, which it did 🙂

I also found a 5V charger with the same connector as the one found on the bottom of the tablet and it is now currently charging.

I unplugged the LCD and Digitiser cables and it still takes a while until it enables the HDMI, I did a factory reset too and it had nothing on the HDMI for quite a while, I was a little worried that it was showing something on the LCD asking me to confirm something during startup. This worries me about re-flashing the firmware as I’ve seen some devices require you to do some selections on the bootloader, I have to rebuild the volume button set in order to test this but I will have to see if it will initialise the HDMI.

Using ROM’s as combinational logic (Updated)

Published by:

Someone commented on my youtube video about the EPROM as combinational logic stating that the video was too quiet. Unfortunately my original footage is no longer available to re-upload so I decided to redo it. This time I decided to expand upon the concept by including other ROM types than just the EPROM since the concept does apply to all parallel ROM’s.

The software I designed should work the same for different types of ROM’s since they follow the same concept.

A new page has been created with the document on it here: http://39k.ca/using-roms-as-combinational-logic/

The new video can be found here: https://www.youtube.com/watch?v=t6alYGpdrqU

 

Using EPROMs and simple combinational logic

Published by:

This post has been replaced by a newer version:

Using ROM’s as combinational logic (Updated)


A few years back I came across something in an old Z80 book that mentioned that EPROMs can be used a crude logic devices, though only supporting combinational logic, you could craft the data to mimic logic. Recently I tried it out and found it to work really well.

I recently uploaded a YouTube video showing my experiment.

In the video I hand-crafted the code to go into the EPROM, this took a while just to act as 2 logic gates, so I decided to have a go at writing a bit of software to do it for me.

Boolean to ROM conversion software

boolean2rom

I wrote this in Delphi and you can put up to 8 boolean algebraic expressions into the boxes, one for each data line output. You select how many address lines you are using (you can put only the number your actually using and ground the rest in hardware) Then you hit the “Parse” button and it will go through each address combination using the boolean expression to create the required data for each location.

This is only a first version so may have some kinks that need to be ironed out. The handling of parenthesis is very crude and does not take them into consideration with order of operation. it does somewhat process the order as ~(NOT), * (AND), +(OR), ^(XOR).

Valid inputs are A-P (not case sensitive), these are representative of A0-A15 inputs. Unused Data lines can be unchecked to not have them used

Once you have parsed what you need, you can view the data to the right on the table. Note: These numbers are all in Decimal!

You can then hit the “Save…” button and select where you want to save the binary file. Note: you need to add you own .bin extension, I’ve not added it yet.

 

Hopefully this will be of some use to people, it’s certainly an interesting concept.

 

Dave Jones from the EEVBlog used a similar method to make a finite state machine PLC back in 2000 : http://alternatezone.com/electronics/plc.htm

 

bye for now, if you have any questions, suggestions, etc.. please contact me:  peter AT 39k.ca

Kepco JQE75-1.5M PSU refurbishment – Part 3 (Finale)

Published by:

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.

 

Hopefully more projects to come soon.

Thanks for watching!

Kepco JQE75-1.5M PSU refurbishment – Part 2

Published by:

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.

 

mod

(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.

2016-03-19 01.08.00

How I reverse engineer digital circuits

Published by:

2016-03-12 19.56.14

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.

Here is the video:

The arduino sketch can be downloaded here

and the Design Spark schematic file can be found here

the PDF of this file can be found here

*There are a few parts not finished in the schematic, but there is enough to provide functional detail.

I hope you enjoy the video, I will eventually follow it up with the repairs and the porting to PIC.

bye for now!

Kepco JQE75-1.5M PSU refurbishment – Part 1

Published by:

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.

PSU Project #11 – Prototype and Calibration

Published by:

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.

 

The schematic as PDF can be found here: PSU – Schematic

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.

flowchart

Here is the Arduino code used in this episode, I will be cleaning it up for the final version:

#include "SPI.h"
#include <LiquidCrystal.h>
#define SW1 18 // Rightmost button
#define SW2 17
#define SW3 16
#define SW4 15
#define SW5 14 // Leftmost button
#define ADC_CS 10 // ADC chip-select
#define DAC_CS 9 // DAC chip-select
#define LCD_D7 8 
#define LCD_D6 7
#define LCD_D5 6
#define LCD_D4 5
#define LCD_E 4
#define LCD_RS 3
//#define SPARE 2
#define vout_cal 0.0065651063;
#define iout_cal 0.001;
#define vin_cal 0.006092087;
#define iin_cal 0.001;
#define max_scount 100000 // Counts for screen update
unsigned int v_set,i_set,v_feedback,i_feedback;
// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(LCD_RS, LCD_E, LCD_D4, LCD_D5, LCD_D6, LCD_D7);
void setup() {
 //set pin modes 
 pinMode(DAC_CS, OUTPUT); 
 pinMode(ADC_CS, OUTPUT);
 
 pinMode(LCD_D7, OUTPUT); 
 pinMode(LCD_D6, OUTPUT); 
 pinMode(LCD_D5, OUTPUT); 
 pinMode(LCD_D4, OUTPUT); 
 pinMode(LCD_E, OUTPUT); 
 pinMode(LCD_RS, OUTPUT);
pinMode(SW1, INPUT); 
 pinMode(SW2, INPUT); 
 pinMode(SW3, INPUT); 
 pinMode(SW4, INPUT); 
 pinMode(SW5, INPUT);
 // 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);
}
void update_screen()
{
 static float vout,vin,iout,iin;
 static char voutstr[15];
 static char ioutstr[15];
 static char vinstr[15];
 static char iinstr[15];
// 0.004884;
 vout = v_set*vout_cal;
 iout = i_set*iout_cal;
 vin = v_feedback*vin_cal;
 iin = i_feedback*iin_cal;
 
 dtostrf(vout, 5,2, voutstr);
 dtostrf(iout, 5,3, ioutstr);
 dtostrf(vin, 5,2, vinstr);
 dtostrf(iin, 5,3, iinstr);
if (digitalRead(SW5)==1)
 {
 lcd.setCursor(0, 0); lcd.print(v_set, DEC); lcd.print(" "); // for calibration
 lcd.setCursor(0, 1); lcd.print(i_set, DEC); lcd.print(" "); // for calibration
 lcd.setCursor(8, 0); lcd.print(v_feedback, DEC); lcd.print(" "); // for calibration
 lcd.setCursor(8, 1); lcd.print(i_feedback, DEC); lcd.print(" "); // for calibration
 }
 else
 {
 lcd.setCursor(0, 0); lcd.print(voutstr); lcd.print("V ");
 lcd.setCursor(0, 1); lcd.print(ioutstr); lcd.print("A ");
 lcd.setCursor(8, 0); lcd.print(vinstr); lcd.print("V "); 
 lcd.setCursor(8, 1); lcd.print(iinstr); lcd.print("A ");
 }
}
void loop() 
{
 unsigned long scount = max_scount+1;
 unsigned int xx = 0b100000;
unsigned int adc0;
 unsigned int adc1;
 unsigned int adc2;
 unsigned int adc3;
adc0 = get_adc_avg(0)/2;
 adc1 = get_adc_avg(1)/2;
 adc2 = get_adc_avg(2)/2;
 adc3 = get_adc_avg(3)/2;
 
 set_dac(0, (adc0),0, 1);
 set_dac(1, (adc1),0, 1);
v_set = adc0;
 i_set = adc1;
 v_feedback = adc2;
 i_feedback = adc3;
scount++;
 if (scount>max_scount)
 {
 scount=0;
 update_screen();
 }
 
}

PSU Project #10 – Current sensing and regulation

Published by:

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.