Don’t have enough storage on your nextcloud box? You can use Object Storage providers like Cloudflare R2, I will how you how.

Why I recommend Cloudflare R2

Cloudflare offers cheap object storage, and Nextcloud has decent performance with R2.

1. Storage capacity

• 10GB free each month, then ~$0.02 each GB exceeded

This means you can have infinite storage for free, but you will be charged a small amount for the month if you exceed 10GB in that month.

2. Low costs for I/O

• 1 Million Write operations for free each month, then $4.50 USD for the other millions
• 10 Million Read operations for free each month, then $0.40 USD for the other millions

This means you will have 1M write operations and 10M read operations completely for free, If you host a personal Nextcloud instance (like I do), then it is very unlikely for your instance to exceed this in a matter of a month.

If you want to check more on Cloudflare’s pricing, check out their R2 pricing calculator.

Configuring Nextcloud

To do this, you must have Nextcloud extracted but not installed via the web UI yet, here’s a tutorial on installing nextcloud so you can get started.

Now, assuming Nextcloud is in /var/www/nextcloud we are going to create a new configuration file while we create our storage bucket.

nano /var/www/nextcloud/config/s3.config.php

On another browser window, go to the Cloudflare Dashboard and go to R2 > Overview

In that page, create a new bucket, doesn’t matter what the name is.

Then, go to your bucket’s Settings, and copy the “S3 API” url.

After this, go back to the R2 overview page and create an API token

This should be the configuration for the API token

For extra security, you can restrict what IP can use the API token

When you click create, do not copy the Token Value, copy the Access Key ID and Secret Access Key.

Now you are ready to configure Nextcloud pre-install.

Go back to your terminal, and write a configuration like this:

<?php
$CONFIG = array (
  'objectstore' => [
       'class' => '\\OC\\Files\\ObjectStore\\S3',
       'arguments' => [
               'bucket' => 'nextcloud-tutorial',
               'hostname' => 'xxxxx.r2.cloudflarestorage.com',
               'key' => 'access_key_id',
               'secret' => 'secret_access_key',
               'use_path_style' => true,
               'region' => "auto",
               'use_ssl' => true,
               'use_path_style' => true,
               'verify_bucket_exists' => false,
               'validateWrites' => false,
               'concurrency' => 1,
               'sse_c_key' => 'your_encryption_key_here',
       ],
],
);

(Edited slightly in 2025-06-07 for this fix)

Here’s what you need to change:

• Change nextcloud-tutorial to your R2 bucket’s name.
• Change xxxxx.r2.cloudflarestorage.com to the S3 API URL you copied, remove the bucket name from the URL.
• Change access_key_id to the Access Key ID you copied.
• Change secret_access_key to the Secret Access Key you copied.
• Change your_encryption_key_here to an encryption key, use openssl rand --base64 32 to generate one, this is optional, if you don’t want to encrypt, delete the line.

Then, save your file by pressing CTRL-S then exiting nano by pressing CTRL-X

After that, you can access your Nextcloud URL and install Nextcloud like normal. Instead of files being stored in internal storage, your files are now in an R2 bucket, enjoy the free space!

So this question has been circulating for a while:

Why am I called Swee?

The answer for this is not quite simple. Around 5-6 years ago at time of posting, I registered a scratch account with the name SweetiePieH1, I actually liked using it, but later on as I matured, I realize the name’s a bit long… and quite embarrassing >//>

So I decided to try something creative, take some part of the same out to make a name that’s easy to type, and not embarrassing, it’s a win win!

What I didn’t realize was that there was a lotta accounts named “Swee” around the web, so from inspiration from Dream (Yes, that Minecraft YouTuber) DreamWasTaken, I set my usernames in GitHub, Discord, etc. to Sweeistaken

So that settles the Swee part, but we haven’t gotten halfway through the question.

How/Why did I pick the name “Nova Cat” for my fursona?

Okay, the name part is simple, but this explains some lore about the character.

At the time, what is called now “SweeZero” started as a Roblox group named “Swee Studios”. It used accent colors of green and red in the logo, which don’t mix well because they’re complementary colors.

I thought it might be time for Swee Studios to have a new name. Rookie mistake: I used AI to do so, and everyone knows the only thing AI is good at is plagiarism.

So I decided to make my own name & logo again, and came up with SweeZero when thinking about binary.

The SweeZero logo uses the same colors as NovaSoftia because Light Green mixes well with Medium Blue since they’re Analogous colors. But the logo design took inspiration from the Swee Studios design (SZ)

This is a sketched concept of the choice, the real logos exist, but aren’t drawn to exact. So my latest fursona is a soft(ia) cat named Nova. He also has colors of SweeZero & NovaSoftia.

Similarly, Nova Cat’s trauma was connected to NovaSoftia’s sudden name change (everyone wants to get rid of him.)

Since I’m now a furry, I decide that I have my display name set as Nova Cat, but still known as Swee.

You can comment here if you want more info.

If you didn’t know, SweeBlogs used to be on WordPress,
later in 2025, I’ve decided to migrate this old wordpress site to Jekyll.

This is just a test post to announce that my migration is in progress!

