In this guide, we’ll use the xine video player to set up basic video playback on a fresh FreeBSD install. The xine multimedia player relies on the XWindow system and the XVideo extension to provide a graphical video playback interface.

Xorg supports a wide variety of video cards, but not all are supported or offer good video playback performance.

It is a good idea to have a short MPEG test file for evaluating various players and options. Since some DVD applications look for DVD media in /dev/dvd by default, or have this device name hardcoded in them, it might be useful to make a symbolic link to the proper device:

Due to the nature of devfs(5), manually created links will not persist after a system reboot. In order to recreate the symbolic link automatically when the system boots, add the following line to /etc/devfs.conf:

There are several possible ways to display video under Xorg and what works is largely hardware dependent. This guide will focus on the Xvideo extension which allows video to be directly displayed, even on low-end machines.

Start by installing the X Window System:

Once the package has been fully installed, the X Window System can be started with:

To check whether the Xvideo extension is running, use xvinfo:

If XVideo is supported, the result will look similar to the example below and may include screen and video card information.

XVideo is likely unsupported by the video card if the result instead look like:

The display may be unable to meet the demands of rendering video playback if XVideo is unsupported (though this is not always the case).

xine is a free multimedia player. It plays back CDs, DVDs, BluRays and VCDs. It also decodes multimedia files like AVI, MOV, WMV, and MP3 from local disk drives, and displays multimedia streamed over the Internet. Get started by installing the package:

In practice, xine requires either a fast CPU or support for the XVideo extension. The xine video player performs best on XVideo interfaces. If in the previous step, the Xvideo extension was unsupported, issues may occur.

The xine player starts a graphical user interface (GUI) and the menus can be used to navigate to multimedia files.

Alternatively, xine may be directly invoked from the command line by specifying the name of the file to play:

You now have a simple way to play a variety of multimedia files on your FreeBSD system! To find out more about the xine player, refer to the SourceForge page.

Follow the link here for part 1

Updated: August 14, 2020

Packages can be downloaded in bulk by adding them to the same command line. Try this by installing the GNOME desktop environment, sudo, the vim editor, and Firefox in one line:

$ pkg install -y gnome3 vim-console firefox

The -y flag in the previous command assumes a pre-confirmation to the installation process, so installation will start instantly.

Gnome requires /proc to be mounted, in order to do this, run

$ vim /etc/fstab

This time we use the vim editor, Vi iMproved, and to begin typing you need to be in “insert mode” and must press ‘i‘ to enter insert mode and begin typing in text. Type in the following one-line configuration:

proc      /proc      procfs      rw      0      0

Exit vim by pressing “Esc” on the keyboard, then type ZZ or :wq followed by Enter/Return. At this point the virtual machine desktop can be started with the following command:

Change to regular user by holding down “control” and pressing “d” on the keyboard which will log out the current user.  Log in again, this time as the regular user account that was created and type the following commands.

$ echo "exec /usr/local/bin/gnome-session" > ~/.xinitrc

$ startx

Here is how to open a local copy of the handbook we installed in the Final Configuration:

Right click on: Desktop > Applications > Firefox Web Browser

Open Firefox and navigate to the following URL: file:///usr/local/share/doc/freebsd/handbook/index.html

This is a local copy of the FreeBSD Handbook, and it will always be available as it doesn’t require an active internet connection. That’s all it takes to install FreeBSD. The next recommended step is to choose a firewall and configure it. Also recommend you pick up a copy of the book “BSD Hacks” to get more familiar with the tcsh shell as well as to acquire several new skills.

Navigate back to Applications and open the terminal.

In the open terminal, run:

$ sudo -i

$ env PAGER=cat freebsd-update fetch install

We’re using env PAGER=cat to modify the value of the PAGER variable which is used by the freebsd-update shell script. If you open up the shell script you will see the default value of PAGER is set to less. You can find the location of the freebsd-update shell script by typing which freebsd-update. By setting the value of PAGER to cat, freebsd-update will not stop to display the list of file to be updated, instead the cat command will only display the list of files and won’t stop to wait for you to read. If you only type freebsd-update fetch install, you’ll need to use the following to get through the prompts

‘Page Down‘ & ‘q‘ should get you through the prompts. If the screen shows END press ‘q‘, use ‘Page Down‘ for the other screens. You can also use ‘q’ for every screen.

Now that FreeBSD itself is up to date, we should also update the packages.

