BMOW title
Floppy Emu banner

68 Katy

68-katy-breadboard  68katy-pcb

68 Katy is a hand-built computer based upon a Motorola 68K series CPU, and designed to run the Linux OS. The initial 2 MHz prototype was constructed on a solderless breadboard, and a later PCB version runs at 12 MHz. The operating system is a customized version of uClinux with the 2.0.39 kernel from 2004, squeezed into just 467K. It’s a full-fledged multitasking OS, and even runs vi and the classic Colossal Cave Adventure! A small monitor/bootloader program acts as a companion to uClinux, and can be used to load bare-metal programs or to update the contents of the flash ROM.

Both the breadboard and PCB versions feature 512K flash ROM, 512K SRAM, and a USB serial port. The heart of the design is a 68008 CPU, a low-cost version of the more familiar 68000 CPU that has an 8-bit data bus instead of 16-bit. Curious readers may wonder how Linux can run on a 68008 CPU, which lacks a memory management unit and can’t support virtual memory. Fortunately uClinux is specifically designed for such “no MMU” architectures. Of course with no MMU there’s no memory protection, so a buggy program can wreak havoc in other running programs, or even crash the whole OS – just like in the good old days.

Much more background about the original “Linux on a breadboard” prototype and the process of building it can be found on this page. For full details, see the postings in the 68 Katy build log.

Here’s a video of the prototype machine booting uClinux and running through its paces:

The breadboard prototype (2 MHz) versus the PCB version (12 MHz):

 
Memory Map

BREADBOARD 68 KATY               PCB 68 KATY
00000 - 77FFF : ROM              00000 - 77FFF : ROM
78000 - 79FFF : serial in        78000 - 79FFF : serial in
7A000 - 7BFFF : serial out       7A000 - 7BFFF : serial out
7C000 - 7DFFF : serial status    7C000 - 7CFFF : serial status RDF
                                 7D000 - 7DFFF : serial status TXE
7E000 - 7FFFF : LED register     7E000 - 7FFFF : LED register
80000 - FFFFF : RAM              80000 - FFFFF : RAM

 
PCB Version

The PCB version is the easiest way to build your own 68 Katy. It replaces all of the glue logic, timers, and other miscellaneous components with a single CPLD. Compared with the breadboard version, the number of status LEDs is reduced from eight to one, and there’s a small change to the serial status address mapping. Get a PCB, solder the components, burn the ROM, and you’ll be in business.

Assembling the PCB requires soldering one surface mount component, the 44 pin CPLD in TQFP package. It can be soldered with a standard iron using the drag soldering method (my preference), with hot air, or with a toaster oven reflow. The rest of the components are easy through-hole parts.

You’ll need an EPROM burner to program the initial flash ROM data, as well as a JTAG programmer for the CPLD. I used a Bus Pirate with the XSVF player firmware to program the CPLD.

Note that the PCB and Breadboard versions of 68 Katy are not binary compatible, due to a small difference in their memory maps. If you’re building the PCB version, be sure to use the files in this section, and not the breadboard version files.

 
PCB Version: Files

  • schematic and board layout – Board definition in KiCad format
  • Gerber files – For getting a copy of the PCB made at a fab like Seeed Studio
  • CPLD source – Xilinx ISE project and Verilog source code for the CPLD
  • 68katy.xsvf – JTAG configuration file for the CPLD
  • monitor.asm – My ROM-based monitor/bootloader program. I used Easy 68K to assemble it.
  • monitor-plus-linux-pcb.bin – This is the final binary image I programmed into the ROM, containing the monitor/bootloader program with the uClinux kernel concatenated to it beginning at address $003000
  • virtualboxes.org Ubuntu machine – For Linux cross-development, I used Ubuntu 12.04 32-bit running as a virtual machine under Virtual Box. Don’t use the 64-bit version, or the 68K toolchain won’t work. You can use this pre-configured Ubuntu Virtual Box machine image. Username “ubuntu”, password “reverse”
  • uClinux-dist-20040218 – I started from the February 18, 2004 release of uClinux. This is the unmodified version.
    uClinux-20040218-pcb.tar.gz – This is my modified version of uClinux. It includes code for kernels 2.0, 2.4, and 2.6, but I only ported kernel 2.0 for 68 Katy. Search the code for “68KATY” to find my changes.
  • m68k-elf-tools-20030314 – You’ll need a 68K cross compiler and other tools in order to build the uClinux source code. I used m68k toolchain 20030314. It’s supposed to be a self-extracting shell script, but that didn’t work for me. I had to extract it manually, like this:
