Close
0%
0%

DSKY

Create a working DSKY using a 3D printer and my AGC simulator running on a Raspberry Pi and slave Arduino Nanos.

Similar projects worth following
This project is designed to build a working model of the Display Keyboard (DSKY) portion of the Apollo Guidance Computer. The model utilizes 3D printed parts and 2 LCD screens along with a Raspberry Pi and 3 Arduinos. The DSKY will be capable of running the actual AGC assembly code internally using simulator code or connect to a hardware version of the AGC I am building as another project.

Objectives:

1) Build a realistic a DSKY using 3D printing.

2) Have the DSKY operate running the original assembly code.

2a) Standalone operation using an internal simulator.

2b) Connect to an AGC to drive the DSKY.

Background:

I have been working for two years on another project to build an Apollo Guidance Computer.  I built a hardware level simulator that runs the actual assembly code provided by Ronald Burkey.  https://www.ibiblio.org/apollo/   Ron created an assembler and has most versions of the source code on his web site.  I modified his assembler to output Motorola S-Record files that can be burned into EPROMs.  Ron also provides a simulator, but his simulator does not drive down to the hardware level.  I built a hardware simulator that utilizes the Control Pulse Matrix to control the simulation.  From this effort I developed a set of schematics that utilize 7400LS TTL chips.  I am in the process of wiring chips together, a long, slow and tedious process.

Part of the AGC is the DSKY.  I have a working DSKY using TTL chips driving 7-segment LCDs and 19 generic keys.  I learned a lot about the use of TTL chips, but I am unsatisfied with the look of the DSKY.  After building a paper model of the DSKY I decided to put my modeling skills to work to 3D print a realistic model of the DSKY.  Fortunately there are a number of people on this site that have 3D printed a DSKY using the actual NASA documents as reference.  

Build Decisions:

The first decision was do I use the guts of the AGC DSKY to drive a simulation or utilize more modern technology?  If I use what I already have developed for the AGC project then this model will only work with the AGC attached.  If I use modern microprocessors to drive a pair of LCD screens then I get a better looking model and I have the ability to run the simulator software internally, thus providing a working standalone model as well as a DSKY for my AGC project.  I will go down the modern processor path.

The second decision is do I drive everything with a Raspberry Pi, Arduino or combination thereof?  My Earth Rover project utilized a Raspberry Pi as the "big brain", providing a web site to drive the rover and an Arduino as the "small brain" to interface with all the sensors and motors.  This is the perfect solution for this project.  I got a 3 for 2 deal on Arduino Nano Everys and decided to use a Nano to drive each of the displays and the third to drive the keyboard.  The Raspberry Pi can set up a WiFi hotspot so can remotely log in and control the simulation.

Technology:

To accomplish this project I needed to learn a CAD program and how to 3D print.  The CAD program I chose was AutoDesk's Fusion 360 as this is free if you are a hobbyist and not a for profit company.  The learning curve for what I needed to do was relatively easy.  I purchased a 3D printer from FlashFusion, the Guider 2S.  The printer needs to be large enough to print a part that is 8" x 8.25" x 3".  After a few screwups on some smaller parts, I got the hang of it quickly.  Note that some of the larger parts take over 34 hours to print.  

As a software engineer, my favorite language is Java, therefore the Raspberry Pi software is mostly Java.  Ardiunos have their own language which is C based and easy to use.  Most every device you purchase for this sort of hobby has Arduino libraries, making coding very straight forward.  I created my own simple protocol between the Raspberry Pi and the Arduinos.  For Java development I would suggest a free IDE such as Eclipse or IntelliJ Idea.  

Tagged Image File Format - 1.37 MB - 07/15/2022 at 21:12

Download

TrueType Font - 18.39 kB - 06/29/2022 at 19:03

Download

  • 1 × Raspberry Pi
  • 3 × Arduino Nano Every
  • 2 × LCD Screen (HXD8357D)
  • 3 × 6" USB cable To connect Arduinos to Raspberry Pi
  • 75 × M3x6x5 Inserts

