DEV Community: sago35

Introduction to the event "TinyGo Keeb Tour 2024"

sago35 — Tue, 05 Nov 2024 01:49:30 +0000

This article introduces an event held in Japan. This is basically a translation of the following post, originally written in Japanese, into English.

https://sago35.hatenablog.com/entry/2024/10/29/095629

What is the TinyGo Keeb Tour 2024?

The TinyGo Keeb Tour 2024 is a hands-on workshop event combining TinyGo and DIY keyboards. Participants spend the morning soldering, followed by a software hands-on session in the afternoon. Don’t worry if you’re new to soldering—tools are provided, and staff are on hand to help.

It's exciting to see a keyboard you've built yourself working on a computer! The project for the event is the zero-kb02 macro pad (12 keys + joystick + rotary encoder + display). Besides functioning as a keyboard or macro pad, it can also serve as a development board for TinyGo with additional ports for various uses. With one of these, you can enjoy a variety of projects.

// Detect dark theme var iframe = document.getElementById('tweet-1812817785573232674-192'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1812817785573232674&theme=dark" }

Follow event information on Connpass:

https://tinygo-keeb.connpass.com/

Workshop materials and build guides are available here:

https://github.com/sago35/tinygo_keeb_workshop_2024

For support and communication before, during, and after the event, join us on Discord:

https://discord.gg/GKFsRXNRsX

The Beginning

On June 13, 2024, this tour started with a small team: micchie, ysaito, taknb2nch, and sago35. Many more staff members joined in as the project grew—thanks to everyone for their hard work!

The first kickoff meeting was scheduled for July 1, 2024. Before that date, we focused on designing and ordering the PCBs, with the current version finalized by June 16. The PCB design includes a matrix layout, and we ensured a display was included to make it fully enjoyable with TinyGo.

Traveling Across Regions

The 2024 tour covered four regions:

August 4, 2024 - Kobe with KOBE.go

Our first event! After deciding on the Kanto event on August 26, we organized a trial run in Kobe without soldering. We gathered at a hack bar, enjoyed drinks, and dived into the hands-on workshop, establishing a good flow for future sessions.

// Detect dark theme var iframe = document.getElementById('tweet-1819986841254461926-188'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1819986841254461926&theme=dark" }

// Detect dark theme var iframe = document.getElementById('tweet-1820110456859812118-145'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1820110456859812118&theme=dark" }

August 26, 2024 - Kanto with Women Who Go Tokyo

This event included soldering. We found a suitable venue and borrowed equipment like soldering irons from HAKKO and nanbuwks. Despite being new to teaching soldering, we managed successfully.

// Detect dark theme var iframe = document.getElementById('tweet-1827570363586507013-23'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1827570363586507013&theme=dark" }

There was also a session covering the basics of DIY keyboards.

While working through the hands-on activities, participants were free to create whatever they wanted, resulting in some interesting projects.

// Detect dark theme var iframe = document.getElementById('tweet-1827630059580231788-223'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1827630059580231788&theme=dark" }

// Detect dark theme var iframe = document.getElementById('tweet-1827623944167243924-715'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1827623944167243924&theme=dark" }

By the second stop on the tour, we had an official T-shirt. The design features a very long gopher holding an ISO Enter key and a soldering iron—such a cool design!

// Detect dark theme var iframe = document.getElementById('tweet-1827490483171684527-794'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1827490483171684527&theme=dark" }

October 12, 2024 - Sendai with Sendai.go

With knowledge accumulated from the first two events, the Sendai session went smoothly. The tour merchandise was expanded to include a tour towel—quite impressive!

// Detect dark theme var iframe = document.getElementById('tweet-1844911820097847705-733'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1844911820097847705&theme=dark" }

The soldering process went well, with significant improvements in the steps and documentation based on KPT feedback from previous events. Although there were a few minor issues, things progressed smoothly.

// Detect dark theme var iframe = document.getElementById('tweet-1844920215051829758-683'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1844920215051829758&theme=dark" }

