Pick And Place Hack Chat

February 7, 2022 by Dan Maloney No comments

Join us on Wednesday, February 9 at noon Pacific for the Pick and Place Hack Chat with Chris Denney!

We in the hacker trade are pretty used to miracles — we make them all the time. But even the most jaded among us has to admit that modern PCB assembly, where components that could easily hide under a grain of sand are handled by robots, borders on witchcraft. The pick and place machines that work these wonders not only have to hit their marks accurately and precisely, but they also do it at blinding speeds and for days on end.

Luckily, even those of us who design circuits for a living and depend on PCB assembly services to realize those designs can, at least to some degree, abstract the details of the pick and place phase of the process away. But making it “just work” isn’t a trivial task, and learning a little bit about what it takes to do so can make us better designers. Plus, it’s just plain cool to watch a pick and place do its thing. And to dive a little deeper into pick and place, Chris Denney, CTO of Worthington Assembly and co-host of “Pick, Place, Podcast” will stop by the Hack Chat. If you’ve ever wondered about the inner workings of PCB assembly and the role pick and place plays in it, or if you’re looking for tips on how to optimize your layouts for pick and place, this is one you won’t want to miss!

Our Hack Chats are live community events in the Hackaday.io Hack Chat group messaging. This week we’ll be sitting down on Wednesday, February 9 at 12:00 PM Pacific time. If time zones have you tied up, we have a handy time zone converter.

Continue reading “Pick And Place Hack Chat” →

The Linux X86 Journey To Main()

November 5, 2021 by Al Williams 7 Comments

Have you ever had a program crash before your main function executes? it is rare, but it can happen. When it does, you need to understand what happens behind the scenes between the time the operating system starts your program and your first line of code in main executes. Luckily [Patrick Horgan] has a tutorial about the subject that’s very detailed. It doesn’t cover statically linked libraries but, as he points out, if you understand what he does cover, that’s easy to figure out on your own.

The operating system, it turns out, knows nothing about main. It does, however, know about a symbol called _start. Your runtime library provides this. That code contains some stack manipulation and eventually calls __libc_start_main which is also provided by the library. Continue reading “The Linux X86 Journey To Main()” →

An Emulator For OBP, The Spaceflight Computer From The 1960s

November 1, 2021 by Donald Papp 9 Comments

[David Given] frequently dives into retrocomputing, and we don’t just mean he refurbishes old computers. We mean things like creating a simulator and assembler for the OBP spaceflight computer, which was used in the OAO-3 Copernicus space telescope, pictured above. Far from being a niche and forgotten piece of technology, the On-Board Processor (OBP) was used in several spacecraft and succeeded by the Advanced On-board Processor (AOP), which in turn led to the NASA Standard Spaceflight Computer (NSSC-1), used in the Hubble Space Telescope. The OBP was also created entirely from NOR gates, which is pretty neat.

One thing [David] learned in the process is that while this vintage piece of design has its idiosyncrasies, in general, the architecture has many useful features and is pleasant to work with. It is a bit slow, however. It runs at a mere 250 kHz and many instructions take several cycles to complete.

Sample of the natural-language-looking programming syntax for the assembler. (Example from page 68 of the instruction set manual for the OBP.)

One curious thing about the original assembler was documentation showing it was intended to be programmed in a natural-language-looking syntax, of which an example is shown here. To process this, the assembler simply mapped key phrases to specific assembly instructions. As [David] points out, this is an idea that seems to come and go (and indeed the OBP’s successor AOP makes no mention whatsoever of it, so clearly it “went”.) Since a programmer must adhere to a very rigid syntax and structure anyway to make anything work, one might as well just skip dealing with it and write assembly instructions directly, which at least have the benefit of being utterly unambiguous.

We’re not sure who’s up to this level of detail, but embedded below is a video of [David] coding the assembler and OBP emulator, just in case anyone has both an insatiable vintage thirst and a spare eight-and-a-half hours. If you’d prefer just the files, check out the project’s GitHub repository.

Continue reading “An Emulator For OBP, The Spaceflight Computer From The 1960s” →

The Epic Saga Of Hacking Knights Of The Round

June 8, 2021 by Tom Nardi 3 Comments

For the uninitiated, Knights of the Round was a hack-and-slash arcade game released by Capcom in 1991 that rather loosely followed the legend of King Arthur and the eponymous Knights of the Round Table. In it, up to three players make their way from stage to stage, vanquishing foes and leveling up their specific character’s weapons and abilities. But [Sebastian Mihai] was looking for a new way to experience this classic title, so he decided to reverse engineer the game and create his own version called Warlock’s Tower.

Those familiar with the original game will no doubt notice some of the differences right away while watching the video below, but for those who don’t have an intimate knowledge of Arthur’s digital adventures, the major changes are listed on the project’s web page. Among the most notable are the removal of cooperative multiplayer and stage time limits. This turns the game from a frantic beat ’em up to a more methodical adventure. Especially since you now have to compete the game in a single life. If we had to guess, we’d say [Sebastian] prefers his games to have a bit of a challenge to them.

Even if you aren’t interested in playing Warlock’s Tower yourself, the story of how [Sebastian] created it is absolutely fascinating. He started with zero knowledge of Motorola 68000 assembly, but by the end of the project, was wrangling multiple debuggers and writing custom tools to help implement the approximately 70 patches that make up the custom build.

