 Greetings risk five friends. So last time we looked at this schematic, which is for a kind of a crossbar or a generic register slash buffer slash multiplexer. So this is one of eight boards that the sequencer uses in order to register something to the PC or the memory address or you know any of five registers and also multiplexes things to the X, Y and Z bus. So there are five registers three buses that makes eight total cards. So that's what this is. This is the printed circuit board layout. It's not quite complete. I made some modifications to it. But what I thought I'd do today is maybe just work through a schematic from pretty much the beginning. I guess we will start on the sequencer card because I have the cards that plug into the sequencer card. So it's cards that plug into another card that plugs into another card, which is the risk five base itself, I guess. So anyway, let's open up a new schematic and take a look at what we need to do. Okay, so before I start I just want to do a little bit of planning because I have that card and I'm going to represent the four connectors by these little doohickey things. And each of these connectors carries specific signals. Each connector can carry up to three 32 bit buses. There is also a four bit signal that you can use for anything. And then there's a reset signal and a clock signal. And you can have as many as four clocks on these things. So on the card, this connector carries the PC, PC plus 4, and the MTVAC. And the selection signal is a constant selector. So this is just a selector that can select any one of 16 different constants. Some of the constants are just shift amounts. And I only use a certain limited number of shift amounts. So 0, 4, 8, 16, and 24 to do various shifts in the instructions. Also, some of the constants can be trap causes. And I only use something like eight of those. So, you know, I can stuff a selection of a constant into a four bit signal. So that's what I'm using that four bit signal for. In addition, this one carries the phase two right signal, clock signal. So the next one down carries the temp register. It also carries the immediate value from the instruction. And it also carries the instruction itself. And in terms of select, well, it's free. I didn't have to use it for anything. So there's four extra bits that I can use. Same thing with the clock. Same thing with the clock. I didn't put anything on there. All of these carry the same reset signal. So all of them have a reset signal. Okay, so the third connector down carries mem data read, mem data write, and also the memory address. So really, this is kind of the almost all of the interface to the memory. There's a few other signals that just aren't on this particular card. And in terms of clock signals, I have phase one going there. And again, I don't use the select signals for anything. And then finally, on this final thing, we have the X, Y, and Z buses. For the select, we have an input select. And I don't use the clock signal on it. So that's effectively free. So the idea basically of one of these cards is you populate the chips for one particular function. And again, there are eight functions, five registers or the three buses. So let's suppose we're talking about bus X. So based on the selection signal, bus X can be fed with any one of these other 32 bit buses. So there's 123456789. Well, you can actually select also Y and Z. So that's 10 and 11. You can select a constant. So that's 12. And then there are a few modifications of some of these buses, like for example, Z can be shifted over by two. So that's 13. And let's see what else the empty that can be shifted over by two as well. So that's 14 signals. And X is 15 signals. And there's one more I'm missing. And I forget what it is, but I think it might be the memory address. Yeah, it's the memory address with the least significant bit zeroed out. So that's 16 possible signals. Now, the way I've made this is that for the registers, if you want to keep the value in the register as it is, you simply select that register as its input. So for example, for the PC, if I didn't want to change the PC, then I would select the PC register. Of course, if I did want to change it, like if I wanted to load it with PC plus four, I would select that. Now for the buses, the buses are a little bit different. If I they're not registers, of course, they will just be buffered out to the X, Y, and Z bus. And of course, there are other cards that share those buses. So if the sequencer needs to output something onto a bus, then it selects whatever input it needs. But if the sequencer wants to not put anything on the bus and free it up for some other card, then it puts the bus itself on the bus. And there's just special logic on the card to prevent anything from going out to the bus. So for example, if I had the card for the X bus, and I didn't want to output anything on the X bus, then I would select X as the input. And this is sort of like, well, why would you take X and put it back into X? So using one gate, I was able to just turn that into the meaning of, well, just disable putting anything onto the bus. So anyway, that is the card. So now what I need to do for the sequencer is I need to set up the schematic to have a set of these. And I need to put them in the right order, right? So let's call this connector A, B, C, and D. So those are the card edges. So the card looks something like this, right? And we'll call that A, B, C, and D. I need to make sure that the schematic reflects that connector A has PC, PC plus four, and MTVAC in the right places, and so on and so forth. Then I need to have eight of them in the sequencer because there are going to be eight cards. Then I need to start putting the circuitry of the sequencer on there. And this is going to include things like the sequencer ROM, the trap ROM, and there's probably some other things that I will just look at the code and see if I can translate that directly into a schematic. So let's do that. With that, I will open up Kaikad. Now I'm using the latest Kaikad Nightly, which I wouldn't recommend if you're a Kaikad beginner. I would just use the release version. I'm using Kaikad Nightly because I just want to see the latest features on there. It's a bit iffy to use the Nightly because sometimes there are bugs and sometimes there are breaking bugs. Then maybe your project will be screwed up. Or if you're lucky, you can just not use the latest Nightly and go back to the Nightly that you were using before. So anyway, that's what I'll be doing. So the first thing that I did is start up the schematic. And I put down a hierarchical sheet with basically a copy of what is on the card. So this is the connector. And if we go into the connector, we can see that it is just this very large 168 pin connector that I'm using. And all the grounds are in the right place. All the power is in the right place. And all the data lines are put in. There are 106 total data lines. Now, the thing is that if I just left it like this, then I would have to break out the D bus that's here into a variety of buses. And unfortunately, when you connect one bus to another and you rename it, Kaikad gets mad because Kaikad does not actually have a concept of a net per se because, well, I mean, it kind of does. Each net has a name. And that's the name it is known as. So you can't have one net with two different names. Unless it's a hierarchical sheet, in which case you can rename a net, you just can't break it up into multiple nets and then name those individual nets because they're all connected together. So, you know, the signals are all wrong. Kaikad solves this by using a component known as a net tie. If you think of it as a zero ohm resistor, that's essentially what it is. Except it's not actually a physical component that you put on the board. The footprint actually just looks like a small trace. And then you connect one end to one end of the, so you connect one net to one end of that little trace. And then the other net that's renamed to the other end of that trace. And there you go. You have two nets that are connected together with effectively a component. The problem is that you have to place that component on the printed circuit board. And that is kind of bad because now you can't push it around, you know, you can't use shove and route because, you know, the two sides of the net are literally two different nets. So instead of that, what I'm going to do is I'm going to rename all of these signals to be what they actually are. So, for example, D0 to D31, I'm going to just call that bus A0 to 31. And then D32 to 63, I'm going to call that bus B0 to 31. And they're all going to be separate buses and therefore separate nets. So let me just go ahead and modify this right now. All right, so, so I've renamed all of the signals here. So here we have bus A, 32 bits, bus B, 32 bits and bus C, 32 bits. So these are passive ports. And we have a four bit selection bus. So that's cell 0 to 3. And then we have just a clock signal and a reset signal. These other four signals are not used. So I've put no connects on them. I also have, of course, the grounds in between and 3V3 power and one 5 volt power pin in case I need it. I probably won't and I may just switch that out for 3V3 as well. But we'll see. Okay, so we go up one level. And now I have this connector that I can import the hierarchical ports into. So let's just take bus A, bus B, C, select, clock and reset. And that should be it, right? Yeah. Okay, great. Let's resize this, make it a little smaller. So that it's nice and compact. And sometimes I like to hide the name of the file. So let's make that not visible. And of course, you couldn't see that because it opens up a separate window, which OBS does not recognize. But anyway, when you edit these sheets, a little pop up appears where you can set various options. And one of the options that I unchecked was visible. Okay, so here is my connector A. So what I can do is I can copy this several times. Okay, and I will go ahead and rename these connectors. And it would be nice if you could see the pop up. Yeah, okay, so I guess I'll just capture the entire display screen instead of just the window. So like I was saying, if you select one of these and hit edit, you get a bunch of options. So that would show the actual file name underneath, which I don't want to do because well, it just takes up a lot of space. So let's rename these connectors. So this one's going to be connector B. And then we've got connector C. And connector. So the other unfortunate thing about capturing the entire monitor is that my monitor is quite large. And we can't really capture the entire thing because it would be like, you know, 3k by 2k instead of, you know, the usual 1920 by whatever. So I can only show a portion of the screen because if I downsize it, everything will look weird and pixelated. So, all right. So there we go. I've got my four connectors. So the next thing that I'm going to do is I'm going to take a bus off of each of these ports. So insert, insert, insert, and then do the same thing. Well, here, I'll just copy this, copy, paste, paste, paste. Okay, and all I'm going to do is I'm going to rename these buses. So the thing about, so the thing that I was talking about with the net, so let's suppose we have a net here. Suppose we have a net here. And, you know, imagine that this is like a wiring harness where there's like a connector on one side and the connector on the other, right? And you want to name both ends of the connector different things, right? So, you know, maybe this one is called, you know, okay, let's play the fun game that manufacturers always love to play, RX on this side and TX on this side, right? So the problem with KACAD is that it's going to look at this net and it's going to look at these labels and it's going to say, well, which is it? Is it RX or is it TX? And it's actually just going to pick one. And in DRC, it's actually going to warn you that this net has two names. Here's the name that I picked. And it may in fact be the wrong name. And also, unfortunately, when you go into the printed circuit board, you only see that name. You don't see it as any of the other names. So instead, what you do is you open up a net tie, you create a net tie. And then what you do is let's put this net tie up here, right? You connect one end to one end of the net tie, one end to the other end of the net tie. And now you've got two nets. They are literally separate nets, which means that, electrically speaking, they're not going to be connected, except through this weird component. And then, again, when you go to the printed circuit board, this component has a footprint that isn't like a trace, which means that it can't get shoved around. So that's the problem. However, when you're dealing with hierarchical sheets, you can rename the nets that come out of the hierarchical sheet, because the only thing that really matters is the very top level. So this is the top level sheet right here. The fact that it's named bus A inside this sheet doesn't really matter. It's going to be named whatever is at the top. So we're going to name this, what should I name it? Add a list of signals. Okay, so bus A for this connector is the PC. So I'm just going to name that PC. And this one is PC plus four, PC plus four. Let's see the next one, MTVAC. And the selectors for this was the const selector. So I'm just going to call this const cell. All right, and the clock here was ph2w. Okay, ph2w. I'll leave the reset pins out for now. So the next connector is temp immediate and instruction, temp instruction, and the selector didn't go anywhere. So I'm just going to no connect that. The next connector has mem data, write, read, and mem address. And again, there wasn't a selector. And the clock was ph1. Okay, and then connector D are the x, y, and z bus x and z. And all of you who are screaming at your screens right now know the mistake that I've made. Okay, so this is basically the input selector. So selector and here is the mistake that I made. You have to say how big the bus is. So I'll just fix that up now. Okay, so the let's see. So the clock here, there is actually no connection there. And here, there's also no connection. And again, like I said, I'll leave the reset signal until later. Well, okay, I may as well just stick it in there. And then I'll name it reset. So this is interesting. If I put this label over here, the overline, I mean, you can see it clearly if I zoom in. But if I zoom out, it's sort of, you know, kind of blends in with with the line. And I've seen this other style, which is intriguing, using a star instead. So that's kind of interesting. Okay, so what have we got to do now? Okay, so these are so this is this is basically one set of connectors, and I'm going to need eight of these. Yeah, I'm going to need eight of these. So the obvious thing to do, I think would be to wrap this up into another hierarchical sheet. So let's create another hierarchical sheet. Let's make it a little big because it's going to have all these signals. And we're going to call this mux, sure, mux, card, con, we're going to call this mux, con, mux, con. And now what I can do is I can take this, copy it and paste it in here. And now I turn all of these into hierarchical ports. So for example, this becomes PC zero to 31. It's a passive connection because it's just a card edge connector. And I'll do that for the rest and then come back after that. Okay, so I've gone ahead and added all of these pins here. And one thing that I did want to do is rename PC plus four to inc underscore PC. The thing about using numbers at the ends of signals is that KiKat will interpret that as sort of like an index, which means that you may run into problems. So I'm just going to rename this as inc PC. Okay. So there we go. I've also no connected all of these other quote reset signals, they're actually just free signals. I mean, I honestly, I only need one reset signal on the set of connectors. So you know, I don't really need to connect them together. It's not like it's a high power signal. And I can free it up for, you know, to use it for something else. So all right. So that is that. So let's go up one level. Let's go ahead and delete these. Because now all I have is my mux card connector. And now I'm going to import the ports. So we've got y. And unfortunately, this is not going to be in any particular order. So let's stick y down here, z here, selection over here, there's x reset should probably go down here. There's pH one. Let's maybe put that up here. Const select. Yeah, I'm going to have to reorder these afterwards. PC mt vac ink PC temp and I need more room. Immediate instruction, data write data read, mem address, and that's it. Okay, so let's see about reordering these so that it looks somewhat sane. So let me first increase the size of this. Maybe I will put the clocks down at the bottom along with the reset signal. Okay. And then I can put PC at the top. Next is ink PC. And I think this will be roughly in the same order as they are in the connector, which is like this, the const selector will probably go down by the selector, which is here. Mem data right, mem data read. I need to move these down. And mem address goes up here. There's x, y, and z. Sure, we'll separate the selectors. Oh, that's that's the wrong size for selector. We'll have the other signals here. Now, unfortunately, if I go into here, if I go in into the sheet, and I rename my port signal, and then I go up one, that renaming doesn't actually rename the imported port. So I'll just rename it there. Actually, that's probably not a good idea. I don't know what kikab will do with that, but we'll just reimport it. All right. So, all right, there we go. That is one connector. Now, obviously, I'm going to need eight of these. So the sheet is not big enough for that. It really should be a larger sheet. I may end up just copying this eight times and then putting that into a hierarchical sheet because all of these signals with the exception of select are going to be common. So the select, because you have, say, one card for the PC, the select signals for that particular card will select what goes into the PC. Then the next card is, say, MTVAC, and the selection signals for that will determine what goes into MTVAC and so on for each of the eight ones. So something like const select, there's only going to be one, and all the buses are basically in parallel. The clocks are the same. The reset signals are the same. So I may as well just move this to another hierarchical sheet. So let's do that. Let's make it approximately as big, and we will call this MuxCardCons, plural, MuxCardCons. And now I will take this, copy it, can I cut it? I can cut it, go into the sheet, and paste, and there we go. Interestingly, all the buses turned into regular ports and not bus ports. I think this is a bug in the nightly Kaikad. It's been a bug for quite a while in Kaikad, nightlies. So if I go up one, and then go back into the sheet, all the colors are the same. And I've seen this effect also in terms of buses, like for example, if I take a bus here, and I take a bus here, you know, now let's suppose I do, I don't know, something like this. So, you know, these appear thick, and this is a green junction. If I go out of the sheet and back into the sheet, they're still thick, but this is a blue junction now, a blue meaning that this is a bus junction. So, you know, there's a bit of a weirdness, but as far as I can tell, it's not a functional bug, it's just more like a display bug. Okay, so I've got one of these. So now what I'm going to do is I'm going to duplicate it eight times, and actually, let me go ahead and name this one. Actually, no, it shouldn't be one. It should be PC, right? Okay, so now let me copy that and let me copy this and paste it. Okay, so now this is not PC one, but it's actually going to be for, let's see, the next register down would be MTVAC. Okay, and now I can just make a copy of those. Now, I'm going to need some room because I need to tile all these buses together, and there's a lot of them. So I may in fact end up needing to increase the size of this schematic. Let's see. No, I think this will probably work. So let's see, the next register down is temp, and the next one down is, what is it? Mem data write. Now, yes, instruction is a register, but it's not the traditional or the common register, it's actually a transparent latch, and it'll sit on the sequencer board itself, not on a card, so it's not multiplexed, and it always gets its data from the memory read. Okay, we need some more. So let's go ahead and slap these down. Maybe I'll move some of these over a little bit. I can never really tell whether these are aligned or placed apart regularly, so. Okay, the next register down here is mem address, and that completes all the registers, so five of them. The next one is x, y, and z. So these are sort of the buffer multiplexers, so I'm going to grab this, and I'm going to copy it into, I guess, around here, or so, and name this y, and the next one is just z. Okay, I can go out of the sheet and back into the sheet and turn all the colors correct. There we go. All right, so now I have to wire up all these buses in common, so I'll just do one. Let's do, say, let's just make it really nice and compact. I'm going to run out of space on the top now, aren't I? Okay, let me preemptively increase the size of the sheet. So let's go from A4 to A3. There we go. Now it's a lot bigger, and then I can run the buses down through the bottom, so let's just do that. We'll start with reset. Okay, let's see if I can go around the name here. So it's going to be, oh wait, no. Yes, right, so the reset signal is going to be common. So it's just going to look like this. This needs to be moved over. I just want to make it look a little more regular, like this, and like this, and then that will go out to a port that, of course, is going to be called reset. Okay, so that's one. Now the next ones, I'm basically going to put very close to the rest, like this, except that's not a good idea because I can't really, okay, that's fine. I'll do this. Probably not going to work too well. I'll do that instead. There. So now I can run these signals at a spacing of one, and these signals at a spacing of two, because I've got plenty of space down here. So this one is now called ph2w, ph2w, and that is basically how I'm going to draw everything. So, and likewise, from the top, we bring this down to here, just like that, and this signal goes down to here, and that would connect these. And now I'll just do all the rest of the signals. All right, so I've placed all of the buses and the ports, and they go up to here. So you can see that, you know, the spacing here is pretty good. I could have compacted it a little more, but, you know, whatever. And now all I have to do is connect all of these connectors up to those buses. And that's it. So once I connected one set up here, I could just copy this section over here and then, you know, just paste it on the other ones, and they just connect up just like that. So that's that. So now I can go up one, and now this is our top level sheet, and now I just import the hierarchical ports again. And I did make a mistake. This selector, again, should be different for every one of the cards, and unfortunately, I tied them all together. So I need to remove that and make eight separate selectors, one for each of the cards. Okay, that's a little better. Now I've got the selects all separated. So now I just need to go up one and correct this by deleting the common select, maybe increasing this a bit, and then importing all of those signals. So temp select, x, sure, it's basically in a random order. And that's it. Okay, so now I just need to organize the ports so that they look somewhat nice. Okay, and now they are roughly in the right order, sort of the right order. And really, the order that I kind of care about are the selectors, because there should be eight of them, and they should be in this particular order so that I know which card goes into which slot. So yeah, that looks pretty good. Okay, so let's grab that sheet and put it up to the top. So okay, again, this is our top level. So we know that we are going to have eight of these slots. All of these buses are now nicely connected. So the next thing that we know we're going to have is the sequencer ROM. And the sequencer ROM is actually going to output some of these selectors. Now there's also a trap ROM, and I need to be sure that the signals that come out of the trap ROM and the signals that come out of the sequencer ROM are combined correctly. Because the trap ROM sort of takes over from the sequencer ROM when there's a trap. So what I can do is I can look at the code and maybe see if I can see if there's an easy way to just combine the signals, you know, maybe it'll just end up being a multiplexer again. Okay, so now the thing that controls these signals right over here are the two, there are two ROMs. There's the sequencer ROM and the trap ROM. So let's go ahead and give us a sheet for the sequencer ROM and the trap ROM. Okay, so apparently, I already have a sequencer ROM. And it looks like this, which I don't like. So I'm just going to get rid of it. Apparently I did that before. So there's my sequencer ROM. And it's basically going to be the 20 inputs that we found that we needed, and the however many outputs are needed. I think at last count, there's 66 of them. Okay, so we also want one for the trap ROM. So let's put that down. Trap ROM. Okay, so for the sequencer ROM, okay, let's start with X, Y and Z. Now I know that the sequencer ROM and the trap ROM are going to be outputting an X select, a Y select, and a Z select. So let's just go into the sequencer ROM and put that in there just as a hierarchical signal. So I have this, again, I'm not sure what is going to go on the inside of this schematic. Let me make this an output. That's definitely going to be an output. Let's give us a Y select, move that up a little bit, and a Z select. So let's rename that Y select and Z select. Okay, great. Okay, I just changed the angle on the camera a little bit. Okay, so XL, Y cell, and Z cell. Okay, those are the selectors, and we'll also put them in the trap ROM. So why don't I simply copy that and just put them in the trap ROM like that. Okay, so those are that. And now let me import those. So XL, Y cell, and Z cell. And same thing here. XL, Y cell, and Z cell. Okay, so I have those, and I'm sure that I'm going to need some of these other signals. So let me take a look and see what I need for PC. Right, so for the PC selector, the sequencer and the trap ROMs are going to generate that. So I will PC selector, copy it, put it in the trap ROM, and import PC and PC. Great. Let's see, for the temp selector, it looks like only the sequencer ROM creates that. So I will create that in the sequencer ROM. Okay, let's see, mem address, both of them generate that. So mem address, so I can copy that and put it in the trap ROM, and import both of these things. So PC select, temp select, and mem address select, and mem address select. Great. Okay, let me just expand these a little bit. Okay, so that's PC, temp, mem address. Now mem data write, only the sequencer ROM creates that. So let's go in there and give us a mem data write selector. Okay. So the only other one is the empty vex selector. Now that is actually generated by the sequencer itself, not the sequencer ROM or the trap ROM. So we'll leave that alone for now. Okay, so what's next? Okay, so how do we get from these signals over here down to these signals over here? Well, for X, Y, and Z, and for PC, and for mem address select, we're going to have to multiplex them. And the way that we do that is with a buffer chip, with buffer chips. So let's create, how about I create a hierarchical sheet, because I know that I'm going to have to multiplex between either the sequencer ROM or the trap ROM. So let's create something here. And we'll call this the selector multiplexer. And we're going to call the schematic the selector multiplexer. So the idea is that I want, for example, X, let's start with Y, because X is slightly more complicated, but let's go with Y. So the idea is that I'm going to take this, put it there, Y, put it there. And there's going to be an additional signal here that comes from somewhere. And where it comes from, we will just put another sheet down here. And we'll call it sequencer ROM enabler. So this is just another sheet, which will generate this signal. How it's going to be generated, that's in the code. So I'll leave that until later. Uh, the signal is going to be called SeqROM enable. So let me name it right now. ROM enable. And I can put that right there. Okay, so that's the idea. The selector multiplexer is going to have to take the SeqROM enable signal in. And it's going to have to take the Y select signals from each ROM in, and it's going to have to output the Y select signal. So it's going to look something like that. So let me go into now the select multiplexer sheet and get us some signals input. So we know that there is a sequencer Y select signal. That's zero to three. And that's going to be an input. So let's put that here, say. Okay, that's an input. That is an input, isn't it? Yes, it's an input. And we're also going to have the same thing for the trap ROM. So those are both inputs. Great. And we're going to have to have an output. That's just going to be called Y select output. And another input input. I'll put that, say, down here. And we will call that SeqROM enable. So clearly what has to happen is we need something in here, which is going to take the sequencer ROM enable signal, and it's going to select between the sequencer Y select and the trap Y select. And it's going to output that to Y select. Well, we've already built multiplexers before they're just made out of buffers. So what I'm going to do is I'm going to create a large sheet that I'm going to call a, what should I call it? A quad four bit multiplexer. And the reason that I'm going to call it a quad four bit multiplexer is because four four bit multiplexer is conveniently is 16 bits. And we've already got 16 bit buffers. So quad four bit MUX. Okay. So again, the idea is that we should be able to take this, this and this signal and output that signal for a whole bunch of four bit selectors. Alright, let's go now into this hierarchical sheet. Alright, and let's now finally slap down. Actually, what I'm going to do is I'm going to, let's see, let me go up one level, let me go up another level that there is a sheet that I've already been working on. I don't know what it is. So let me load it now. Let's see, is it a buff 32? Yeah, why isn't that here? Well, let me copy it from, okay, so let me just copy that from the register multiplexer card. Okay, so buff 32. Sure. Alright, so the only reason that I did that is so that I could get one of these things, right? So let me just copy it. I'm going to need basically two 16244s. And you can see that these are actually grouped in groups of four, which is kind of what we want. So let's go back to the select multiplexer, the quad four bit multiplexer and place this down here. Alright, so this bus now is not a 32 bit bus rid of those this. Okay, so we're also going to have to renumber these. So let's just get rid of those. Excellent. Okay, so the idea is that yes. Yes, okay. Okay, so let's just disconnect all of these output enables for now. So the convenient thing about this chip is that it's broken up into groups of four, each of which has its own output enable. So we can put down a one gate 04. Okay, so this is a single gate package, which is kind of convenient. So what I'm going to do is just place it here. I'm going to move this signal to here. And instead of calling it output enable, I'm just going to call it select. So the idea is that what I want to do is first of all, use things, move this away, move this out of the way so that I can take this and put that here. And I'm going to need one more capacitor for the bulk decoupling capacitor for that one gate. Okay, so that one gate is basically a, it looks like a four pin package. I think it's a maybe it's a five pin package. In other cases, it's one of these tiny little slot 23 packages. So and that's just going to be local to this thing. So the idea is that if the selector is zero, then we're going to select this group of four. But if the selector is one here, then we are going to select this group of four. So this is zero. And this is one zero and one zero and one zero and one. So that's how I'm going to make a sort of quad four bit multiplexer. So it looks like this. And the other part is here. So now what I'm going to have to do is grab these and extend these out. I could probably grab this and move it up a bit, maybe up here. Sure, that's fine. Grab this and move it down a bit. Sure, that looks good. Let me move the labels over so that it looks a little nicer. Sure. Okay. So we're going to call this a zero to three. No, we're just going to call it a zero a one. Oh, I have to change my preferences, preferences, editing options to skip by one. Great. Okay, a one, two and a three. And this is going to be what the zero one, two and three. Okay, so now I have a bus here and a bus here. It looks kind of stupid. Bus here and a bus here. And I call them, this is going to be an input. This is a zero to three. This is B zero to three. And then what I do is I combine capacitors over, take these outputs. Now only one of these sets of four is going to be enabled at a time. So I'm going to call this a B zero to three. And so this is now a B zero, one, two and three. And these are also a B zero, one, two and three. So the idea is that when you select the upper part, this gets sent to here and that goes out to the bus. When you select the lower part, this gets sent to here. The other part is disabled and you send it out to that output. So now all I have to do is multiply that here and here and here. And I will have a set of four multiplexers. Maybe I don't actually need to make it, do I need to make it a set of four? Yeah, I think I do. Because I could make it just a set of two and include one inverter per one of these chips. But I could save one inverter by having this section contain two chips instead of one. So I think that's okay. So I'll go ahead and do that now. Right, okay. So that's basically it. Two chips, groups of four. So we've got eight four bit inputs coming in and four four bit outputs coming out. And we've got a select. So now we can go up one and take a look at this four bit mux and import the signals. So hard to see. All right, I'll make this as the output. Actually, you know what, I'm going to take this and mirror it. Because in general, you want inputs to be on the left side and outputs to be on the right side. So which I guess if you're in a left to right language, that makes sense. If you're in a right to left language, that probably doesn't make too much sense. But you know, we've got to have our standards. So let's go ahead and import some more things. E F G H G is an input. So let's put that, let's put that over here. F is another input. Let's put that up there. H E C. I'll move these around later. A select will go down here. B will go up here. AB will be aligned with A and B. C and D will be aligned there. And that's it. So this here, this here, let's see, we want, yeah, so this needs to move up one, this needs to move up one, and actually all of these need to move up one up to here, up to actually think I can just say here there. Okay. That looks, that looks a little better. So now we can see that we want to take our Y select. And let's just put that over here so that we can use the X select as the first inputs. And there's our Y select that goes here. Here's our sequence ROM enable. Now, again, if the selector is zero, that will select the first of the pair. So that means that we need to move these around, right? So if the ROM, if the sequence of ROM is enabled, then the selector will be one, which means that we're selecting not zero, but one of the pair. So that's basically that. Let's copy that and give us a trap Z select also, and a sequencer, and a sequencer Z select, and the output Z select. And I may as well do the same thing for X, even though I know it's going to be a little more complicated, because there are actually three inputs and not two. Just kind of unfortunate. So let's call this X select and X select. And this is X. And let's see this other one. Let's just call it PC select, PC select, sequencer, PC select, and output PC select. Okay, so that's, that's just one section of this larger select multiplexer. It's pretty likely that I'm going to need to make this a lot bigger. So let's just do this. And let us start importing some signals. All right, sequencer ROM enabled, we know that we're going to want that all the way at the bottom. So I put that at the bottom trap. Yeah. Okay, so I'm just going to just slap them down, and then reorder them later, because they generally appear in sort of a random order. So that's it. Okay, so let's take this is the X select output. So let's move that up here. And then there are the two select inputs. So here's one. Here is the other. Let's go ahead and delete these and make this bigger. Okay, so there's X select, here's Y select, and sequencer Y select, up Y select, sequencer Z select, trap Z select, sequencer PC select, trap PC select, Z select. Okay. So really, I mean, this, this is no different from what I had on the inside. It's just that now, now I can actually copy this and make two of them. Oh, yeah, I'm going to have to rename these, aren't I? Okay. I will, I will do that later. But for now, let's just take a look at what the routing looks like. So here is sequencer ROM X select, and here is trap ROM X select, Y select, Y select, and Z select, Z select, and then PC select, PC select. So that's a little messy, but I can clean it up later. And then we have the sequencer ROM enable thing down here. So I can just hook that straight into there. Okay, so that's what we have so far. The next thing that I'm going to do is I'm going to duplicate. So the next thing that I'm going to do is I'm going to duplicate this multiplexer so that I have, so that I have enough for all of these signals. And then I'm going to have to complicate up the X selector. In fact, let's see, yeah, I'm going to have to complicate the X selector because there are actually three inputs, the sequencer ROM, the trap ROM, and then there's one other selector, which happens when I want to, when I want to read the MTVAC register into the X register, and that's not actually handled by the sequencer or the trap ROM. It's not handled by the sequencer because then I need an extra input signal. Maybe I can give it to the trap ROM if I have enough inputs, or if I don't have enough inputs, I mean, I can add one bit and it won't be that crazy. So that's a possibility because then, then I probably don't have to have a three input multiplexer. Yeah, maybe that's what I'm going to do. Okay. Okay, so first of all, what I've done here is I've changed things around. So if we go up one, ignore all these signals for the moment. This is just our multiplexer, which will multiplex four bit signals. So if I go in there, basically at this level, what I did was I said, okay, there are three copies of this bunch of chips and one of this chip. And you can see that the difference between the hookups for this chip and the hookups for these other three chips is that I have an extra select signal down here. Up here, there is one select signal that selects for seven of these signals. And then there's this extra one which selects for the eighth one. Now what I'm going to be doing is I'm going to be combining the eighth set of signals with the seventh set of signals to create a three input multiplexer rather than two two input multiplexers. So that's what I need. If we take a look at what the ROMs output, we can see that the sequencer ROM and the trap ROM each output seven four bit signals, which are going to need to be multiplexed. One of those signals, which is the x select is going to be need is going to need to be three way multiplexed, which is what that extra multiplexer is for. So that's basically what I'm going to be doing. Okay, so let's see if we can make this make sense. So I've also relabeled things so that the zeros are the ones that get selected when selected zero and the ones are the ones that get selected when select is one, which makes a lot more sense to me than A, B, C and D. A, B, C and D in this case are just, you know, separate four bit signals. So there's zero A and one A and there's zero B and one B. And the output is just A and B and C and so on. H is the special one. So and we know that that's going to be applied to X. So instead of routing X to A, and let me just get rid of all of these signals. So let's handle that one three way multiplexer first. So the way to do that is we have one signal going into zero G, another signal going into one G, and another signal going into one H. And the idea is that G gets fed into zero H and the output is H. So that's going to be our X select. So X right here is going to go into zero G. From the trap rom, X is going to go into one G. And then here is that special other signal. And here is the selector for that special other signal, which we can get to later. But the point is that the way it works is that if this special selector signal is one, then one H is going to get selected to go out to H. Otherwise, if it's zero, then it's whatever it is either zero G or one G, depending on select. And that's the way it should work. So now all I have to do is route these other signals YZ, PC, Mem address, const, and ALU to these other six and route them into the MUX card connections. Now, the ALU op to Z doesn't go to the MUX card. That is just some other multiplexing multiplexed signal. It just happens to be multiplexed by the same signal, the same selector signal. So that's why I just included it in here. So that's what I'll do next. And this is what it looks like now. So let me get rid of the crosshairs. Okay, so we've got our multiplexer in the middle. We've got our signals from the sequencer ROM on the right side and the trap ROM. And they go into the multiplexer and the output of the multiplexer goes into the multiplexing card connectors. And that's it. So what's this entitled sheet thing? That was just something that I guess I didn't really need at this point. So this dangling thing is for the ALU op to Z signal, which I haven't routed to anything at this point. Let's see temp select. Okay, well, we know that that is actually going to go straight into the card connectors. Same thing with mem data write select. Okay, so that's pretty much that taken care of. I think I'll probably take a break right now. Because there are more things that we need to look at and hook up. There's a lot of other signals that come out of the sequencer ROM, not to mention all the signals that go into the sequencer ROM. So we're going to have to choose what we want to focus on next. But for now, I think that this is pretty good right now. So I guess that's it for now. See ya.