Why Linux?

It’s a simple question, but doesn’t have a simple answer.
Most of my opinions on Linux over Windows are from experience for years, so it will probably be biased.

1. Privacy

Trying to get the maximum privacy on a Windows box is hard, especially patches/tools that aren’t power user-friendly.

Linux, however, has privacy in your own hands/paws, whatever you choose has a mixed capability of privacy, most importantly,

Linux and (almost all of) its software are open-source, meaning anyone has the ability to read its code & what it does, that also means people can contribute to its code or make their own versions of it to increase features or more importantly, privacy.

Windows completely lacks this as it is a proprietary operating system, with mostly proprietary software (since it’s easier to do so)

2. Performance

Mainly, the latest version of Windows (Right now, 11) is a very bloated piece of shit, it “requires” high-end hardware and even then, computers that meet the requirement suffer from the OS’ use of resources, I also believe Windows services (like Update) are a waste of time.

Linux offers more of a choice of your balance of a lightweight system, or a heavy (but beautiful) look. With many choices of a desktop environment like:

• XFCE (Popular and lightweight)
• GNOME (Kind of in the middle)
• KDE (Great looks, lots of GPU power)

3. Virtualization

We all know virtualization is quite an important part of testing application development, we all know of VirtualBox & VMWare workstation, in my opinion they’re all quite shit.

KVM is a great hypervisor for Linux, there’s no denying. It’s fast, it’s free, and it fully supports Linux. My recommended alternative for KVM on Windows would be Hyper-V.

What distro do I use?

Last year, I’ve been using Debian Testing for more up-to-date packages. In 2025 I decided to try Alpine Linux.

