Macintosh Digital Logic Simulator

The primary objective of this project was to develop a digital logic simulator specifically designed for the Apple Macintosh. The aim was to create a user-friendly environment where users could interactively design and simulate logic networks. This involved creating a system that enabled the placement of components like gates (AND, NAND, OR, NOR, NOT), flip-flops (D and JK), and signal sources. The circuit simulation process needed to be efficient and allow for immediate feedback, enabling users to modify their designs and rerun the simulation. The project emphasized the interactive development of circuits, highlighting the challenges of component placement and the interconnection of components using wires. A key feature was the implementation of output tracing, allowing users to monitor the circuit's behavior. The use of simulation was seen as a cost-effective alternative to hardware-based circuit development, significantly reducing expenses associated with building and testing physical circuits. The chosen platform, the Apple Macintosh, was selected for its strengths in interactive applications and its advanced user interface.

A significant portion of the project focused on the interactive aspects of circuit design. Users interact with the system by selecting components from a palette and placing them onto the screen using the mouse. These components are then connected using wires, also drawn with the mouse. The system facilitates this interactive circuit design process by providing visual cues and feedback. The ability to move selected components, delete them using the 'cut' function, and undo actions enhances the user experience. The underlying data structures manage components and their connections, using a doubly linked list in the current implementation. A notable feature is the use of invisible grid points for precise alignment of components, and the implementation of a ShapeSketcher command to manage the component creation and placement. This interactive approach prioritizes user-friendliness and efficiency in circuit design. The system also accounts for the need to define connection points for wires on different components. Wire drawing employs manual routing, offering flexibility over an automatic approach, but requires users to specify line segments. Careful consideration was given to the management of data structures to ensure efficient logic network simulation.

The other major part of the project involves the efficient circuit simulation of the designed logic networks. The software uses a three-level logic system ('high', 'low', 'undefined') to handle undefined inputs. A 'transform' method is employed to compute component outputs, which are subsequently sent through connected wires using a 'SetSignalState' method. The algorithm assumes that all logic devices have the same delay. To deal with the practical impossibility of simultaneous updates, each wire stores both 'current' and 'next' signal values. The use of probes allows users to monitor signal values on specific wires at the end of each gate cycle; these values are then used to generate traces in a dedicated view. The simulation process offers features for halting and restarting at any point, with a 'reset' option to begin from the initial state. The implementation included a continual 'DoIdle' method to manage tasks like menu updates and simulation step execution. This circuit simulation process provides real-time feedback, improving the digital logic simulator user experience.

The simulator's development leveraged MacApp, a software development tool from Apple, which simplified the creation of the user interface elements. This framework, written in Object Pascal, provided many standard objects and methods useful for GUI development, reducing development time. The document discusses the importance of Object Pascal in implementing the simulator, highlighting the creation of custom objects for components and wires to support the interactive circuit design and simulation. Document objects store circuit information, while window and command objects manage the user interface. The system used custom command objects, such as ShapeSketcher, WireSketcher, ShapeDragger, and ShapeSelector, to handle mouse interactions and component manipulation, allowing for a highly responsive user experience and enabling the capabilities of the Macintosh platform to facilitate this interactive approach to digital logic simulation. The use of templates (TGate and TFlipFlop) reduces code duplication in object implementation.

The Macintosh's highly developed user interface was a key reason for its selection as the platform for this digital logic simulator. The interface's strengths lie in its organization of information into 'documents,' a concept similar to files. Each document represents the application's data. Users interact with a portion of the document displayed on the screen, manipulating data directly within the view. The mouse is the primary tool, allowing users to move a cursor to select and move objects, enabling seamless interactions within the application's windows. The most prominent features of this user interface are windows and menus, ubiquitous in almost every Macintosh application. The intuitive design of the Macintosh user interface was critical in facilitating an interactive approach to circuit design and simulation.

The Macintosh user interface, with its windows and menus, facilitates dynamic interaction. Menus are context-sensitive; some menu items are disabled depending on the application's state. For example, a 'delete' command is disabled when no objects are selected. Menus also indicate the current state; for instance, a checked item in the menu may show whether the data is displayed in binary or hexadecimal format. Windows display information, showing a portion of the document's data at a time; users can scroll to view different parts. Multiple windows can be open simultaneously, allowing for a multi-faceted view and flexible management of information. The 'active' window receives all user input, making the system highly responsive. The menu bar at the top of the screen displays menu titles, allowing users to access commands instantly. The intuitive use of windows and menus in the Macintosh environment is crucial for building a highly intuitive experience for interactive circuit design.