$ pkg update

$ pkg upgrade -y

Set UTF-8 as the locale for this host:

$ vim /etc/login.conf

Change the line with :umask=022: to look like the following:

:umask=022:\ :charset=UTF-8:\ :lang=en_US.UTF-8:

Save and quit the editor then run the following:

$ cap_mkdb /etc/login.conf

$ logout

Log in as root and type the following to verify UTF-8 locale has been set

$ locale

Install iocage

$ pkg install -y py37-iocage

The following command assumes your zpool is named zroot adjust as necessary. Type zpool status to see the current name of your zpool.

$ iocage activate zroot

$ iocage list

We should now see an empty table as the output of iocage list, we’ll do some additional housekeeping below to improve performance of iocage. There are many things you can do to optimize performance of various applications. One way to learn several new tips and tricks is to read the supurb collection of FreeBSD Mastery books available at https://MWL.io (In fact, the following performance optimization trick was in the book FreeBSD Mastery: Jails)

$ mount -t fdescfs null /dev/fd

$ vi /etc/fstab

Add the following line to the file and exit when finished. ‘i‘ for insert mode, ‘ESC‘ then ‘ZZ‘ to save and quit the file. Press ‘TAB‘ between each of the fields for the fstab file rather than using spaces to separate fields.

fdescfs /dev/fd fdescfs rw 0 0

Download a Release branch of FreeBSD first

$ iocage fetch

We used [Enter] to fetch the default release iocage wants to provide. Verify the download with the following command

$ iocage list -r

View the help documentation

$ iocage --help

Any sub-commands can also have the –help flag appended

$ iocage create --help

Create a base jail

$ iocage create -T -n JAILNAME ip4_addr="10.0.2.16" -r 12.1-RELEASE

List current jails

$ iocage list

Startup jail-one and jump into the console

$ iocage console JAILNAME

The console command will start the jail if it isn’t already started. To manually start a jail use this:

$ iocage start JAILNAME

Similarly to stop a jail issue

$ iocage stop JAILNAME

Verify networking is working

$ pkg

Say yes to the pkg bootstrap prompt. Exit the jail console with ctrl + d.

To delete a jail:

$ iocage destroy JAILNAME

The following commands will work on the virtual machine we’ve been using so far, but it will take a long time to compile all the packages.

We’re going to use the cloned virtual machine we created earlier to explore Poudriere.

Start up the cloned VM.

Execute the following commands as the root user:

$ pkg install -y poudriere vim-console

$ mkdir /usr/ports/distfiles

$ mkdir /usr/local/poudriere

$ vim /usr/local/etc/poudriere.conf

poudriere.conf content to modify

ZPOOL=zroot FREEBSD_HOST=https://download.freebsd.org

Continue executing:

$ poudriere jail -c -j amd64-12-1 -v 12.1-RELEASE

$ poudriere jail -l

$ poudriere ports -cp head

$ poudriere ports -l

Get together a list of packages to build. I ran pkg query -e '%a=0' %o on my laptop and a large list appeared. pkg query on my VM was much shorter. To learn more about pkg query issue the command pkg help query to see help text for the query subcommand. Most commands support some form of help (-h, –help, or simply reading the man page with man PROGRAM) For this tutorial we will just build a shorter list of packages. The command to export the current packages installed on the system to a file called pkglist is:

$ pkg query -e ‘%a=0’ %o | tee pkglist

$ editors/vim-console

$ ports-mgmt/pkg

$ ports-mgmt/poudriere

Note: tee writes output to a file and also to stdout. Also the following two bits of information are optional for this tutorial and are included to show you how to customize packages.

Two ways to configure custom options for packages, manually and with the normal make config screen. FYI: Manually looks like this:

$ vim /usr/local/etc/poudriere.d/amd64-12-1-make.conf

$ DEFAULT_VERSIONS += ssl=libressl

To customize a package one can use the normal package configuration screens, which will appear when issuing the following command

$ poudriere options -j amd64-12-1 -p head -f pkglist

For this tutorial we’ll just actually build the packages with the default options to get the hang of Poudriere by issuing the following:

$ poudriere bulk -j amd64-12-1 -p head -f pkglist

$ cd /usr/local/poudriere