![Screenshot of my fastfetch output in January 8th, 2025(1.jpeg)

Why Alpine?

Alpine Linux is a linux distribution that uses an alternative suite of programs/services than other distributions like Debian or the 10 billion Red Hat Linuxes (no offense lol).

• Regular Linux distros use systemd, Alpine (and Gentoo) uses OpenRC
• Regularly, Linux distros today have the GNU Coreutils, Alpine (and other minimal distros) still use BusyBox.
• Almost all Linux distros use GNU C Library (glibc) while Alpine uses the more recent musl libc, which can ruin compatibility though.

But Alpine is for containers!

Shut up, Alpine is just as good as a desktop distribution. It has the latest KDE 6 and its suite. While Debian Testing does have KDE 6, it still has components that are stuck in version 5. Plus, I find Alpine more snappier than Debian-based distributions with the same DE. I also love the OpenRC init system, it makes my boot speed way faster.

Conclusion

I love using Linux on all of my machines, it’s fast, private, and easy to develop with. I really love Alpine for its more lightweight approach in a system suite. despite Alpine being popular for containers (especially docker), it’s just as good for desktops.

Though I am aware Linux is more friendly for geeks, but IMO, Linux seems to be evolving a lot when it comes to user friendliness, and will probably be ready for regular users in the upcoming years.

This post is mainly showing how my life completely changed in 2024.

1. Joined IRC this year.

IRC is a rather old chatting platform, possibly one of the oldest on the net! I’ve decided to try out IRC when I saw “Quassel IRC” preinstalled on Lubuntu, after that, I decided to register my first IRC account, on the Libera.Chat network as swee using my galaxy tab 3.

What stood out most was some popular off-topic channels (Like ## and ##chat) and the ##furry channel, but we’ll get to that later.

The Libera.Chat network has an interesting but rather friendly community, I spent most of my time staying awake the whole night, using my tab 3 to chat on IRC. It was a nice experience actually! People were quite impressed with my skills for such a young age.

IRC also changed my path when it came to programming, my most successful projects being MeowNexUS and Codename IRCat.

2. Became a furry.

Now this is another one of the major changes I had.

Either last year or two years ago, I tried to become a furry on scratch. Rookie mistake: I told my parents about it.

This time, in the ##furry channel on libera, I’ve decided to fake myself as a furry with the nickname sweeCat though the “pretending” didn’t last long when I began making fursonas and ref sheets, months later I decide “fuck it, I’m a furry now.”

So I basically faked it ‘till I made it.

Honestly, I absolutely adore furry roleplay (as long as it’s SFW & wholesome), although the thought of being e-cuddled lots (and enjoying it) might sound weird to you, but whatever, it’s cute :3

3. Got a domain & VPS.

Yeah, all this work to get my website up, and this discourse instance too!
I now get an allowance of $5/mo so it’s pretty easy if I get a budget VPS like I have right now.
It’s not that much work for me to moderate all of this, so yeah :3

Other things:

• Joined discord
• Tried the Mastodon Fediverse
• Joined Matrix
• Started migrating to Linux

So, I was away for a bit. Why? I just wanted to take a break and just follow my heart. Soo I ended up with 2 Pi Zero 2 W’s, and a Pi camera module I’m going to be talking about. Let’s see if this is as good as the regular!

Part 1: Setup

So, for this you’ll need:

• The camera (DO NOT OPEN BOX YET)
• A Pi
• Some kind of grounding*
• Pi Camera to Pi Zero CSI port**

* although optional, still highly recommended. I accidentally killed my first camera module with static even though the humidity in my room is at the comfortable 50%.

** required only if you’re using any kind of Pi Zero.

After getting the supplies, ground yourself and open the camera module box. It should include the camera, a regular cable and a piece of blue film. At first I thought that was a filter that will remove the saturation, but it made things worse on the color side.

Get out your camera module, and if you’re using the Pi Zero, yoink that cable and take out the cable you bought. Both for the Pi and the camera, have the piece of film on the cable face away from the board(image 2).

If you’re on the regular Pi, then, on the most versions, film should be facing the Ethernet port(image 1). Lift up the black tab and insert in the correct orientation.

Look closely near the Pi, black film is looking upwards

Now, the great thing is, Camera Module 3 works without any software setup, so it’s plug-and-play. Just boot up your pi and enter this into terminal:

libcamera-hello

In a second, you’ll see a camera preview if you have a desktop environment and copies of a line like this outputted in the console:

#111 (30.01 fps) exp 16834.00 ag 1.12 dg 1.06

To take a photo, you can enter this command:

libcamera-still -o coolname.jpg

Note: the setup and use applies to the regular camera module 3 too

Part 2: Review

Note: the review only applies to the NoIR version. Normal camera module review and more expansive testing will be done in the second part

So, let’s get to the pros and cons shall we?

Pros:

• Picks up IR light
• Includes an IR filter to correct the colors
• Picks up most if not all the colors indoors
• High quality photos
• High quality build
• Low price ($25 for regular & NoIR, $35 for regular & NoIR wide)
• Easy to use
• Ships with a cable compatible with most of the RPi versions

Cons:

• Colors are lost if photos are taken of the outdoors
• IR filter doesn’t do that great of a job correcting colors
• Very ESD static sensitive
• Doesn’t include a cable for Pi Zero
• Focus is off sometimes

To clear some things up, it’s a pretty dang good camera. Indoor photos all looked good and I was wondering why were people showing the scarily saturated photos. But when I took photos of the outside, I understood why.

So this is not really recommended if you’re doing any kind of outdoor photography where color really matters. It’s not big deal if you want to do object recognition, using the camera for security reasons or if you don’t care about the color. I couldn’t get it to work with motioneye though. So, here are all the test images:

INDOOR:

Camera module:

My phone:

Camera module:

Original image:

Natural light test indoors:

Natural light test indoors 2:

OUTDOOR:

Camera Module:

Camera Module w/ Included Filter:

My phone:

Camera Module 3:

My phone:

Yes, this is real! You don’t have to spend $100 on a practically illegal item for a funny prank or to educate your loved ones! In this guide, I will explain how to use USB HID libraries.

Part 0: Legality yap

Please be VERY sure that whatever your doing with this project is legal and follows the policies of the place if you’re doing it at a public place. DO NOT use this on stranger’s computers. I wish you happy jail-free fun!

Part 1: Required items

Here’s your shopping list for the project:

• Arduino capable of HID. This includes but is not limited to Arduino Leonardo, Arduino Nano ESP32, Arduino Due, Arduino Uno R4(both versions), etc.

• A cable to program the board.

Optional:

• A wire to short B1 and GND while programming.

• A breadboard for ease of use and shorting B1 and GND.

• A dummy computer to make sure you don’t ruin the main one.

Part 2: Code (Mouse)

Now open Arduino IDE, and paste in this code provided in the official Arduino Nano ESP32 cheatsheet:

#include "USB.h"
#include "USBHIDMouse.h"
USBHIDMouse Mouse;

void setup() {
  // put your setup code here, to run once:
  Mouse.begin();
  USB.begin();
}

void loop() {
  // put your main code here, to run repeatedly:
  Mouse.move(5, 0, 0); 
  delay(50);
}

If you upload this to your Arduino and keep it plugged in, it should start moving your mouse! We can easily modify the script to turn it into an annoying mouse jitterer:

#include "USB.h"
#include "USBHIDMouse.h"
USBHIDMouse Mouse;

void setup() {
  // put your setup code here, to run once:
  Mouse.begin();
  USB.begin();
}

void loop() {
  // put your main code here, to run repeatedly:
  Mouse.move(random(-50, 50), random(-50, 50), 0); 
  delay(50);
}

Now upload the code again and see your mouse jitter like crazy!

Tip: I recommend turning on boot loader mode on your Arduino before uploading, because uploading will get difficult to do!

Here’s the syntax for the function Mouse.move():

mouseObj.move(int x, int y, int wheel, int pan);

Now time to talk clicks. Paste this code into Arduino IDE:

#include "USB.h"
#include "USBHIDMouse.h"
USBHIDMouse Mouse;

void setup() {
  // put your setup code here, to run once:
  Mouse.begin();
  USB.begin();
}

void loop() {
  // put your main code here, to run repeatedly:
  Mouse.click(); 
  delay(50);
}

Now unplug the board and repeatedly left click somewhere on the screen. Now plug in the board, and you should see the exact same behavior.

Here’s Mouse.click() syntax:

mouseObj.click(uint8_t button = MOUSE_LEFT);

NOTE: You don’t have to stick to the left click. You can do middle and right clicks too!

And last mouse functions: Mouse.press() and Mouse.release(), where Mouse.press() acts like a click and hold, and Mouse.release() acts like a button release. Syntax is similar to Mouse.click().

Part 3: Code (Keyboard)

Mouse was pretty fun, but keyboard is even more fun! You can write words, you can activate shortcuts, and more with pressing keys! But before that, lets first write something with it, just to see. Here’s Arduino-provided example of the keyboard:

#include "USB.h"
#include "USBHIDKeyboard.h"
USBHIDKeyboard Keyboard;

void setup() {
  // put your setup code here, to run once:
  Keyboard.begin();
  USB.begin();
}

void loop() {
  // put your main code here, to run repeatedly:
  Keyboard.print("Hello World");
  delay(500);
}

Now hit upload and click on a search bar or inside the code editor. You will see Hello World! being typed! You can basically use a text file as a serial monitor! Here’s the syntax for the Keyboard.print() function:

keyboardObj.print(const char * var);

Now, let’s get to keys! Paste this into the Arduino IDE:

#include "USB.h"
#include "USBHIDKeyboard.h"
USBHIDKeyboard Keyboard;

// Windows and Linux:
char ctrlKey = KEY_LEFT_CTRL;
// MacOS X:
//char ctrlKey = KEY_LEFT_GUI;

void setup() {
  Keyboard.begin();
  USB.begin();
}

void loop() {
  delay(1000);
  Keyboard.press(ctrlKey);
  Keyboard.press('n');
  delay(100);
  Keyboard.releaseAll();
}

After you hit upload, don’t exit Arduino IDE. And in a second after the sketch uploads, you should see a new Arduino IDE window pop up. And this was done with the help of the guys named Keyboard.press()(presses the keys) and Keyboard.releaseAll()(releases the keys). Here’s the syntax for both:

keyboardObj.press(uint8_t key);
keyboardObj.releaseAll();

Now, let’s make some more complicated projects with this. I won’t go too advanced (i.e. using other libraries, more than 100 lines of code), but you definitely can!

Part 4: Example projects

1: Chaotic mouse

This will not only jitter the mouse like crazy, it will also make it randomly click and hold buttons!

WARNING: Please save all important files before uploading the code!

Here’s the code:

#include "USB.h"
#include "USBHIDMouse.h"
USBHIDMouse Mouse;

void setup() {
  Mouse.begin();
  USB.begin();
}

void loop() {
  int pressChoice = random(0, 3);
  int pressButChoice = random(0, 3);
  if (pressChoice == 2) {
    if (pressButChoice == 0) {
      Mouse.press();
    } else if (pressButChoice == 1) {
      Mouse.press(MOUSE_MIDDLE);
    } else {
      Mouse.press(MOUSE_RIGHT);
    }
  } else if (pressChoice == 1) {
    if (pressButChoice == 0) {
      Mouse.click();
    } else if (pressButChoice == 1) {
      Mouse.click(MOUSE_MIDDLE);
    } else {
      Mouse.click(MOUSE_RIGHT);
    }
  } else {
    Mouse.release();
    Mouse.release(MOUSE_MIDDLE);
    Mouse.release(MOUSE_RIGHT);
  }
  Mouse.move(random(-100, 100), random(-100, 100)); 
  delay(50);
}

Now, be ready for the chaos! I tested this on my school laptop and accidentally resized all the shortcuts…

2: Tab closing thing

Your friend took embarrassed you for no reason? Got you in trouble at school or with your parents? Now you can get back! Close all their windows, which will demolish their progress in a game, destroy their unsaved part of the essay, remove part of their class notes and more.

Code to activate on Windows/Linux(shortcut tested on Ubuntu):

#include "USB.h"
#include "USBHIDKeyboard.h"
USBHIDKeyboard Keyboard;

char altKey = KEY_LEFT_ALT;
char f4Key = KEY_F4;

void setup() {
  Keyboard.begin();
  USB.begin();
}

void loop() {
  delay(250);
  Keyboard.press(altKey);
  Keyboard.press(f4Key);
  delay(100);
  Keyboard.releaseAll();
}

And this code for MacOS X:

#include "USB.h"
#include "USBHIDKeyboard.h"
USBHIDKeyboard Keyboard;

char cmdKey = KEY_LEFT_GUI;
char f4Key = KEY_F4;

void setup() {
  Keyboard.begin();
  USB.begin();
}

void loop() {
  delay(250);
  Keyboard.press(cmdKey);
  Keyboard.press(f4Key);
  delay(100);
  Keyboard.releaseAll();
}

Now plug it in when they’re not looking and see your burning revenge!

See more in the Part 2!

Sorry, there’s no part 2 coming anytime soon!

Ever had projects stopped because you didn’t have springs? You’re in the right place! Here’s a guide on how to design a 3D printable spring.

Part 0: Files

Heres the Thangs 3D page with the STL I am using for this project.

Part 1: Design rules for these springs

Here’s an example of how to design these:

*  ****  ****  *
*  *  *  *  *  *
*  *  *  *  *  *
*  *  *  *  *  *
****  ****  ****

----------
Key:      |
* - .5 mm |
NOTE:     |
The coil  |
is 1 wall |
thick.    |

So, as you can see, it’s not very hard.
The only real requirement is to 3D print these 1 wall thick.
The actual lines can be any length and height.

You can try this in your own slicer when you will 3D print this coil later in this guide.

Generally, the wall thickness depends on the thickness of your nozzle. I was using a .4 mm nozzle, so I designed the walls as .5 mm, and printed as .625 mm. So if I had a .2 mm nozzle, I would design it as approximately .3 mm thick.

Part 2: Software prep

For this project I used:

• SketchUp (free) - You can use any CAD software that you’re comfy with, but for this guide I will also explain the workflow for SketchUp.

• Ultimaker Cura (free) - Again, you can use any slicer, but I will explain the workflow for Cura.

Part 3: Design

Step 1: Get a rectangle as wide as the thickness of the walls in your slicer

How do I do that in SketchUp?

First, get out this tool called “Rectangle” by searching the toolbox or typing “R” on your keyboard.

Then, make it any random length, and as wide as your walls are (as described in Part 2). After that, get the “Push/Pull” tool by searching for it in the toolbox or pressing “P”, select the rectangle you made and pull up until you feel like it’s good.

Step 2: Add a second rectangle to the first one, with the same width as the first, but shorter.

How do I do that?

From any edge, measure the double of the wall thickness of the first rectangle with the “Tape Measure” tool allocated to the “T” key, and draw the line from the little plus that appears after you measure (MAKE SURE IT’S ON THE FACE) with the “Line” tool on the “L” key,

then find the midpoint between the line and the edge, and draw the second line parallel to the first line. Erase the first line with the “Eraser” tool linked to the E button. Extrude from the segment you made with the line tool

Step 3: Add a third rectangle to the second one so that first and this rectangle would be parallel and equal to each other.

Step 4: Repeat a few more times until it looks something like this:

Part 4: Slicing

This part is fairly quick and should be a breeze. Make sure that you use appropriate settings for your printer and if you haven’t used the printer in awhile, I advise you to print a calibration print and calibrate before tackling this.

How to change the settings?

In Cura, click this:

You will see the “Recommended print settings” appear. Click “Show Custom” to find more versatile settings, and it will look like this:

Now feel free to change any settings you want.

Now, assuming everything is done, export your STL file into the slicer and slice the print. Then, save to the removable drive after you’re satisfied with the print time.

How to export file as STL in SketchUp?

First, click on the 3 parallel lines in your top left corner. Next, find and click “Download.” Then, click “STL”, and you should see your browser notify you about the download.

How do I import the STL file into Cura?

First, click on the folder icon. Then, choose the file you exported. After choosing, you will see your file appear as yellow. Any red areas indicate that it will print in the air. This is not a big deal if you’re printing overhangs or bridges, but if it was unintentional, make sure to either add supports or optimize your design.

Part 5: Printing

This might be the most frustrating part about this process, which is why I have quit 3D printing several times. So make sure the settings are right!

Now, insert the removable drive into the printer, select the file and hit print. Make sure to look for any potential flaws in the first layers and check in for once in awhile- is what I would say if this was a more than 20 min print.

You can just leave it alone while printing, it took me 9 minutes to print.

Part 6: Now what?

If you found this useful, great! If you can see some improvements, remix it on Thangs and share the link here in the comments. See ya next week!

Sorry for not posting for a week! I got kinda busy after the winter break was over. In this tutorial I’ll teach you how to make a super simple games console.

1. Supplies

You will need the following components:

• An Arduino-compatible, I2C inclusive dev board (Xiao ESP32-S3 Sense in my case)
• An I2C OLED that is SSD1306 compatible: get on Adafruit
• Neokey board: get on Adafruit
• MX-compatible mechanical switches: get on Adafruit
• Keycaps for the switches (optional if you’re on a VERY tight budget or you’re a psycho): get on Adafruit
• Arduino IDE
• Some prior Arduino IDE experience.

This project was not optimized for the parts from other manufacturers, so you might need to do some debugging, like changing a library or changing an I2C address.

2. Setup

This project will require some simple wiring if you’re using Stemma QT, but you will need to solder if you want to use pins. Here’s a quick list of steps to connect:

• Get your dev board’s I2C pin position
• Place the key caps on the switches
• Insert the switches on the flatter side of the PCB by pushing the switches into the sockets
• Insert the Stemma QT cable into the Stemma QT socket (if using Stemma QT)
• Connect the other end of the cable into the I2C pins of the dev board (blue -> SDA; yellow -> SCL)
• Repeat the last 2 steps for the OLED

3. Code

Insert this code into your Arduino IDE:

#include "Adafruit_NeoKey_1x4.h"
#include "seesaw_neopixel.h"
#include "Adafruit_GFX.h"
#include "Adafruit_SSD1306.h"
 
Adafruit_NeoKey_1x4 neokey;  // Creates the NeoKey object
 
#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 64 // OLED display height, in pixels
 
// Declaration for an SSD1306 display connected to I2C (SDA, SCL pins)
// The pins for I2C are defined by the Wire-library. 
#define OLED_RESET     -1 // Reset pin # (or -1 if sharing Arduino reset pin)
#define SCREEN_ADDRESS 0x3D ///< See datasheet for Address
#define NEOKEY_ADDRESS 0x30 // Change this as needed
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);
 
int x = 2; // Integers for the sprite position
int y = 2;
 
void writeTextReset(String text, int x, int y) { // Function to save some time coding
  display.clearDisplay(); // Clears the display
  display.setCursor(x, y); // Sets the cursor to the x and y parameters
  display.println(text); // Writes the text to the display
}
 
void setup() {
  delay(1000); // Delay to initialize I2C
  display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS); // Starts the display
 
  // Show initial display buffer contents on the screen --
  // the library initializes this with an Adafruit splash screen.
  display.display();
  delay(2000); // Pause for 2 seconds
 
  // Clear the buffer
  display.clearDisplay();
 
  display.setTextSize(1); // Sets the text size
  display.setTextColor(SSD1306_WHITE); // Draw white text
  writeTextReset("Awaiting connection...", x, y);
  display.display(); // Displays the text. This function is used to show the graphics that were prepared.
 
  Serial.begin(115200); // Begins searial
  //while (! Serial) delay(10); // Uncomment if you want to prevent the game to run without serial
   
  delay(100);
 
  if (! neokey.begin(NEOKEY_ADDRESS)) {     // begin with I2C address, default is 0x30
    Serial.println("Could not start NeoKey, check wiring?");
    writeTextReset("Could not connect", x, y);
    display.display();
    while(1) delay(10);
  }
   
  Serial.println("NeoKey started!");
  writeTextReset("Key's animation playing...", x, y); // Tells the user that the NeoKey animation is playing
  display.display();
 
  // Pulse all the LEDs on to show they're working
  for (uint16_t i=0; i<neokey.pixels.numPixels(); i++) { // The animation itself
    if (i == 0) {
      neokey.pixels.setPixelColor(i, 0xFF0000); // Changes the NeoPixel's color
    } else if (i == 1) {
      neokey.pixels.setPixelColor(i, 0xFFFFFF);
    } else if (i == 2) {
      neokey.pixels.setPixelColor(i, 0x00FF00);
    } else {
      neokey.pixels.setPixelColor(3, 0x00FFFF);
    }
    neokey.pixels.show();
    if (i == 0 | i == 1) {
      delay(250);
    } else {
      delay(500);
    }
    neokey.pixels.setPixelColor(i, 0);
  }
  for (uint16_t i=0; i<neokey.pixels.numPixels(); i++) {
    neokey.pixels.setPixelColor(i, 0x000000); // Turns off the LEDs
    neokey.pixels.show();
    delay(50);
  }
 
  writeTextReset("Key started! Key key: \n A = red/Go left \n B = white/Go up  \n C = green/Go down  \n D = blue/Go right", x, y); // Displays the controls on the display
  display.display();
 
  neokey.pixels.setPixelColor(0, 0xFF0000); // Shows the user which key is which
  neokey.pixels.setPixelColor(1, 0xFFFFFF);
  neokey.pixels.setPixelColor(2, 0x00FF00);
  neokey.pixels.setPixelColor(3, 0x00FFFF);
  neokey.pixels.show();
  delay(5000);
}
 