The mouse is integral to the user interaction in the system. The mouse allows for direct manipulation of objects within the active window. Objects selected within the active window are considered the 'active selection' and are typically highlighted visually. Commands generally operate on this selection. For instance, deleting objects requires selecting them with the mouse and then choosing the delete command from a menu. When placing new objects, the active selection often acts as an insertion point, and the position of new components is indicated by a rectangle that follows the mouse cursor. This direct manipulation approach using the mouse, combined with clear visual cues and immediate feedback, makes the user interface intuitive and efficient for circuit creation and modification, enhancing the interactive aspects of circuit design on the Macintosh platform. This interaction approach was integral to the design of the application.

The development process for this application was significantly eased by the use of MacApp, a development tool from Apple. This tool handles many basic application features, including code for reading and writing data from files, printing document content, and generically managing the creation of windows and menus. Building upon MacApp significantly simplifies application development compared to building from scratch. MacApp is written in Object Pascal, an extension of Pascal incorporating object-oriented programming concepts. This object-oriented approach greatly enhanced code organization and reusability. Standard objects (document, window, view, and command) are provided, with the ability to customize or extend functionality as needed. This focus on efficiency in the implementation of the application greatly benefited the development of the interactive aspects of the circuit design application on the Macintosh.

The circuit view is the core of the interactive circuit design process. It provides a window where users can build circuits by selecting components from a palette and placing them using the mouse. A key aspect is the ability to connect components by drawing wires between them. The system is designed to provide a clear visual representation of the logic network, enhancing the user experience during the circuit design process. The palette includes common components like AND, NAND, OR, NOR, NOT gates, D flip-flops, JK flip-flops, pins (for inputs and outputs), and probes for monitoring signals. The system supports deleting components using a 'cut' command and allows for the easy movement of components using the mouse. An 'undo' function provides error correction, allowing users to quickly revert to previous states. The circuit view uses an invisible grid to ensure accurate component placement. The use of the mouse for component placement, wire drawing, and component selection makes this aspect of the system inherently interactive and user-friendly. This interactive circuit design approach greatly improves workflow efficiency.

The efficient management of components and their interconnections is crucial. Internally, the system employs a doubly linked list to represent all components within the circuit view. When a new symbol (component) is created, it is added to the end of this list. While the current implementation doesn't order the symbols, the document notes that ordering may be beneficial when simulating large circuits. Each component has defined connection points to which wires can be attached. A FindConnectPoint method determines the closest connection point to the mouse cursor when a wire is connected. The system supports the removal of components; the 'cut' command eliminates both components and their associated wires. To prevent issues with 'dangling' wires, the system manages data structures to ensure that the system maintains structural integrity. The use of Object Pascal and the object-oriented design of the software promotes an elegant and manageable approach to data management, supporting the real-time nature of the interactive circuit design process.

Connecting components involves drawing wires. The system supports manual routing, where the user creates line segments by clicking the mouse. This approach, though requiring more user input than automatic routing, offers flexibility in wire placement. Each wire segment is stored as a separate object, with start and end points. The wire object itself contains a pointer to a list of these line segments. This detailed representation ensures accurate tracking of connections during simulation. To maintain the logical structure, each component object has pointers to all connected wires, and wires maintain pointers to the components and other connected wires. This ensures that the system maintains the correct wiring information. This careful management of wire connections is crucial for accurate signal propagation and is a key feature in supporting efficient logic network simulation. The choice of manual routing balances the benefits of user control and system accuracy.

The circuit view allows for flexible component selection and manipulation. The mouse is used to select individual components, or groups of components using area selection. Selected components can be moved by dragging them with the mouse; a rectangle indicates the area affected. A ShapeDragger command object handles these movements, automatically aligning components with the grid. Component selection is efficiently managed using a Hit.Detect method, which avoids requiring precise clicking on the component itself. This method defines a small rectangle around the clicked point, checking for intersections with component boundaries. For area selection, a ShapeSelector command is created, tracking mouse movements to identify components within the selected area. These command objects, and methods, manage various aspects of interaction within the circuit view, and enable the sophisticated manipulation of components and wires in an intuitive and interactive manner. The functionality of naming components is also mentioned.

