Jeff Hopkins

Transferring to my local server

2010-08-29T18:27:00.001-07:00

http://www.jeffmhopkins.com/blog.php

Sorry for the delay

2010-08-24T22:58:00.000-07:00

Sorry in the delay of information, I've been away from home for the past month and was unable to complete and progress on the project. Progress will continue when time permits.

SD Card interface

2010-07-04T10:27:00.000-07:00

Rigged up an SD Card socket from an IDCC Connector, and used a Bus Pirate to interface via serial commands over SPI. This gave me better understanding of SPI and how my eventual SD Card interface will work on my processor.

GUR Board Complete

2010-06-26T21:37:00.000-07:00

Not the prettiest of boards, but here is the GUR board. I used 32 gauge enameled wire instead of the ribbon cable I had been in the past. It seemed to have worked well, and I'm waiting on a couple more chips to populate the board completely, but all the traces are soldered in place.

Construction of the GUR

2010-06-25T04:52:00.000-07:00

Construction of the GUR card has began, I'll post later this weekend with pictures. I've opted to go with 32 gauge coated wire instead of the 22 gauge ribbon cable as the wire on the board to conserve space, so it's a little different.

I've also opted to remake the ALU with a few improvements including the decoupling capacitors and shift registers.

Either way, this weekend will supply more pictures of my current progress.

Video Controller - 8-bit Color

2010-06-09T17:47:00.000-07:00

This is the new diagram for the Video Controller. It is an 8-bit true-color 80x30 character generator, with 256 stored characters in the Text PROM and 256 colors formed from the color memory (each character can have a color, or easily extended to two colors FG and BG by adding an additional Color Memory bank and a NAND from the mux).

The VGA Screen Resolution is 640x480 with each character being 8x16.

See the monochrome version for some more infor about the vsync and how the character prom and such works.

See this pdf file for detailed operations of vga timing and simple vga circuits.

PLCC to PDIP Converter

2010-06-05T15:51:00.000-07:00

So I strayed a little and purchased PLCC packaged flashes instead of PDIP, so I wired up a converter for my programmer....

IRU - Interrupt Request Unit

2010-05-31T18:05:00.000-07:00

The Interrupt Request Unit is located between the JIU and the actual memory itself. There is a 7-bit interrupt bus, a 1-bit interrupt request signal line, and a 1-bit interrupt complete line. The seven bits allow for a possible 128 interrupts without inherit priority.

A device would first check and see if the interrupt request signal line is high, if so pulls it low to tell the IRU there is an interrupt while simultaneously placing it's interrupt code on the interrupt bus. At this point the IRU overwrites the JIU's PC location with a $FF00 - $FFFE location. At this point two instructions based off of the 7-bit interrupt code is created.

If there is no handling code for the interrupt there will be a NOP(IR.C) and JMP(-2) command, placing the PC to the previous location and clearing the interrupt request line. If a subroutine needs to be called, a PUT($23, SUR.JumpHigh) and JMP($00) will jump to $2300 as a subroutine. SUR.E and SUR.F will be clocked with the old PC's location so that it may be JMP'd to at the return of the interrupt. When ending the subroutine a NOP(Int.C) and a JMP($NN) will return it the previous location. The NOP(IR.C) command puts the clear interrupt line into an active state, but delayed one instruction so the JMP command can be performed before another interrupt can be initiated.

With how the NOP(IR.C) command works it becomes possible to perform Nested interrupts by manually moving around the stored PC locations to a vectored table. This would allow for instance a real time clock to still tick while performing a lengthy subroutine in another interrupt. Generally speaking though, the interrupts should be short: real time clock, keyboard press, etc...

Schematics will follow later...

Addressing Mode Units

2010-05-22T16:40:00.000-07:00

These units are what control the 24-bit address bus for RAM and the external bus. There are two of these units in the processor, allowing for simultaneous use of two addressing modes, to be used in separate LOD and STO instructions. Provides access to arrays of 512 bytes without the use of additional algorithms.

DC Power Supply and Frequency Generator / Counter

