close-circle
Close
0%
0%

YGREC-РЭС15-bis

YG's 16bits Relay Electric Computer, rebooted

Similar projects worth following
close
For administrative reasons, I shelved the project "YGREC16 - YG's 16bits Relay Electric Computer". All the background is still available there and I continue working here instead.

This project is the first to implement the ideas of AMBAP, using old russian SPDT relays.
This is an experimental architecture, surfing the neovintage and electropunk wave that imagines a world without transistors. Old technologies can still yield new techniques, such as the Capacitively-Coupled Pre-Biased Relay Logic (CCPBRL), MUX trees with balanced fan-in, a new algorithm to compute the Game of Life, and I refine the YGREC's architecture!

It's also a warning for the young generations : Kids, don't waste your time with SPDT relays !
Use DPDT instead ;-)

You will find a lot of background information in #AMBAP: A Modest Bitslice Architecture Proposal and #YGREC16 - YG's 16bits Relay Electric Computer, this new project contains the latest developments since April 1st.


Logs:
1. Evolution of the architecture
2. DRAM (again)
3. PROM boards
4. Assembler and disassembler
5. I hope that's enough
6. First DRAM array prototype
7. The Program Counter's circuit
8. Tubular bell
9. Flip Dots !
10. Electromechanical User Interface : the Assembler board
11. How to drive РЭС15 relays with a computer ?
12. Programming the YGREC
13. Carry chain considerations
14. I hope that's enough this time
15. The instruction register (cont'd)
16. Now it should be enough
17. I can see now
18. Instruction display panel
19. Relay DAC
20. Display technology again
21. Chime on me...
22. DIY backplane construction


Let's build a computer. Literally a bare metal computer, that is also funny and ridiculous !

  • Ridiculously slow (20 IPS ?)
  • Ridiculously greedy ( >200W)
  • Ridiculously noisy (OK, that's actually desirable)
  • Ridiculously incompatible (it's a brand new architecture called YGREC that I develop at the same time)
  • Ridiculously limited (512 words of DRAM, a bit more instructions)
  • Ridiculously unreliable (I added 2 parity bits)
  • Ridiculously useless (except to compute the Game of Life to prove my point that ridicule doesn't kill)...

It started almost as a joke one year ago with #SPDT16: 16-bits arithmetic unit with relays but the joke was on me and the fun, the learning, the charting of new design spaces have slowly changed my approach to computer design.

Now I have a complete architecture, an instruction set, all the needed essential parts, and I continue to put things together in the logs. In parallel, every new breakthrough is reinjected in such projects as #YASEP Yet Another Small Embedded Processor and #F-CPU (which was rebooted thanks to this project).


The YGREC architecture is pretty simple and designed to use as few resources as possible, yet run the #Game of Life bit-parallel algorithm efficiently (though it's not the original goal or purpose, there was none in fact, it was just "loooook those cute relays must be fun to use!")

The datapath is shown below : The 16 registers (including PC) are accessed as the SRCX operand while only 8 registers are read as the SRC operand (because such a large MUX uses a LOT of relays). The narrower SRC operand can be shifted/rotated, or substituted with an immediate value from the opcode. Both operands are then processed in the ALU (either in ROP2 mode, where all combinations are possible, or in Add/Sub mode where comparison, carry and Min/Max are possible). The result is checked for being zeroed, and sent back to the register set.

Really, it can't be smaller or simpler while preserving functionality (I'm not doing a Brainfuck computer, I'm interested in actual practical architectures)

The register set maps memory addresses, memory data, the Program Counter and Input/Output ports. Only R1-R4 and T1-T3 are "standard registers", making the YGREC a hybrid architecture: it looks like some classic RISC and also behaves like TTA (for operations other than Shift/ALU/ROP2). There is indeed no actual opcode, only 32 combinations for the ALU and 16 Shift/Rotate combinations to care about. The architecture is highly orthogonal, all the essential operations can be achieved with a combination of the available fields and special registers. All the instructions are predicated, except CALL which replaces the condition "NEVER". In this case, the result goes to PC, while PC+1 goes to the register set.

The YGREC can be reduced to MUXes and DFF registers (which can also be made with MUXes). This maps perfectly to dual-throw relays !


Some characteristics (if you haven't read the other project) :

  • Based on a bitslice architecture, with 18 bitplanes (16 data bits and 2 parity bits, one bit per byte)
  • Uses about 3000...
Read more »

circuit-20170426-1850.circuitjs.txt

DRAM Circuit to simulate with http://www.falstad.com/circuit/circuitjs.html

plain - 5.57 kB - 04/26/2017 at 18:18

download-circle
Download

  • 3000 × РЭС15 Low voltage, russian SPDT mini-relay
  • 10000 × 100µF 25V electrolytic capacitors 5mm or 6mm diameter
  • 10000 × BAV99 Dual diode, SOT23
  • 768 × DIP Switches 8 positions (that should be enough for more than 1K instructions)
  • 200 × 1N4148 Diodes

View all 7 components

  • DIY backplane construction

    Yann Guidon / YGDES07/10/2017 at 01:57 0 comments

    The computer contains 18 vertical boards, all joined by a horizontal backplane: see the log Structural sketches


    The vertical "bitslices" boards can be easily made as 20 identical boards so they are quite cost effective. However the backplane is large, complex and costly. Prototyping will be hard...

    Fortunately I found 18×30cm perf boards on ebay: cheap, large and easy to fix (though wiring it all will be another marathon).

    Now, there is a little issue : how can one wire everything on both sides of the board ?

    The point of this log is to document the solution : it's not one board but actually two similar boards where the wiring is on one side and the connectors are on the other side. Both boards are then joined together, on their wiring side, using mating connectors, so neighbouring cards can communicate.

    (insert sketch here in the future)

    Overall, I get a 300mm wide backplane, which is enough for the width of 9 bitslices: one inch or 25.4mm is enough for one board, 9 boards take 23cm and there is margin on both sides. For long bitslice boards (the DRAM will take some room...) I can add more such cards. All the wiring can be inspected and modified as needed.

    This system can be adapted to other implementations of the YGREC architecture :-)

  • Chime on me...

    Yann Guidon / YGDES06/22/2017 at 22:39 0 comments

    After the not-success of the previous tubular bell system, I went searching for a better electromagnet and a better chime. Thank you eBay !

    I received two chimes, both made in China but with different quality and different notes. I think I'll use both :-) One for user signals and one for system errors.

    They are shorter, with a higher pitch than the tubes. The more expensive one sounds better but the sustain might be a bit too long :-DI might use it for the system errors.

    The operate horizontally, suspended by strings. They work even better upside-down ! This is fortunate because the the electromagnets I have found have no spring to hold the hammer back. But gravity is enough (when the coil is totally de-energised) so there is no spring to add. It's a very fortunate combination of mechanical parameters.

    The electronic circuit is pretty simple : a charge capacitor is being held at +12V (through a current-limiting resistor) and a SPDT switch (either mechanical or a relay) discharges it through the 30 ohms coil. 1000µF is a good compromise, I tried 470µ and 2200µ and both have issues...

    I didn't implement it but I should add a diode (top of the diagram): this would dissipate the energy in the coil for a faster return to standby position.

    You can hear the sound in this obligatory video:


  • Display technology again

    Yann Guidon / YGDES06/13/2017 at 12:04 2 comments

    Foreword: this page led to the creation of #Numitron Hexadecimal display module


    I try to stay true to the project's philosophy, which implies the use the technology that was available in the 40's and 50's (or at least, would make sense). Relays, incandescent lamps, carbon resistors, electrolytic capacitors are fair game (even though I use capacitors that are way more sophisticated than what was available then). Good silicon diodes appeared in the 60s-70s but are deemed indispensable so they are OK'd.

    Vacuum tubes are in the spirit as well but not my taste : I don't want to have 200V in some wires, or to have to generate any high voltage. 24V is already high enough for me ! So this rules Nixie tubes out (they require 130 to 200V depending on the models).

    That's sad because Nixies give a really vintage look that adds a lot to the "charater" of the processor as a piece of ... bizarre stuff. And Nixies are interesting because you just need to power one out of 10 electrodes, which fits my decoding system rather well.

    Another kind of Nixie tubes used VFD and work in the 30 to 60V range, which is more acceptable, but they require some power for an electrode (?) and they are organised as 7 segments. The nice side is that they can display hexadecimal digits, but they need a 4->7bits decoder which adds more complexity...

    So the digital non-7segments displays are a requirement (at least for the instruction disassembler board). This brings us to the "Edge-Lit Displays" and the #"Lixie", an LED alternative to the Nixie Tube where one (out of ten) panel is turned on.

    While searching for different kinds of Nixies, I found this beauty on eBay: 3x IND-1803 Edge Lit Incandescent Displays and 1x IND-1818 nixie tube era (seller boilingflask2426) I guess the "nixie" keyword brought me there... Look at this beauty :

    The auction is finished but the page still describes the display modules thusly:

    "

    Up for sale is a lot of 3 IND-1803 edge lit displays and 1 IND-1818 display with drivers in good used condition. This is an obscure model of display that has plates with dimples placed in the shape of numbers. The plates are bent back to lightbulbs on the back of the display, when a bulb is lit, the light travels down the plate and lights up the holes. One photo shows the display with the cover removed so the plates can be seen. The IND-1803 displays 0 through 9 and the IND-1818 displays 0 and 1, so there enough displays here to make a 4 digit clock if you can live without 24 hour time. You could also replicate the 3 digit timer from the bomb in the James Bond 'Goldfinger' movie, the prop for which used this style of display. These displays still have their driver cards attached, which includes the hard to find board mount connector for this part. Note that these are the models that have two dots located on either side of the digit instead of a comma, which is good if the buyer intends to use these for a clock. The look of this display with the cover removed can really only be described as "totally awesome".

    "

    More display porn can be found http://www.industrialalchemy.org/articleview.php?item=1093

    I'd love to have a similar system for the #Clockwork germanium !

    Unfortunately this doesn't look possible at this moment...

    And then I stumbled upon another style of "Nixie" tube, I could even qualify as the "poor man's Nixie" but not in the derogatory sense. Let me introduce you to the IV-9, a Soviet-era tube clone of RCA's Numitron, that encloses 8 incandescent filaments to form a lovely, funky 7-segments display. It's not as classy as the usual Nixie but it looks so vintage!

    The look is one thing, the electrical characteristics are another : each segment draws 17 to 22mA, under 3.15V to 4.5V. This is totally compatible with the power supplies of the YGREC-РЭС15 ! With the keywords "IV-9"...

    Read more »

  • Relay DAC

    Yann Guidon / YGDES05/23/2017 at 17:43 0 comments

    Some people have already implemented relay-based DACs (such as the sound card of TIM-8) so there is nothing groundbreaking here. However, since it's my first relay-analog converter, a log was important! I had shelved the galvanometer-hexadecimal-display in the last log, but I now have the voltmeter so I had to test it.

    I chose a model with a wide display area and screws on the front so I can easily modify the display grades. It's lousy but it seems to work.

    Then I tested the display against a known good source and it actually works well.

    The resistance is measured with an ampmeter in series at 10V: 0.976mA, or R=10245 ohms. This gives an estimate of the required resistors in the R/2R ladder, the relative error and the power that it draws (hint: low).

    I don't know exactly yet how I'll provide 16V (the galva uses 15V but the R/2R ladder drops 1V minimum) but several rails that can be combined, for example the difference between the +6.6V and the 24V rail is about 17V, a series potentiometer (5K ?) will adjust the needle. The differential supply will certainly fluctuate quite a lot and heavy filtering (regulation, capacitors and/or diodes ?) will be required...

    The display is quite large and slow but cheap and easy to use so it is not suitable for the main display but can serve for auxiliary display...

  • Instruction display panel

    Yann Guidon / YGDES05/20/2017 at 11:08 0 comments

    After I completed the instruction switch panel, came the necessity to build the corollary: the panel that displays the instructions. I had a sketch but soon realised that the system used too many relays, making it both power-hungry and expensive. For example, the hexadecimal display with 4 digits requires 16×4 LEDs, no big deal, but also 15×4=60 relays to demultiplex the nibbles ! According to the display:

    there are

    • 2 × MUX4 (3 relays each)
    • 2 × MUX8 (7 relays each)
    • 2+4 × MUX16 (15 relays each)
    • 1 × MUX32 (31 relays)

    so the total is 141 relays, or 4 boxes of 36 pieces, with some pretty high fanouts (despite knowing strategies to balance them). This also uses a significant amount of PCB surface !


    Discussing with @Dr. Cockroach about a similar concern with his #IO - The Inside Out Cardboard Computer - bis, (he uses a servo to point to one out of 16 numbers), I came to the conclusion that I should try a galvanometer. It's reasonably cheap and simple : a R/2R network driven by one relay per bit, and you're done.

    However readability is not great and despite having found a 0-15V model (which is great for displaying from 0 to F), this causes the other problem of getting 15V (actually 16 !) in the first place... See the rest in the log Relay DAC


    Then I realised that I got the initial MUX thing wrong.

    The light dots can be either a LED (which is a diode) or a Glühbirnchen (which can be wired in series with a diode). I couldn't find suitable flipdot elements (too large, harder to drive) so let's stick to diody elements.

    MUX4 isn't really a problem with only 3 relays but... This can be reduced to only two ! The LED can be arranged in a 2×2 array with one relay for the rows and another for the columns. It's only one relay saved per MUX4 but the fanin is just one coil per bit.

    The same idea can be extended to the MUX8 : one MUX2 for the rows and one MUX4 for the columns. But wait ! the MUX4 is already an array, so we need to go in the 3rd dimension... With LED, this is easy as connecting them in pairs with reverse polarity. As a result there is one relay for the 2 rows, one relay for the columns, and one relay that selects between +3V and -3V. 8 relays are saved. Splendid !

    For MUX16 however, I'm not sure a 4th dimension exists... This forms the bulk of the display, the CND and SRC fields can use single-dotted display but the IMM field (4 hexadecimal digits) would be awesome with 7 segments (I'm ok with the diode matrix). At this point I'm forced to use a "standard MUX4" for the row, with 3 relays instead of two, and one bit has a higher fan-in than the others (which is quite annoying because I'd love all the board's bits to have a single coil fan-in). I could cheat with a DPDT relay but no model matches the RES15's characteristics. Anyway, MUX16 is reduced from 15 relays to 5, thanks to diodes !

    MUX32 would use two standard MUX4 and total 3+3+1=7 relays instead of 31. Impressive what some careful design can do :-)

    Total : 2×2 + 2×3 + 7 + 6×5 = 47 (instead of 141), this is totally reasonable....

    I'm concerned however about the imbalance of fan-in between the various bits, this makes the design more complex. I could add resistors in series to balance the single coil signals but it's wasteful...

    Another concern is the digital display : bipolar matrices don't ease 7-segments decoding. I'm thinking about the #"Lixie", an LED alternative to the Nixie Tube approach but I'd need a tiny version and readability would be worse than the large displays...


    20170323 : OK, another simplification : what if the digital display was in octal ? This would save 4 relays (though unlike Seymour Cray I'm not an octal guy).

    Even more desirable: more input signals will have a fan-in of one coil.

    This leaves a couple of MUX16 and one MUX32...

    I'm trying to come up with a "4th dimension", and I was thinking about...

    Read more »

  • I can see now

    Yann Guidon / YGDES04/26/2017 at 17:59 2 comments

      @roelh was suspicious that my "new DRAM array" would work.

      It took him a while and conviction, and it was difficult to wrap my head around it.

      I'm too lazy to finish the prototype, but it would be useless for 2 reasons :

      1. Probing the capacitors would disturb the array and storage
      2. I don't have enough channels to observe a 16×16 array !

      So I resorted to simulation.


      Spoiler alert : @roelh was right. But why ?

      After I did the experiments, I realised that I was influenced by the flipdot array and impressed that it could drive several rows at the same time. Using the re-steering diodes makes sense.

      But the rows are always driven so the current "loop" that roelh identified don't occur. In my case however I leave many rows undriven. And the simulation shows really bad consequences.


      In practice...

      Just go to http://www.falstad.com/circuit/circuitjs.html and "import from local file" the circuit that I have uploaded.

      Click on the push buttons and the SPDT switches to steer the current. You'll see the capacitors' charges vary. I added a bit of ESR to reduce the pulses. Be ready for some ... lag. The simulator gets confused after a few manipulations and I have already encountered errors...

      I have "probed" all the capacitors (with virtual scopes) to check that charging one doesn't influence the others.

      I have chosen a topology of double binary tree because I don't want the data to have too much fanout. Using the recent tree command topologies, the double tree is actually practical and has a fairly balanced fan-in.



      Conclusion : I must reorganise the DRAM geometry.

      The double-tree that selects the row is a big burden which shouldn't increase so I consider reducing the rows to only 8 per bitplane. In parallel, there are 18 bitplanes with 8 rows each, which amounts to 18×14=252 relays.

      As a consequence, the backplane must handle more columns : 512/8=64 columns, or 64 relays. It must withstand the simultaneous switching current of 18×100µF so I consider using a small series resistor to mitigate the transients.

      I think about building DRAM modules made of 8 rows and 16 columns.

  • Now it should be enough

    Yann Guidon / YGDES04/22/2017 at 09:03 2 comments

    That moment when you order 5 lots of 2K diodes, and you receive a pretty large reel of 10K diodes.

    "normal" reel size for scale.

    The DRAM should be covered now, and there is only 1 part and 3 soldering joints instead of 4 soldering joints and 2 parts.


    I also received the KOA diodes in SSOP24. The 1100 pieces should be enough for about 730 instructions. Good thing I extended the PC to full 16-bits width :-)

  • The instruction register (cont'd)

    Yann Guidon / YGDES04/20/2017 at 09:41 2 comments

    Here is one of the 24 bits of the instruction register.

    3 relays each amount to 72 relays.

    The instruction bus uses 6V signaling to provide more swing into the capacitor, but not enough to damage the diodes (the KOA diode networks are limited to 7V in reverse polarity).

    The sensor is made more sensitive by charging the capacitor with a higher voltage swing, bringing more charge to upset the coils. The middle point is centered by resistors, but large capacitors are required to keep the ends at a somewhat constant voltage. I got a stock of 1500µ capacitors so the swing ratio is at least 1/10.

    The reduction of the current on the instruction bus is pretty important. If 60mA per bit was required, then a INV instruction (FFFFFFh) would draw 1.5A ! Hopefully this is now reduced to about 10mA, or 240mA for a full FFFFFFh instruction. This increases the longevity of the parts...

    I'll have to prototype the above circuit !

  • I hope that's enough this time

    Yann Guidon / YGDES04/17/2017 at 21:23 1 comment

    I just received a pretty large package.

    That's 750 8-positions DIP switches.

    with 24-bits words, that's approx. 256 instruction words, or 4 boards of 64 instructions...

    Or 8 boards of 32 instructions, to fit in a 16×20cm board :

    However there's a little gotcha:

    The DIP package must be slightly too large because they don't fit well on a 2.54mm pitch board.

    Once again this proves that you must have your definitive parts before you commit to a final design ! I'll have to adjust the snap grid size when I do the PCB layout. This also shatters my hope to make a nice compact prototype, 2.4mm will be lost for every row...

  • Carry chain considerations

    Yann Guidon / YGDES04/17/2017 at 09:48 0 comments

      The incrementer and the ALU are becoming the critical parts of the whole system and the length of the carry chain will affect the operating speed. In itself, the clock speed is not a goal (the thing is already sooo sloooow that you can see it think, which is all the point). However, the faster it runs, the faster it can scan and refresh the memory, which is quit a big deal. If I can manage to get 25IPS (approx 2× faster than the Harvard Mark II), then it still requires 10 seconds to scan 256 words, 1/3 of a minute to refresh the whole 512 words of DRAM. And refresh only happens when the processor doesn't access the memory, a full refresh could last one minute. I haven't yet evaluated the retention time of the DRAM but I feel I'm pushing the design in uncharted territories.

      With 100µF capacitance, a 1µA leakage will make a time constant of approximately 100s which, depending on parts tolerance, where the leaks go, the actual rate and current of leakage etc. This is pretty close to the above quoted minute and I'm concerned.

      The new instruction register introduces a "latched sensor" which has several interesting benefits but one major consequence over the overal design: the processor is now pipelined, with fetch, execution and DRAM cycles being overlapped. The clock sequencing is pretty simple now : 2 phases, which directly drive the temporary storage caps of the DFF. There is no funky sub-cycles anymore. The complexity is now relegated to the software because data access and jumps are now delayed. I should add a 25th instruction bit to tell the program sequencer to wait for one more cycle until data are available...

      The speed is now limited by two main factors:

      1. the carry chain delay
      2. the time to fully charge the latching capacitors of the DFF

      As I have already examined, the charge time depends on several factors, such as the charging voltage and the series resistance, so they can be somewhat adapted. The carry chain length is however a more structural problem. If a relay switches in 4ms, a chain of 4 relays will need 16ms to propagate, and I would ideally keep it under 20ms. Add to this about 10ms to charge the caps then switch them to the coil, and we have about 30ms of cycle time, or 30Hz.

      To reach this speed, the critical datapath must be under 6 relays.

      My problem is that the РЭС has a rather low fanout capability and it wouldn't drive 15 coil loads. I guess a reasonable fanout is 4, though I remember I estimated 3 when I started the #SPDT16: 16-bits arithmetic unit with relays project.

      Of course, less fanout is better and the LSB relay (bit 0) will take all the heat, vibrations and load so it must be particularly carefully designed (or it might break).

      @Tony Robinson has explored a particularly interesting approach: a OR-chain made of diodes that could greatly accelerate the propagation in my case. However the diode drops are significant, let's assume 0.8V for the 1N4148 and this becomes quicly impractical. And the fanout problem is not solved, the first diode will take all the current to drive all the coils in the chain... I could cheat by using high power Schottky diodes though but it wouldn't remove the high current draw when all the chain is ON.

      Apparently I am forced to use a segmented approach. Naturally the 16-bits incrementer is split into 4 equally sized segments, but not identical: the LSB have a high fanout while the MSB have a high fanin. I can also mix with a diode here and there to reduce the complexity/size/cost/consumption a bit. With this scheme, the propagation time might drop to 2 coils delay, but the incrementer will use a LOT of relays...

      The linear approach is slow, the fast approach (O(n²)) is prohibitive, so a hybrid approach is considered, using 4-bits segments. Hopefully, the fanout is not excessive and the cascade time is 4 coils (in the 16ms range).

      I have a drawing in my head, I'll need to refine it...


      Update 20170420: I made...

    Read more »

View all 23 project logs

Enjoy this project?

Share

Discussions

Frank Buss wrote 04/30/2017 at 07:40 point

Are you sure about 10000×100µF 25V electrolytic capacitors? Looks like they are surprisingly cheap, found them for 3 Euro-cent at Digikey ( https://www.digikey.de/short/3nz34z ), but why not ceramic capacitors? Self discharge would be much lower and they would last forever. If you don't need 100 µF, it can be even cheaper, and smaller, e.g. 10 µF for 2.6 cent and 0805 package ( https://www.digikey.de/short/3nz349 ). But of course, for such a quantity it might make sense to ask the manufacturer or search on AliExpress.

  Are you sure? yes | no

Yann Guidon / YGDES wrote 04/30/2017 at 09:12 point

Hi Frank !

For the DRAM : 100µF is the result of my early experiments with CCPBRL. And yes they're cheap, I got them on eBay but at that price, ESR and leakage are not guaranteed :-P

Ceramic capacitors : not for this case, for several reasons. Main one being that capacitance drops with voltage. Ceramic capacitors can sustain the rated voltage OR preserve capacitance, not both for high value. 

25V is required because I need to charge the capacitor as much as possible to a) allow for some leakage and b) store as much energy as possible to upset the sense relay. The sense coil is biased around 12V so it needs a strong pulse to change state, lower than 12V or higher than 12V. So I charge the capacitors to 0V and 24V.

I should experiment with it soon...

  Are you sure? yes | no

Ulysse wrote 04/21/2017 at 16:34 point

I love relays.  Bravo !

  Are you sure? yes | no

Yann Guidon / YGDES wrote 04/21/2017 at 22:07 point

Who doesn't ? :-)

  Are you sure? yes | no

thekidtonystark wrote 04/20/2017 at 23:28 point

Do I have to put everything to a pitch board?

  Are you sure? yes | no

Dylan Brophy wrote 04/11/2017 at 13:15 point

Hey, I noticed you wrote "Kids, don't waste your time with SPDT relays ! Use DPDT instead ;-)". I'm just curious, but why?

  Are you sure? yes | no

Yann Guidon / YGDES wrote 04/11/2017 at 23:46 point

I explained this on the #SPDT16: 16-bits arithmetic unit with relays project :-)

SPDT is one switch per coil, DPDT is 2 switches per coil, better "fanout" and a direct reduction in the cabling and drive current. A MUX or adder uses half the number of relays compared with SPDT. You don't need hysteretic hacks. Etc.

But well, I chose the rope that will hang me in this project and I must stick to it :-D

Learn from my mistakes, kids ! :-P

  Are you sure? yes | no

Hacker404 wrote 04/05/2017 at 10:09 point

You've probably already though of this but ... 

You can get switch banks that are actuated from above rather than from the side. There are press toggles and slide on - off and they will bunch up more closely. 

Are the switches for the bootloader? It would be great if they were. 24 to 32 words could do it or even less with the instruction bit width you have chosen. 

All looks great!!!

  Are you sure? yes | no

Yann Guidon / YGDES wrote 04/05/2017 at 19:29 point

Well, I did the rough placement with the switches I have in stock, and I have 41 of these. what matters is the width, I wanted to see if it fits.

I'm expecting to receive a "suitable quantity" of "normal" switches (I bought the piano because "hey, it's unusual, it could be a lifesaving part, you never know" :-D)

There is no bootloader : execution starts at address 0 and reads whatever instruction is stored in the board plugged in the corresponding slot.

There will be several slots with detachable cards, so you can put "PROM" (programmable with switches) or "ROM" (soldered diode arrays), change their address... Maybe even create a small library (in the physical sense of the term) of routines that you will plug when you need them :-D

But that's for a coming log...

  Are you sure? yes | no

Yann Guidon / YGDES wrote 04/17/2017 at 21:11 point

Look at the latest log, you'll see what I mean with "a lot of switches", as I just received them ;-)

  Are you sure? yes | no

Hacker404 wrote 04/17/2017 at 22:17 point

Wow!! You could put the entire boot code in DIP switches and still have most of them left. 

  Are you sure? yes | no

Yann Guidon / YGDES wrote 04/17/2017 at 22:36 point

I don't consider this as "bootcode" but enough for a small but interesting program :-)

I'll spread the switches over several independent modules so I can pull one, program it and put it back, to test code  before I solder it with diodes...

  Are you sure? yes | no

Similar Projects

Does this project spark your interest?

Become a member to follow this project and never miss any updates