void loop() {
  uint8_t buttons = neokey.read();
 
  // Check each button, if pressed, light the matching neopixel
   
  if (buttons & (1<<0)) { // If the button 0 (A) is pressed, then...
    Serial.println("Button A"); // Tell the Serial
    neokey.pixels.setPixelColor(0, 0xFF0000); // Set the NeoKey color to red
    neokey.pixels.show(); // Show the color
    x -= 1; // Move the character in the right direction
    display.display(); // Display is used in here and not at the end to remove flicker
  } else { // If not...
    neokey.pixels.setPixelColor(0, 0); // make sure that the neokey is off
    neokey.pixels.show();
  }
 
  if (buttons & (1<<1)) {
    Serial.println("Button B");
    neokey.pixels.setPixelColor(1, 0xFFFFFF); // walter heisenberg white
    neokey.pixels.show();
    y -= 1;
    display.display();
     
  } else {
    neokey.pixels.setPixelColor(1, 0);
    neokey.pixels.show();
  }
   
  if (buttons & (1<<2)) {
    Serial.println("Button C");
    neokey.pixels.setPixelColor(2, 0x00FF00); // green
    neokey.pixels.show();
    y += 1;
    display.display();
  } else {
    neokey.pixels.setPixelColor(2, 0);
    neokey.pixels.show();
  }
 
  if (buttons & (1<<3)) {
    Serial.println("Button D");
    neokey.pixels.setPixelColor(3, 0x00FFFF); // blue
    neokey.pixels.show();
    x += 1;
    display.display();
  } else {
    neokey.pixels.setPixelColor(3, 0);
    neokey.pixels.show();
  }
   
  writeTextReset(":)", x, y);
 
  delay(10);    // Gives the dev board some time to show the NeoPixels
}