2010-05-14T15:32:00.001-07:00

Finally my DC Power Supply and Frequency Generator / Counter arrived. This pretty much completes all of my hobby bench equipment. Soldering / SMD Rework station, Multimeter, Function Generator/Counter, and a USB based Oscilloscope/Spectrum Analyzer/Logic Analyzer.

Adder

2010-05-12T18:39:00.000-07:00

This is probably the most simple unit of the processor, used for register index and memory offsets or as a general use up counter.

JIU

2010-05-09T15:09:00.000-07:00

New Instruction Set Complete

2010-04-26T15:13:00.000-07:00

There are now six instructions: PUT, MOV, LOD, STO, JMP and NOP.


PUT 000.T.DDDDDDDD.RRRR
    T - Register Type (0 = GUR, 1 = SUR)
    D - Data
    R - Register Number
MOV 001.XXX.S.D.RRRR.RRRR
    S - Source Register Type
    D - Destination Register Type
    R - Source Register Number
    R - Destination Register Number
LOD 01.M.T.AAAAAAAA.RRRR
    M - Mode (0 = AM0, 1 = AM1)
    T - Register Type (0 = GUR, 1 = SUR)
    A - Address Low Byte
    R - Register Number
STO 10.M.T.AAAAAAAA.RRRR
    M - Mode (0 = AM0, 1 = AM1)
    T - Register Type (0 = GUR, 1 = SUR)
    A - Address Low Byte
    R - Register Number
JMP 110.M.AAAAAAAA.S.O.CC
    M - Mode (0 = Absolute, 1 = Relative to PC)
    A - Address Low Byte
    S - Address Source (0 = Adder.Result, 1 = Operand)
    O - Operation (0 = PC + S, 1 = PC -S)
    C - Condition (00 = Always, 01 = A > B, 10 = A < B, 11 = Equal)
NOP 111.XXXXXXXXXXXXX

Example 16-bit math

2010-04-25T16:41:00.000-07:00

This take two 16-bit numbers from GUR.0/1 and GUR.2/3 and leaves the answer in GUR.4/5. Also gives an example of function calling, making this code reusable anywhere in the program.


16-bit Addition Algo

function add([GUR.0, GUR.1], [GUR.2, GUR.3]) {
    //Return PC Address to [GUR.E, GUR.F]
    GUR.4 = GUR.0 + GUR.2;
    if(ALU.CarryOut) {
        GUR.5 = GUR.1 + GUR.3 + 1;
    } else {
        pGUR.5 = GUR.1 + GUR.3;
    }
    return [GUR.4, GUR.5];
}

::FROM PROGRAM 0x3AA2 (15,010) + 0x40D1 (16,417), Returns 0x7B73 (31,603)
PUT(3A, GUR.0);
PUT(A2, GUR.1);
PUT(40, GUR.2);
PUT(D1, GUR.3);
MOV(SUR.E, GUR.E);
MOV(SUR.F, GUR.F);
JMP(10, ::ADD);
::ADD SUBROUTINE
MOV(GUR.0, SUR.0);
MOV(GUR.2, SUR.1);
PUT(0, SUR.2);
MOV(SUR.0, GUR.4);
MOV(SUR.1, SUR.C);
PUT(1, SUR.D);
MOV(GUR.1, SUR.0);
MOV(GUR.3, SUR.1);
JMP(6, 2);
PUT(1, SUR.2);
MOV(SUR.0, GUR.5);
MOV(GUR.F, SUR.B);
MOV(GUR.E, SUR.3);
PUT(3, SUR.4);
JMP(8);

Organized Parts and Mounting Solution

2010-04-25T16:36:00.000-07:00

A total of about ten PCB cards will be mounted with all-thread and nuts.... making a kind of tower of protoboard, should make the eventual construction of a case easy. All the buses will run along the sides of each board.

The Parts

2010-04-16T12:00:00.001-07:00