View all 23 components

  • 26-Pin Connector

    wglasford07/20/2022 at 14:46 0 comments

    For those of you that just want to run the DSKY using the internal software simulator, congratulations!  Your model is complete.  For those of you that want to connect to an external AGC, you will need to wire up the 26-pin connector.  

    The external AGC I am working on is comprised of TTL chips and therefore uses 0-5v voltage levels.  The DSKY uses a Raspberry Pi that is CMOS based and uses 0-3.3v levels.  This requires voltage level conversion on the lines.  There are many solutions from making your own from discrete components to using fancy chips.  The Channel bus lines are bidirectional.  I chose a simple yet clean solution, pre-manufactured boards using MOSFETs.  You can pick up a bag of five 8-line converters for under $10.  Two are required for the Channel bus and two are required for the control lines.  

    KiCad did not have a symbol for this level converter so I chose a device that is essentially the same except it has an output enable pin that I didn't use.  

    Here are the level converters installed with double sided foam tape. There were no mounting holes, but a smooth back.  

  • Run as a Service

    wglasford07/17/2022 at 21:05 0 comments

    To make this a stand-alone DSKY you need to run the two processes (DSKY and AGC simulator) as services.  This is fairly simple on a UNIX variant, in this case I am using Rasbian, the default OS for a Raspberry Pi.  Start by running as root and cd to /etc/systemd/system.  Now copy the two files I have out on Git hub named AGC.service and DSKY.service.  To auto run the AGC you will also need a file named command.file.  I placed this file in /home/pi/virtualagc/yaAGC but you can place it just about anywhere and name it almost anything.  The important thing is that it contains a single line with the text "run".  Here is the AGC.service text.

     After=multi-user.target

    [Service]

      Type=idle

      WorkingDiretory=/home/pi/virttualagc/yaAGC

      ExecStart=/home/pi/virtualagc/yaAGC/yaAGC ../Luminary131/Luminary131.bin --command=/home/pi/virtualagc/yaAGC/command.file

    [Install]

      WantedBy=multi-user.target

    The description is simply a name you give this service. 

    Now that you have the two services in place, you need to reload the daemon.

    > systemctl daemon-reload

    Now enable both services.

    > systemctl enable AGC.service

    > systemctl enable DSKY.service

    Now every time you reboot the two services will start and the DSKY will fire up and you can start using it right away.  If you don't want to reboot you can start them by using the following commands.

    > systemctl start AGC.service

    > systemctl start DSKY.service

    You can also stop the services in a similar way.

    > systemctl stop DSKY.service

    > systemctl stop AGC.service

  • Model Polish

    wglasford07/15/2022 at 21:16 0 comments

    I added a nameplate to the back, just to make the model more realistic.  There is a thin part named NamePlate that I 3D printed.  There is also a file named NamePlate to print on thick card stock.  Glue the paper name plate to the 3D name plate.  I colored the side of this assembly with silver paint and then glued this to the back of the DSKY.  To make it even more realistic, I dug up four small screws with rounded heads and cut the heads off and glued them to the four corners of the name plate.  

  • Software Improvements

    wglasford07/15/2022 at 15:18 0 comments

    The first improvement is to simplify the indicator commands between the Pi and the Arduino.  Instead of splitting out the channel 11 and channel 10, relay word 12 writes into separate commands on the Pi, I modified the interface to send a single command each to the Arduino and let the Arduino sort it out.  Here is the following new command structure.  The Display and Other indicators command send the command followed by a number.  Ex: "3 20" is used to light the ALT and PROG indicators.

    0    Noop

    1     Reset to power on state

    2    Identify

    3    Display Indicators:

              NO ATT : bit 0

              GIMBAL LOCK : bit 1

              PROG : bit 2

              TRACKER : bit 3

              ALT : bit 4

              VEL : bit 5

    4    Other Indicators:

              UPLINK ACTY : bit 0

              KEY REL : bit 1

              OPR ERR : bit 2

              TEMP : bit 3

              STBY : bit 4

              RESTART : bit 5

    I always seem to do my best thinking at night when I am asleep.  Woke up this morning and realized that checking for a clock pulse on the clock line is not a good way to check for the presence of hardware since the hardware can be in debug mode and you can stop the clock, step the clock or not even have the hardware running yet.  A better way to do this is to use one of the unused hardware pins as a H/W Present pin.  I will configure that pin on the Raspberry Pi with the internal pull-up resistor.  If the hardware is connected, it will pull that pin low signaling the presence of hardware.  I have also decided to have my hardware simulator run external to the DSKY, thereby simulating the hardware through its 26 pin connector.  This means I will modify the way the Raspberry Pi starts up.  By default there will be no arg, an arg will only be used if you wish to run the internal test.  The software will check the H/W Present pin and if low take inputs from the 26 pin connector, if high it will connect to the internal software simulator.

    The interface to the Display Arduino has been modified to simplify this interface as well, pushing the decode logic to the Arduino.  Here is the new command structure.

    0    Noop

    1     Reset to power on state

    2    Identify

    3    Display command

    4    COMP ACTY indicator

    5    Flash Verb/Noun

    The display command takes the 15-bit Channel 10 values, all except relay word = 12 which is routed to the Indicator Arduino.

    I also simplified the program interface.  If no argument is supplied, the internal software simulator is used.  If "--TEST" is supplied then the internal test is executed.  In the near future the software will check one of the GPIO pins for a H/W Present signal which will cause the code to interface with the 26-pin connector.  Either the hardware AGC or hardware simulator will connect to this pin.

  • LCD Version 2

    wglasford07/13/2022 at 17:32 1 comment

    Now that I have Ron's simulator up and running, I realize the SPI interface to the LCD is too slow.  The interface is too slow to get the Verb/Noun flashing to work.  My next step is to get the 8-bit interface working between the LCDs and the Arduinos.  I will now take one of the LCDs out, solder up the 8-bit connector and breadboard that to see how much faster it runs...  

    And the results are in!  The 8-bit is not any faster and in some cases slower than the SPI.  Both interface libraries have graphics test programs but they are a bit different.  I took the 8-bit test program and modified it to run using SPI and performed a run-off using the same code for both interfaces.  Here are the results.  Times are in seconds.

    TestSPI8-bit
    Screen Fill3.0970482,758792
    Text0.1684320.356892
    Lines2.7375406.946940
    Hor/Vert Lines0.2609360.278024
    Rectangle(outline)0.1479640.172116
    Rectangle(filled)7.5503767.670884
    Circles(outline)0.9880201.851536
    Circles(filled)1.1444722.950412
    Triangle(outline)0.5318561.316972
    Triangle(filled)2.9964523.605184
    Roundtangle(outline)0.4215240.920348
    Roundtangle(filled)7.5626087.917336

    So despite the AdaFruit documentation claiming the SPI interface is 2 to 4 times slower than the 8-bit, I don't believe it.  Maybe this is because the Arduino Nano Every uses a newer ATMega4809 processor versus the older ATMega328P processor.  I had assumed the SPI interface pushing bits across the interface would be significantly slower than pushing 8-bits at a time.

    The numbers don't lie so I will stick with the Nanos and look at improving the code performance.

  • Software

    wglasford07/05/2022 at 19:18 0 comments

    I have tested the three Arduino's software with test code on the Raspberry Pi.  The Arduino code is out on my GitHub website.  https://github.com/bglasford1 

    There are 3 Arduinos: Display, Indicators and Keyboard.  The display and indicators wait for a command from the Raspberry Pi, execute the command and then wait for another command.  The first command for all three is an Identify command in which they respond with who they are.  This allows me to map the port to purpose as I am not guaranteed each Arduino will connect to a specific port name.  The Keyboard periodically scans the matrix waiting for a key press.  When a key is pressed it sends a notification to the Raspberry Pi.  I used a matrix scheme versus connecting each switch to a digital input because the Arduino has 13 digital input pins and I need 19.  The switches are arranged in a 3x7 configuration.  This requires 10 pins.  I could have configured them into a 4x5 configuration that would have used one less pin but I kept the matrix simple and logical, keeping the keys as they relate to the matrix in their physical configuration.  

    An initial version of Java is out there on GitHub for the Raspberry Pi.  The software has a completely functioning Arduino interface.  The interface to the AGC has been fleshed out but not tested.  In its place is a test class that runs the Arduinos through their paces.

    The DSKY code interfaces with either an internal simulated software AGC or via the 26-pin connector.  The 26-pin connector is used to connect a hardware AGC implementation or a hardware simulator.  There is also an internal test program which can be executed by providing an argument of "--TEST".  

    I am now working on getting Ron's simulator working with the DSKY.  His simulator has a separate DSKY module with a software protocol based on the real interface.  The real interface has a 15-bit Channel bus and various control lines directing where the data should be routed based on channel number.  I view it as memory mapped I/O.  The DSKY deals with five channels (as defined by NASA).

    Channel 10: AGC to DSKY: Used to send display updates 2 characters at a time plus indicators.

    Channel 11: AGC to DSKY: Used to send indicator status.  Not sure why 1/2 are here and 1/2 in ch10.

    Channel 13: AGC to DSKY: Test lights and STBY indicator.  (Ron put this into his fictitious ch163.

    Channel 15/16: DSKY to AGC: Sends one key code at a time when a key is pressed.

    Channel 32: DSKY to AGC: Used to send a PRO key press.  

    Channels 13 and 32 have other functions as well that the DSKY doesn't care about.  Note that Channels 15 & 16 are the same format.  The Command Module had two DSKYs, hence two channels for key presses.  I am implementing DSKY #1, therefore I only use ch15.

    Ron's interface combines the 15 bits of the channel register along with a 7-bit channel number plus a "u" and "t" code that are set to zero for the DSKY.  He packs this into four bytes with the first two MSBs of each byte used to define the sequence of four bytes.  The following is the format of the four bytes (both directions).  "p" denotes channel number and "d" denotes the channel data.

    00utpppp 01pppddd 10dddddd 11dddddd

    The details of all this can be found at https://www.ibiblio.org/apollo/developer.html or at my GitHub site in the AGCBlockIIComputer wiki pages.

    The code using Ron's simulator is now working and code updates have been made to GitHub.

    Here is how to load, compile and run Ron's simulator.  The instructions on his site are a bit old and the version of wxWidgets has changed.

    1) Install these packages: sudo apt-get install wx3.0-headers libwxgtk3.0-gtk3-dev libwxgtk3.0-gtk-0v5 libncurses5-dev liballegro4-dev git

    2) Load his code: git clone https://github.com/virtualagc/virtualagc

    3) cd virtualagc

    4)...

    Read more »

  • Painting Model

    wglasford07/01/2022 at 22:48 0 comments

    This model needs to be painted to look as realistic as possible.  I am using Bondo to smooth out the visible surfaces when the model is assembled.  Once the Bondo surfaces are sanded I will paint all surfaces with a gap filling primer, sand again and then paint the pieces with as realistic a paint as I can find.  

    I have started the Bondo process.  Here is a picture of the initial Bondo application of some of the pieces. 

    Once it dries overnight I sand it down to 220 grit and clean it up.  

    The paint arrived and I sprayed it.  You will notice that I enlarged the font of the keys and reprinted them.  I'm getting better at mixing the dye into the epoxy and filling in the characters.

    The case is complete!  As is the keyboard.

  • Switches/Keyboard

    wglasford06/27/2022 at 14:17 0 comments

    The switches are the hardest to get right.  Fortunately I had a starting point thanks to M. DeSilva and his DSKY replica.  From what I can gather, he put the spring inside the housing.  I could not find a spring that would fit so I placed the spring on the outside.  I also used screws to secure the microswitch instead of force fitting them onto plastic posts.  I used 3mm white LEDs.  I modified the key caps using a Gorton font I found at https://github.com/dakotafelder/open-gorton.  I had to convert the .otf file to a .ttf file so it would work with Fusion 360. I used a small amount of white dye added to epoxy to fill in the back side of the key caps to make the letters white and to allow light to show through.  Here are pictures of the switch pieces and three views of the switch.

    For the large nut that holds the switch assembly down I created the nut in the CAD system and then scaled it up, something like 10%, I don't remember the exact value.  Without the scale up the nut was too tight a fit.  To install the set screws, instead of scaling up the threads I chose to simply tap the hole for a perfect fit.  I first drilled each hole to 3/32" and then tapped them with a 6-32 tap.  For the smaller holes that hold down the microswitch I did not have a 2-56 tap in my set so I drilled those holes with a 5/64" bit and simply installed the screws.  The plastic is pliable enough that the screw made its own threads.

    The keys are now mechanically working.  I had to sand the surfaces that grate against each other to eliminate that strange rasping sound.  The set screws had to be adjusted so the keys are level with the front cover.  I'm not happy with the way the key covers came out, all except the + and -, those are OK.  I changed the font to Gorton Heavy and scaled the size up.  

    The keyboard wiring was simple enough.  I chose to go with a matrix solution even though there is enough input pins on the Arduino to connect  each switch to its own pin.  Here is a schematic of the keyboard.

    And here is a picture of the back side of the keyboard.  I not only laid in 19 diodes, there is also 19 resistors to reduce the brightness of the LEDs.

    I forgot to mention the LEDs.  I used the smaller 3mm white LEDs.  Solder two wires to the leads.  You only need to shrink wrap one of the leads.  The wires get pushed through the center of the switch as in the picture below.

  • Hardware

    wglasford06/26/2022 at 17:01 0 comments

    Here is a picture of my AGC DSKY from the AGC project.  It is not the prettiest thing, but it works.

    From this effort I decided this would be a much better model if I used a pair of LCD displays instead of the 7-segment LCDs and backlit indicators.  Besides, the 7-segment LCDs cannot display a plus.

    Here is the first cut at the indicators panel, much better looking than the display above.  I need to work on the colors of the indicators.  The display is from Adafruit, a 3.5" LCD display.  

    Here are the display LCD under test.  I connect them using SPI and created a simple protocol to identify each one upon initialization.  

    The LCD displays both connect to their respective Arduino in the same way using SPI.  There is an option of using 8-bit mode as well, however that mode is seriously more complicated so for now I have gone with SPI mode.  It is 2 to 4 times slower.  I will have see once everything gets wired up and working if that is acceptable.  For SPI mode you have to solder the IM2 jumper closed.  Here are the connections between the LCD and the Arduino.

    Arduino
    Pin
    LCD
    Acronym
    Wire ColorUse
    GNDGNDBlackGround
    5V3-5VWhitePower
    D13CLKGreyClock
    D12MISOPurpleMicrocontroller In/Serial Out
    D11MOSIBlueMicrocontroller Out/Serial In
    D8CSGreenChip Select
    D9D/CYellowData/Command Select
    RSTRSTOrangeReset
    LiteRedBacklight on/off (on by default)

    Here is an example of keyboard logic: https://www.gammon.com.au/forum/?id=14175. The DSKY has a 7x3 keyboard thus requiring 10 digital input pins. I could have connected each key to its own pin but found this solution more interesting if I ever find myself needing to implement a larger keyboard.  I used the 1N4148 fast switching diodes.  Each column needs a pull-up resister. Note that the Arduino has an internal pull-up resistor that can be utilized.  Here is a schematic of what I wired up.

    Part of making the model realistic is to use a military style jam nut connector on the back.  I need 24 pins to connect the DSKY with the AGC.  There are 26 pin connectors available and they look exactly like the original.  The pin-outs I will use are:

    Pins A-R: 15 bit Channel Bus

    Pin S: CLK1: Clock 1 pulse

    Pin T: RST: Reset the DSKY

    Pin U: STBY: Put DSKY in Standby mode

    Pin V: KBD1: Get Keyboard data

    Pin W: DISP: Display data on the channel bus

    Pin X: INDC: Indicator data on the channel bus

    Pin Y: RPRO: Read PRO key

    Pin Z: KB_STR: Keyboard data is available

    Pin a: PARALM: Parity alarm

    Pin b: H/W Present

    Here is the jam nut and its connector, very cool.

    I have installed and tested the Arduinos.  Here is the backside of the Front Housing showing everything assembled.

    And here is the Main Housing bolted onto the front with the Raspberry Pi installed.  So far I have a test program and have put the Arduino interface protocol and the Arduinos through their paces.  Everything is good to go.  Notice that next to the main connector I installed a micro USB port.  On the original DSKY there was a bicycle tube air valve so they could fill the interior with pure nitrogen so a spark would not cause a fire.  

    The only thing left to do hardware wise is to solder a 40-pin ribbon cable to the main connector and the 5V/GND connectors that back light the keys.  

  • 3D Printing

    wglasford06/26/2022 at 16:57 0 comments

    3D Printing:

    Having never owned a 3D printer, I purchased a printer and started taking my modeling abilities to the next level.   After learning a few important lessons in 3D printing (mistakes), I was up and running.  It takes a day or more to print the larger pieces so I worked on the switches and their many parts while periodically printing the larger parts.  

    Thanks to M. daSilva and others I have put together what I believe is the best collection of solutions for this model.  What you will notice is that the parts have cryptic ID numbers.  These numbers came from the original drawings.  Looking at the collections of various parts out there, there seems to be some parts with multiple ID numbers.  What helped me understand this device is I purchased the paper model and assembled it.  I learned two things assembling this model:  1) understanding how the parts fit together and 2) I never want to build another paper model. 

    The following is a list of the parts I printed.  I start out with a name of the part followed by the file name.  The parts are listed in order from back to front to aid in assembly.  Files that say "exact" are unmodified by me.  Files that say "modified" are files that I modified.  There are other files that relate to the key assembly and mounting the Arduinos that are not original.  I have placed the CAD files out on my GitHub site.

    Rear Cover : 2004900-exact-COVER,REAR

    Rear Cover Gasket : 1006349-exact-GASKET,RETAINED

    Main Housing : 2004974D-modified-PLATE,IDM

    Main Housing Gasket : 1006350A-exact-GASKET,RETAINED

    Front Housing : 2004968E-modified

    Arduino Mount : ArduinoMount  (attaches to underside of front housing)

    Adapter Plate : 2004919E-modified-PLATE,ADAPTER

    Adapter Plate Gasket : 1006351-exact-GASKET

    Display/Indicator Block : 1006315G-modified

    DIsplay/Indicator Cover : 2004699A-modified

    Front Cover : 2004929-exact-COVER,FRONT

    Key Body : 2004949D-exact-HOUSING

    Key Housing : 2003926-reconstructed-HOUSING

    Key Shaft : 2004948B-modified-SHAFT

    Key Nut : Nut

    Key Caps : (19 files located in the Keys sub-directory)

    Here is the first significant part I printed, the front cover.

    And here is the front and back of the adapter plate.  Notice the inserts used to screw the pieces together.  I use a hand held torch to warm the inserts and then carefully push them into the plastic using a long screw, taking care to keep the insert perpendicular while the plastic hardens.  You can also see that I created two holes to route wires from the LCD panels to the Arduino Nanos.  

    I won't show every part but here is the front 1/3 of the DSKY which consists of 11 printed parts.  I have installed one of the LCD panels.  The other one is being used to develop code.  

    To mount the LCDs I needed to make the opening in display covers a bit smaller and I modified the underlying block to press fit the LCD board and create a hole for the wires to pass.  Notice that I cut off the mounting tabs of the display to get the display to fit under the cover.  

    Here is the back cover finally complete.  It took 36 hours to print. Since this part is supposed to be black and it came out so well, I probably will leave this part as is.

    I have now completed the 3D printing of the parts and have assembled them to test the fit.  Everything came together perfectly.  Here are some pictures of the plastic.  I did not install the keys yet because I am still waiting for paint to be delivered.  