This directory contains logs related to Poudriere builds. There are even a few different website files generated at /data/logs/bulk/.html/ with information about the builds. You can open the website in Firefox using the URL file:///data/logs/bulk/.html/index.html to check on the status of a current Poudriere build. You can also press ctrl + t on the command line where you issued the poudriere bulk command to issue a SIGINFO to Poudriere which is configured to print out the current status of the Poudriere build while the command is still processing. This trick works on many other commands as well to show you the status. For instance if you were using scp to download a large file and wanted to see how far along the download was SIGINFO would print out the status on the command line to show you. Another example is if you were decompressing a zip file and wanted to know the status of the extraction process.

Once Poudriere has finished, the packages that were built are available at

$ /data/packages/amd64-12-1-head

Create a pkg repository

$ mkdir -p /usr/local/etc/pkg/repos

Disable the main FreeBSD repo by creating a file to override the default settings found in the default FreeBSD repository file /etc/pkg/FreeBSD.conf

$ vim /usr/local/etc/pkg/repos/FreeBSD.conf

Type in the following configuration with enabled set to no

FreeBSD: {
        enabled: no
}

Create a new configuration file for your local Poudriere package repository similar to the FreeBSD.conf file to hold the repository configuration

$ vim /usr/local/etc/pkg/repos/amd64-12-1.conf

Add the following configuration

amd64-12-1: {
        url: “file:///data/packages/amd64-12-1-head”,
        enabled: yes,
}

To reinstall all packages using the new repo

$ pkg upgrade -fy

NOTE: A good Systems Administration practice is to add comments to your configs to let the future you know what the config options do and why there were put there in the first place. That way when you revisit a config file after some time, you’ll have some context as to why those options were chosen.

$ vim /usr/local/etc/poudriere.conf

# by default Poudriere builds all packages in the pkglist by default, these two lines tell Poudriere to look at each package individually

CHECK_CHANGED_OPTIONS=verbose CHECK_CHANGED_DEPS=yes

$ poudriere jail -j amd64-12-1 -u

$ poudriere ports -p head -u

$ poudriere bulk -j amd64-12-1 -p head -f pkglist

You can now install the updated packages:

$ pkg update

Avoiding Issues

Terminate current command:

$ ^C (Ctrl-C)

Clear to start of line:

$ ^U (Ctrl-U)

Finding Information:

Manual page for the “cmd” command, replace with any other command to access its manual page:

$ man cmd

Rebooting / Shutting Down

Power Down:

$ sudo shutdown –p now

Reboot:

$ sudo shutdown –r now

Log Out:

$ exit

$ logout

Directory Navigation

Display present work directory:

$ pwd

List contents of current directory:

$ ls

Files

Create file if it does not exist:

$ touch filename

Delete file:

$ rm filename

Rename a file:

$ mv oldname newname

Search for a file: (full filename is not needed)

$ locate filename

File editing

$ vi filename

$ ee filename

Change to your home directory

$ cd

$ cd ~

Change to parent directory

$ cd ..

Change to previous directory

$ cd -

Website: www.freebsd.org

FreeBSD Foundation: archive.freebsdfoundation.org

GitHub: github.com/freebsd  

Mailing Lists: https://lists.freebsd.org/mailman/listinfo

Forums: https://forums.freebsd.org

FreeBSD Handbook: https://www.freebsd.org/doc/handbook/

Updated: June 15, 2022

Start by opening up the terminal, found under Applications > Utilities > Terminal. Then use the code:

sysctl -n machdep.cpu.brand_string

This will return a string identifying the computer’s processor. Running a web search for this processor will take you to the manufacturers website, which should list the processor’s stats as well as whether it is 32-bit or 64-bit.

Navigate to “Control Panel → System and Security → System” and look for the highlighted information to determine whether your system is 32-bit or 64-bit.

Visit the VirtualBox downloads website, and in the highlighted area, select the platform package binary that applies to your operating system. VirtualBox is available on Windows, macOS, Linux, and Solaris.

Opening the downloaded file will start the installation walkthrough. Once it finishes, you’ll be able to launch the application.

Visit the official FreeBSD releases page. The disk images are listed in order of release date, so the most recent release can be found at the top of the page as highlighted.

After clicking the link, you will be redirected to a file directory containing multiple formats and versions of the FreeBSD installer.

For Virtual Machines, the format you are looking for is the file ending in -disk.iso as shown above. Click this file and it will start downloading the installer.

Once the FreeBSD installer has been downloaded in the last step, run VirtualBox to start hard disk configuration. Select the “New” button on the top left of the window to open the configuration window. 