Add this chunk of code if you want to translate RGB into HEX:

// Input a value 0 to 255 to get a color value.
// The colors are a transition r - g - b - back to r.
 
uint32_t Wheel(byte WheelPos) {
  if(WheelPos < 85) {
   return seesaw_NeoPixel::Color(WheelPos * 3, 255 - WheelPos * 3, 0);
  } else if(WheelPos < 170) {
   WheelPos -= 85;
   return seesaw_NeoPixel::Color(255 - WheelPos * 3, 0, WheelPos * 3);
  } else {
   WheelPos -= 170;
   return seesaw_NeoPixel::Color(0, WheelPos * 3, 255 - WheelPos * 3);
  }
  return 0;
}

What should happen:

• The display shows the Adafruit splash screen
• The same display shows text saying “Key’s animation playing…”
• After it finishes, the OLED shows the controls and NeoKey shows the color code for each button
• When the NeoPixels eventually turn off and you press the NeoKeys, a moving smiley face will appear.
• Try pressing different keys and key combos and see how the smiley moves.

Now we’re gonna go into the juicy stuff, which is

4. Code Explanation

First, We’ll dive into the code outside of the functions. If we scroll for a bit, you can see this line of code:

#define SCREEN_ADDRESS 0x3D

This defines the screen’s address, which is required if you want to use the module with I2C. This info is usually in:

