Doc Dragonbeard's Map

His journal starts with the usual hopeful, "This is my new journal in which I will record all of my exciting adventures...", followed by blank page after blank page, with the occasional dated entry, along the lines of "Ate a pork chop this morning."

However there is one possibly valuable document, a map, over two pages:

Join Us

You will need to take the following steps to join.

Install Java Minecraft

The server is running Java Edition.

There are two editions of Minecraft. The original version, Java Edition, and Bedrock Edition. The Java version can run on Windows, Mac OS, Linux, Chromebooks. Bedrock runs on iPads, XBox, other consoles and on Windows.

I am biased, but the Bedrock Edition seems to be a "modern" game with lots of opportunities to buy upgrades and packs and tails and pets and cloaks. I don't trust it. The Java edition, on the other hand, is a nice old fashioned game; there is a one-time cost to buy an account, the game is in slow but constant development and there is a huge mod community of people running weird and wonderful servers.

Download The Game

You can download the game here.

Purchase An Account

You will need to purchase an account.

Run The Game

We try to keep the server on the latest snapshot. You can enable snapshots from the Minecraft Loader screen. Click the Installations menu at the top of the screen.

Use The Latest Snapshot

From the installations screen enable Snapshots, as in the screenshot below.

And then ensure that you have Latest Snapshot selected.

Connect To The Server

To add the server choose Multiplayer from the main screen and then choose Add Server.

Enter a name of your choice for this server and the server address (which will be given to you separately).

Then you should be able to join!

OMG The Pins

This is a little lesson about reading the documentation. I spent hours trying to upload a blink sketch to the Uno. I tried all the boards available in the IDE. I loaded more boards using the IDE Boards Manager. I did rend my clothes and tear my hair. Finally I looked at the Jaycar site to try to find some howto stories.

On the product page linked above I found a note:

Please note: you must upload code to both processors then configure the switches for them to talk to each other

And a manual, and in the manual I found found some very clear instructions explaining that you have to set some dip switches on the board in order to program the Arduino MCU.

As they are two separate processors, you must upload code to both processors for them to function. You can set this by configuring the dip switches as per the table below, so that the USB/programmer can communicate between both processors individually. Once you have finished programming, configure the dip switches so both of the processors can communicate with each other to send messages back and forth.

For the moment I am not using the wireless functionality, so I've just set the dip switches so that I can program the Arduino MCU.

Interactivity

To work with the Arduino you have to be able to program it in C++. But the compile, upload, run loop of C++ can be daunting and time consuming. A more interactive programming cycle can give you more freedom to try out ideas, let you be more creative and is generally helpful for learning. I do a lot of programming in Python and I wanted to see if there was some practical way of working with the Arduino with Python.

Firmata

Firmata is a protocol for communicating with microcontrollers from software on a host computer. The protocol can be implemented in firmware on any microcontroller architecture as well as software on any host computer software package.

You load a general purpose sketch called StandardFirmata (or StandardFirmataPlus in this example) on the Arduino board and then use the host computer exclusively to interact with the Arduino board. In the Arduino IDE the Firmata sketches can be found in File -> Examples -> Firmata.

PyMata

PyMata is a Python library for interacting with an system running Firmata. The library has three flavours, the most straightforward of which lets you interact directly with the Arduino from the python interpreter.

Firmata Hello World

A basic Firmata hello world is to turn the on-board LED on and off.

First you load the Firmata sketch onto the Arduino. I tried StandardFirmataPlus. I quickly became apparent that this would not run on the Duemilanove. The only Firmata sketch the would was the OldStandardFirmata sketch. The python library, however, would not connect to this. In the end I got StandardFirmataPlus running with the Uno.

The python library was easy to install with pip install pymata-aio

Turning the on board LED on and off:

from pymata_aio.pymata3 import PyMata3
from pymata_aio.constants import Constants
board = PyMata3(arduino_wait=5)

BOARD_LED = 13
def setup():
    board.set_pin_mode(BOARD_LED, Constants.OUTPUT)

def loop():
    print("LED On")
    board.digital_write(BOARD_LED, 1)
    board.sleep(1.0)
    print("LED Off")
    board.digital_write(BOARD_LED, 0)
    board.sleep(1.0)

setup()
while True:
    loop()

MaxMatrix

But why just light up one LED when you can use 64? I did some work with the C++ MaxMatrix library and then ported it to python so I could drive the matrix from the python command line.

Wiring The LED

The LED is easy to wire. The VCC and GND pins should be connected to 5V and GND. The remaining pins can be connected to any digital pins on the board. They just have to be correctly identified when using the software.

One nice thing about driving the Arduino interactively is that you don't need to worry about memory as much. I was able to add an additional method to the library to load a Dwarf Fortress tileset and use this as a convenient source of high quality 8x8-bit ascii graphics. I chose the Potash tileset

Some sample code:

from pymata_aio.pymata3 import PyMata3
from pymata_aio.constants import Constants
import maxmatrix