user@ubuntu$ tail -n +43 m68k-elf-tools-20030314.sh | gunzip > tools.tar
user@ubuntu$ tar xvf tools.tar

 
PCB Version: Parts List

 
Breadboard Version

Want to build a 68 Katy on a breadboard, for the ultimate in geeky fun? This version uses discrete 7400-series chips for most of the address decoding and other glue logic, with the exception of one PAL. The PAL replaces some logic that would otherwise have required more NAND’s, OR’s, flip-flops, etc. If you’re building your own version of 68 Katy, you don’t necessarily need the PAL – just replace it with the equivalent 7400-series basic logic gates.

You’ll need an EPROM burner to program the initial flash ROM data, as well as to program the PAL if you’re using one. Beyond that, no special hardware or skills are required.

Note that the PCB and Breadboard versions of 68 Katy are not binary compatible, due to a small difference in their memory maps. If you’re building the breadboard version, be sure to use the files in this section, and not the PCB version files.

 
Breadboard Version: Files

  • monitor.asm – My ROM-based monitor/bootloader program. I used Easy 68K to assemble it.
  • ehBASIC.zip – A slightly modified version of Lee Davison’s ehBASIC for 68000.
  • monitor-plus-linux.bin – This is the final binary image I programmed into the ROM, containing the monitor/bootloader program with the uClinux kernel concatenated to it beginning at address $003000
  • virtualboxes.org Ubuntu machine – For Linux cross-development, I used Ubuntu 12.04 32-bit running as a virtual machine under Virtual Box. Don’t use the 64-bit version, or the 68K toolchain won’t work. You can use this pre-configured Ubuntu Virtual Box machine image. Username “ubuntu”, password “reverse”
  • uClinux-dist-20040218 – I started from the February 18, 2004 release of uClinux. This is the unmodified version.
    uClinux-20040218.tar.gz – This is my modified version of uClinux. It includes code for kernels 2.0, 2.4, and 2.6, but I only ported kernel 2.0 for 68 Katy. Search the code for “68KATY” to find my changes.
  • m68k-elf-tools-20030314 – You’ll need a 68K cross compiler and other tools in order to build the uClinux source code. I used m68k toolchain 20030314. It’s supposed to be a self-extracting shell script, but that didn’t work for me. I had to extract it manually, like this:
user@ubuntu$ tail -n +43 m68k-elf-tools-20030314.sh | gunzip > tools.tar
user@ubuntu$ tar xvf tools.tar

 
Breadboard Version: Parts List

 
CPU

68katy-schematic-cpu

 
RAM and ROM

68katy-schematic-memory

 
Control Logic

68katy-schematic-control

 
555 Timer for Scheduler

68katy-schematic-555

 
USB Serial FIFO

68katy-schematic-ft245serial

 
LED Display

68katy-schematic-LEDs

61 comments 