View all 10 project logs

  • 1
    Overview

    If you have ever purchased and assembled a model you will discover quickly that there are no step by step instructions.  It is best to concentrate on specific areas of the model and create sub-assemblies that can then be assembled into a complete model.  The following are the sub-assemblies.

  • 2
    Switches

    Print and assemble one switch.  When you are satisfied, repeat the steps 18 more times.  

  • 3
    3D Model

    Print the rest of the 3D parts.  Install inserts.  This was fairly straight forward.  Verify fit as you print each part.

View all 8 instructions

Enjoy this project?

Share

Discussions

Jrsphoto wrote 07/26/2022 at 03:37 point

Hey Bill, I've created an Adobe Illustrator vector of the name plate.  it's not 100% spot on but its pretty close.  A PDF version of the file is here:

https://drive.google.com/file/d/1-yWVgDu6LiZ6LjtDXnz8Zys22EiaarBl/view?usp=sharing

It should open up in Illustrator (Or likely InkScape) with two layers.  1st layer is the name plate tiff file you have, second layer is the vector.

While I wait for some large 3d prints to arrive, I've got some thin copper clad PCB board that I'll etch the name plate into. I print the design onto laser pcb transfer paper and with a lamination machine iron it onto the PCB and etch the boards.   I've done this before with other projects and they come out pretty nice.  I'll make 3 or 4 of them so if you want one, let me know.

  Are you sure? yes | no