Almost everything I could ever ask for as far as component parts. Transistors, resistors, diodes, LEDs, linear voltage ICs, sockets, ribbon cable, IDC sockets/connectors, and a good collection of the 74HC/AHC family ICs. Yay!

Update

2010-04-11T16:56:00.000-07:00

It's been a while since I've posted an update. The reason is that I'm still waiting on some of my component parts. A rather large order from Futurlec has had some things on backorder, but should ship by the 25th. Same with some of my test equipment. It's on backorder till they get their shipment in. I do eagerly await the DC power supply and function generator. I'll pretty much be all set up for any prototyping I want to do.

All in all I will have a Variable DC Power supply (0-20V, 0-5A), Function Generator (TTL, CMOS, Sine, Triangle, Square, 0-2MHz), Digital Oscilloscope + Logic Analyzer + Pattern Generator, Multimeter (Generic), Capacitance Meter (DIY kit), Soldering Station with hot-air rework, a couple of BS2 micro-controllers, and an Atmega168.

As far as component parts go I'll have pretty much all the 74HC/AHC series ICs I need (along with a plethora of sockets), various special ICs such as DACs and ROMs, resistors/capacitors/transistors/diodes like crazy, various LEDs, LED Displays, Matrix Displays, lots of ribbon cable and hook-up wire, switches, sockets, a ton of PCB proto boards, and my trusty HP48GX calculator (reverse polish notation fun).

UPDATE: 12APR2010 - My large order of component parts were just shipped from Hong-Kong... about time.

Testing propagation delay

2010-03-31T15:11:00.000-07:00

Finally received my oscilloscope / logic analyzer. Hooked it up to the ALU, and it has a maximum propagation delay of 65ns, giving it a parallel computation speed of 15.38MHz. Couldn't ask for more!

Oscilloscope and Component Parts

2010-03-24T17:22:00.000-07:00

Shipping right now is a MSO-19, a 2GSa/s oscilloscope, 200MSa/s logic analyzer, and 100MSa/s pattern generator. Puts me into the realm of a more serious hobbyist.

On top of that I went and purchased a large supply of component parts, 10-20 of all the common 74HC/AHC series, IC sockets, LEDs, and Proto Boards. This will enable me to complete most projects without ordering more parts and waiting for shipping.

Now all I need to do is stock up on solder....

Real Time Clock + SRAM

2010-03-06T10:22:00.000-08:00

Yesterday I was gifted with two "lithium battery packs" in chip form. I found the datasheet for these M48T59Y-70PC1s and found out that they are real time clocks with 8kb of SRAM built in. My idea is to have this chip hold the clock, and useful system settings. It also has an alarm function built in which I can probably interface to turn the system on when set.

It will be included into the address space as IO under $0900000 - $090FFFF, and an IRQ of 0.

Jump / Increment Unit

2010-03-06T10:15:00.000-08:00

Schematic for the JIU. This unit handles the standard plus one to the program counter, and also handles the jump / branch command. Conditional jumps can be handles with greater than, less than, and equal conditions. Forward and backward relative and absolute jumps are also handled in this unit.

Complete GUR Schematic

2010-03-04T07:44:00.001-08:00

Pretty nice and simple. There are 16 8-bit general use registers. Databus for in/out, Register Select Bus from CU for register selection, and two control lines with active low inputs.

MIDI Keyboard Download

2010-02-27T17:50:00.000-08:00

Midi Keyboard v3.1 (Unfinished)

Here's what Midi Keyboard looks like right now. It works, but the event viewer doesn't and some computers have a render bug. To fix the render bug goto preferences and select "Bufferstrategy Render"

NOTE: You must have java installed to run. If you do not have the SDK installed you might have to manually load the soundbank. THIS IS NOT THE FINAL VERSION. So if some things don't work right now, they don't work.

Things you should do: Make sure audio is working (keyboard starts at "C" and "Q"). Load a MIDI file into the playlist (Some are included). Enable chord analysis on MIDI playback (make sure all channels are being analyzed).

If you have any questions or comments let me know, and I might be able to help. But like I said, there is still more work to be done, I just wanted this out there for now.