We also enjoyed a traditional Imoni-kai (potato stew party)—it was delicious!

// Detect dark theme var iframe = document.getElementById('tweet-1844937065437462537-570'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1844937065437462537&theme=dark" }

// Detect dark theme var iframe = document.getElementById('tweet-1844944511551910147-74'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1844944511551910147&theme=dark" }

In Sendai, participants created a variety of interesting projects, as expected.

// Detect dark theme var iframe = document.getElementById('tweet-1845013834190184448-361'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1845013834190184448&theme=dark" }

The addition of the tour towel made for some fantastic photos.

// Detect dark theme var iframe = document.getElementById('tweet-1845018762350563375-221'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1845018762350563375&theme=dark" }

October 26, 2024 - Fukuoka with Kizuku.go

The final event of 2024. Documentation was further refined, reducing potential trouble spots.

// Detect dark theme var iframe = document.getElementById('tweet-1849996657875877892-943'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1849996657875877892&theme=dark" }

Participants mainly followed the build guide on their smartphones or other small devices while working.

// Detect dark theme var iframe = document.getElementById('tweet-1850015908787630157-119'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1850015908787630157&theme=dark" }

Even if there were any mistakes, the staff was ready to rework them, so participants could feel at ease!

// Detect dark theme var iframe = document.getElementById('tweet-1850026223176696257-875'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1850026223176696257&theme=dark" }

We also showcased a new MIDI functionality demo specifically for the Fukuoka event. Afterward, we ended up having a spontaneous MIDI session, practically forgetting about the keyboard hands-on workshop!

// Detect dark theme var iframe = document.getElementById('tweet-1850057554614943908-252'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1850057554614943908&theme=dark" }

// Detect dark theme var iframe = document.getElementById('tweet-1850083873906176037-211'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1850083873906176037&theme=dark" }

To wrap up, we took a final group photo to commemorate the tour.

// Detect dark theme var iframe = document.getElementById('tweet-1850100615810367812-300'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1850100615810367812&theme=dark" }

What is the zero-kb02 Hardware Used in the Tour?

The zero-kb02 is a 12-key macro pad specifically designed for the TinyGo Keeb Tour 2024. It includes a rotary encoder and joystick, making it enjoyable for everyday use as a DIY keyboard or macro pad. It also features a screen, allowing it to function as a development board for TinyGo.

As a demo, we’re developing a 2D game engine called Koebiten.

// Detect dark theme var iframe = document.getElementById('tweet-1841091471786852685-809'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1841091471786852685&theme=dark" }

For more details on zero-kb02, including the actual PCB data, check here. Since it's open-source, you’re free to order it yourself or 3D print a case.

sago35 / keyboards

keyboards

This repository was created to manage the circuitry and firmware for the keyboards I designed.
The firmware is created using sago35/tinygo-keyboard.

sg24

kicanvas

zero-kb02/

kicanvas
case (stl / 3mf)
workshop - https://github.com/sago35/tinygo_keeb_workshop_2024

pinout

Name	Pin	Info
VR_BTN	machine.GPIO0	InputPullup
WS2812	machine.GPIO1	Output
ROT_BTN1	machine.GPIO2	InputPullup
ROT_A1	machine.GPIO3	InputPullup
ROT_B1	machine.GPIO4	InputPullup
COL1	machine.GPIO5	Output
COL2	machine.GPIO6	Output
COL3	machine.GPIO7	Output
COL4	machine.GPIO8	Output
ROW1	machine.GPIO9	InputPulldown
ROW2	machine.GPIO10	InputPulldown
ROW3	machine.GPIO11	InputPulldown
SDA0_TX0	machine.GPIO12	I2C SDA
SCL0_RX0	machine.GPIO13	I2C SCL
EX01	machine.GPIO14	GPIO
EX02	machine.GPIO14	GPIO
EX03	machine.GPIO14	GPIO / ADC
EX04	machine.GPIO14	GPIO / ADC
VR_Y	machine.GPIO28	ADC
VR_X	machine.GPIO29	ADC

