Unleash the Power: Programming GAL 22V10 for Homebrew Computers

Table of Contents

1. Introduction
2. Address Decoding on the BSX
3. Implementing the Logic in GAL
4. GALasm - a Low-Level Programming Language
5. Programming the GAL with a TL866II+ EPROM Programmer
6. Defining the Logic in GALasm
7. Implementing the Logic Table
8. Running the GALasm Utility and Generating Files
9. Programming the GAL with a ATF22V10C Chip
10. Troubleshooting and Updating Firmware
11. testing the Logic and Integrating it into the BSX
12. Conclusion

Introduction 🌟

Are you familiar with address decoding circuits? In this article, we will explore the process of address decoding on the BSX and how to implement it using a GAL (Generic Array Logic) chip. We will discuss the GALasm programming language, guide you on programming the GAL with a TL866II+ EPROM programmer, and troubleshoot any issues that may arise. Additionally, we will cover how to integrate the GAL into the BSX and test its functionality. So, let's dive in and unravel the secrets of address decoding with GAL!

Address Decoding on the BSX 💡

To understand address decoding on the BSX, we need to consider the inputs and outputs involved. The two main inputs are the Memory Request (MREQ) and A15. Depending on the combination of these inputs, we need to set the ROM and RAM chip selects accordingly. For example, if MREQ is low and A15 is low, the ROM chip select should be low and the RAM chip select should be high. On the other HAND, if MREQ is low and A15 is high, the ROM chip select should be high and the RAM chip select should be low. This address decoding logic will be implemented in the GAL using the GALasm programming language.

Implementing the Logic in GAL 🔧

GALS are mystical creatures programmed in a low-level language called GALasm. This language simplifies coding as long as we phrase the problem correctly. Thankfully, we have the GALasm utility that translates our human-readable code into a format understood by GAL programmers. To program the GAL, we will be using the trusty TL866II+ EPROM programmer. However, if you have a different brand or model, your mileage may vary. It's worth noting that GALs have various pins, including input-only pins, pins that can be input or output, power and ground pins. We will label the necessary pins for our address decoding implementation, including memory request, I/O request, and address lines.

GALasm - a Low-Level Programming Language 🛠️

Let's dive deeper into the GALasm programming language. It allows us to define the logic for our GAL chip and facilitates the translation of our code into the appropriate format. GALasm makes the implementation process straightforward, especially for address decoding. We can declare inputs, outputs, and intermediate signals using GALasm's syntax. Additionally, we'll use logical operators like NOT, AND, and OR to construct the logic table. It's important to declare the specific GAL device we are using, such as the GAL22V10.

Programming the GAL with a TL866II+ EPROM Programmer 💻

With our GAL logic defined in GALasm, it's time to program the GAL chip using the TL866II+ EPROM programmer. This versatile programmer supports GALs and can flash them with ease. Before we proceed, let's ensure we have the correct device and Pin information. By consulting the programmer's database, we can select the GAL 22V10, filtered by Atmel. With the programming setup complete, we can load our GALasm file, which generates the necessary files for programming and documentation. The GALasm utility allows us to generate files such as '.chp' and '.pin' for documentation purposes, as well as the crucial '.jed' file used to program the GAL.

Defining the Logic in GALasm 📑

To define the logic in GALasm, we start by labeling the pins of the GAL chip. With 24 pins on the GAL22V10, we assign labels to the necessary pins for our address decoding implementation. Inputs for memory request, I/O request, and address lines are labeled accordingly. For outputs, we assign labels to denote the RAM select and ROM select lines. The unused outputs will be labeled as not connected. This clear labeling of pins ensures smooth implementation and minimizes confusion during the programming process.

Implementing the Logic Table ⚙️

Now that we have labeled the pins and defined the logic in GALasm, it's time to implement the logic table. The logic table determines the behavior of the GAL chip based on the inputs provided. By carefully crafting the logic expressions using GALasm syntax and logical operators, we can map each input combination to the appropriate output. For instance, if the memory request is low and A15 is high, the RAM select should be low and the ROM select should be high. We must ensure the logic expressions accurately reflect the desired behavior in our GAL chip.

Running the GALasm Utility and Generating Files 📄

With the GAL logic defined and the logic table implemented, it's time to run the GALasm utility. This utility will process our GALasm file and generate the necessary files for programming and documentation. Among these files, the '.chp' and '.pin' files are particularly useful for documentation purposes as they detail the pin assignments and whether they are programmed as inputs or outputs. The '.fus' file provides a visual representation of the bits in the logic matrix, while the '.jed' file is essential for programming the GAL chip.

Programming the GAL with a ATF22V10C Chip 🧩

Now comes the exciting part - programming the GAL chip with the '.jed' file we generated earlier. We connect our EPROM programmer to the computer and ensure the correct device is selected based on the label of the chip. It's crucial to perform a blank check to ensure proper communication between the programmer and the GAL chip. Once the blank check is successful, we load the '.jed' file into the programmer and begin the programming process. After a successful programming, we can also verify the GAL to ensure the programmed logic matches our expectations.

Troubleshooting and Updating Firmware 🛠️

In the process of programming and verifying the GAL, we may encounter obstacles and unexpected results. We must troubleshoot these issues to ensure the GAL chip functions correctly. In some cases, the verify function of the programming software or the TL866II+ EPROM programmer may cause discrepancies. However, with proper software updates and firmware updates, we can resolve these problems. Keeping our programming tools up to date and ensuring proper communication between the programmer and the GAL chip is crucial for successful implementation.

Testing the Logic and Integrating it into the BSX 🧪

After successfully programming and verifying the GAL chip, it's time to test its functionality and integrate it into the BSX. We carefully connect the GAL chip to the Relevant components and wires, replacing the previous address decoding logic. Through a series of tests and observations, we can verify whether the GAL chip is functioning as expected. We can check the select lines for the ROM and RAM chips to ensure they behave correctly based on the inputs we provide. This thorough testing ensures that our GAL chip effectively decodes addresses and allows for seamless memory access.

Conclusion 🎉

Congratulations on successfully implementing address decoding with a GAL chip on the BSX! Through GALasm programming and the TL866II+ EPROM programmer, you were able to define the logic, program the GAL chip, and integrate it into the BSX. This process involved careful troubleshooting and testing to ensure proper functionality. By understanding the inputs, outputs, and logic expressions, you have gained valuable insights into address decoding circuits and GAL programming. Now you can unleash the power of GALs in your projects with confidence!

Resources:

• GALasm: GALasm Utility
• TL866II+ EPROM Programmer: TL866II+ EPROM Programmer
• GAL22V10 Datasheet: GAL22V10 Datasheet