Final ALU Schematic

2010-02-27T16:14:00.000-08:00

Final ALU Schematic. All chips are labeled correctly and added is a magnitude comparator and shift functions.

PC and Jump Options

2010-02-14T21:24:00.000-08:00

This is the block diagram for the PC. Should be pretty self explanatory. All the MUXs are controlled via control line for the control unit. The SUM adder can also subtract via the control lines (A+!B+1) for backwards relative jumps.

PC++, Jump from instruction, relative jump from PC, or goto 0.

Video Controller

2010-02-14T15:34:00.000-08:00

I've started researching how to output VGA signals, it's not as complicated as I had thought it would be. I found this paper that explains how simple VGA circuits could be made. I'm currently thinking that a 640x480 monochrome display is what I'll be working with, but perhaps it will be an 8-color display in the end.

As of right now it will be implementing an 80x30 text mode (8x16 pixel characters). Ram size for the text mode will only be 2,400 bytes, requiring only 12 address lines. This ram will provide the 8-bit character code, which then goes through a prom to provide the render data. Part of the vertical counter goes to the prom which gives the vsync offset to the data. Additional counters need to be added to account for the phantom pixels of the trace portion of the signal. 25.175MHz clock is needed for the 640*480 resolution, giving a 40ns maximum time per pixel.

ALU Test Board

2010-02-13T09:10:00.000-08:00

It's not pretty, but it's done. It's the test-board for the ALU. It provides 3 banks of eight 5 volt high/low inputs to the A, B and Op pins of the ALU, and outputs 8 bits data and the carry flag via LED.

The best news about this is that it proves that the ALU if functioning correctly. I still need to add the decoupling capacitors for high speed switching, but for testing out the logic, it's working perfectly.

Example microcoded program

2010-02-11T10:40:00.000-08:00

LARGEST FACTOR

This is the same program that the first true computer (the Manchester Mark I "The Baby") ran. Altered to run on this instruction set of course.

Pseudo Code

Start R0,R1 = DIP1
Loop1 R1=R1-1
if(R1==0) GOTO: ERROR
R2=R0
Loop2 R2=R2-R1
if(R2==0) GOTO: FOUND
if(R2<0) GOTO: LOOP1
GOTO: LOOP2
Found LED=R1
GOTO WAIT
Error LED=0xFF
Wait WAIT
GOTO WAIT

0x0000 Start 4E 10 11 // Debug DIP.1 to Rx0 and Rx1
0x0003 Loop1 21 30 // Rx1 to ALU.A
01 31 // 0x01 to ALU.B
             04 03 32 // SUB to ALU.Operation
             40 11 30 // ALU.Result to Rx1, ALU.A
             00 31 // 0x00 to ALU.B
             04 38 32 // XNOR to ALU.Operation
             40 3C // ALU.Result to Jump Flag
             00 3A //
             04 4E 3B // 0x004E to Jump address
             F1 // Conditional Jump to Error
             10 22 // R0 to R2
0x001C Loop2 22 30 // Rx2 to ALU.A
             01 31 // 0x01 to ALU.B
             04 03 32 // SUB to ALU.Operation
             41 13 // ALU.Flags to Rx3
             40 12 30 // ALU.Result to Rx2, ALU.A
             00 31 // 0x00 to ALU.B
             04 38 32 // XNOR to ALU.Operation
             40 3C // ALU.Result to Jump Flag
             00 3A //
             04 48 3B // 0x0048 to Jump address
             F1 // Conditional Jump to Found
             23 30 // Rx3 to ALU.A (ALU.Flags)
             02 31 // Negative value bit mask to ALU.B
             04 20 32 // OR to ALU.Operation
             40 3C // ALU.Result to Jump Flag
             00 3A //
             04 03 3B // 0x0003 to Jump address
             F1 // Conditional Jump to Loop1
             04 1C 3B // 0x001C to Jump address
             F0 // Jump Loop2
0x0048 Found 21 3E // Rx2 to Debug LED1
             04 51 3B // 0x0051 to Jump address
             F0 // Jump to Wait