View on GitHub

The Nature of a Tour

Since this is a multi-event tour with the same theme, we’ve been able to gradually improve various aspects over time. For example, we’ve added notes to highlight common soldering mistakes and clarified the front and back sides of the PCB to prevent confusion. We also addressed questions like “How can I display Japanese fonts on the screen?” by adding relevant instructions to the workshop materials.

// Detect dark theme var iframe = document.getElementById('tweet-1846853358067356079-694'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1846853358067356079&theme=dark" }

Contributions

The event has inspired contributions to both the TinyGo core and the hands-on workshop materials, which is fantastic.

TinyGo Core
- https://github.com/tinygo-org/tinygo/issues/4519
Hands-On Materials
- https://github.com/sago35/tinygo_keeb_workshop_2024/pulls?q=is%3Apr+is%3Aclosed

Upcoming Plans

Planning an Online Event for Year-End

We’d like to hold an online event by the end of the year for people who already own a zero-kb02 or those interested in TinyGo embedded development. Stay tuned!

Interested in Hosting an Event in Your Area?

We’re looking for locations to host events in 2025 and beyond. If you’re interested, please reach out to the staff (micchie, ysaito, sago35, etc.). If there’s a local Go community, we’d love to collaborate with them as well.

Currently, the approach is to let local organizers handle venue selection. Events without soldering are possible (like the initial event in Kobe), but soldering is preferred if possible.

The TinyGo Keeb Tour Continues in 2025

The first event of 2025 is scheduled for January 13 in Takamatsu, Kagawa. We’re also considering additional locations as shown below.

TinyGo Conf!

We’re also planning a TinyGo event called TinyGo Conf in Japan.

In Closing

Thank you to all participants, the staff, and especially micchie, ysaito, and taknb2nch for starting this tour. We look forward to TinyGo Keeb Tour 2025!

Create Your Own Keyboard with sago35/tinygo-keyboard

sago35 — Fri, 01 Mar 2024 00:55:19 +0000

This article compiles information on creating a custom keyboard using TinyGo + Wio Terminal with sago35/tinygo-keyboard.

sago35/tinygo-keyboard is a package for building custom keyboards with TinyGo. It includes features such as layer support, various switch reading methods, and Vial compatibility.

sago35 / tinygo-keyboard

USB HID keyboard firmware for tinygo

USB HID Keyboard firmware for TinyGo

The API is not yet fixed.

The following are supported.

key input
- squared matrix scan
- matrix scan
- duplex-matrix scan
- rotary encoder
- GPIO
- UART
- Shifter (tinygo.org/x/drivers/shifter)
layer feature by mod key
mouse click / mouse wheel
support TRRS (UART)
support Vial
- Keymap
- Layers (MO(x), TO(x))
- Matrix testers
- Macros

Microcontrollers

The following microcontrollers are supported.

rp2040
nrf52840
samd51
samd21

Tutorial

tutorial.md

Additional Resources

sgkb-0.4.0

# sgkb-0.4.0
$ tinygo flash --target xiao-rp2040 --size short ./targets/sgkb/left/
$ tinygo flash --target xiao-rp2040 --size short ./targets/sgkb/right/

# sgkb-0.3.0 or before
$ tinygo flash --target xiao-rp2040 --size short ./targets/sgkb/left-0.3.0/
$ tinygo flash --target xiao-rp2040 --size short ./targets/sgkb/right/

files
- ./kicad/sgkb for KiCad 7.0
  - KiCanvas : sgkb-0.4.0 left
  - KiCanvas : sgkb-0.4.0 right
  - KiCanvas : sgkb-0.3.0 left
  - KiCanvas : sgkb-0.3.0 right

name	amount
Cherry MX / Kailh Choc V1	72
key cap (1u)	68

…

View on GitHub

Creating a Go / TinyGo Project

