Searched Projects

This is a CPU witch is capable of executing a lot of stuff in one clock cycle, and this CPU can shift left up to 7 times and shift right up to 7 times witch means that it is possible to  multiply and divide in one clock cycle if you program a table in the program memory. it has a 32 bit instruction width and a 8 bit address. it also has 

The ALU has the following operations:

• ADD
• SUBTRACT
• SHIFT_LEFT (up to 7 times per cycle 3 bit)
  
• SHIFT_RIGHT (up to 7 times per cycle 3 bit)
  
• XOR
• OR
• NOT

This Was made by miles

-reset before beginning-

type whatever you want on the Type pad 2000* using its state-of-the-art (non-removable) keyboard

then read it back by clicking on the ''Read/type'' button

change the scroll speed with the ''scroll speed'' and then visualize the speed by looking at the multy colored LEDs 

with its whopping 1000 character space, you can write whatever you want in it without fear of emptying the storage space**

_{*backspace not included}

_{**filling the memory will cause overflow and overwrite over previously written text}

I have finally got the CPU to run a more complex program that involves more jumping commands, MUCH more RAM usage, and uses up more of the program memory. This is the dot mover arounder emulator. It emulates the very basic function of the Dot Mover Arounder. I had to use a specialized subcircuit and some registers to help decode the commands sent to the screen by the CPU. Unfortunately, this doesn't work properly with the 1000-1000A since the ALU in this CPU has different commands. You could edit the commands in the program if you want to make it compatible.

Same as old one, but with STRING2000C.

I have programmed a new version of Dot Mover Arounder Emulator. This emulator is like the old one, however you can load and save a position on the screen. For now, there will only be one slot to save on, so you can only save one position at a time, but I may expand the slot count later. This program only works with 3000 series+ string CPUS and up because the previous series don't support the same ALU opcodes and don't support the "save loaded" instruction. If you were to run the new emulator on the 2000 series CPUS, it would run normally just without the ability to save positions.

How to load and save:

To save your current position, enter 1 into the keyboard.

To load the saved position, enter 2 into the keyboard.

Make sure you move around on both axis since the program will only update an axis when you move on it.

Now with new and improved adapter and can now move to 0,0 and with STRING3000SA

About the Combinox R1:

This is the third 16-bit CPU I have made. Its new name was inspired by the new combinational code. It is also my first computer to feature a graphics and base ten display. As a result of its brand new architecture, code, and clock it is much faster than my previous CPUs. 

Directions for use:

Choose the desired EEPROM program and insert it into the slot. First press the "RESET" button. Now press the "ON" button and enjoy your program.

Descriptions of programs:

blank: A blank EEPROM to be coded.

count up forever: Counts up by one until it reaches 65,535 then loops back to 0.

2+2: adds 2+2 and displays the output to the number display

transfer from keyboard to display: Displays the ascii value of whatever key is being entered on the keyboard.

random noise: Displays random noise on the screen.

Fibonacci: calculates the Fibonacci sequence 

Credits:

Sanderokian Stfetoneri - clock

Sanderokian Stfetoneri - 16 bit division

Overview

The STRING32000 is a 32-bit CPU. It reads and executes each instruction in 1 clock cycle like all the old string CPUS. It has addressed pins and can modify its own code. While this CPU usually needs special external circuitry to interact with complex outputs like the RGB LED matrix, these external drive circuits are just meant to store the bitmap being drawn on the screen. The overall unspecialized nature of this CPU allows it to address up to input and output 65,536 32-bit pins.

Self-modifying code

Probably the most exciting feature about this CPU is that it can write to its main memory, which is where its program is stored. This means it supports self-modifying code. Self-modifying code is the ability for the computer to alter its own code that it is running. This was very very annoying to get working properly.

Executing values in registers as instructions

The second most exciting feature of this CPU is temporary instructions. This means that the CPU can make a very temporary custom instruction and execute it while it's in a register instead of being in something permanent like main memory, which is much safer since it decreases the risk of accidental corruption of the program. This was mildly annoying to get working.

Memory

There are two memories, which are both 32-bit with 16-bit addresses. The main memory sits outside the CPU and is nonvolatile and stores the program to execute and data to save. The second memory is also located outside the CPU and is volatile and used to store temporary values that are needed when operating, for example cursor position. For the safety of the program and the user's mental wellbeing, the CPU cannot activate the reset pin on the main memory to delete its own program all at once, since if there was some dumb bug and the CPU deleted data that the user didn't have a copy of, that could result in severe depression because of how heartbreaking it would be for an entire program that you didn't have a copy of to be deleted in the blink of an eye. So yeah, better to be safe than sorry.

About the morbidly obese main memory

Since the only memory that can be edited by circuitry and be used as permanent storage (EEPROM) only supports up to 10-bit addresses and STRING32000 supports up to 16-bit addresses, I have decided connect 64 EEPROM, which in total supports up to 16-bit addresses, fully utilizing the CPU's address space.

STRING32 excel Assembler:

The documentation on how to program the CPU is in the assembler. To use it, you'll need to download it.

Link: https://1drv.ms/x/c/fa007333c2aab537/EUIHbqhMAVpLr7OQLWN3YP4BNOPuOfYEncFrDDHcGgUxyg?e=LO1VnA

-----------------------

This computer currently only runs one program where you can make 32x32 pictures in black and white, but I'll make more programs for it in the future.

Controls for 32x32 painter:

keyboard controls: WASD to move cursor, Q to display an image, E to toggle pixel between black and white.

stepper: Use to select the picture slot. There is a face drawn in slot 0

PWR and EN: toggle both on to run. PWR is the main switch and EN freezes the clock when disabled.

-----------------------

CREDITS:

Credit to Sanderokian Stfetoneri (author of Femto) for the fast clock circuit

FORK FOR BEST USER EXPIERIENCE

i have litory no idea how this works and i do plan on making a computer better then this but this made me scrach my head 

I made a bouncing ball, it took 130 lines of code 😭

performance is so bad because the clock is too slow