0x004E Error 04 FF 3E // 0xFF to Debug LED1
0x0051 Wait 00 3A //
             04 56 3B // 0x0056 to Jump address
0x0056 0F // Wait
             F0 // Loop Wait

4E 10 11 21 30 01 31 04 03 32 Start
40 11 30 00 31 04 38 32 40 3C Loop1
00 3A 04 4E 3B F1 10 22 22 30 Loop2
01 31 04 03 32 41 13 40 12 30
00 31 04 38 32 40 3C 00 3A 04
48 3B F1 23 30 02 31 04 20 32
40 3C 00 3A 04 03 3B F1 04 1C Found
3B F0 21 3E 04 51 3B F0 04 FF Error
3E 00 3A 04 56 3B 0F F0           Wait

01001110 00010000 00010001 00100001 00110000 00000001 00110001 00000100 00000011 00110010 01000000 00010001 00110000 00000000 00110001 00000100 00111000 00110010 01000000 00111100 00000000 00111010 00000100 01001110 00111011 11110001 00010000 00100010 00100010 00110000 00000001 00110001 00000100 00000011 00110010 01000001 00010011 01000000 00010010 00110000 00000000 00110001 00000100 00111000 00110010 01000000 00111100 00000000 00111010 00000100 01001000 00111011 11110001 00100011 00110000 00000010 00110001 00000100 00100000 00110010 01000000 00111100 00000000 00111010 00000100 00000011 00111011 11110001 00000100 00011100 00111011 11110000 00100001 00111110 00000100 01010001 00111011 11110000 00000100 11111111 00111110 00000000 00111010 00000100 01010110 00111011 00001111 11110000

Conditional Jump if Zero

00 3A 00 3B // 0x0000 to Jump Address
20 30 00 31 // Rx0 to ALU.A, 0x00 to ALU.B
04 28 32 // NOR to ALU.Operation
40 3C F1 // ALU.Result to Jump Flag, Conditional Jump

Conditional Jump if Less Than Zero

00 3A 00 3B // 0x0000 to Jump Address
20 30 01 31 // Rx0 to ALU.A, 0x01 to ALU.B
04 03 32 // SUB to ALU.Operation
41 30 02 31 // ALU.Flags to ALU.A, 0xFE to ALU.B
04 20 32 // OR to ALU.Operation
40 3C F1 // ALU.Result to Jump Flag, Conditional Jump

NOTE: Microcode instuctions may have since changed.

Instruction Set

2010-02-11T10:32:00.000-08:00

The following is the current microcode instruction set for the 8-bit processor.

Instructions
ICU 0x00 Hardwired 0x00 to Bus
0x01 Hardwired 0x01 to Bus
0x02 Hardwired 0xFE to Bus
0x03 Hardwired 0xFF to Bus
0x04 Data to Bus from next address
0x0F Wait
REG 0x1N Bus to General Use Register N
0x2N General Use Register N to Bus
SREG 0x3N Bus to Special Use Register N
0x4N Special Use Register N to Bus
SU 0x50 Shift Left
0x51 Shift Right
JUMP 0xF0 Jump to JP
0xF1 Conditional Jump to JP

Special Registers
0x30 ALU.A ALU register
0x31 ALU.B ALU register
0x32 ALU.Operation ALU register
0x33 SRAM.P1 Memory Pointer, the address to select SRAM from
0x34 SRAM.P2 Memory Pointer, the address to select SRAM from
0x35 IR.P1 Interrupt Register, address to return to
0x36 IR.P2 Interrupt Register, address to return to
0x37 ISS Instruction Source Select, to choose between ROM and SRAM
0x38 IO.P IO Pointer to select which IO module
0x39 SU.In Shift Unit Register
0x3A Jump.P1 Jump Pointer, address to jump to
0x3B Jump.P2 Jump Pointer, address to jump to
0x3C JF Jump Flag, if all 1s then conditional jumps are active
0x3E LED.1 Debug LED 1
0x3F LED.2 Debug LED 2