wglasford wrote 07/26/2022 at 13:47 point

I'm very interested.  I can't wait to see how it comes out.  It's always these little touches that really make a model.  

  Are you sure? yes | no

Jrsphoto wrote 07/26/2022 at 15:56 point

I'll post some pics when I get them done

  Are you sure? yes | no

Jrsphoto wrote 07/16/2022 at 16:20 point

I've been re-watching the CuriousMarc videos and it seems that the cad models (from virtualagc that most are based on) don't seem to match what I see in the videos.  The main keyboard frame file 2004968E.step and bracket 2004919E.step are both slightly different from what I see in the videos.  Your version of those files differs from the virtualagc file as well, which I get.  What I don't get is why the MIT designs don't match what I'm seeing in the videos.  There must have been multiple versions of the Block-2 designs.  You can see the differences pretty clearly in this link: https://youtu.be/feRCZyLzAwA?t=369

  Are you sure? yes | no

wglasford wrote 07/16/2022 at 18:59 point

I noticed that, not sure why the one out on virtualagc seems off.  I double checked some of the pieces with the NASA documents and my version matches.  It also looks the same from a keyboard standpoint as the real thing in the CuriousMarc video.  I knew my two LED screens were smaller than the real thing.  They were the largest I could find that would fit.  It appears their mounts stick out a little too far.  You may want to fix that by making the mounting block behind them a little shorter.  I may fix that after I get everything else working.  I would be interested if you find any larger LCD screens that still fit.  

  Are you sure? yes | no