• Product description
• Official guide
• Datasheet

Usually, the I2C have these weird solder pads.
You might think, “what is this for?”. The answer is changing the I2C address.

This is useful when you want to use multiple I2C modules at once, but one of the modules has the same I2C address as another module you want to use.

For example, you want to use an I2C time of flight sensor, but you’re also using a screen, and both of them have the 0x3D address, and with those solder pads, you can take any one of the modules and your all-mighty soldering iron and solder it on.

The solder pads I was talking about

Next, we have this:

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

This makes the screen object. Now let’s talk about our first function in the program:

void writeTextReset(String text, int x, int y) { // Function to save some time coding
  display.clearDisplay();
  display.setCursor(x, y);
  display.println(text);
}

I made this function to save some time, and I think this is a good way to explain the display’s basic functions and text functions. First, we have two most important functions, these are:

display.display();
display.clearDisplay();

The first function displays EVERYTHING you put on the canvas after the boot or last clearDisplay call, which clears the display.

If you call the first function after the boot, it will show the Adafruit splash screen. Here’s the syntax for the functions:

dispObj.display();
dispObj.clearDisplay();

dispObj: display object name

Now, let’s come back and talk about the display object. The display object is created with this syntax:

Adafruit_SSD1306 dispObjName(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, RESET_PIN);