First, run go mod init to create a file called go.mod. This is a common procedure for starting a project in both Go and TinyGo.

$ mkdir mykeyboard

$ cd mykeyboard

$ go mod init main
go: creating new go.mod: module main

$ ls
go.mod

After creating go.mod, you'll need to go get the necessary sago35/tinygo-keyboard. Note that if you go get without specifying a version, it will fetch the latest version at that time, so the version may differ.

$ go get github.com/sago35/tinygo-keyboard
go: downloading github.com/sago35/tinygo-keyboard v0.0.0-20240229115423-a1702f57f94c
go: added github.com/sago35/tinygo-keyboard v0.0.0-20240229115423-a1702f57f94c
go: added golang.org/x/exp v0.0.0-20231226003508-02704c960a9b
go: added tinygo.org/x/drivers v0.27.0

Creating the Source Code

Next, import sago35/tinygo-keyboard and start building your keyboard.
It's a good idea to copy the code around here to use as a template:

Here, we'll create the following source code. The complete source code is available in the basic branch of the following repository:

https://github.com/sago35/tinygo-keyboard-examples/tree/basic

package main

import (
    "context"
    "machine"

    keyboard "github.com/sago35/tinygo-keyboard"
    "github.com/sago35/tinygo-keyboard/keycodes/jp"
)

func main() {
    d := keyboard.New()

    gpioPins := []machine.Pin{
        machine.WIO_KEY_A,
        machine.WIO_KEY_B,
        machine.WIO_KEY_C,
    }

    for c := range gpioPins {
        gpioPins[c].Configure(machine.PinConfig{Mode: machine.PinInput})
    }

    d.AddGpioKeyboard(gpioPins, [][]keyboard.Keycode{
        {
            // layer 0
            jp.KeyA,
            jp.KeyB,
            jp.KeyMod1,
        },
        {
            // layer 1
            jp.Key1,
            jp.KeyBackspace,
            jp.KeyMod1,
        },
    })

    d.Loop(context.Background())
}

Flash

We'll write to the Wio Terminal.

$ tinygo flash --target wioterminal --size short .
   code    data     bss |   flash     ram
  39076     684    9316 |   39760   10000

Operation Check

After flashing, the buttons at the top of the Wio Terminal will function as follows: respectively, as a, b, and Layer 1. While holding down Layer 1, it will function as 1 and BackSpace.

Explanation of the Source Code

The basic usage of sago35/tinygo-keyboard involves calling keyboard.New(), adding the desired keyboard type with AddXXXXKeyboard(), and then calling Loop(). Since all buttons on the Wio Terminal are directly connected to GPIO pins, we use AddGpioKeyboard().

    d := keyboard.New()
    d.AddGpioKeyboard(gpioPins, [][]keyboard.Keycode{
        {
            // layer 0
            jp.KeyA,
            jp.KeyB,
            jp.KeyMod1,
        },
        {
            // layer 1
            jp.Key1,
            jp.KeyBackspace,
            jp.KeyMod1,
        },
    })
    d.Loop(context.Background())

The values labeled jp.XXX above represent key settings.

Note: Instead of jp.XXX, you can also use the code from machine/usb/hid/keyboard/keycode.go.

jp.KeyMod1 is a special key used to switch layers. The keys related to layer switching are as follows. Note that for KeyModX, the same key needs to be assigned to the destination layer.

In sago35/tinygo-keyboard, you can currently use a total of 6 layers, from layer 0 to 5.

Key name	Action
`KeyMod0` to `KeyMod5`	Temporarily switch to layers 0 to 5 while pressed
`KeyTo0` to `KeyTo5`	Switch to layers 0 to 5 (sticky)

https://github.com/sago35/tinygo-keyboard/blob/main/keycodes/keycodes.go

Supported Key Inputs by sago35/tinygo-keyboard

sago35/tinygo-keyboard supports the following input methods. Additional formats can be added as needed. Please refer to the circuit diagram for details, as they may differ from common naming conventions.