wglasford wrote 07/12/2022 at 21:18 point

Here's something to think about while you are building this.  Why are the keys on the DSKY so large?

  Are you sure? yes | no

Jrsphoto wrote 07/15/2022 at 18:12 point

I've watched all of CuriousMarc's youtube videos on the AGC they restored and he covers this.  Its so the astronauts  could hit the buttons with gloves on. 

  Are you sure? yes | no

wglasford wrote 07/15/2022 at 18:35 point

Yes, that's it.  It's a good thing they are so big.  It would be much more difficult to get them to back light if they were much smaller.  

  Are you sure? yes | no

Jrsphoto wrote 07/16/2022 at 02:50 point

How are you lighting your keys, I don't see led's in your keyboard pics

  Are you sure? yes | no

wglasford wrote 07/16/2022 at 13:50 point

Oops, forgot to talk about that.  I added a picture at the end of the switches log.  You need to use the smaller 3mm white LEDs.  Solder a pair of wires to the leads.  The space is tight so use the smallest gauge wire you can find.  To save space you only need to shrink wrap one of the leads.  I would also use the same small wires for the microswitches as the tunnel they have to go through is really small.  The LED wires get pushed through the center post of the switch.

  Are you sure? yes | no

Jrsphoto wrote 07/12/2022 at 19:39 point

