Sometimes, a question will lodge in my brain and not let me go until I solve it. Thankfully, these are not the questions of philosophers and theologians, or I would have gone mad(der) ages ago. One lodged in my mind while trying to learn basic electronics. Specifically, the function of a Shift Register. In particular the Texas Instruments SN74HC595. A lovely, difficult to remember name for an inexpensive chip that is designed to remember one byte of data, converting from a serial input to a parallel output.
The first stage of this fixation was just trying to comprehend how this chip worked in a general manner to make some lights light up in a pattern I defined. My simplistic understanding of electronics and electrical engineering is going to irritate the more learned among us, but I will endeavor to be correct and keep it such that those for whom this is a mystery can still follow.
I have made no secret that of late I’ve been running through tutorial projects from an educational electronics kit I recently acquired. But I endeavor to fully understand what is going on and prove it by making the hardware do some arbitrary other thing that I decided upon. When it was just blinkenlights, that was much simpler. But now I was faced with my first integrated circuit – a black box with sixteen pins that did stuff more complicated than just toggle on or off. Yes, at a basic level elements within the black box were just toggling on and off, but I can’t interrogate those elements directly. I have the sixteen pins and the documentation.
In physical appearance it was a piece of black plastic with eight metal pins on each of the long sides, and a small notch on one of the short sides to help you orient it in the correct direction. I didn’t pay enough attention to that notch once and I broke one. Thankfully, they are cheap, and I acquired four more. Electrically, we’re going to abstract things a bit. Because we’re concerned with things when they are working correctly, we will only have two states – high and low – and treat the flow as ending at ground. Because the exact behavior of the electrons isn’t a factor in this discussion, we will avoid that rabbit hole. There’s enough blathering about things I marginally comprehend without getting into more trouble. Since we’re talking about data that originates at a computer, and is stored in the registers, I will end up referencing bits, which are ones and zeroes. Thankfully, these correspond to high and low values respectively at the locations where we can see them.
If the initial text I read had done a better job of describing how the chip worked, I might not have become fixated on delving its mysteries. At the most high level, well above the logically useful, you feed it ones and zeroes on a single pin and it holds on to eight of them, outputting the remembered values on eight separate pins. Now, if I were designing the interface for this chip, I’d have lined up those output pins along one side in a neat row. But, for whatever reason, pin eight is instead dedicated to ground, and the output is done on pins one through seven, and pin fifteen. Worse, pin fifteen is the first digit, followed by pins one through seven, in that order.
From the Official Documentation
In the example I was learning from, they had a jumper tying pins sixteen and ten together, and ran pin thirteen to ground, without explaining one iota of what any of that was supposed to accomplish. An uncurious soul would have seen that power was going into pin sixteen and gone “two power, two ground” and moved on. No, this is very wrong. Pins ten and thirteen have important functions but are also what are known as “Active Low”, which means they trigger their logical functions when not getting current. So, the example had permanently disabled pin ten and permanently enabled pin thirteen. What do they do? Pin thirteen is “Output Enable”. So, by tying it to ground, they permanently turned-on pins one through seven and pin fifteen to send out whatever data they’re responsible for. And pin ten? That pin clears the contents of the register, making it forget what was in there and switch to all zeroes. So, while we could play around with them (and I did change the pin ten wiring to be able to send clear messages) my curiosity there was satisfied with regards to those.
But then there’s pin nine.
In the example, pin nine was not hooked up to anything. It was hanging out there, unused, and that got my attention. Searching the internet, I found that pin nine was there to allow for chaining these chips together. It always output the H bit from the register. Notation wise, the eight bits in the register are lettered A-H. In normal output pin fifteen is A, while one through seven are B-H. So pin nine imitated pin seven. Or so I thought. I might not have kept digging had I not run into an offhand remark in someone else’s article on the chip. They asserted that the purpose of pin nine was to feed into the input of another shift register chip and allow you to control “and infinite number of chips” in series “from just three pins”.
Of course, my head tried to sort out how you would do that. Which is where the as yet undiscussed pins come into play. Eleven, twelve and fourteen are the only ones I haven’t talked about yet. Fourteen is the serial input. It’s where you send the ones and zeroes to get them into memory. If chaining two chips in series, you’d run pin nine from the first to pin fourteen of the next. Pins eleven and twelve are the SR-Clock and the R-Clock. So what exactly are these clock pins? If the chip were a macro-scale mechanical device, these are the levers which cause the mechanism inside to move to its next state. It acts each time either of these pines switching from low to high. Note the language. If the pin stays high, the chip doesn’t care. If the pin switches to low, the chip doesn’t care. It only has an effect when switching from low to high. This is because it triggers a logical operation on the contents of the memory inside the chip, changing to the next state.
To get a handle on what the clock pins trigger, we need a picture of the logical guts of the register. While I’ve been saying it holds eight bits, that’s a bit of a lie. If you try, you can make it remember sixteen. That’s because there are two registers in the chip – the shift register and the storage register. The storage register is the simpler one to talk about. It is the memory which pins fiften and one through seven are outputting when the output enabled pin is low. Any time the R-Clock moves from low to high, whatever is in the shift register gets copied into the storage register, and the output changes. If the R-Clock doesn’t toggle, the output doesn’t change, regardless of the inputs (except for a clear signal on pin ten, or a loss of power overall).
So what about the other register? The one the whole chip is named for? Well, it still has eight bits, from A-H, and it doesn’t care what the R-Clock is doing. It pays attention to the SR-Clock. When the SR-Clock goes from low to high, the shift register shifts all the bits forward one spot, A moving into B, B into C, and so on, forgetting the old value in H, and then reads from the serial input to populate A. So, it’s sort of like a moving sidewalk, advancing every time the SR-Clock ticks, and whenever the R-Clock ticks, a snapshot gets taken and put in the storage register for output.
So what’s that “control multiple chips with just three pins” thing? Well, I could only assume they meant all the chips would have the same two clock signals, and each additional chip would read from pin nine of the previous one.
That’s when my brain hit a snag.
It became convinced that this setup would result in bit H of chip one and bit A of chip two moving in lockstep, providing only seven additional bits per chip and one duplicate. This was not the world the articles were implying. There had to be some means of interrupting the clock so the bits were sequential. So I began mentally drafting crazy circuits. Logical trees of shift registers controlling the clocks of the other chips in the tree, feeding a mix of data and control bits into a system with a rapidly exploding amount of control data for a laughably small amount of stored data. No, that wasn’t what was implied either.
I kept digging into the documentation. There had to be something I was missing. I mean, why have pin nine clone pin seven? Only it wasn’t a clone of pin seven. I didn’t find that detail in the text of anything, but in a timing chart in Texas Instruments’ data sheet on the chip. Pin nine went high a half tick before pin seven. Before? Looking closer at the graph, pin seven was going high on the R-Clock signal as expected. Pin nine was synchronized with the SR-Clock signal, which they had drawn as inverse of the R-Clock. Plus, pin nine was shown as not being impacted my the state of the Output Enable signal. That meant it wasn’t outputting from the storage register the regular output pins were connect to. It had to be outputting bit H of the Shift Register.
Also from the official documentation. Credit Texas Instruments. Red lines added
Okay, so, how does this help me? It means I can push data into the shift registers of as many chips as I like in series without changing the state of the outputs from the other chips. But if they shared an SR-Clock signal, wouldn’t the H bit from chip one still be in lock step with the A bit from chip two in the shift register values?
So what about filling the first chip’s storage register first then the second? Well, if they share an R-Clock, then it doesn’t matter, because the current state of the shift register would overwrite that first round of data.
Well, could we invert the R-Clock signal for the even chips and interleave the writes? I mean, it only happens when the signal switches To high. I suppose it’s possible, but that wasn’t even hinted at in anything I’d seen talking about chaining the chips.
The truth is, I’d reached my theoretical limit. I had to set up a practical experiment where I chained some chips together and saw whether bits 1H and 2A were indeed in lock step, or if there was something at play that made it work as is.
The Experimental Apparatus
*Four Hours Later*
Behold – Actual wires!
I’ve gone and wired two of the chips into a bread board with some cargo cult engineering. I don’t know why the other examples have a 220Ω resister in-line with LEDs. I can speculate that it takes the edge off the current provided to something the LED is happier with, but I don’t know for sure. But, I figured that I should do the same. I attached one LED to each output pin, including pin nine. I attached pin nine of the first chip to pin fourteen on the second. I have both pin thirteens connected to ground to always enable output. I connected the SR-Clocks together and the R-Clocks together, so that the chips are synched. This is the “Three pin” layout the internet implied should work. Though I did choose to connect the clear pin to its own signal source.
Some of the LEDs have been color-coded. I put a Red LED on the pin fifteen signal from each chip, so bit A will show up as red. Blue LEDs are connected to pin seven on each chip, so bit H will show up as blue. I’ve attached green LEDs to pin nine on each to see what that is up to. This will make it easier to examine what’s going on when we run our tests.
I stopped referencing the internet once I decided to do this experimentally. I don’t doubt you can find the exact same circuit elsewhere – it’s not that unique.
The source of power, ground, and the data signals is a ribbon cable adapter connected to a raspberry pi. This lets me programmatically control the inputs to the system. So I can do a number of tests without having to fuss around with the wiring. My first few will be sanity tests to make sure my wiring is correct. Since I only have experience in driving the ribbin cable pins from Python, the code will be in that language. I am an extreme novice in Python, so I borrowed the code from other sources.
Test Number One – One pin at a time
The test code is supposed to hold the input pin to high and then cycle both clocks sixteen times, to fill both registers with ones. As it does so, the LEDs should come on in sequence. While this test can test my hypothesis regarding the chained registers, I am more interested in making sure my layout is done correctly.
#!/usr/bin/env python3 import RPi.GPIO as GPIO import time # Set up pins SDI = 17 # Pin to write to register RCLK = 6 # Write from register to output buffer SRCLK = 26 # Clock pin, shifts and reads from SDI SRCLR = 18 # Clears register. def setup(): GPIO.setmode(GPIO.BCM) GPIO.setup(SDI, GPIO.OUT, initial=GPIO.LOW) GPIO.setup(RCLK, GPIO.OUT, initial=GPIO.LOW) GPIO.setup(SRCLK, GPIO.OUT, initial=GPIO.LOW) # Reset is active low, so set to high GPIO.setup(SRCLR, GPIO.OUT, initial=GPIO.HIGH) def main(): i = 0 GPIO.output(SDI, GPIO.HIGH) for i in range (0,16): GPIO.output(SRCLK, GPIO.HIGH) time.sleep(0.001) GPIO.output(SRCLK, GPIO.LOW) time.sleep(0.5) GPIO.output(RCLK, GPIO.HIGH) time.sleep(0.001) GPIO.output(RCLK, GPIO.LOW) while TRUE: i += 1 time.sleep(i) def destroy(): GPIO.output(SRCLR, GPIO.LOW) GPIO.cleanup() if __name__ == '__main__': setup() try: main() except KeyboardInterrupt: destroy()
So what does that all mean?
#!/usr/bin/env python3 import RPi.GPIO as GPIO import time # Set up pins SDI = 17 # Pin to write to register RCLK = 6 # Write from register to output buffer SRCLK = 26 # Clock pin, shifts and reads from SDI SRCLR = 18 # Clears register.
Here we define what interpreter we’re using so linux knows what type of file this is. Then we load some libraries that are needed to do pretty much anything beyond arithmetic that we want to do. Lastly we are setting variables to identify which of the pins from the ribbon cable we’re using for what. Now, the pinout on the ribbon cable is… deranged. I assume it is the result of factors that are not immediately obvious to the casual user, but they are in no kind of rational order without that in-depth knowledge. Someday I might run down that, but today, we’re looking at the shift register. So, we’ll let that slide and use whatever was printed on the board.
def setup(): GPIO.setmode(GPIO.BCM) GPIO.setup(SDI, GPIO.OUT, initial=GPIO.LOW) GPIO.setup(RCLK, GPIO.OUT, initial=GPIO.LOW) GPIO.setup(SRCLK, GPIO.OUT, initial=GPIO.LOW) # Reset is active low, so set to high GPIO.setup(SRCLR, GPIO.OUT, initial=GPIO.HIGH)
Here we are defining a function called “setup”. This function initializes our hardware pins to a sane default value. The line “GPIO.setmode(GPIO.BCM)” is picking the manner in which we reference the pins off the ribbon cable. There are several naming schemas to choose from. That is also beyond the scope of this discussion. The BCM naming schema is the one we used when we set variables to identify our pins.
def destroy(): GPIO.output(SRCLR, GPIO.LOW) GPIO.cleanup() if __name__ == '__main__': setup() try: main() except KeyboardInterrupt: destroy()
I skipped to the end for this part of the overview. We define one more function “destroy” which we call to clean up before we exit the program, then we reach the arcane symbols which tell Python that logic execution starts here. It runs setup, then puts our main function in a try clause. This is to catch any errors, exceptions, or interrupts generated. We only have a defined action for “KeyboardInterrupt” which runs the destroy function. KeyboardInterrupt is generated by hitting Ctrl-C on the linux window.
Lastly, we have the guts of the logic.
def main(): i = 0 GPIO.output(SDI, GPIO.HIGH) for i in range (0,16): GPIO.output(SRCLK, GPIO.HIGH) time.sleep(0.001) GPIO.output(SRCLK, GPIO.LOW) time.sleep(0.5) GPIO.output(RCLK, GPIO.HIGH) time.sleep(0.001) GPIO.output(RCLK, GPIO.LOW) while TRUE: i += 1 time.sleep(i)
The SDI pin is hooked up to pin fourteen on the first chip and thus is the input into the registers. We’re setting it to HIGH and leaving it there so we fill the registers with ones. The for loop cycles the clocks to move the data along and put it into the storage register for output. After going through sixteen iterations, we go on to the infinite while loop. This is so I can observe the state of the LEDs and trigger a cleanup with a Ctrl-C.
The results:
I ran into some bugs as I’d written the code for a Pi 4 and ran it on a Pi5 where they’d gone and done darn silly move of changing the output architecture and thus the libraries. Once I fixed the python environment I altered the code slightly to add another sleep at the end of the main function and flood the registers with zeroes in the destroy function because the Clear pin did not seem to be doing its job. I may have miswired something. But I can work around that. Once I’d fixed the code, the LEDs did come on in a manner consistent with expectation. Now to check the actual internal logic.
Test Number Two – Alternating Bits
Once I’m satisfied that my wiring is correct, I’m going to change the logic in the main function so that it indefinitely feeds alternating ones and zeroes into the input. That code looks like so:
def main(): i = False while True: j = not i i = j if i: GPIO.output(SDI, GPIO.HIGH) else: GPIO.output(SDI, GPIO.LOW) GPIO.output(SRCLK, GPIO.HIGH) time.sleep(0.001) GPIO.output(SRCLK, GPIO.LOW) time.sleep(0.5) GPIO.output(RCLK, GPIO.HIGH) time.sleep(0.001) GPIO.output(RCLK, GPIO.LOW) time.sleep(0.5)
Other than this block, the program will be identical to the first test. Instead of a stream of ones, we switch between ones and zeroes forever, so the LEDs will march forward on the regular output bits, on-off-on-off… This repeating pattern will allow an inspection of the behavior of bits 1H and 2A in relation to each other. If my hypothesis is right, the middle red and blue LEDs will match each other and the second set of data bits will be the inverse of the first. If my hypothesis is wrong, the red and blue LEDs will be in opposite states, with both reds being on when the blues are off and vice-versa. In this circumstance, I will have to observe the behavior of the green LEDs to figure out what’s going on.
The results:
The Red LEDs blinked together, opposite the Blue. The Green LEDs lit up a half second before the Blue. The only thing I can think of is that the read operation to set the next state happens at some point or in some manner that captures the value on pin 9 before it changes to the new state triggered by the SR-Clock comes into effect. If I dug into the documentation, I could probably figure out how fast that window is, but it’s immaterial at this time. (Okay, I looked, it might be thirteen nanoseconds if I’m reading this right). I just know that the read for determining the next state of the bits in the register isn’t impacted by the change that takes place during the operation.
At least I’ve satisfied my curiosity. I’ve proven my intuition wrong, but found out I have set up a successful test. I call that a win.
I looked for a good way to break this into two articles, but didn’t try that hard
This article is an incredible achievement. Bringing automotive controls into the IC generation was necessarily a part of my career over 20 years ago, so I recognize a lot of the issues and certainly the nomenclature.
Thank you. I hope I didn’t cause any bad flashbacks.
You did! Auuggghhh!
Okay, not that bad. But it makes me feel old.
I was taking an IC course at the local community college before heading off to basic training in Texas. All I can remember is the final exam involved making some chips “do math” manually. I needed the credit hours from the course to get myself over the limit to leave basic as an E-3 instead of as an E-1. I think half the class failed. I didn’t. Whew!
And, good morning UCS… and the rest of you ne’er-do-wells.
All the 0s go in one article and all the 1s go in another.
Serious geek cred for learning to forge and fiddle bits.
Yes. Way more than my late night after work brain can handle.
I’ll have to look again in the AM. Thanks for the post however!
Yes indeedy. I remember starting off with IC’s using the venerable 555 timer chip. You are doing great!
I like to learn. And sometimes, I have to do so by making something.
Me right now, flashing back to digital electronics class
Seriously though, interesting stuff! Can’t wait ’till you get to the big boy ICs.
I have “fond” memories of working out on the elliptical while reading the datasheet for the microcontroller we used in senior design class. I read that thing cover to cover dozens of times, trying to commit it’s functions to memory so that I could get my part of the project done.
One of my project mates for that class was an occasional commenter at TOS, but I don’t think he made the jump over here.
I have a ways to go, I misplaced the LED dot matrix component that’s supposed to be in the next tutorial, but from the code it appears to have a shift register built into it.
try:
main()
except KeyboardInterrupt:
destroy()
I’d put that destroy call in a finally clause and not bother with catching the exception. That way if you have other exceptions (which won’t be caught and instead raised higher up), your destroy function will get called.
I’ll keep that in mind.
I know very little about python, so for that part I took the delivered code.
And here I am done work for the day and reviewing code.
I need to step away from the computer.
The code looks good otherwise.
Reading the text and the looking at the diagrams, I had flashbacks to some early hardware classes.
Nerd.
Seriously, I have zero background and about as much interest in chip mechanics(?), but I admire the commitment. I enjoyed following the thought process, as logic is in short supply these days, and its good to see it now and again.
One of the advantages of this site is the eclectic nature of the skills and interests involved (and somehow we’re still more or less intact.)
Damn. This is way above my pay grade. I’m gonna give it the ol’ college try and see what I can gather from things I’m clueless about.
Thanks for making this an article and putting so much work into it. I wanted to comment before the eve ended so (maybe?) you’d see it.
You’re welcome. I tried to write plainly, but I might have started getting carried away, I donno, the piece got long.
This was meant as a reply to Evan. But I Brooks’d it.
I haven’t slogged through it all yet, but it gave me flashbacks to programming an NCR 500 computer in machine language; it had 400 bytes total, which had to include the program, data, and results.
You couldn’t attach any external storage – like paper tape?
We did have paper tape to load the program and data, but it couldn’t keep more than 400 bytes at one time.
This was back around 1968 or so when I was in junior high.
In Junior High they barely let us use anything with electricity.
It wasn’t school. Actually, my father’s small company go the computer and he (as treasurer) let me write some programs (for $25 a pop!).
AS/400 is still in use.
Great article, UCS. Growing up in the analog age, Im constantly challenged with digital things.
So much this. I was in the last HS class (’89ers Rule!) that wasn’t required to take a computer class. And I wasn’t the
nerdforward thinking fellow who knew what was coming.You are giving me serious flashbacks. This is what I went to college for (Electrical Engineering Technology, aka EET). Four years of that, then an extra 1.5 years to get another degree in Computer Information Systems. Right after school I got a job writing software and I’ve been at it for 25+ years. Never built a single circuit on the job. Of course I always wanted to be an artist but that’s another story.
You can still be an artist, it’s just very difficult to do it professionally.
Indeed. As I type this I just closed my sketchbook after a half hour of drawing practice. I’m not drawing every day, but this year I want to draw or paint MOST days.
Same here. If just for the mental and dexterity exercises.
Thanks for the article. I just skimmed it. I will have to go back when I have more time.
The lowest level I ever got to was a serial port driver on a TI signal processor running naked without an OS. Bits come in one port, get buffered up and trigger an interrupt when the buffer is full, then you grab the data and put it into an output port. This was in the middle of a SATCOM system — voice data in; voice data out; 8 kHz interrupts. Oh, and I had to write the built-in test for the handler.
That was ’93. I haven’t written code since.
“Unprocessed write-ins”
https://justthenews.com/politics-policy/holdbiden-projected-win-nh-primary-through-write-ins-ap
Yep. That’s how it works.
15% of NH municipalities count everything by hand. The rest use counting machines.
Municipalities have until 8 AM the day after the primary to report primary results. For those that use counting machine, they’re allowed to report the write-in count from the machine and then hand count the write-ins to get a break down later. I think those municipalities have a week to report the write-in break down.
The news outlets are assuming write-ins on the Democrat side are all for Biden.
duh.. proofread.
The reports go to the Secretary of State’s office, which rolls all the reports up into a statewide total.
I have this vision of people writing Biden’s name on carnival tickets and putting them into a cardboard box with a slot at the top.
I’m glad I comprehended “debits by the window side, credits by the door side” and stayed with an accounting major as I’m sure I couldn’t have understood any chips except potato chips.
Strangely, I still have trouble with double entry bookkeeping.
If you want to learn CMOS, I recommend Don Lancaster’s CMOS cookbook. You can download it for free off the internet.
Also, unless you need the higher speed of 74HC, 4000 series is somewhat easier to learn, and can be run off different supply voltages (even though most 4000 is run off 5V in practice).
“But, for whatever reason, pin eight is instead dedicated to ground”
That’s because logic chips have Vcc and ground diagonally across from each other so the guy laying out the printed circuit board doesn’t have an aneurysm.
Today was my 53rd birthday. I went to the dentist.
Happy Birthday, and congratulations on still having teeth 🙂
Happy Birthday!
This seems quite appropriate.
https://m.youtube.com/watch?v=P2jMQahM7cI
Obviously they are Sisters of Mercy fans.
How dare you slander the Sisters.
Its my…
(puts on sunglasses)
Mission(uk)!
Are you a Richard Ayoade fan?
https://www.youtube.com/watch?v=EE10PSt0pN4
AAAAnd now I have fallen down a hole of British game shows.
Happy birthday!
Welcome to the club, youngster.
He said, “Boy you better try to have fun no matter what you do.”
I would say thanks for this article, but it reminds me too much of when I worked for the cop car company.
Anyway, nice work UCS!
Sportzballz. Come for the pretty lady, stay for the laffs.
Thanks, Moj. Good stuff.
I pitched that right over the plate and nobody swung.
I don’t take First low hanging fruit.
She’s actually pretty sharp.
Electricity math is hard.
However, I too can do double-entry bookkeeping. I DON’T, but I can.
Damn, UCS, You make me feel bad
I was an electronic tech, specifically Microwave Equipment Repair, ’til I got side tracked into logistics. Looking at your project I’m kinda glad I did.
/Hides Heathkit 5 tube receiver
I did all that, too much work. Now I just build synthesizers and guitars
Enjoy!
Skims partway thru article – no idea what you’re banging on about, but you sound knowledgeable.
* skips to comments, looks for non-techy stuff I understand *
If/when you need to drive higher current loads than an LED, or you’re driving with lower current chips, i recommend the DS2003 or ULN3003. They are Darlington transistor arrays that take a small signal in and can drive quite a bit out, and at a higher voltage.
Available in convenient DiP form so it’s still friendly for your press-in breadboard experiments.
Also, I echo Yusef’s recommendations for the Forrest Mims series of pamphlets and books to learn electronics by doing.
Have fun!!
“ULN2003” not 3003.
The “Way out there” ultimate goal involves vacuum tube outputs, but I’m not sure what voltages the data part of those run at. I think 12, but don’t quote me on that.
Drove a Chevy Silverado today. What a complete piece of shit.
Our motor pool has more troubles with Chevys than any other…even Dodges are more reliable. Yep, absolute crap.
Breakfast time! ☕🍖
https://m.youtube.com/watch?v=ESldl2Dd41I
Fun tune. 🎶🎶
Morning.
Mornin’ all!
Good article UCS.
Good morning, Beau, U, and Sean!
U, I read part of your article last night, but as I had already been nodding off in front of Oak Island, I decided that for me, copious amounts of caffeine were in order to aid my understanding and allow me to appreciate it more completely.
OK, I’m going in now…
Just pausing to note that I like this analogy very much.
(OK, technically it’s a simile.)
I tried to think of a way to explain the action that was easy to visualize.
Yes, it was very helpful.
Overall, I think this was very thorough, well thought out, and well-written. For my own better understanding, I think I’d have to back up to the earlier “blinkenlights” stage you mentioned before I tackled the IC. Hell, I could use a grade-school level tutorial in how electricity works before trying to wrap my brain around electronics.
Have I mentioned my abysmal early science “education”? I keep pondering how I could go back in time and get a better background, but that would involve either growing up in a different city or having wealthier parents who could have sent me to a private or parochial school. Naught to do now but try to make up for it on my own.
They haven’t found that treasure yet? Tune in next week, I’m sure it’s just a few feet more down.
The archeology going on in some areas of the island and the advanced technology they’re using in the primary search are interesting in their own right, just not quite enough to keep me awake on the sofa until 10 p.m.
They found the treasure years ago – in selling TV shows.
The other day I was looking for “history” programming on cable, just out of curiosity. All of the possible channels were full of shows like this, and no “history” programming whatsoever.
Finding real history and not relaity shows or pseudoscience is a pain. It just seems to get lost in the shuffle.
The only place I can get actual history programming is on Samsung’s free service and even then I have to wade through to find it.
https://www.history.com/shows/the-food-that-built-america
I don’t care if it’s not 100% accurate (I don’t know how many liberties they take with the truth), I still enjoy this one.
Agree. Most of the “The [fill in the blank] That Built America” series are interesting.
Nice article UCS. Now that takes me back a few years but interestingly enough, I still lean on the theory today in some of my troubleshooting.
Mornin’, reprobates!
Very nice, UCS. But what I really want to know is, how many angels can dance on the head of pin nine?
Silly question – chip pins don’t have heads.
I identify as a pinhead!
Good morning, ‘patzie! Rest assured – we all think of you that way! 😉
Glib parrots!
https://nypost.com/2024/01/24/lifestyle/potty-mouthed-parrots-teaching-other-birds-to-swear-as-zoo-hatches-plan-to-stop-problem/
A wildlife park in the UK conspired a new plan to stop their potty-mouthed parrots from cursing, telling zoo visitors to “f—k off.”
Totally worth the price of admission.
I know which outcome my money is on. (I’ve met some African greys. Scary smart.)
The noises get a reaction from the wandering apes, make more of those noises.