The hundreds of hours of work that went into creating these patches is documented as a sort of stream of consciousness on the project page, allowing you to follow along in chronological order. Whether it inspires you to tackle your own reverse engineering project or makes you doubt whether or not you’ve got the patience to see it through, it’s definitely worth a read. If you’re a Knights of the Round fan, you should also take a look at the incredible wealth of information he’s amassed about the original game itself, which honestly serves as an equally impressive project in its own right.

Modified versions of classic games, known colloquially as “ROM hacks” are fairly common among serious fans who want to see their favorite games improved over time. While they aren’t always as ambitious as Warlock’s Tower, they all serve as examples of how a dedicated community can push a product well beyond the scope envisioned by its original creators.

Continue reading “The Epic Saga Of Hacking Knights Of The Round“ →

AVR Reverse Engineering Hack Chat

April 19, 2021 by Dan Maloney 10 Comments

Join us on Wednesday, April 21 at noon Pacific for the AVR Reverse Engineering Hack Chat with Uri Shaked!

We’ve all become familiar with the Arduino ecosystem by now, to the point where it’s almost trivially easy to whip up a quick project that implements almost every aspect of its functionality strictly in code. It’s incredibly useful, but we tend to lose sight of the fact that our Arduino sketches represent a virtual world where the IDE and a vast selection of libraries abstract away a lot of the complexity of what’s going on inside the AVR microcontroller.

While it’s certainly handy to have an environment that lets you stand up a system in a matter of minutes, it’s hardly the end of the story. There’s a lot to be gained by tapping into the power of assembly programming on the AVR, and learning how to read the datasheet and really run the thing. That was the focus of Uri Shaked’s recent well-received HackadayU course on AVR internals, and it’ll form the basis of this Hack Chat. Then again, since Uri is also leading a Raspberry Pi Pico and RP2040 course on HackadayU in a couple of weeks, we may end up talking about that too. Or we may end up chatting about something else entirely! It’s really hard to where this Hack Chat will go, given Uri’s breadth of interests and expertise, but we’re pretty sure of one thing: it won’t be boring. Make sure you log in and join the chat — where it goes is largely up to you.

Our Hack Chats are live community events in the Hackaday.io Hack Chat group messaging. This week we’ll be sitting down on Wednesday, April 21 at 12:00 PM Pacific time. If time zones have you tied up, we have a handy time zone converter.

Click that speech bubble to the right, and you’ll be taken directly to the Hack Chat group on Hackaday.io. You don’t have to wait until Wednesday; join whenever you want and you can see what the community is talking about.
Continue reading “AVR Reverse Engineering Hack Chat” →

Retrotechtacular: Design For Assembly, 1980s-Style

February 3, 2021 by Dan Maloney 23 Comments

To get its engineers thinking about design for assembly back in the 1980s, Westinghouse made a video about a product optimized for assembly: the IBM Proprinter. The technology may be dated, but the film presents a great look at how companies designed not only for manufacturing, but also for ease of assembly.

It’s not clear whether Westinghouse and IBM collaborated on the project, but given the inside knowledge of the dot-matrix printer’s assembly, it seems like they did. The first few minutes are occupied by an unidentified Westinghouse executive talking about design for assembly in general terms, and how it impacts the bottom line. Skip ahead to 3:41 if talking suits aren’t your thing.

Once the engineer gets going on the printer, though, things get really interesting. The printer’s guts are laid out before him, ready to be assembled. What’s notably absent from the table are tools — the Proprinter was so well designed that the only tool needed is a pair of human hands. And they don’t have to be particularly dexterous hands, either — the design favors motions that are straight down, letting gravity assist the assembly process and preventing assemblers from the need to contort their bodies. Almost everything is held in place by compliant mechanisms built into the plastic parts. There are a few gems in the film, like the plastic lead screw that drives the printhead, obviating the need to string a fussy timing belt, or the unique roller that twists to lock onto a long shaft, rather than having to be pushed to its center.

We found this film which we’ve placed below the break to be very instructive, and the fact that a device as complex as a printer can be assembled in just a few minutes without picking up a single tool is pretty illustrative of the power of designing for assembly. Slick designs that can’t be manufactured at scale are all too common in this age of powerful design tools and desktop manufacturing, so these lessons from the past might be worth relearning.

Continue reading “Retrotechtacular: Design For Assembly, 1980s-Style” →

Access An 8-bit Atari Through Twitter

October 11, 2020 by Bryan Cockfield 3 Comments

Building a retro computer, or even restoring one, is a great way to understand a lot of the fundamentals of computing. That can take a long time and a lot of energy, though. Luckily, there is a Twitter bot out there that can let you experience an old 8-bit Atari without even needing to spin up an emulator. Just tweet your program to the bot, and it outputs the result.

The bot was built by [Kay Savetz] and accepts programs in five programming languages: Atari BASIC, Turbo-Basic XL, Atari Logo, Atari PILOT, and Atari Assembler/Editor, which was a low-level assembly-type language available on these machines. The bot itself runs on a Raspberry Pi with the Atari 800 emulator, rather than original hardware, presumably because it’s much simpler to get a working network connection on a Pi than on a computer from the 80s. The Pi runs a python script that polls Twitter every two minutes and then hands the code off to the emulator.

[Kay]’s work isn’t limited to just Ataris, though. There’s also an Apple II BASIC bot for all the Apple fans out there that responds to programs written in AppleSoft BASIC. While building your own retro system or emulating one on other hardware is a great exercise, it’s also great that there are tools like these that allow manipulation of retro computers without having to do any of the dirty work ourselves.