board = PyMata3(arduino_wait=5)
# I wired the LED to 11, 12 and 13
DIN, CLK, CS = 12, 13, 11
mm = maxmatrix.MaxMatrix(board, DIN, CS, CLK)
mm.set_column(0, 0b1011011)

Working with sprites from a tileset:

ts = maxmatrix.Tileset()
sprite = ts.get_sprite('7')
mm.write_sprite(sprite)

maxmatrix.py

Full code listing of my python port of the MaxMatrix library.

maxmatrix.py (Source)

As I only have the one LED I haven't dealt with the parts of the MaxMatrix library that handle with multiple daisy-chained LEDs.

Connecting To The Arduino

The display has six wires. The documentation suggests that the blue (RST) wire does not need to be connected. In practice I found that it is better to not connect the white wire as well.

If the white wire is connected then it is not possible to upload a sketch as an error occurs:

avrdude: stk500_getsync() attempt 1 of 10: not in sync: resp=0xa5

The documentation suggests that you disconnect the green and white wires (RX and TX) while uploading a sketch. The you have to press the reset button to start the sketch again. If instead you just don't connect the white (RX) wire at all, everything works fine.

E-Paper Hello World

Following is a basic hello world program that displays the butterfly and flower image that is in the internal memory.

epaper_hello.ino (Source)

Things to note:

• line 13: epd_wakeup because we put it to sleep earlier. While it is awake it draws a fair amount of power.

• line 15: set the screen orientation to landscape, with wires on the left

• lines 21-23: clear the display, load a picture from the internal flash memory and update the display

• line 25: epd_enter_stopmode so it stops drawing power. Note the red light at the top left turns off.

Then the on-board LED starts flashing again. Just so it is clear that there is something happening.

E-Paper Calendar

My vision of an epaper word-a-day calendar is a little more challenging than I had at first anticipated. The software for drawing to the display is extremely rudimentary, with commands to display text, an image from the SD card or internal NAND flash and basic vector drawing commands.

void epd_draw_pixel(int x0, int y0);
void epd_draw_line(int x0, int y0, int x1, int y1);
void epd_fill_rect(int x0, int y0, int x1, int y1);
void epd_draw_circle(int x0, int y0, int r);
void epd_fill_circle(int x0, int y0, int r);
void epd_draw_triangle(int x0, int y0, int x1, int y1, int x2, int y2);
void epd_fill_triangle(int x0, int y0, int x1, int y1, int x2, int y2);
void epd_clear(void);

void epd_disp_char(unsigned char ch, int x0, int y0);
void epd_disp_string(const void * p, int x0, int y0);

void epd_disp_bitmap(const void * p, int x0, int y0);

There is also an exciting looking function for writing images to the SD card documented in the manual, but there are no library functions to use this functionality.

Send a file to the SD card using UART (0x40) After this command executed, any data from UART will be saved into the SD card and saved with the given filename. If the transmission stops more than 1s, this function will stop too. After the file sent, file size and Xor check will be returned and you should compare them to check if the file was sent properly. Last, if the file was sent properly, you should send the character ‘y’ to confirm. If the file is an image (.JPG or .BMP), you should set the storage area to SD card (A5 00 0A 07 01 CC 33 C3 3C A9), and then use the display image command to display it. UART input stream command is not affected by the storage area settings.Files are only going to be saved into the Micro SD card.

Nevertheless I laboriously laid out a basic mockup of a calendar page. While laying this out I used a grid of points to help align the text.

/**
* Draw a grid from (t,l) with points spaced `w` pixels apart and with
* major `tick` marks as specified.
*/
void draw_grid(int t, int l, int w, int tick) {
  int i = 0;
  int j = 0;
  for (int x = l; x <= 800; x += w) {
    i++;
    for (int y = t; y <= 600; y += w) {
      j++;
      epd_draw_pixel(x, y);
      if ((i % tick == 0) && (j % tick == 0)) {
        draw_tick(x, y);
      }
    }
  }
}

The finished sample:

The code:

epaper_calendar.ino (Source)

Clearly this project needs a higher level text layout capability. An interesting solution to this problem is to build an image on a remote server and then chop it into scanlines which are then delivered piecemeal over wifi.

Resources

• Manufacturer Main Page - https://www.waveshare.com/4.3inch-e-Paper.htm

• Manufacturer Docs - https://www.waveshare.com/wiki/4.3inch_e-Paper_UART_Module

Trouble

I had a lot of trouble getting this to work at all. There are a lot of basic things that you have to get right.

• As mentioned, fix group access permissions to the USB device.

• Make sure you have selected the right board from the Tools > Board menu, it won't be auto-detected for you.

• Select the right processor from the Tools > Processor menu. It might help to have a close look at the chip on the board to work out which one it is.

• If this all fails, you can turn on additional debugging output from File > Preferences > Show Verbose Output and start searching Stack Overflow.