DuplexMatrixKeyboard

This refers to a Duplex Matrix, also known as a Japanese Duplex Matrix, which allows handling twice the input compared to a regular matrix.

AddDuplexMatrixKeyboard(colPins, rowPins []machine.Pin, keys [][]Keycode)

The following circuit is targeted. It is used in targets/sgkb/left-0.3.0 and similar configurations.

GpioKeyboard

This is a keyboard that uses pins directly connected to GPIO. The polarity of button presses can be set using opt.

AddGpioKeyboard(pins []machine.Pin, keys [][]Keycode, opt ...Option)

MatrixKeyboard

This is probably the most commonly used method in DIY keyboards. By creating rows and columns of pins, you can handle many inputs with few pins. The polarity of diodes can be set using opt.

AddMatrixKeyboard(colPins, rowPins []machine.Pin, keys [][]Keycode, opt ...Option)

The following circuit is targeted. It is used in targets/sgkey and similar configurations.

RotaryKeyboard

This can handle rotary encoders.

AddRotaryKeyboard(rotA, rotB machine.Pin, keys [][]Keycode)

The following circuit is targeted. It is used in targets/xiao-kb01 and macropad-rp2040.

ShifterKeyboard

This can handle shift registers. It was created for the 74165TSSOP (74HC165 compatible?) used in pybadge/gobadge. The polarity of button presses can be set using opt.

AddShifterKeyboard(shifterDevice shifter.Device, keys [][]Keycode, opt ...Option)

SquaredMatrixKeyboard

This can handle improved squared matrices. It is very pin-efficient, allowing you to handle 20 input pins with just 5 pins, for example.

AddSquaredMatrixKeyboard(pins []machine.Pin, keys [][]Keycode)

The following circuit is targeted. It is used in targets/sgh60 and targets/xiao-kb01, among others.

UartKeyboard

This can handle key information sent via UART. It was primarily created for split keyboards.

AddUartKeyboard(size int, uart *machine.UART, keys [][]Keycode)

It is used in targets/sgkb, among others.

Configuring Vial Support

Vial is a project for setting keymaps from web browsers and the like. To use it with sago35/tinygo-keyboard, you need to set keyboard.KeyboardDef []byte. You can create a manual yourself, but basically, it's a good idea to prepare vial.json and create def.go with gen-def. We'll discuss this later.

When configured correctly, you can make settings from a web browser as shown in the screenshot below.

https://vial.rocks/

Creating vial.json

For detailed instructions on how to create vial.json, please refer to the following. However, since only a few items are used in sago35/tinygo-keyboard, it's a good idea to refer to existing vial.json files.

https://get.vial.today/docs/porting-to-via.html

Existing vial.json files can be found under targets/.

https://github.com/sago35/tinygo-keyboard/tree/main/targets
- https://github.com/sago35/tinygo-keyboard/blob/main/targets/wiokey/vial.json

For the layouts.keymap, you can create it by copying JSON from KLE / Keyboard Layout Editor's </> Raw data.

http://www.keyboard-layout-editor.com/

Since only the top 3 buttons of the Wio Terminal are used this time, the vial.json looks like this. The minimum required settings for sago35/tinygo-keyboard are as follows. Note that name / vendorId / productId can be set to anything.

{
    "name": "tinygo-wioterminal",
    "vendorId": "0x2886",
    "productId": "0x802D",
    "matrix": {"rows": 1, "cols": 3},
    "layouts": {
        "keymap": [
            ["0,2","0,1","0,0"]
        ]
    }
}

After saving the above as vial.json, run gen-def.

$ ls
go.mod  go.sum  main.go  vial.json

# Install gen-def
# It will be installed in the location displayed by `go env GOPATH`
$ go install github.com/sago35/tinygo-keyboard/cmd/gen-def@latest

# Generate def.go from vial.json
$ gen-def vial.json