Name your operating system as “FreeBSD”, then select FreeBSD from the dropdown menu as well as the version (32 or 64 bit).

Choose the defaults options for disc setup until you reach the memory allocation section

After the hard disk has been configured, boot up the operating system with the “Start” button. VirtualBox will start up a virtual machine and ask for a virtual optical disk file. This will be the .iso file that you downloaded through the FreeBSD website. Navigate to this file by clicking the small file symbol next to the drop-down menu. Once selected, the booting process will continue and the FreeBSD installer will start.

The FreeBSD booting system will automatically start once VirtualBox starts the virtual machine. While this how-to will provide a detailed installation guide, the FreeBSD handbook’s installation guide can also be used. When in doubt, use the default options provided, as they can be reconfigured later if necessary.

While the FreeBSD installation process has been completed, there a few more configuration options that need to be set before booting into the newly installed system.

Once FreeBSD has been properly configured, a window will appear asking to reboot. Select “yes” and wait until the FreeBSD booting page appears again. Once this happens, manually close the virtual machine window and select “Power off the machine”.

On the main VirtualBox application, click the the section (on the lower right side of the window) that says “Storage”. A new window should appear showing the storage options.

Under the main “Controller: IDE” there will be two options. One will be the hard disk that VirtualBox created for the system (it will have a square blue hard drive icon) and the other is the original FreeBSD download (with a light blue disk icon). Right click the sub-storage with the disk icon and select “Remove” from the drop-down menu.

Once it is removed, the window should resemble the one pictured above.

Use the Snapshots menu in VirtualBox to Clone the VM. Check the box “Reinitialize the MAC address of all network cards”. We could choose either a Full clone or a Linked clone. We’ll use the Full clone option. Later on in the installfest we’ll use this cloned VM.

Click “Start” with the original VM selected, and the FreeBSD virtual machine should now boot in its configured form. In order to download packages you need to be logged into, or emulate the root user. After logging into the previously created user, enter the following command in the terminal:

$ su

Install the VirtualBox guest addition packages, and configure the startup service configuration:

$ pkg install emulators/virtualbox-ose-additions

$ sysrc vboxguest_enable=YES

$ sysrc vboxservice_enable=YES

sysrc is a pre-packaged command that allows rc.conf (system configuration to be read on boot) to be edited from the command line, without using a text editor.

Before installing a desktop environment, a graphical user interface (GUI) is needed. The X Window System is an open source GUI that supports FreeBSD and offers a ton of customization and user tools.

To install the Xorg binary package and configure the X Window System:

$ pkg install -y xorg

$ ee /boot/loader.conf

ee(1) is the first text editor we will be using, the following line can be added simply by typing it:

kern.vty=vt

Escape and then hit Enter twice to save changes and exit the ee(1) editor:

$ ee /usr/local/etc/X11/xorg.conf.d/driver-vboxvideo.conf

Use the same method above and add the following content to the new file:

Section “Device”

        Identifier "Card0"

        Driver "vboxvideo"

EndSection

Enter the following commands:

$ sysrc dbus_enable=YES

$ sysrc hald_enable=YES

$ dbus-uuidgen > /etc/machine-id

$ pkg install -y sudo

$ visudo

(we will use another text editor, the vi editor, to edit sudo )

Within the sudo config type /wheel press Enter and uncomment the line below to allow all members of the wheel group to use sudo (in vi you can type the following to accomplish this task: j0xxZZ) ( pressing j moves down, 0 moves to the beginning of a line, x deletes one character, ZZ is saves and quits)

$ reboot

Follow the link here

The next part will include installing a desktop environment, updating FreeBSD, setting up a FreeBSD jail, as well as using Ansible and Poudriere.

Updated: September 10, 2021

# pkg install git

# git clone https://git.freebsd.org/ports.git /usr/ports

# cd /usr/ports/ports-mgmt/poudriere

# make install clean

# cd /usr/local/etc

# cp poudriere.conf.sample poudriere.conf

# ee poudriere.conf

FREEBSD_HOST=_PROTO_://_CHANGE_THIS_

FREEBSD_HOST=ftp://ftp.freebsd.org

# rehash

# poudriere ports -c

# mkdir /usr/local/poudriere

# poudriere jail -c -j 91x64 -v 12.1-RELEASE -a amd64

# cd poudriere.d

# echo WITH_PKGNG=YES >> 91x64-make.conf