61 Comments so far

  1. Charles - November 28th, 2014 6:16 pm

    Gosh i hate to be a pain in the butt, but a pcb of this would be kinda sweet…
    just saying 🙂

  2. Karim Yaghmour - November 29th, 2014 12:48 pm

    AMAZING!!! Thank you so much for doing this.

    Karim

  3. Lubomir Rintel - December 27th, 2014 12:01 am

    Thank you very much!

  4. matze - June 25th, 2015 10:01 am

    What about running Minix 68k on this Thing ?
    it would be less Memory demanding and much faster 🙂

  5. Vincent - October 6th, 2015 3:59 pm

    I wonder if using an 68SEC000 and MCP you could fit it on a 1″ by 1″ PCB…
    https://hackaday.com/2015/10/02/the-square-inch-project-challenges-your-layout-skills/

  6. Steve Chamberlin - October 6th, 2015 4:17 pm

    What’s MCP? Looks like the smallest 68SEC000 package is about 0.4 inches square (10 mm), then you’d still need to fit a CPLD, an SRAM, a ROM, a clock oscillator, the USB serial port chip, power header, button, and a bunch of misc passive components. That would be a heck of a layout job, assuming the parts even fit the PCB in the first place!

    The smallest ever PCB I’ve designed is the Backwoods Logger – mini version, which is just over 2 square inches. http://www.bigmessowires.com/backcountry-logger/

  7. Vincent - October 6th, 2015 6:14 pm

    MCP is combined flash and SRAM in a single package
    http://www.datasheetarchive.com/dl/Datasheets-IS76/DSAH00322896.pdf – 48 pin
    http://www.dataman.com/media/datasheet/Renesas/M6MGB_T641S8TP.pdf – 52 pin, more memory

    One would have to cheat a little by putting solder pads on the board edge, like the Bluetooth modules, for CPLD JTAG, USB connector, reset button, power etc

    But you are right – not an easy job, regardless. Thanks for doing this in the first place.

  8. Steve Chamberlin - October 6th, 2015 7:13 pm

    Well, now you’ve got me thinking about it… 🙂

  9. Steve Chamberlin - October 9th, 2015 11:35 am

    I really like the idea of the square inch project challenge, so I spent some time looking into just how small I could squeeze the 68Katy design, using all SMD parts in the smallest practical packages. 1 square inch is about 645 mm2 or 1290 mm2 if we use both sides of the board, and I estimated the footprints of the required chips would be ~1000 mm2. That wouldn’t leave enough room for mounting all the passive components, let alone routing the traces, so I don’t think it’s possible. But I do like the idea of a tiny 68Katy, and I think a 2 or 3 square inch board could work. Maybe power it direct from USB, and use some kind of JTAG indirect method to program the bootloader… except the 68SEC000 doesn’t even have JTAG.

  10. Vincent - October 9th, 2015 12:14 pm

    Yes, I came to the same conclusion. The original thought was that 8 bit mode and 4 layer PCB would free up sufficient board space to route, with CPLD + passives on one side and CPU & MCP on the other – tho it still might be possible with 6 layer. Programming the bootloader would probably involve temporarily soldering to an adapter, burning and uncomfortably removing and resoldering to the tiny target PCB. A stopgap might be to have the bootloader in a separate DIP 24 pin 3V flash with components underneath the socket, but this 3V 24 pin Flash doesnt exist…

    The MC68332 is the next logical conclusion as that has 3 wire Background Debug Mode, like a JTAG predecessor, but is bigger, is drifting further away from the spirit of an early 1980’s 68k board running Linux.

  11. Thanasis - November 2nd, 2015 4:33 am

    Hello,
    This is the best project for Linux and Electronics.
    Is it possible to provide a full schematic even if it is hand written with all components?I really want to build the breadboard version.

    Thank you in advance
    Thanasis

  12. Steve Chamberlin - November 2nd, 2015 7:57 am

    The (hand drawn) schematics for the 68 Katy breadboard version are here on this page – just scroll up a little. 🙂

  13. Thanasis - November 3rd, 2015 2:24 am

    I saw that but it is a bit confusing I would like a drawing all in one. If it is too much trouble I will try to use the separate ones.
    Thank you again for posting this.

  14. Tony - November 17th, 2015 7:08 pm

    I have built a board and tested it, it woks fine.
    Have you looked at adding any expansion devices like a lcd display.

    Any ideas on adding a chip select that I could use fo connecting a lcd display.

    Thanks Tony

  15. Steve Chamberlin - November 18th, 2015 7:09 am

    To add more peripherals like an LCD display, you’d have have to modify the address decoding to map them into the address space somewhere. A simple but cheesy method would be to re-use the status LED as a chip select for your LCD.

  16. Kiaas - January 13th, 2016 6:12 pm

    have you thought about maybe using an MRAM instead of SRAM? it’s not through-hole but it’s as fast as SRAM (with the same interface) and non-volatile like flash. I’ve hand soldered one before on a as-of-yet incomplete project.

  17. Kiaas - January 14th, 2016 7:36 am

    Oh I should mention the point of asking, the 1 square inch thing, mram would allow you to replace the flash and sram with just 1 mram. That’s why we’re using it in our project (plus a few transistors to protect a portion of it from being written to protect the firmware, you might be able to stick such functionality on your cpld.)

  18. Steve Chamberlin - January 14th, 2016 7:58 am

    See the suggestion above from Victor, posted October 6. It sounds like the same thing?

  19. Tom - January 15th, 2016 5:47 am

    Thanks for this – I wonder where computing would be if IBM had taken the 68008 instead of the 8008 to make the PC!

  20. ramin assadollahi - November 7th, 2016 12:01 am

    thanks for this really inspiring project! i will try to rebuild your design and document it a bit broader for people like me who are not as deep in electronics as you are. i noticed the GAL chip, which i don’t understand at all, what it is for and what i should do with these equations. i know i need a eeprom programmer for the flash, can i use the same for the GAL? thinking of buying this one: https://www.amazon.de/dp/B00NGFIGOS/ref=wl_it_dp_o_pC_S_ttl?_encoding=UTF8&colid=TTDG7TOKT25L&coliid=IG7GOXHJNFAT3 hefty price, imho, so i just want to be sure i’ll be able to flash the ROm and write the GAL with it. alternatively: can i build the computer without the GAL and only discrete chips?

  21. Steve - November 7th, 2016 7:18 am

    A GAL is a rewritable PAL, and is like a simpler version of a CPLD or FPGA. Some EEPROM programmers can also handle GALs, but not all. See this article for some basic information: http://www.uchobby.com/index.php/2008/03/30/gals-for-electronics-hobby/ Alternatively you could use a few discrete NAND and NOR gates to implement the GAL equations. The equations are in EQN format suitable for a tool called Opal Jr. Equations using an = sign are simple combinatorial logic. The equations using a := sign are registered logic and use a DQ flip-flop. * means AND, + means OR, / means NOT.

  22. Matthew Bettcher - February 10th, 2017 5:37 pm

    I’ve been working on my own 68k computer and I’m trying to assemble your monitor.asm, but it includes “dis.asm” and that file isn’t included on your site. I found it here http://www.kswichit.com/68k/68k.html but it’s not using some of the same variables and constants your using. Any help is appreciated.

  23. Steve - February 12th, 2017 2:36 pm
  24. Matthew Bettcher - February 13th, 2017 6:55 pm

    Yes, thank you!

  25. Matthew Bettcher - March 30th, 2017 2:28 pm

    What is the purpose of the pull-up resistors on the data bus? I\’ve working on my own 68k design for some time now and have never seen that on any other design that I can remember. Is it to ensure a correct value on the data bus during an interrupt? As per the datasheet external devices supply vector # on data bus during interrupts, but the only device that fires interrupts (CPLD) isn\’t fully connected to the data bus, so you tie it high?

  26. Steve - March 30th, 2017 2:51 pm

    Hmm, that’s a good question. There are no data bus pull-ups in the hand drawn schematic, and I don’t remember why I added them when I redid it in KiCad. I think I was worried about the bus being left to float in an undefined state, and that that might cause problems for other components. I believe the CPLD can act weird if its inputs aren’t well-defined 0’s or 1’s, if I recall correctly.

  27. Matthew Bettcher - March 30th, 2017 3:02 pm

    Interesting, so only D0 would need to be pulled up as it’s the only one going into the CPLD.

  28. Bill Shen - November 23rd, 2017 9:11 am

    Thank you, This is really inspirational!
    I have designed a 68000 SBC called Tiny68K. It is in 100mm x 100mm format to keep the cost down. It has 68681 for serial port and timer, serial EEPROM for boot ROM, Altera 7128 for CPLD, CF disk, and 16 megabyte of DRAM running at 12MHz.
    https://www.retrobrewcomputers.org/forum/index.php?t=msg&th=222&start=0&
    I ported CP/M-68K to it successfully, but I\’ve never thought about uCLinx. I didn\’t even think it is possible. I would love to port your version of uCLinx to my board. Your serial port and timer are different than mine, but I wonder if all your I/O are handled by one set of routines, ideally interrupt service routines so I can just redirect it to a different drivers? I ask this because I\’m not at all experienced with Linux so I have a steep learning curve to climb working with the various tools you have kindly provided. In fact if this port works, it will be my very first Linux machine!

  29. Bill Shen - November 23rd, 2017 8:23 pm

    I looked over your monitor and see COUT, CINS, and CIN are the routines that interface to the USB serial port. The entry points are 0x618, 0x63a, and 0x65c respectively. This is the patch to your monitor binary:
    ————————————-
    * patch the BMoW’s monitor.
    * replace the USB serial with 68681
    SRA equ $FFF003 * status A
    RHRA equ $FFF007 * Rx Hold reg A
    THRA equ $FFF007 * Tx Hold reg A

    ORG $0
    INCBIN monitor.bin * this is the binary of BMoW’s monitor
    org $618 * entry to console out routine
    COUT:
    btst.b #2,SRA * output ready?
    beq COUT
    move.b d0,THRA * write data to serial port
    rts

    org $63a * entry to console in routine
    CINS:
    btst.b #0,SRA * input character available?
    beq CINS
    move.b RHRA,d0 * read input character
    rts

    org $65c * entry to console in with echo routine
    CIN:
    btst.b #0,SRA * input char available?
    beq CIN
    move.b RHRA,d0 * read input char
    bsr COUT * echo back
    rts

    END $42E * $42E is entry point of BMoW’s monitor
    ———————————————-
    When I load & execute, zBug signs on and I seems to able to run most commands.

    zBug(ROM) for 68Katy (press ? for help)

    084000>?
    zBug(ROM) for 68Katy 20150113 by W. Sirichote, S. Chamberlin
    Using code from 000000-00246F, data above 0FFE26
    Monitor commands

    D Disassemble machine code at current pointer
    E Edit memory
    F Fill memory with 0xFFFF
    H Hex dump memory from current pointer
    I Init from RAM [$80000] -> SP [$80004] -> PC
    J Jump to address
    L Load Motorola S-record
    N Load binary data
    P Set current pointer
    R Register display
    S Stack display
    T Trace instruction at PC
    U Update Flash ROM
    Z Clear memory with 0x0000
    . Modify registers, as .PC .D0 .A0
    ? Help

    084000>register display (A7 = user stack pointer)

    PC=084000 SR=2700 X=0 N=0 Z=0 V=0 C=0
    D0=00000000 D1=00000000 D2=00000000 D3=00000000
    D4=00000000 D5=00000000 D6=00000000 D7=00000000
    A0=00000000 A1=00000000 A2=00000000 A3=00000000
    A4=00000000 A5=00000000 A6=00000000 A7=000FFE26

    084000>

  30. Barana - December 15th, 2017 7:01 pm

    Wow. Katy is already that popular it has a compatible-clone. Onya, Steve!

  31. Barana - December 16th, 2017 11:51 pm

    Steve, if you were wanting to address more memory to fit in say u uclinux based on 2.4 or something else, according to the 68008 manual, the qpp 68008 will address 4mb ram. It has 4 extra pins.

  32. Gary - May 4th, 2019 3:14 pm

    Hi Steve, I spotted Katy some time ago when browsing the web during work hours 🙂 (er lunchtime). Recently I disscovered that I had a MC68008 in my “Moto” box of IC’s, so I put together a breadbaord circuit with the DIP processor, 2 512kx8 RAMs, and after having problems with the MC68901 MFP, I added an Altera FPGA and wrote my own UART code. I have ported your monitor and got it working yesterday (modifying UART and LED status code of course).
    I also downloaded the uClinux tarball, figured out where to make the changes for my UART, and was able to build a binary image (after fixing various issues).
    BTW my circuit is called Karen (named by a chap called Lawrence who has a very interesting blog with various 68k projects) and she is of cource Katy’s sister.
    I can load all 1Mbyte of RAM using a Teensy which uses DMA to get control of the RAM.
    I’ll be uploading a YouTube video in the near future.
    My .rom file is 700k, not less than 512k like yours, but in theory I have enough RAM. The question is, what is the base load address of this rom image file and what is the entry address? From your video you appear to call the entry at 0x3000.
    –Gary

  33. Steve - May 5th, 2019 6:19 am

    Nice work! It’s been several years since I worked on this, and I don’t remember the details of the ROM image, but hopefully you can find what you need in the modified uClinux source code download.

  34. Tarun Govind - May 5th, 2019 12:49 pm

    Hi Steve, I have some m68k with me, and I saw your post on running linux on m68k. I am planning to build one in the coming days. I recently found that uclinux webpage is down, and I feel that there wont be any support for uclinux in the future. And the linux vanilla kernel still supports m68k. So my question is, can I use linux kernel instead of uClinux kernel. Have you given it a try?.

  35. Phil - June 18th, 2019 1:17 pm

    This looks like a striped down version of this guy 68k board:
    https://www.youtube.com/watch?v=GJmPS3jMwD4
    Too bad that there are no recent updates about it – only found this old repo:
    https://code.google.com/archive/p/m68k/
    But it does have the code and schematics.

    Tarun,
    As far as I know, starting on kernel 3.x the m68knommu code was merged to the main kernel tree.
    You can see the source code does support the plain 68000:
    https://github.com/torvalds/linux/blob/master/arch/m68k/68000/head.S
    The guy from above was able to run it on his board as seen here:
    https://www.youtube.com/watch?v=gu0Y4vliJcQ

  36. Phil - June 20th, 2019 1:57 am

    Tarun,
    Starting on kernel 3.x the m68knommu code was merged to the main kernel tree:
    https://github.com/torvalds/linux/blob/master/arch/m68k/68000/head.S
    This guy was able to run it on a plain 68000: https://www.youtube.com/watch?v=gu0Y4vliJcQ
    And he also had a breadboard version: https://www.youtube.com/watch?v=mncS0ZLWKSY

  37. Mike - July 16th, 2019 12:38 pm

    Hey Steve, Do you have an example \”hello world\” type app/tutorial that will compile and run under the uCLinux environment for the 68 Katy? or is there a tutorial/information already existing?

    the 68K system I am dealing with has a VME Bus and I/O cards with LEDs, Etc but not sure how to write a program to run under the UCLinux environment.

    thanks!

  38. Steve - July 16th, 2019 1:34 pm

    I’ve largely forgotten the details after five years, but the source code for the ledblink program (shown in the demo video) should be in one of the download files, either in uClinux-20040218.tar.gz or in the VirtualBox Ubuntu machine image. It’s not going to be very interesting, though. It’s like a 5-line program that pushes different values into a hard-coded memory address that’s the memory-mapped address of the LEDs.

  39. Rein - November 20th, 2019 12:54 pm

    I\’m trying to create a Kicad schema layout but I\’m a little confused on the OESTATUS inputs (?) on the 74LS244. I can\’t seem to find where they connect to any other part on the board. Does anyone have an explanation, or even a Kicad schema for this build?

  40. Steve - November 20th, 2019 1:03 pm

    The OESTATUS output comes from a ‘139, shown in the control section of the schematic.

  41. Rein - November 23rd, 2019 7:13 am

    Ah I see, that was rather silly of me, thanks!

  42. Rein - November 23rd, 2019 11:13 am

    Is there as simple an explanation for the inverters? There are three of them in the logic section, but I don\’t see them listed in the parts list, nor on the prototype board at https://www.bigmessowires.com/wp-content/uploads/2014/11/68-katy-protoboard-final.jpg so how does that work? Thanks again.

  43. Steve - November 23rd, 2019 12:37 pm

    Good catch. I tore down the breadboard long ago, but I think I used three of the NAND gates as inverters by wiring the same signal to both NAND inputs.

  44. Rein - November 26th, 2019 11:01 am

    That is making perfect sense now. The last bit I’m not sure about is the 1A1 through 1A4 input ports on the 74LS244. Are 1A1 and 1A2 tied to +5, where RXF is wired to 1A3 and TXE to 1A4? I don’t quite know how to read the schematic here. Your pointers are highly appreciated!

  45. Steve - November 26th, 2019 2:44 pm

    Yeah the schematic for that section is confusing. I think it was 1A1 is RXF, 1A2 is TXF, and the rest are connected to +5V. Have you looked at the Kicad schematic for the PCB version with the CPLD? It uses the same conventions.

  46. Simon - May 18th, 2020 12:20 pm

    Hi Steve,

    Thank you for posting all this information. I’ve made a VR version of the 68Katy for Unity3D and today decided to compile my own kernel. Problem is I just can’t get the size of the kernel down below about 679 K. I note in the above blkmem 0: its clearly 7791F as the upper range. Can I ask how you do that as even if I truncate the rom is still says AC813 and then unable to open an initial console after the vfs message.

    heres a video of your ROM running in Unity3D https://youtu.be/n5lPGkjMqME

  47. Simon - May 18th, 2020 12:57 pm

    I found out a large number of apps were hiding out in the romfs/bin folder so I did a makeclean and a rebuild and now the kernel is 351K, and more importantly it works!

  48. Tony - August 16th, 2020 9:42 am

    Hello Steve
    I am looking for the dis.asm file for easy68k which is missing from your source code files.

    Monitor.asm requires it to build.

    Thanks Tony

  49. Mike - October 22nd, 2020 7:41 am

    Cool build! does this support a GUI? I’m not very good with CLIs or TUIs.

  50. Lee Morgan - February 9th, 2022 3:49 pm

    Quick question, the SparkFun board is retired and I’m missing libraries to view the schematic in KiCAD. Is the board only used for serial communications or do I need to come up with a full replacement?

  51. Tony - February 10th, 2022 1:42 am

    Hello, you can import the files to easyeda and export them to Kicad.
    Yes the is only for serial com’s

    I had some boards made a few years ago, it is a very simple board.

  52. gonzalo - March 22nd, 2022 4:02 pm

    Hi:

    Could anyone post the file uClinux-dist-20040218.tar.gz?
    The copy in Wayback Machine of the uClinux site is corrupted, download ends around 50Mb.

    thanks

  53. Gary - March 23rd, 2022 5:08 am

    Hi @gonzalo, I have a copy.

    Do NOT post/reveal your email address.

    Setup some kind of temporary email account and post that here, then I will email the tar.gz as an attachment. The only possible glitch is that it 181Mb in size, so might be too big for an attachment.

    If you have any other ideas for safe transferral please let me know (post here _ I get an update).

  54. gfernval - March 23rd, 2022 8:42 am

    Temporary email to put the uClinux-dist-20040218.tar.gz is uclinux@outlook.es, a good advice would be to .zip the uClinux-dist-20040218.tar.gz file with password, in this manner can be added as attachment. Other advice would be to chunk the file in 40mb chunks.

    thanks

  55. gfernval - March 23rd, 2022 8:43 am

    Temporary email to put the uClinux-dist-20040218.tar.gz is uclinux@outlook.es, a good advice would be to .zip the uClinux-dist-20040218.tar.gz file with password, in this manner can be added as attachment. Other advice would be to chunk the file in 40mb chunks.

    thanks

  56. gfernval - March 23rd, 2022 10:36 am

    Hello:

    Yesterday download from Wayback Machine ends at 48Mb, today I have been able to download succesfully the archive, no need to send by email.

    thanks

  57. Steve - March 23rd, 2022 11:47 am

    Sorry, I had to free some space on the server and removed those files. Glad you found it on the Wayback Machine.

  58. lastprinces - March 24th, 2022 1:02 am

    Your video quality is very poor.

  59. JoyBed - April 30th, 2022 1:51 pm

    Are the files still downloadable from somewhere? I also have some questions for you regarding the uclinux and the hardware side of things. Can we get in touch on some chatting platform to quickly sort out the things I wanted to ask for my build?

  60. Jason Stevens - November 30th, 2022 1:57 am

    For anyone looking for uClinux-dist-20040218.tar.gz, I put a copy on archive.org

    https://archive.org/details/uClinux-dist-20040218.tar

    or on github https://github.com/neozeed/uClinux-dist-20040218 if you prefer that kind of thing.

  61. serge - December 18th, 2022 6:07 pm

    HEllo,

    Your monitor and uclinux port is working on the Jaty68k emulator base on m68k emulator project.

    I also add a target for your board on the py68k emulator project. zbug is working except the “S” command who try to read outside of RAM.

    084000>stack display, shows 16-word deep

    1FFC7C [0000]
    1FFC7E [0000]
    1FFC80 [0000]
    1FFC82 [0000]
    1FFC84 [0000]
    1FFC86 [0000]
    1FFC88 [0000]
    1FFC8A [0000]
    1FFC8C [0000]
    1FFC8E [0000]
    1FFC90 [0000]
    1FFC92 [0000]
    1FFC94 [0000]
    1FFC96 [0000]
    1FFC98 [0000]
    1FFC9A [0000]
    1FFC9C [0000]

    084000>
    Waiting for emulator, hit ^C three times quickly to

    ** I tracked the bus error when executing
    MOVEA.L #SUPER_STACK+USER_STACK,A1 ; TOP OF USER STACK
    LEA.L -32(A1),A0 ; EACH COMPOSED OF TWO BYTE

    ** At this point A0=0x1ffc7c
    ** For some reason #SUPER_STACK+USER_STACK is outside memory range.

    EXECUTE : 0x00000ed0 : movea.l #$1ffc9c, A1 A1=0x100000
    READ : 0x00000ed6 : 0x41e9
    READ : 0x00000ed8 : 0xffe0
    EXECUTE : 0x00000ed6 : lea (-$20,A1), A0 A0=0x0 A1=0x1ffc9c
    READ : 0x00000eda : 0x3e3c
    READ : 0x00000edc : 0x0010
    EXECUTE : 0x00000eda : move.w #$10, D7 D7=0xffff
    READ : 0x00000ede : 0x2c7c
    READ : 0x00000ee0 : 0x000ffe7a
    EXECUTE : 0x00000ede : movea.l #$ffe7a, A6 A6=0xffe7a
    READ : 0x00000ee4 : 0x2008
    EXECUTE : 0x00000ee4 : move.l A0, D0 D0=0x84000 A0=0x1ffc7c
    READ : 0x00000ee6 : 0x2f00
    EXECUTE : 0x00000ee6 : move.l D0, -(A7) D0=0x1ffc7c A7=0xffe72
    WRITE : 0x000ffe70 : 0xfc7c
    WRITE : 0x000ffe6e : 0x001f
    READ : 0x00000ee8 : 0xb1ee
    READ : 0x00000eea : 0x00b2
    EXECUTE : 0x00000ee8 : cmpa.l ($b2,A6), A0 A0=0x1ffc7c A6=0xffe7a

    ** Then later in SKIP_PRINT_BLANK this instruction MOVE.W (A0)+,D0 will generate a bus error, because A0=0x1ffc9c
    READ : 0x000ffe6e : 0x00000f16
    READ : 0x00000f16 : 0x3018
    EXECUTE : 0x00000f16 : move.w (A0)+, D0 D0=0x1ffc5b A0=0x1ffc7c
    BAD_READ : 0x001ffc7c : 0xffffffff

    Trying to start uclinux

    084000>jump to address 084000>003000

    uClinux/MC68000
    Flat model support (C) 1998,1999 Kenneth Albanowski, D. Jeff Dionne
    MC68000 68 Katy support by Big Mess o’ Wires, Steve Chamberlin

    Line F emulator!FTDI FT245 driver version 1.01 by Steve Chamberlin
    ttyS0 at 0x00078000 (irq = 2) is a FTDI FT245
    Ramdisk driver initialized : 16 ramdisks of 4096K size
    Blkmem copyright 1998,1999 D. Jeff Dionne
    Blkmem copyright 1998 Kenneth Albanowski
    Blkmem 1 disk images:
    0: 48530-7792F (RO)

    Line F emulator!
    Exception has no handler!Jump to 0

    zBug(ROM) for 68Katy (press ? for help)

    I keep trying to get it run 😉

    Latest commits for both project are on my github @see https://github.com/demoze

Leave a reply. For customer support issues, please use the Customer Support link instead of writing comments.