$ ls
def.go  go.mod  go.sum  main.go  vial.json

The automatically generated def.go looks like this. Vial support is completed by calling loadKeyboardDef() defined here.

package main

import keyboard "github.com/sago35/tinygo-keyboard"

func loadKeyboardDef() {
    keyboard.KeyboardDef = []byte{
        // ...
    }
}

Please execute before calling d.Loop() as follows.

    loadKeyboardDef()
    d.Loop(context.Background())

The complete example source code is in main.go below.

sago35 / tinygo-keyboard-examples

examples of sago35/tinygo-keyboard

tinygo-keyboard-examples

This repository is an example of a project using sago35/tinygo-keyboard.

You can write to the Wio Terminal using the following command.

$ tinygo flash --target wioterminal --size short .

how to start your keyboard project

You can use the "gonew" command to copy the project template. Alternatively, you can also clone the GitHub project or download it as a zip file.

$ gonew github.com/sago35/tinygo-keyboard-examples example.com/your/keyboard
gonew: initialized example.com/your/keyboard in .\keyboard

$ cd ./keyboard

$ tinygo flash --target wioterminal --size short .

Update def.go

Use gen-def.

# install gen-def
$ go install github.com/sago35/tinygo-keyboard/cmd/gen-def@latest

# generage def.go from vial.json
$ gen-def vial.json

View on GitHub

Once you've successfully created the source code, try accessing Vial.
Note: Please use Chrome or Edge browser

https://vial.rocks/

Conclusion

We've covered the information for creating a custom keyboard using TinyGo + Wio Terminal with sago35/tinygo-keyboard. If you have any questions or concerns, feel free to reach out by posting on the Issues section of the following repository or mention me on Twitter/X or mention me on Mastodon. We're here to help, so don't hesitate to ask.

TinyGo + Vim + gopls

sago35 — Sat, 09 May 2020 07:19:14 +0000

You can now use tinygo.vim. For information on other editors, please check the URL below.

tinygo.vim
- https://github.com/sago35/tinygo.vim
IDE Integration | TinyGo
- https://tinygo.org/docs/guides/ide-integration/

In the following GIF, gopls works well with the PyPortal (atsamd51j20a) configuration.
You can confirm that you are jump correctly to board_pyportal.go etc.

Introduction

Gopls does not work well on tinygo for the following reasons.

TinyGo has its own built-in package
- machine, device, ...
buildtag

In this article, I will fix these problems by the following three items.
In the end, you will be able to use LSP with TinyGo.

Add replace directives to go.mod
Add go.mod to each package folder in tinygo
Set environment variables (GOOS + GOARCH + GOFLAGS)

Environment

Windows 10
Go version go1.14.1 windows/amd64
tinygo version 0.13.1 windows/amd64 (using go version go1.14.1 and LLVM version 10.0.1)
gopls ead0a569305d87def8dc4ad3899a7d78432b12c6
Vim 8.2.147
vim-go 13af5df6a1b3bc4bdfd03e3c05fa600d1dd16de6

note: Maybe it will work the same way on non-Windows and non-Vim.

1. Add replace directives to go.mod

Add directives for things like machine packages that are special to tinygo.
For example, it might look something like this

module tinygo.org/x/drivers

go 1.14

replace (
    device/sam => C:\tinygo\src\device/sam
    internal/reflectlite => C:\tinygo\src\internal/reflectlite
    internal/task => C:\tinygo\src\internal/task
    machine => C:\tinygo\src\machine
    os => C:\tinygo\src\os
    reflect => C:\tinygo\src\reflect
    runtime => C:\tinygo\src\runtime
    runtime/interrupt => C:\tinygo\src\runtime/interrupt
    runtime/volatile => C:\tinygo\src\runtime/volatile
    sync => C:\tinygo\src\sync
    testing => C:\tinygo\src\testing
)

2. Add go.mod to each package folder in tinygo