Ok, Thanks.  It will take me a while to print the bigger pieces.  I'm considering sending the front panel and keys printed at Shapeways, but the remainder of the parts I'll print on my Voron or with my resin printer.  Once I have a better idea how things fit together, I'll look at a PCB.  Your right though, not a lot of room.

  Are you sure? yes | no

wglasford wrote 07/12/2022 at 20:03 point

I'm very happy with the way the front turned out using Bondo and airbrushing it.  It did take 36 hours each for the two large pieces to print.  Let me know how this is working out for you.  

  Are you sure? yes | no

Jrsphoto wrote 07/12/2022 at 20:11 point

Will do.  Thanks for all your work on this.  That's a lot of hours in Fusion 360 ;-)

  Are you sure? yes | no

Jrsphoto wrote 07/12/2022 at 17:35 point

This is a nice build and something I've been wanting to try.  I've downloaded the DSKY files from github and I'd like to start printing some of the parts.  I'd also like to design a PCB for the 3 Arduino's with jst connectors for the displays and keyboard.  Do you have any pictures you can post of the boards your using now?  I'd like to see some pictures of the boards installed in the case so I can have some idea of how they mount. - Thanks

  Are you sure? yes | no

wglasford wrote 07/12/2022 at 18:47 point

I created an Arduino mount you print out.  Solder the pins that come with the board to the board itself.  These pins then slide into the slots of the Arduino mount, at least the unused pins. The few pins I use are bent out at a right angle.  Maybe not the cleanest way to mount an Arduino, but the space between the two pieces was limited.  The picture of the mounted Arduinos are at the end of the Hardware log.  The picture at the end of the switches log shows the Arduino mounts.  You can see the slots for the pins.  You may be able to print up a right angle plate and screw the Arduinos to that plate in place of where I mounted them.  Here is a video that gave me the idea for this mount.  https://www.youtube.com/watch?v=CViy2QeS7nc I use screws to attach the mount and not double sided tape as he suggests.

  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