The core of the simulator is its algorithm for circuit simulation. The simulation process begins by taking user-specified inputs from signal sources (pins). The simulator then calculates the new state of the system by iteratively processing each component. This involves using a 'transform' method for each component, calculating the output values based on its input values and the logic function it performs (e.g., AND, OR, NOT). A three-level logic system ('high', 'low', 'undefined') is employed to manage undefined inputs and outputs. Signal propagation is managed by updating the 'state' of each wire; this updated signal is then used in the subsequent simulation steps. The 'transform' method is designed to update component outputs and send these values through connected wires. The entire simulation process is designed to be responsive to user interaction, allowing users to pause, restart, and reset the simulation at any point, all managed through the user interface. This efficiency is key in providing a responsive circuit simulation tool.

The simulator aims for simultaneous updates of all components during a single gate cycle. This assumes equal delays in all logic devices. However, to deal with the practical limitations of simultaneous updates, each wire stores two values: the 'current' state (from the last gate cycle) and the 'next' state (calculated in the current cycle). This strategy enables the system to handle asynchronous updates and signal propagation correctly. The 'current' state of a wire represents the value at the end of the previous simulation step, and is used as input to the next iteration. The use of a SetSignalState method ensures signals propagate to all connected wires, managing the flow of information effectively through the entire logic network. The careful consideration of these details in managing the circuit simulation ensures efficient and accurate results. This aspect of the design showcases sophisticated planning in the implementation of the digital logic simulator.

The simulator provides various controls to manage the simulation process. The 'Halt' command stops the simulation at the end of the current step. The 'Run' command resumes the simulation, starting either from the halted point or from the beginning after a 'Reset'. The 'Reset' command reinitializes the system, resetting signal sources to their initial values and performing other necessary initializations. To monitor signals, probes are placed on wires in the circuit view. Probes capture the signal values at each gate cycle, storing this information for later analysis and display. The 'DoIdle' method, called repeatedly, handles various background tasks, including menu management. During simulation, it calls a procedure to perform a single step, ensuring efficient resource utilization and timely updates. These various control mechanisms and features, such as output tracing using probes, provide users with fine-grained control and extensive feedback during the circuit simulation process. The simulation process is responsive and intuitive to use for the design of digital circuits.

The circuit simulation involves using signal sources, implemented as pins. These pins can serve as inputs or outputs depending on their connections. While output pins have no special functionality beyond their connections, input pins act as signal sources for connected wires. The system uses a dedicated trace view to display the signals captured by the probes. The trace view has a name panel showing the names of all probes and an area where the signal traces for each probe are shown. The system is designed to ensure that the user has real-time feedback about the operation of the circuit during the logic network simulation. While the full trace view was not implemented by the time of the report, the structure and functionality are well-defined. The system's design shows the importance of feedback in the development of an effective digital logic simulator

At the time of the report, not all planned features were fully implemented. The simulator and trace view, while conceptually designed, existed only in a detailed outline form. The circuit view, while mostly completed, still required debugging. The incomplete nature of the simulator and trace view presents significant limitations to the overall functionality of the digital logic simulator. This highlights the complexity involved in developing a fully functional circuit simulation tool. The lack of a fully functioning trace view directly impacts the system's ability to provide comprehensive feedback to users during logic network simulation. Further development is required to address these limitations and provide a more complete and reliable digital logic simulator.

A key limitation of the current implementation is that gates are restricted to exactly two inputs. This is a significant constraint on the complexity of circuits that can be effectively modeled. To address this, the report suggests allowing gates to accept variable numbers of inputs. This enhancement would involve modifying the methods of the TGate object to handle a dynamic number of inputs. The 'transform' method for each component would also require modification to accommodate this change. Another crucial area for improvement is the addition of the ability to define macrocircuits. This feature would allow users to create complex circuit elements, which are internally represented as collections of components, but appear as single units. This would greatly enhance the system's usability and capability for modeling large and complex logic networks. Further enhancements suggested include the ability to rotate circuit symbols and improve the appearance of some components.

The report identifies the location of connection points as a major problem to overcome in future development. The connection points on gates would need to be dynamically adjusted based on the number of inputs each gate has. The transform method would also require adjustments to handle a variable number of inputs for each component. The document mentions other tasks needed to fully complete the project, including testing and debugging the existing code. The circuit simulation aspects need to be rigorously tested, and the visuals of components refined to improve usability. Hardware issues such as a damaged disk and corrupted source file also affected the project’s completion; these technical challenges highlight the complexities associated with software development. The completion of the digital logic simulator requires resolution of these technical obstacles and significant further development.