A simple Ti-86 assembly language program typed on the calculator

First of all, if you manage to type something in wrong it can hard lock the calculator, and you may have to pop the batteries, and lose everything on the calculator. So don't try typing assembly language programs unless losing everything on the calculator is acceptable.

Some basic facts about the Ti-86. It uses the Z-80 processor. Because it is difficult to write relocatable assembly language programs, the Ti-86 always relocates them to 0D748h. Two useful routines are _clrScrn at 4A82h and _puts at 4A37h

Google Gemini wrote the following assembly code and compiled it (note that Google Gemini did make a mistake once, which hard locked the calculator, so again, don't do this if there is anything on the calculator you care about losing).

CD 82 4A	; CALL $4A82
21 52 D7	; LD HL, $D752
CD 37 4A	; CALL $4A37
C9	        ; RET
48 45 4C 4C 4F 00	; DB "HELLO\0"

Next, we need to get it into the calculator, edit a program:

PROGRAM:ASMHELLO
AsmPrgm
CD824A
2152D7
CD374A
C9
48454C4C4F00

Then run this with: Asm(ASMHELLO)

You should get HELLO Done printed on the screen. Note that this was tested on a calculator with a rom version of 1.6

The start address and the calling routine numbers were found at https://github.com/abbrev/ti-86-asm/blob/db010670f8aad1509633b01d39c0c563e4ee7fb0/stranded/ti86asm.inc

Some notes Gemini wrote for readers of this post:

🧠 The Z80 Architecture: Why We Use HL

The Zilog Z80 processor, a 1970s workhorse, forms the brain of the TI-86. To understand the program, we need to look at its core components, especially its registers.

Our program uses the HL register pair. The 21 opcode for LD HL, nnnn is specifically designed to load a 16-bit memory address. This is critical because the _puts system routine (4A37h) is hardwired by the TI-86 operating system to look only at the HL register to find the starting address of the string it needs to print.

---

⚙️ Deconstructing the Hex: What the CPU Sees

Typing in hex means we are speaking the Z80's native machine language. Here is a breakdown of the "magic numbers" in our code:

• CD 82 4A (CALL $4A82): CD is the opcode for CALL. The address 4A82h is written in the Z80’s little-endian format (low byte first) as 82 4A. This is the absolute jump to the OS’s _clrScrn routine.
• 21 52 D7 (LD HL, $D752): 21 is the opcode for "Load 16-bit value into HL." The address D752h is where our string data starts, calculated from the program's load address 0D748h.
• CD 37 4A (CALL $4A37): Another CALL, this one jumps to the _puts routine at 4A37h to draw characters to the display buffer, starting from the address currently stored in HL.
• C9 (RET): This is the most crucial byte for stability. C9 is the opcode for Return, which safely hands execution control back to the Asm( shell, preventing a calculator lockup.
• 48 45...00: These are the ASCII codes for 'H', 'E', 'L', 'L', 'O', and finally, the null terminator (00), which tells _puts when to stop printing.

---

🛑 The Hex Trap: Why Relocatable Code Fails Here

Our program relies on absolute addressing, which is not ideal but necessary. We tried to write relocatable code using the Z80's "Pop the PC" technique (involving CALL followed by POP HL), but that method has a hidden requirement:

It needs a Relocating Loader (a feature of advanced assemblers) to fix the address inside the CALL instruction at runtime. Since the TI-86's hex editor is primitive, it loads the CALL operand as an unfixed absolute address, which would always jump to the wrong place ($0009 in our test) and crash the calculator.

Therefore, we are forced to rely on the fact that the shell always loads programs at 0D748h to calculate the string pointer. This makes the code fast and functional, but brittle—if the TI OS ever changes that load address, the program will break.

Use computers as powerful as in 1985 or AI controls humans or ?

A way to prevent AGI from taking over or destroying humanity is to strictly limit the computing power used on unknown AI algorithms. My back of the envelope calculations[1] show that restricting the hardware to 64 KiB of total storage is definitely sufficient to prevent an independence gaining AGI, and restricting to 2 MiB of storage is very likely to be sufficient to prevent an indepence gaining AGI. State of the art AI on the other hand tends to be using at least 1 GiB of RAM or much more and processing power in the teraflops range or more. As for an upper limit before we get AGI, whole brain emulation provides one, but that is on the order of 1 exoflops and 1 petabyte, so we do not have a precise idea of where the limits for AGI are. Also, we don't have a way to make sure that AI software is aligned with human goals and ethics.[2]

So here are options:

1. Only use really weak computers (midrange 1985 computers like a Mac 512K or an Atari 520ST would almost certainly be safe)
2. Just let AGI take control.
3. Hope that AGI really requires very powerful computers and ban them but allow less powerful computers that are well above what we are sure cannot be an AGI.
4. Hope there is outside intervention that prevents dangerous AGI (space aliens, divine intervention, dark lords of the matrix, etc.)
5. ???

So what should humanity do? I talked to a non-computer scientist about this, and his answer was that restricting us to circa 1985 power of computers was the best choice, which actually surprised me a little. Letting AGI take control can result in extinction, or the AGI imposing rules that we don't like.[3]

The problem is that we are metaphorically experimenting with 15 kiloVolt AC when we really should be experimenting with 5 volt DC because we have a very weak understanding of AI safety.

There can be different safe paths, but one that I am fairly sure would prevent independence gaining AGI would be: first of all, do research on what the limits are (check my back of the envelope calculations). Next, start working towards shutting down integrated circuit fabrication that is too advanced (10 μm feature size would at least make computers above the AGI limit expensive. 1 μm feature size would also significantly limit computers.) If consumer computers were on the order of 512 KiB RAM with 10 MFLOP/S processing power with one or two 720 KiB floppy drives for storage, stand alone, these could not be used for an independence gaining AGI.[4] (I think one 1200 bit/s or four 300 bit/s modem could probably be allowed, and a Mini CD-R drive could probably be allowed, but that would take new research.) A hard limit of 1 GiB of RAM and 1 GFLOP/S for computers that are restricted to non-AI research could probably be allowed for people willing to follow licensing restrictions of what can be run on the computer. 1 GiB RAM and 1 GFLOP/S compute would seriously restrict most current AI algorithms, and so would be hard to accidentally create an AGI on.

It seems to me that any path that is not at risk of accidentially creating an independnce gaining AGI will be very hard to achieve. Convincing people that AGI is a problem will be hard, figuring out what the limits are and convincing people of that will be hard, and since it seems like the limits are below currently existing computers, convincing people to give up running AI programs and other programs that might accidently turn into AI programs will be hard.

I don't know what humanity should do. As for me personally, if I had the choice between my current 1.6 GHz 4 core CPU with 24 GB of RAM computer that I am typing on, versus living in a world where we had eliminated existential risk from things like uncontrolled AGI and nuclear bombs, I would gladly trade my computer in for a 512 KB, 8 MHz computer with a floppy drive and a Mini CD-R and an modem level network connection if that is what we all need to do. I am curious what others think.

These are my own opinions and not those of my employer. This document may be distributed verbatim in any media.

[1]: https://www.researchgate.net/publication/388398902_Memory_and_FLOPS_Hardware_Limits_to_Prevent_AGI and for an earlier draft https://www.lesswrong.com/posts/9kvpdK9BLSMxGnxjk/thoughts-on-hardware-limits-to-prevent-agi and if you see any mistakes I made or have questions please tell me.

[2]: https://intelligence.org/2023/04/21/the-basic-reasons-i-expect-agi-ruin/ and https://www.lesswrong.com/posts/uMQ3cqWDPHhjtiesc/agi-ruin-a-list-of-lethalities

[3]: For example, two rules that I can imagine humans disliking would be 1. No eating vertebrates or cephalopods and 2. No going farther than 1 million km from Earth. I am not even sure that trying to change the AGI's mind on this would be a good idea (since we are vertebrates that do not like not to be eaten and we might want the AGI to impose restrictions like 2 on dangerous aliens).

[4]: Note that this very likely to host an independence gaining AGI because the re-writtable storage is under the 2 MiB limit (512 + 2 * 720 = 1952 <= 2048). New computers such as the 512 KiB Pineapple One RISC-V computer or the Adafruit Trinket M0 would be examples of other computers that would fine.

Truth, and How not to find it

This sermon is on various thoughts on truth that I gave at the Unitarian Universalist Church in Idaho Falls on October 20th 2024. HTML, PDF, Youtube

Moral Questions for the 2nd and 3rd Millennium

I gave a sermon on Moral Questions for the 2nd and 3rd Millennium on Sunday 2023-October-1 on moral questions for the 2nd and 3rd millennium, how new technology like AI, nuclear weapons, and horse drawn combine harvesters lead to new ethical questions. Also available in PDF

The coming technological singulary (30 years on)

30 years ago, Vernor Vinge gave a talk: The Coming Technological Singularity It is surprisingly still good. Also, I support: pausing AI experiments with powerful computers.

Open source house plans

Here are two places I have found open source house plans.
The first is by Jay Osborne and he has put up three CC 4.0 BY-SA farmhouses: Free Farmhouse
The second is an on going project to create various sustainable houses that is open sourcing the plans: One Community Global

Alpha and Omega, Omicron and LaMDA

I gave a sermon last Sunday on Alpha (Genesis), Omicron (Evolution), LaMDA and Omega (The End of Human dominance).

So if we create an AGI and fail to get sufficiently good Ethics in ver, the result is extinction or hell. ... Evolution mindlessly created beings with better Ethics than it. Hopefully, we can mindfully create beings with better Ethics than us.

Creating a pdf book from images or pdfs

This is my method of creating a pdf book for uploading to archive.org. First, I scan it into pdfs, usually about 10 scans (10 or 20 pages depending on the size of the page). I use a HP-Laserjet-200-colorMFP-m276nw. These scripts were all done on Fedora 35. Next I split out the images from the pdf:

mkdir out
for D in t??0; do
    cd $D
    mv scan.pdf scan0000.pdf
    for S in `ls scan0*`; do
        I=`echo $S | sed 's/scan\([0-9]*\).pdf/\1/'`
        echo $D $I
        pdfimages -png scan${I}.pdf ../out/s${D}_${I}
    done
    cd ..
done

Next I have three different ways of processing the book depending on how it was scanned. For each of these, I usually open a page and figure out what numbers I should use for the crop statement. The simpliest is if I scanned two pages at once, and am not splitting them:

cd out
for I in st*.png
do
    R=`echo $I | sed 's/s/r/' | sed 's/-/_/'`
    T=`echo $I | sed 's/s/t/' | sed 's/-/_/'`
    if test $I -ot $R
    then
	    echo $I $R $T already done
    else
	    echo $I $R $T
	    convert $I -crop 2550x3510+0 -rotate 90 -despeckle $R
	    convert $R -resize 33% -level 10%,90%,0.5 -posterize 32 $T
    fi
done

If I had to scan each page individually, half of them will flipped, so I need to flip some of them differently. Notice for this to work, I have to make sure that I always fip the odd ones and the even ones correctly when scanning.

cd out
for I in st*[02468].png
do
    R=`echo $I | sed 's/s/r/' | sed 's/-/_/'`
    T=`echo $I | sed 's/s/t/' | sed 's/-/_/'`
    if test $I -ot $R
    then
    	echo $I $R $T already done
    else
	    echo $I $R $T
	    convert $I -crop 1800x2700+0 -despeckle  $R
	    convert $R  -resize 33% -level 10%,90%,0.5 -posterize 32 $T
    fi
done

for I in st*[13579].png
do
    R=`echo $I | sed 's/s/r/' | sed 's/-/_/'`
    T=`echo $I | sed 's/s/t/' | sed 's/-/_/'`
    if test $I -ot $R
    then
	    echo $I $R $T already done
    else
	    echo $I $R $T
	    convert $I -crop 1800x2700+0 -rotate 180 -despeckle  $R
	    convert $R  -resize 33% -level 10%,90%,0.5 -posterize 32 $T
    fi
done

If I scanned two pages at once, and am planning to split them, I have a different script:

cd out
for I in st*.png
do
    R=`echo $I | sed 's/s/r/' | sed 's/-/_/'`
    RA=`echo $R | sed 's/.png/a.png/'`
    RB=`echo $R | sed 's/.png/b.png/'`
    T=`echo $I | sed 's/s/t/' | sed 's/-/_/'`
    TA=`echo $T | sed 's/.png/a.png/'`
    TB=`echo $T | sed 's/.png/b.png/'`
    if test $I -ot $R
    then
	    echo $I $R $T already done
    else
	    echo $I $R $T $RA $RB $TA $TB
	    convert $I -crop 1790x1350+0 -rotate 90 -despeckle $RB
	    convert $I  -crop 1790x1350+0+1350 -rotate 90 -despeckle $RA
	    convert $RA -resize 33% -level 10%,90%,0.5 -posterize 32 $TA
	    convert $RB -resize 33% -level 10%,90%,0.5 -posterize 32 $TB
    fi
done

Lastly, I need to create pdfs out of it.

img2pdf tt*.png --author "Fred Smith"  --title "Smithing" -o ../smithing_1925_small.pdf

img2pdf rt*.png --author "Fred Smith"  --title "Smithing" -o ../smithing_1925.pdf

Checklist for if a book or magazine might be public domain

First of all, I am not a lawyer, and so this is not legal advice. I would recommend that if you are interested in copyright terms in the United States, you read Circular 15a from the US Copyright Office

If it is a paper document (book, magazine etc) that was published more than 95 years ago, then it is out of copyright (in 2022, this is 1926, and it goes up every year until 2071, when it gets more complicated because the US laws changed in 1976/1977)

For the years till 1963, if the copyrights were not renewed, then it might be out of copyright (note that there is no completely reliable way to check that something newer than 95 years is out of copyright, since part of it could be based on something that is still in copyright). Here is my checklist for finding things that might be out of copyright

1. Published in 1963 or before
2. Published in the United States (The title page better include a United States city for the publisher, and nothing that says published in Great Britain or other country)
3. Search the Stanford's Copyright Renewal Database and make sure it is not found in it. Note that it only lists books copyrighted in the United States.
4. Search the Library of Congress Copyright Catalog. Note this includes magazines and other things besides books, but it does not include renewals before 1978, so anything published 1950 or before will not be in here (and you could renew early, so 1951 or nearby could also be missed)

If you are trying to find a book that might be in the public domain, most of these checks can be done from the information in a library catalog or a used book site. Different book subjects have different probabilities of being renewed. For example, of the math and physics books I have checked, 90% or so were renewed. For computer hardware books, only 10% or so were renewed. I have checked five difference scientific conferences (over a hundred articles) and have yet to find a paper in them that was renewed. Also, if you have a bibliography, you can do these checks with the information in the bibliography and if they pass you can then see if you can get a hold of the book, article or magazine.

If the renewal requirement hadn't been eliminated in the 1980s, I suspect there would be a lot more books in 1964 and later that would have become public domain, but are currently out of print and getting harder to find.

 

Fascinating article, If you read one article about American politics this month, I recommend this one:

 

"It’s common these days to hear people talk about sick America, dying America, the end of America. The same kinds of things were said in 1861, in 1893, in 1933, and in 1968. The sickness, the death, is always a moral condition. Maybe this comes from our Puritan heritage. If we are dying, it can’t be from natural causes. It must be a prolonged act of suicide, which is a form of murder.

 

I don’t think we are dying. We have no choice but to live together—we’re quarantined as fellow citizens. Knowing who we are lets us see what kinds of change are possible. Countries are not social-science experiments. They have organic qualities, some positive, some destructive, that can’t be wished away. Our passion for equality, the individualism it produces, the hustle for money, the love of novelty, the attachment to democracy, the distrust of authority and intellect—these won’t disappear. A way forward that tries to evade or crush them on the road to some free, smart, real, or just utopia will never arrive and instead will run into a strong reaction. But a way forward that tries to make us Equal Americans, all with the same rights and opportunities—the only basis for shared citizenship and self-government—is a road that connects our past and our future."

https://www.theatlantic.com/magazine/archive/2021/07/george-packer-four-americas/619012/

Public Domain Books to Restart Computer Technology

CollapseOS is a project to make an operating system and tools that can help restart technology after a civilization collapse: https://collapseos.org/

Of course, the software is only part restarting computer technology.  The other part is building things like transistors or vacuum tubes and turning those into computers. 

If you only had one book to take back, I would recommend Understanding Digital Computers by Paul Siegel, which includes overviews of how transistors, vacuum tube, magnetic core memory and other things work. It shows how to make memory and logic gates from these, and how to put them together into a full computer. And more importantly the 1961 edition of this book does not seem to have the copyright renewed (checked at Stanford and LOC) so it is public domain and available at: https://archive.org/details/understanding_digital_computers

Of course, you might want more detail if you have to recreate computers, since manufacturing something with feature size smaller than a millimeter and control of the composition at better than parts per million. So I made a list of books that I believe are public domain (either because they were written by the government or because they are US books publish 1963 or before and the copyright was not renewed). This list includes ones with much more detail on transistors, vacuum tubes, magnetic core memory and also basic materials and science information that can be useful.

General Computer Information:

• Understanding Digital Computers https://archive.org/details/understanding_digital_computers
• Electronic Computers: A Made Simple Book https://archive.org/details/electronic_computers_made_simple
• Digital Computer Components and Circuits https://archive.org/details/digital_computer_components_and_circuits

Numbers with Computers:

• Arithmetic Operations in Digital Computers https://archive.org/details/arithmetic_operations_in_digital_computers
• Introduction to Numerical Analysis https://archive.org/details/introduction_to_numerical_analysis_hildebrand

Transistors:

• Transistor Circuit Analysis and Design https://archive.org/details/transistor_circuit_analysis_and_design
• TM11-690 https://radionerds.com/images/0/01/TM_11-690_BASIC_THEORY_AND_APPLICATIONS_OF_TRANSISTORS.pdf
• Transistor Technology Volumes 1 to 3:
  https://archive.org/details/transistor_technology_v1
  https://archive.org/details/transistor_technology_v2
  https://archive.org/details/transistor_technology_v3
• Semiconductors https://archive.org/details/semiconductors_hannay

Vacuum Tubes:

• Theory of Thermionic Vacuum Tubes https://archive.org/details/Theory_of_Thermionic_Vacuum_Tubes_E._Leon_Chaffee_Ph.D._1933
• TM11-662 https://archive.org/details/TM11-662

Alternative Computer Construction:

• Digital Applications of Magnetic Devices https://archive.org/details/digital_applications_of_magnetic_devices
• Relay Engineering https://archive.org/details/relay_engineering_1962

Basic Science:

• Principles of Chemistry https://archive.org/details/principles_of_chemistry_1963
• Elementary Quantum Mechanics https://archive.org/details/elementary_quantum_mechanics_fong
• Introduction to Theoretical Physics https://archive.org/details/introduction_to_theoretical_physics_wangsness

Materials:

• Metals Handbook 1948 https://archive.org/details/metals_handbook_1948
• Metals and Plastics https://archive.org/details/metals_and_plastics_1947

This list is unfortunately missing the technology that made computers cheap in the 1970s: mask produced integrated circuits using complementary metal oxide semiconductors (CMOS), since that was just starting to be developed in 1964 when copyright still applies. (Transistor Technology Volume II chapter 9 discusses field effect transistors and Transistor Technology Volume III chapter 5 discusses photo engraving which are precursors technologies.)

Never the less, having a paper copy of these books would help you greatly should you ever wish to restart computer technology after a civilization collapse.

Update (2021-October-1): 

Additional public domain books and papers.

CMOS article:

• DTIC ADA033080: Introduction to Custom CMOS LSI's for Digital Logic https://archive.org/details/DTIC_ADA033080
  

Printing and Engraving (Similar techniques to photo-lithography for integrated circuits):

• Circular of the Bureau of Standards no. 565: https://archive.org/details/circularofbureau565davi
• Microphotography  https://archive.org/details/microphotography_1957

Transistor engineering and physics:

• Transistor Engineering and Introduction to Integrated Semiconductor Circuits https://archive.org/details/transistor_engineering_1962
• Semiconductor Device Physics https://archive.org/details/semiconductor_device_physics_1962

Logic design:

• Digital Computer Design Fundamentals https://archive.org/details/digital_computer_design_fundamentals_chu
• The Logic Design of Transistor Digital Computers https://archive.org/details/the_logic_design_of_transistor_digital_computers_1963
• Switching Circuits with Computer Applications https://archive.org/details/switching_circuits_with_computer_applications_humphrey

More Math:

• Boolean Algebra and Its Applications https://archive.org/details/boolean_algebra_and_its_applications_1961
• Elementary Mathematics from an Advanced https://archive.org/details/elementary_mathematics_arithmetic_algebra_analysis and https://archive.org/details/elementary_mathematics_geometry

Integrated Circuits:

• Introduction to Integrated Semiconductor Circuits https://archive.org/details/introduction_to_integrated_semiconductor_circuits_1963
• Semiconductor Fundamentals Devices and Circuits https://archive.org/details/semiconductor_fundamentals_devices_and_circuits_1963

Dictionary of Applied Physics (From the 1920s, but comprehensive):

• https://archive.org/details/in.ernet.dli.2015.152557
• https://archive.org/details/in.ernet.dli.2015.176701
• https://archive.org/details/dli.bengal.10689.570
• https://archive.org/details/in.ernet.dli.2015.212412
• https://archive.org/details/in.ernet.dli.2015.37757

P.S. TM11-690 is also at archive.org: https://archive.org/details/tm_11_690_theory_and_application_of_transistors

Internet doesn't have to be awful

"This way of thinking has some distinct advantages. Right now companies fight intensely to retain their exemption from “intermediary liability,” guaranteed to them by the now-infamous Section 230 of the Communications Decency Act. This frees them from legal responsibility for nearly all content posted on their platform. Yet striking down Section 230 could mean that the companies will either be sued out of existence or start taking down swaths of content to avoid being sued. Focusing on regulating algorithms, by contrast, would mean that companies wouldn’t be liable for each tiny piece of content, but would have legal responsibility for how their products distribute and amplify material. This is, after all, what these companies actually do: organize, target, and magnify other people’s content and data. Shouldn’t they take responsibility for that?"

https://www.theatlantic.com/magazine/archive/2021/04/the-internet-doesnt-have-to-be-awful/618079/

Polebridge Montana makes the BBC

 Polebridge makes the BBC: http://www.bbc.com/travel/story/20210215-welcome-to-polebridge-one-of-the-us-last-frontiers

Joe Biden's inauguration speech

 https://www.bbc.com/news/world-us-canada-55656824

Equifax doesn't actually send yearly credit reports

Equifax doesn't actually send an annual credit report. What they will send is a credit report if it has been 365 days since the last time they sent an annual credit report, and since they will not send it on a weekend, if you order one on the same day, you will not always get it if you ask for it on the exact same day.  So some years you actually have to wait more than one year for their "annual" credit year. For me, this year I got a letter from them "We received your request for a copy of your annual free credit report from Equifax. However, our records indicate that a free copy already has been sent to you in the past 12 months." This is BS since I requested it last year on January 1, 2020, and I ordered it this year on January 1, 2021.  (Experian and Transunion do not have this problem.)
Another comment is that it would be better for consumers if the law just required sending a credit report every year instead of every 365 days.

(P.S. after complaining, Equifax, did send one.)

circuitpython example with text

Now with some text as well (and I grant this python code to the public domain as well.)

import time

import board
import displayio
import digitalio

import vectorio
import gamepadshift
import terminalio

BUTTON_LEFT = 128
BUTTON_UP = 64
BUTTON_DOWN = 32
BUTTON_RIGHT = 16
BUTTON_SELECT = 8
BUTTON_START = 4
BUTTON_A = 2
BUTTON_B = 1

print('About to begin.')
for i in range(3,0,-1):
    print(i)
    time.sleep(0.2)


circle = vectorio.Circle(10)
circle2 = vectorio.Circle(6)

display = board.DISPLAY

palette = displayio.Palette(2)
palette[0] = 0x000000
palette[1] = 0xFFFFFF
palette.make_transparent(0)

def get_char_tile(c, x, y):
    g = terminalio.FONT.get_glyph(ord(c))
    tile = displayio.TileGrid(g.bitmap, pixel_shader=palette,  tile_width=g.width, tile_height=g.height, default_tile=g.tile_index, x=x, y=y)
    return tile

def get_string_group(s, x, y):
    text_w, text_h = terminalio.FONT.get_bounding_box()
    group = displayio.Group(max_size=len(s))
    for i, c in enumerate(s):
        group.append(get_char_tile(c, x+text_w*i, y))
    return group


palette2 = displayio.Palette(2)
palette2[0] = 0xFF0000
palette2[1] = 0x0000FF
palette2.make_transparent(0)

vect = vectorio.VectorShape(shape=circle, pixel_shader=palette)
vect2 = vectorio.VectorShape(shape=circle2, pixel_shader=palette2, x=5, y=-5)
s = get_string_group("Hey World!",15,0)
vect3 = vectorio.VectorShape(shape=vectorio.Rectangle(2, 10), pixel_shader=palette2)

move_group = displayio.Group()
move_group.append(vect)
move_group.append(vect2)
group = displayio.Group()
group.append(move_group)
group.append(s)
group.append(vect3)


display.show(group)
#display.show(group2)

group.x = 20
group.y = 20

pad = gamepadshift.GamePadShift(digitalio.DigitalInOut(board.BUTTON_CLOCK),
                                digitalio.DigitalInOut(board.BUTTON_OUT),
                                digitalio.DigitalInOut(board.BUTTON_LATCH))
button = 0
while button != BUTTON_START:
    button = pad.get_pressed()
    if button & BUTTON_UP == BUTTON_UP:
        move_group.y += -1
    if button & BUTTON_DOWN == BUTTON_DOWN:
        move_group.y += 1
    if button & BUTTON_LEFT == BUTTON_LEFT:
        move_group.x += -1
    if button & BUTTON_RIGHT == BUTTON_RIGHT:
        move_group.x += 1
    time.sleep(0.01)
    move_group.x %= display.width
    move_group.y %= display.height

Simple pybadge circuitpython code example

I just got a pybadge, and I was trying to find an example that used the display but only used the core libraries. I couldn't find one, so here it is. I grant this code to the public domain.

import time

import board
import displayio
import digitalio

import vectorio
import gamepadshift

BUTTON_LEFT = 128
BUTTON_UP = 64
BUTTON_DOWN = 32
BUTTON_RIGHT = 16
BUTTON_SELECT = 8
BUTTON_START = 4
BUTTON_A = 2
BUTTON_B = 1

print('About to begin.')
for i in range(3,0,-1):
    print(i)
    time.sleep(0.2)

circle = vectorio.Circle(10)
circle2 = vectorio.Circle(6)

palette = displayio.Palette(2)
palette[0] = 0x000000
palette[1] = 0xFFFFFF
palette.make_transparent(0)
palette2 = displayio.Palette(2)
palette2[0] = 0xFF0000
palette2[1] = 0x0000FF
palette2.make_transparent(0)

vect = vectorio.VectorShape(shape=circle, pixel_shader=palette)
vect2 = vectorio.VectorShape(shape=circle2, pixel_shader=palette2, x=5, y=-5)

group = displayio.Group()
group.append(vect)
group.append(vect2)
display = board.DISPLAY

display.show(group)

group.x = 20
group.y = 20

pad = gamepadshift.GamePadShift(digitalio.DigitalInOut(board.BUTTON_CLOCK),
                                digitalio.DigitalInOut(board.BUTTON_OUT),
                                digitalio.DigitalInOut(board.BUTTON_LATCH))
button = 0
while button != BUTTON_START:
    button = pad.get_pressed()
    if button == BUTTON_UP:
        group.y += -1
    elif button == BUTTON_DOWN:
        group.y += 1
    elif button == BUTTON_LEFT:
        group.x += -1
    elif button == BUTTON_RIGHT:
        group.x += 1
    time.sleep(0.01)
    group.x %= display.width
    group.y %= display.height

  

How Trump Changed America

 "Seeking to understand rather than be understood requires a suppression of ego that takes practice. Lots of us are out of practice."

https://fivethirtyeight.com/features/how-trump-changed-america/

Don't vote for Trump

In 2016 American voters did not know whom they were getting. Now they do. They would be voting for division and lying. They would be endorsing the trampling of norms and the shrinking of national institutions into personal fiefs. They would be ushering in climate change that threatens not only distant lands but Florida, California and America’s heartlands. They would be signalling that the champion of freedom and democracy for all should be just another big country throwing its weight around. Re-election would put a democratic seal on all the harm Mr Trump has done.

https://www.economist.com/leaders/2020/10/29/why-it-has-to-be-biden

MeWe 400 bad request

I have tried to create an account at MeWe multiple times, on two different ISPs spaced months apart (June and September of 2020), on Firefox, Chromium and Safari on Fedora, Ubuntu and macOS and every single time I get a 400 Bad Request when it tries to access
https://mewe.com/api/v3/auth/register

Posting because this in not in their support page, and no one else seems to have posted about this problem.