0x40 ALU.Result ALU register Result
0x41 ALU.Flags ALU register Carry Flag
0x42 SRAM.Out SRAM from MP1 and MP2
0x43 IO.Out IO register value
0x44 SU.Out SU Out
0x45 SU.Flags SU Flags (left and right bit values)
0x4E DDIP.1 Debug DIP Switch 1
0x4F DDIP.2 Debug DIP Switch 2

ALU Op Codes
1st Nibble 2nd Nibble
0 0 M1 M2 IO IA IB CI

0x0N ADD
0x1N AND
0x2N OR
0x3N XOR
0xN1 CI
0xN2 Invert B
0xN4 Invert A
0xN8 Invert Output

0x03 SUB (A+!B+1) A-B
0x05 SUB (!A+B+1) B-A

MIDI Keyboard v3.1 rc1

2010-01-25T16:32:00.000-08:00

I've been working on this program for a while, here are some screen shots of it in action. I hope that here soon I'll have the actual RC1 ready for download. There are only a few things left that make this not ready to be released yet, nothing major however, so expect it soon.

Features:

MIDI Input/Output and Synthesis
MIDI Routing
Loading and Playing of MIDI files
Real-time MIDI keyboard display
Real-time Chord Analysis
Keyboard to MIDI (Using your actual keyboard as a MIDI input device, including Control Messages such as modulation and pitch-bend)
MIDI Even Log with Filtering

Distortion Box

2010-01-15T12:45:00.000-08:00

This is for Pena, who wanted the schematics to one of my distortion boxes. Enjoy

The HoP - Simulator

2009-12-08T16:36:00.001-08:00

I've been working on a simulator of The HoP, it is currently working, and I'm testing various programs to prove that the design is sound before final construction of control logic.

New Audio

2009-12-06T21:55:00.000-08:00

120609 - Flute and Piano

Not quite the finished product, but here you go...

ALU

2009-11-24T17:33:00.000-08:00

This is the ALU for my processor. While it might look like just a blob of random wires it can do addition, subtraction, and all logical operations. It's an 8-bit parallel circuit capable at working at speeds up to almost 20MHz.

It can invert A, B, or Output, Carry In, Add, AND, OR and XOR. It does this by going through a XOR gate for the invert, into the adder and logic gates, MUXed into a single 8-bit out, and sent through another XOR for the output invert.

It's constructed of 74HC series IC chips and soldered.

Music Examples

2009-11-23T09:09:00.000-08:00

030406 - Piano and Violin

001 - Orchestra and Violin

002 - Ostinato in Dm, Piano

003 - Orchestra, Harmonic Minor study

004 - Flute, Piano, Guitar, Bass, Drums

005 - Polysynth, Piano, Bass

Status

2009-11-23T08:53:00.000-08:00

I have many interests and hobbies, but mainly I'm currently concerned about the following: Music, Programming and Electronic Engineering. When I get the chance I'll post examples of both onto this site.

My compositional genre consists of classical and jazz, I've not been to active with this in a while, but mayhap more shall follow.

Programming wise I've done quite a bit of work, mainly with Java. Many small programs have existed, but they are quite esoteric in design and nature. The major program is something called MIDI Keyboard, which is a fully functional keyboard (music) with an analysis and display suite. I'll add that here when I get the chance as well.

As far as the Electronic Engineering goes I've created a few projects. Mainly a custom distortion box for my guitar (finished), an 8-bit binary adder/subtracter out of logic gates (finished), and currently in the works is a home-built custom architecture CPU and an overdrive/distortion box (more options) for my guitar. I've done a lot of work with the BS2 and PIC series micro-controllers but really wanted to get gritty with how hardware works, hence the CPU project.

Anywho, audio, binary, and lots of pictures will follow when I get the chance.

New Site

2009-11-22T16:32:00.001-08:00

So since Google Pages is shutting down I thought I'd try and find a new host for some of my projects and such and decided that this indeed might be a good medium. We'll see.