# cd /usr/local/etc

# ee poudriere-list

This step is optional unless manual configuration is needed.

# poudriere options  -c sysutils/tmux

# poudriere bulk -j 91x64 -f poudriere-list

# cd /usr/local/etc

# poudriere bulk -j 91x64 -f poudriere-list

We are actively iterating on adding NVDIMM support to FreeBSD. To test the program without actual NVDIMM hardware, we use the newest version of QEMU which has support of virtual NVDIMM and is not yet available in ports.

 – Contributed by Guangyuan (Charlie) Yang

FreeBSD now has a number of continuous integration jobs on Jenkins CI to build and test FreeBSD on various architectures, and the newly implemented Tinderbox View presents a high-level, simple dashboard to the real-time FreeBSD CI build status.

This display is so useful that we wanted a physical version in our office to monitor the build status more easily. What started as a side project during my first few weeks of interning at The FreeBSD Foundation, has become a useful LED display of the current FreeBSD CI (continuous integration) build status, and is running 24/7 in the Foundation Kitchener office, proudly running FreeBSD on a BeagleBone Green.

To get started, you can download an image from the FreeBSD Snapshot site with filename labeled as BeagleBone. In this case, we download:

then extract it:

to get the .img image.

You can always choose to build FreeBSD from source code if you want to experience the latest changes for the support of BeagleBone and are comfortable with the process. Crochet is the tool to use, and you can find a detailed guide on GitHub.

The dd(1) utility is used for raw data copying such as, initializing a disk from a raw image.

dd requires specifying if (input file), of (output file) and bs (copy block size). These arguments should be changed to match the actual file and device name.

Specifying a block size is not necessary, but the default setting will result in very slow operation.

If you are not sure of which device it is, simply run:

right after inserting the micro-SD, or:

to see the corresponding device name.

After the operation finishes, you can insert the micro-SD card into the BeagleBone.

A serial cable might not be necessary as you can wait until it boots and try to ssh to it (the system configuration might prevent you from logging in as root with ssh though). However, since BeagleBone Green doesn’t have an HDMI output, you can see what is going on through the whole booting process with a serial cable, making it much easier to diagnose if something goes wrong.

The serial console of BeagleBone Green is exposed on a 6-pin header.

The built-in cu(1) utility can be used for serial communications. cu can only access the /var/spool/lock directory via user uucp and group dialer. Use the dialer group to control who has access to the modem or remote systems by adding user accounts to dialer using pw(8):

Then log out and log in again to make the above change live.

Connect the USB to TTL cable to BeagleBone and computer, then run the cu utility and specify the line speed of 115200 baud.

You won’t see any output yet.

Note: Using sudo to use cu is not a good practice, instead you should add the user to the dialer group as above stated, or grant everyone’s access as an alternative by running:

For more info about serial communications, see FreeBSD Serial Communications.

The BeagleBone Black can boot from either the onboard eMMC or a micro-SD card. By default it boots from eMMC. To boot from micro-SD, first hold down the boot switch, then apply power. Don’t release the button until you see it starts booting FreeBSD (or count to 5).