Note: if the right-hand side of a replace directive is a filesystem path, then the target must have a go.mod file at that location. If the go.mod file is not present, you can create one with go mod init.
https://github.com/golang/go/wiki/Modules#when-should-i-use-the-replace-directive

go.mod can be an empty file.
So, for example, in bash, you can create a go.mod like this

touch C:/tinygo/src/device/sam/go.mod
touch C:/tinygo/src/internal/reflectlite/go.mod
touch C:/tinygo/src/internal/task/go.mod
touch C:/tinygo/src/machine/go.mod
touch C:/tinygo/src/os/go.mod
touch C:/tinygo/src/reflect/go.mod
touch C:/tinygo/src/runtime/go.mod
touch C:/tinygo/src/runtime/interrupt/go.mod
touch C:/tinygo/src/runtime/volatile/go.mod
touch C:/tinygo/src/sync/go.mod
touch C:/tinygo/src/testing/go.mod

3. Set environment variables (GOOS + GOARCH + GOFLAGS)

When your target is a PyPortal, you can find out which environment variables to set with the following commands.

$ tinygo info -target pyportal
LLVM triple:       armv7em-none-eabi
GOOS:              linux
GOARCH:            arm
build tags:        cortexm baremetal linux arm sam atsamd51 atsamd51j20 atsamd51j20a pyportal tinygo gc.conservative scheduler.tasks
garbage collector: conservative
scheduler:         tasks

The following three things are required.

set GOOS=linux
set GOARCH=arm
set GOFLAGS=-tags=cortexm,baremetal,linux,arm,sam,atsamd51,atsamd51j20,atsamd51j20a,pyportal,tinygo,gc.conservative,scheduler.tasks

In bash, I think you can configure it as follows.

export GOOS=linux
export GOARCH=arm
export GOFLAGS=-tags=cortexm,baremetal,linux,arm,sam,atsamd51,atsamd51j20,atsamd51j20a,pyportal,tinygo,gc.conservative,scheduler.tasks

Conclusion

Add replace directives to go.mod
Add go.mod to each package folder in tinygo
Set environment variables (GOOS + GOARCH + GOFLAGS)

DEV Community: sago35

Introduction to the event "TinyGo Keeb Tour 2024"

What is the TinyGo Keeb Tour 2024?

The Beginning

Traveling Across Regions

August 4, 2024 - Kobe with KOBE.go

August 26, 2024 - Kanto with Women Who Go Tokyo

October 12, 2024 - Sendai with Sendai.go

October 26, 2024 - Fukuoka with Kizuku.go

What is the zero-kb02 Hardware Used in the Tour?

sago35 / keyboards

keyboards

sg24

zero-kb02/

pinout

The Nature of a Tour

Contributions

Upcoming Plans

Planning an Online Event for Year-End

Interested in Hosting an Event in Your Area?

The TinyGo Keeb Tour Continues in 2025

TinyGo Conf!

In Closing

Links

Create Your Own Keyboard with sago35/tinygo-keyboard

sago35 / tinygo-keyboard

USB HID keyboard firmware for tinygo

USB HID Keyboard firmware for TinyGo

Microcontrollers

Tutorial

Additional Resources

sgkb-0.4.0

Creating a Go / TinyGo Project

Creating the Source Code

Flash

Operation Check

Explanation of the Source Code

Supported Key Inputs by sago35/tinygo-keyboard

DuplexMatrixKeyboard

GpioKeyboard

MatrixKeyboard

RotaryKeyboard

ShifterKeyboard

SquaredMatrixKeyboard

UartKeyboard

Configuring Vial Support

Creating vial.json

sago35 / tinygo-keyboard-examples

examples of sago35/tinygo-keyboard

tinygo-keyboard-examples

how to start your keyboard project

Update def.go

Conclusion

TinyGo + Vim + gopls

Introduction

Environment

1. Add replace directives to go.mod

2. Add go.mod to each package folder in tinygo

3. Set environment variables (GOOS + GOARCH + GOFLAGS)

Conclusion