Now, we’re writing. Literally! The functions for writing to the display are the same as if you were using serial.

The cursor function changes the position of the text and syntax looks like this:

dispObj.setCursor(x, y);

The function for changing the text color applies to all Adafruit display libraries and looks like this:

dispObj.setTextColor(str);

str = String variable

And last but not least, we have the function that changes the size, the syntax looks like this:

dispObj.setTextSize(Int);

Int = int variable

Now, that we finished with the display functions, we can talk about our dear friend: NeoKey! The first NeoKey’s function used is this:

Adafruit_NeoKey_1x4 neokey;

This defines the NeoKey object. Next we have this:

neokey.pixels.setPixelColor(i, 0xFF0000);

This changes the NeoKey’s color. The syntax looks like this:

neokey.pixels.setPixelColor(Int, hexCol);

neokey = NeoKey object Int = NeoPixel number hexCol = Color (HEX)

Then, we have this:

neokey.pixels.show();

This shows the NeoPixel’s color that you set previously. To turn off the NeoPixels, you can just use the setPixelColor and write 0 in the color parameter.

And it looks like we came to the end! See ya next week.

Welcome to this tutorial on making a Linux Distro with archiso!
Here are the requirements:

• Arch Linux
• 20GB or more disk space
• 4GB RAM recommended
• 64-Bit CPU recommended for regular use

Tip: If you don’t want to use Arch linux, you can use a VM, but you won’t be able to test the new ISO unless you import the ISO to your host, then use a VM there.

Why ArchISO?

archiso is a simple tool for creating ISO images and respins (distros) of Arch Linux.
Fact: Arch Linux’ official ISO images are made with archiso.

Preparing tools

To install archiso on your machine, run this command as root:

pacman -Syu archiso

Tip: There could be an enchanced or newer version of archiso in AUR.

According to Arch Linux Wiki, there are two default profiles, base and releng. We’re going to use releng because it is recommended for respins.

To use the releng profile, you must copy the profile to the current directory you’re in. You can run this command without root:

cp -r /usr/share/archiso/configs/releng ./archlive

Now that you’ve got a base profile, you’ll need to check this README file to get an understanding of what’s in the profile directory.

Editing packages

Now that you prepared the profile, you should edit the packages.x86_64 file located in the root directory of the profile, you can also remove some unwanted packages that are originally for the Arch Linux installation medium.

WARNING: Make sure the packages exist in your pacman repositories or the ISO build will fail!