(image from http://wiki.seeed.cc/BeagleBone_Green/)

The boot switch is just above the micro-SD slot.

After booting, log in as root (the default password is “root” as well).

Tip: Making a BeagleBone Black Always Boot From the Micro-SD
The AM335x chip on board actually boots from the first partition that has the active flag set. After using the “holding the boot button” method described above to boot FreeBSD and log in as root, you will be able to turn off the bootable flag of the onboard eMMC to make it always boot from the micro-SD:

To restore this change and make the eMMC available again do:

Alternatively, you can copy the FreeBSD image to eMMC so no pressing the button is needed.

The system may refuse to proceed on some commands if the system clock is wrong.

In FreeBSD, it is recommended to use both ntpdate and ntpd. ntpdate will set the clock when you first boot so it’s close enough that ntpd will work with it. Add the following to /etc/rc.conf:

Then read through /etc/ntp.conf. It’s pretty well documented so it should be obvious what to set.

Open /etc/ssh/sshd_config and change this line:

to:

then, restart the ssh daemon:

and you will be able to login as root via ssh.

Let us start from mastering the control of an external LED.

First let’s take a look at Beaglebone Green’s pin map:

(image from http://wiki.seeed.cc/BeagleBone_Green/)

Now we connect a LED and a 200Ω resistor using jumper wires.

(image from https://learn.adafruit.com/blinking-an-led-with-beaglebone-black/wiring)

The top two connections on the BeagleBone expansion header are both GND. The other lead is connected to a pin of your choice.

No programming is required at this moment, as FreeBSD provides us with the gpioctl(8) utility which could be used to list available pins and manage GPIO pins from userland.

Let’s list all the available pins defined by device /dev/gpioc0:

By default, all the IO pins are set to be inputs. This does not work for our LED. Instead, we need the pin it is connected to be an output, so we configure that:

The pin should be output mode now, but the LED should still be off. To turn it on, type:

Now we have set the logical value of pin 3 to be 1, and the LED is on! To turn it off again, type:

You can try blinking the LED by writing a bash script with a simple loop.

Awesome! GPIO is working well with BeagleBone, it’s time to start using the addressible LED strip.

The LED RGB strip we used is packed with 60 APA102s and can be controlled with a standard SPI interface. However, at this moment, FreeBSD has no userland support for SPI devices. We used Bit banging to simulate the SPI Protocol as a workaround.

(image from https://www.sparkfun.com/products/14015)

Using the pin map, we connected:
VCC -> SYS_5V
CI -> GPIO of your choice
DI -> GPIO of your choice
GND -> DGND

We used Python and the fbsd_gpio python bindings for the code. Install Python and pip first, and then cffi and fbsd_gpio libraries via PyPI.

Note: You may encounter an error when using `pip` which will give an error like:

This is because FreeBSD uses some cross-compile tools on some embedded platforms (mips, arm, aarch64, etc.) which aren’t used in this setup and will cause build errors. The bug has not been fixed yet (Bug 208282), but in the meantime, we could just change all references in /usr/local/lib/python2.7/_sysconfigdata.py as a workaround:

There is a SPI bit banging abstraction in the fbsd_gpio package used below but has not been documented yet. You can use that abstraction and skip this step, or you can still choose to follow it as a good learning practice.

Import the library and create a controller:

Set which pins we are using:

Note:
SCLK: Serial Clock (output from master)
MOSI: Master Output Slave Input (data output from master), or DI from LED

Provide SPI init and write functions (it’s better to use bitwise operators when working with bits):

A complete description of fbsd_gpio can be found in the fbsd_gpio documentation on PyPI.

Once we set up the SPI functions, we were ready to send SPI data, but first we needed to figure out what to send in order to light up the LEDs we want. Follow the APA102 Manual to find out the data format:

(image from https://cdn-shop.adafruit.com/datasheets/APA102.pdf)

Each update consists of a start frame of 32 zeroes, 32 bits for every LED, and an end frame of 32 ones. So our send function will most likely to work as follows:

Read this article if you want to Understand the APA102 “Superled” better.

Many objects of Jenkins provide remote access APIs. We used the provided Python one to get status of all jobs:

This is how the data will look like:

And the latest status could be extracted from color attribute in data["jobs"] and stored in a dictionary called status.

The Jenkins API manual can be found in the Jenkins CI API reference.

Recalling the APA102 data format, we wrote some predefined data frames:

and some send functions:

so that once we updated the status dictionary, we were able to use led_send(status) to update the display:

Now the display works really well with the static states of the job. However, we noticed that the blue_anime and red_anime colours in Jenkins, which indicate a project is in the process of building (and should be blinking), were treated as static status in the code.

How can we make the LEDs blink while keeping their current status? We added a blink_flag boolean inside the loop, reversed it each time, and decided if we should turn the lights off based on that.

Add the flag to the LED updating loop:

and reflect changes in the send function:

We considered splitting the data fetching and the LED updating process, since blinking requires updating the LEDs every 0.5s, but fetching data should be every 20s or even longer. This could be achieved by simply adding a nested loop (for example, 40 led updates, 1 data updates, loop), but I chose to use threading so both jobs will not affect each other if one gets stuck.

Move the LED updating process into a controller class and run it separately:

And the LEDs should be able to blink at an interval of 0.5s.

We cut the strip to parts and stuck them inside a picture frame.

Looking good!

My implementation of this project: yzgyyang/freebsd-ci-ledstrip

FreeBSD’s support for BeagleBone: FreeBSD/arm/BeagleBoneBlack

A guide of building, installing and updating FreeBSD on a BeagleBone:
Getting Started with FreeBSD on BeagleBone Black

Official BeagleBone Green Document: BeagleBone Green

APA102 Manual

Understanding the APA102 “Superled”

I would like to thank my supervisor Ed Maste for his guidance and support on my work. I would also like to thank Siva Mahadevan, my colleague and friend, for the help and useful suggestions.

– Contributed by Guangyuan (Charlie) Yang

Updated: December 1, 2019

This page will serve as a guide to setting up a basic Minecraft server on FreeBSD. 

Before setting up the server, choose between setting up a dedicated device or a virtual machine running FreeBSD.

If the device or virtual machine is already running FreeBSD, continue to the next step. Otherwise, consider one of the Foundation’s guides to get set up with FreeBSD

All commands in this section should be run as root, using the “su” command will also work. To download a compressed snapshot of the Ports Collection into /var/db/portsnap:

# portsnap fetch

When running Portsnap for the first time, extract the snapshot into /usr/ports:

# portsnap extract

After the first use of Portsnap has been completed, as shown above, /usr/ports can be updated as needed by running:

# portsnap fetch update

The FreeBSD ports collection has a wide variety of gaming ports available, including a great option for running a basic Minecraft server: the minecraft-server port.

The first step will be to install the port, now that the ports collection has been added, this can be done simply with the command:

# cd /usr/ports/games/minecraft-server/ && make install clean

To populate the necessary files, the user will need to execute the program with the command:

# minecraft-server

Next, the user will need to agree to the Minecraft End User License Agreement (EULA). This can be done by using the vi command. The following command will bring up the vi text editor:

# vi /usr/local/etc/minecraft-server/eula.txt

Using the editor (use the manual page if unfamiliar with the editor) change the 4th line to read:

eula=true

The server can then be run with the command:

# minecraft-server

To stop the server:

# stop

To connect to the Minecraft server over the internet, the user will need the external IP of the device as well as configure the router’s port forwarding. This process will be different for every single type of router so this guide provides a few links to make this easier.

First, identify the external IP of the device. A super easy way of doing this is using the wget(1) command:

# pkg install wget

proceed through the installation, typing ‘y’ when prompted. Next, use  wget(1) to pull the IP address from a website that will identify the device’s external IP.

# wget -qO - http://wtfismyip.com/text

This should return an IP that looks similar to “65.214.224.57”, however, each set of numbers will be different. This is the external IP address. Other devices will need this string to connect to the Minecraft server.

The next step is to make sure that the router connected to the device is properly forwarding all Minecraft traffic to the device. Even if there are no other computers on the network, this is a required step. Minecraft uses port 25565, so the router needs to be set up to send any traffic on port 25565 to the computer that has the Minecraft server. Router set-up will have to be done in a separate computer with a desktop environment set up.

Only do this step if on a virtual machine: Many virtual machines will have the same IP adress as the host computer but will receive none of the incoming traffic. To remedy this, a bridged network adapter will need to be used. This can be changed by opening the virtual machine’s network settings and switching the network adapter from NAT to bridged. This will give the virtual machine it’s own unique IP address that can be used to forward traffic. It is important to use this and not the host computer’s IP address in the next few steps, as traffic will not be correctly forwarded to the Minecraft server.

During setup, the router will have to identify the correct device to forward traffic to, while many routers will list the devices and the internal IP (different than the one found in step 4), this may not be the case. This IP should resemble  192.168.1.176 and is the number assigned to the device by the router. The command to identify this IP on the device is:

$ ifconfig

Each router will have a unique set-up process for port forwarding. Visit portforward.com and select the router model (usually listed on the back of the router). If an ad appears , click CLOSE, the application being advertised is not needed. 

The next page will have a guide to set-up port forwarding on that model of router, while each router is different, the important ports to forward to the device are listed below:

TCP: 25565
UDP: 19132-19133,25565

The external and local IP addresses may change when the device is shut down or the modem is reset. Each time the server is restarted, check that these have not changed and update the settings as required.

Now that the server has been set up, any Minecraft client should be able to connect with the external IP address found in step 4. First, ensure that the server is running on the host device or VM with the command:

# minecraft-server

Next, boot up the Minecraft client on the computer that will be connecting to the server, click Multiplayer and then Direct Connect, the client will then ask for the server address. This is the external IP found on step 4 of this guide. Clicking Join Server will then start the game session.

Once you have started playing on the server you can play around with server commands, these will be entered in the terminal on the device running the server and can be used to manipulate the game world, game rules, and players allowed on the server.