If your package is located in AUR or isn’t in an online repository, you can append this code to pacman.conf and make a custom repository with that. Click here if you need information about custom repositories.

[customrepo]
SigLevel = Optional TrustAll
Server = file:///path/to/customrepo

Tip: You can also uncomment the multilib repository in pacman.conf if you need any packages there.

Adding files

If you use a graphical file manager like pcmanfm, then it will be simple to transfer your current configuration to your archiso profile.

Note: even if your machine has the default configuration of the program you want, you can copy the one from your machine to airootfs and edit it.

if you are using the command line to prepare your profile, then you can use the following command to copy iptables (can be any file) to your archiso profile.

cp -r /etc/iptables ./archlive/airootfs/etc

Tip: files like /etc/sudoers should copied to archlive/airootfs/etc/. think of airootfs being a filesystem offset.

Changing OS branding

Now it’s your turn for rebranding your OS, you can start with copying and editing /etc/os-release to airootfs and then editing the profile’s grub and syslinux folders. with editing these folders, you can change the OS names and descriptions in different bootloaders. plus a new splash for SYSLINUX is great.

Enabling SystemD services

To enable systemd services on your archiso profile, you have to add the service’s packages to both your packages.x86_64 file and your system.

systemd units run by wants targets, for example, multi-user.target can be added to the system by using this command.

mkdir -p ./archlive/airootfs/etc/systemd/system/multi-user.target.wants

And to enable the services that is wanted by multi-user.target such as gpm.service, you can run this command to make a symlink of the service just like systemctl enable will.

ln -s /usr/lib/systemd/system/gpm.service ./archlive/airootfs/etc/systemd/system/multi-user.target.wants/

WARNING: Point the symlink to the system file, symbolic links do not care if the target path doesn’t exist. If you set the target to an airootfs path, then the environment will still try to use that same path without translating to a system path.

How to enable display manager?

You can also use systemd to add a display manager to your distro, to do this with LXDM, you can check display-manager.service to see which display manager is set.

ls -l /etc/systemd/system/display-manager.service

And then to enable LXDM by creating a symbolic link.

ln -s /usr/lib/systemd/system/lxdm.service ./archlive/airootfs/etc/systemd/system/display-manager.service

Creating users and passwords

Adding users is pretty complicated but it’s simple to encrypt the password. to add a user named user, follow these steps:

Step 1: Edit /etc/passwd

To add a user, you can change /etc/passwd like this

root:x:0:0:root:/root:/usr/bin/zsh
user:x:1000:1000::/home/user:/usr/bin/zsh

and create the respective home directory in airootfs.

Step 2: Generate encrypted password

To make the encrypted password, create a dummy user with the password you want, then use the following command and copy the encrypted password after the colon (:) next to the username and before the colon next to 14871.

cat /etc/shadow

Now, create /etc/shadow in airootfs and edit it like this.

root::14871::::::
user:enc:14871::::::

Replace enc with the password hash you just copied.

Step 3: Add groups

Groups are an important part of the multi-user linux, it allows to tell programs what permissions someone has. create and edit /etc/group and add these important groups.

root:x:0:root
adm:x:4:user
wheel:x:10:user
uucp:x:14:user
user:x:1000:

Step 4: Create /etc/gshadow

You can create and edit /etc/gshadow like this.

root:!*::root
user:!*::

Setting autologin

To set autologin on the console, you must create or change /etc/systemd/systemgetty@tty1.service.d/autologin.conf on the airootfs like this.

[Service]
ExecStart=
ExecStart=-/sbin/agetty --autologin user --noclear %I 38400 linux

Replace user with the username of the user for the profile.

How to set autologin on LXDM?

to setup autologin on LXDM, copy /etc/lxdm/lxdm.conf to airootfs and uncomment the following line.

#autologin=dgod

Replace dgod with the username of the user for the profile.

Info: To setup autologin on any other Display Manager other than LXDM, you must follow their documentation.

Build the ISO

to build the ISO, you must prepare an empty folder that archiso will use to prepare the ISO for compilation.

Note: If you have enough RAM and the system allows to do so, you can make an empty folder in /tmp and use it as the work directory.

After preparing the folder, you must run the following command, replacing each directory path with the ones on your machine:

mkarchiso -v -w /path/to/work_dir -o /path/to/out_dir /path/to/profile/

Tip: After making the ISO, you can try making your ISO bootable with secure boot enabled machines, but I’m not that experienced to describe it for beginners yet.

Warning: you must delete everything in the folder before building again, or archiso will skip the building entirely!

Testing

To test your new ISO on an emulator, you can install the required packages using this command as root:

pacman -Syu qemu-desktop edk2-ovmf

And after installing qemu, run archiso’s built-in command for testing the ISO, replacing the file path(s) with the path(s) on your machine:

run_archiso -i /path/to/file.iso

Tip: you can emulate UEFI by adding the -u argument to the command.

Now what?

Now that you have created your own distro, go ahead and customize it as you like and improve it to the way you want it to be.

If you liked this tutorial, please like this post and subscribe to SweeBlogs for more Tutorials and blogs!

Arch Linux and the Arch Linux Logo are trademarks of the Arch Linux project.