Recently I've been moving my gaming rig from Windows 10 to Linux. After seeing how well everything works in the Steam Deck, I would prefer to be out of Windows as much as possible.

After preparing everything (I use Ubuntu 20.04 LTS as my Linux OS) and installing the latest Nvidia Graphics, I set up Steam and started playing my actual games (I'm pretty "busy" with Diablo IV) and everything went really fine.

But, one little issue appeared, after putting the computer in standby (suspend to ram) and resuming, the Steam UI did not work and hanged. I had to kill it and restart it.

The problem had to do with activating Steam UI Hardware Acceleration, that I had to enable because if not, the UI was really laggy.

If I disabled those options, Steam UI was working properly after resuming from STR.

After asome digging, I found out a post in the Steam Community Forums that fixed the problem and I wanted to resume here the steps that worked for me.

1- Enable NVidia Suspend Service

sudo systemctl enable nvidia-suspend.service

2- Prepare a folder where the driver will store graphics memory. We want this to be into a ramdisk to optimize the suspend time. In my case, /tmp is not a ramdisk and it is stored in the root FS and because of that, I created a folder and configured fstab to mount it on restart:

sudo mkdir /tmp/nvidia-tmpfs
sudo vi /etc/fstab

Append to the file this line (and save it):

tmpfs /tmp/nvidia-tmpfs tmpfs defaults 0 0

3- Create a module config for NVidia driver to use the temporary folder when computer is going STR:

sudo vi /etc/modprobe.d/nvidia-power-management.conf

And add this line to the file:

options nvidia NVreg_PreserveVideoMemoryAllocations=1 NVreg_TemporaryFilePath=/tmp/nvidia-tmpfs

This line will tell the driver to enable the Video Memory storage to file when going STR

4- We need to update initramfs to include the module configuration:

sudo update-initramfs -u

5- Reboot to enable these changes.

After the computer being rebooted, you can check if driver is properly configured to handle STR correctly with theses command and their expected response:

$ grep -i pres /proc/driver/nvidia/params
PreserveVideoMemoryAllocations: 1

$ grep -i temp /proc/driver/nvidia/params
TemporaryFilePath: "/tmp/nvidia-tmpfs"

If you see "1" for PreserveVideoMemoryAllocations, you are fine (a 0 will be a bad thing) and in the TemporaryFilePath you should see the path we setup prevously.

One last check would be ensuring the folder we created previously for storing video ram is indeed a tmpfs, you can check this with this command:

$ df /tmp/nvidia-tmpfs/
Filesystem     1K-blocks  Used Available Use% Mounted on
tmpfs            8158628     0   8158628   0% /tmp/nvidia-tmpfs

If in the Filesystem column you get "tmpfs" everything is fine

Last Christmast I received a new external USB Disk for my Raspberry PI 4.

In this Raspi I have a set of SMB mounts to use for several things including:

• PS2 USB share (for loading PS2 games)
• General SMB share
• Backup of different Internet repositories I own

Previous disk was a Western Digital one that entered standby automatically after some time but my new one a 5TB Seagate was not spinning down

I research in the issue and after some time, I found out that the OS (10 Buster) was not being able to use SMART in this drive and the drive firmware seems not to have automatic power down.

The OS, using SMART, can configure automatic spindown after some time being inactive, and this is what I wanted. So, after installing smart tools package (it wasn't install in my Raspi):

sudo apt-get install smartmontools

And trying to do anything with the drive, I was getting errors regarding not supported USB drive:

Read Device Identity failed: scsi error unsupported field in scsi command

After some digging (and thinking that the USB drive from Seagate was not appropiate for the usage I wanted) I found out the issue. The problem was that the drive was using the UAS module in the operating system and this module was generating the issue with SMART mon tools, so, let's configure Raspberry PI OS for not using UAS for this drive.

Get Vendor and Product ID

fms@gate:~ $ lsusb
Bus 002 Device 003: ID 0bc2:2034 Seagate RSS LLC 
Bus 002 Device 001: ID 1d6b:0003 Linux Foundation 3.0 root hub
Bus 001 Device 002: ID 2109:3431 VIA Labs, Inc. Hub
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub

In my case it was Vendor ID 0bc2 and Product ID 2034.

Configure Raspberry PI OS boot sequence to not use UAS for this device.

Edit /boot/cmdline.txt and add the following parameter to the kernel loading (ensure to put the correct Vendor and Product ID you got in the previous step):

usb_storage.quirks=0bc2:2034:u

The cmdline file should look like this:

console=serial0,115200 console=tty1 root=PARTUUID=8c926f11-02 rootfstype=ext4 elevator=deadline fsck.repair=yes usb_storage.quirks=0bc2:2034:u rootwait

And reboot the Raspi to apply this setting.

Check the drive is accesible for SMART mon tools

After reboot, execute a sample smartctl command to ensure the drive is acceisble for SMART tools, for example (if your drive is mapped to /dev/sda):

sudo smartctl -a /dev/sda -d sat

You should get a full SMART response, similar to this one:

smartctl 6.6 2017-11-05 r4594 [armv7l-linux-5.4.79-v7l+] (local build)
Copyright (C) 2002-17, Bruce Allen, Christian Franke, www.smartmontools.org

=== START OF INFORMATION SECTION ===
Model Family:     Seagate Barracuda 2.5 5400
Device Model:     ST5000LM000-2AN170
Serial Number:    FMSSN
LU WWN Device Id: 5 000c50 0f21e09d5
Firmware Version: 0001
User Capacity:    5.000.981.078.016 bytes [5,00 TB]
Sector Sizes:     512 bytes logical, 4096 bytes physical
Rotation Rate:    5526 rpm
Form Factor:      2.5 inches
Device is:        In smartctl database [for details use: -P show]
ATA Version is:   ACS-3 T13/2161-D revision 5
SATA Version is:  SATA 3.1, 6.0 Gb/s (current: 3.0 Gb/s)
Local Time is:    Sun Jan  7 11:49:27 2024 CET
SMART support is: Available - device has SMART capability.
SMART support is: Enabled

=== START OF READ SMART DATA SECTION ===
SMART overall-health self-assessment test result: PASSED

General SMART Values:
Offline data collection status:  (0x00)	Offline data collection activity
					was never started.
					Auto Offline Data Collection: Disabled.
Self-test execution status:      (   0)	The previous self-test routine completed
					without error or no self-test has ever 
					been run.
Total time to complete Offline 
data collection: 		(    0) seconds.
Offline data collection
capabilities: 			 (0x73) SMART execute Offline immediate.
					Auto Offline data collection on/off support.
					Suspend Offline collection upon new
					command.
					No Offline surface scan supported.
					Self-test supported.
					Conveyance Self-test supported.
					Selective Self-test supported.
SMART capabilities:            (0x0003)	Saves SMART data before entering
					power-saving mode.
					Supports SMART auto save timer.
Error logging capability:        (0x01)	Error logging supported.
					General Purpose Logging supported.
Short self-test routine 
recommended polling time: 	 (   1) minutes.
Extended self-test routine
recommended polling time: 	 ( 808) minutes.
Conveyance self-test routine
recommended polling time: 	 (   2) minutes.
SCT capabilities: 	       (0x30a5)	SCT Status supported.
					SCT Data Table supported.

SMART Attributes Data Structure revision number: 10
Vendor Specific SMART Attributes with Thresholds:
ID# ATTRIBUTE_NAME          FLAG     VALUE WORST THRESH TYPE      UPDATED  WHEN_FAILED RAW_VALUE
  1 Raw_Read_Error_Rate     0x000f   076   069   006    Pre-fail  Always       -       44189864
  3 Spin_Up_Time            0x0003   096   096   000    Pre-fail  Always       -       0
  4 Start_Stop_Count        0x0032   100   100   020    Old_age   Always       -       29
  5 Reallocated_Sector_Ct   0x0033   100   100   010    Pre-fail  Always       -       0
  7 Seek_Error_Rate         0x000f   065   060   045    Pre-fail  Always       -       3102614
  9 Power_On_Hours          0x0032   100   100   000    Old_age   Always       -       455 (149 190 0)
 10 Spin_Retry_Count        0x0013   100   100   097    Pre-fail  Always       -       0
 12 Power_Cycle_Count       0x0032   100   100   020    Old_age   Always       -       13
183 SATA_Downshift_Count    0x0032   100   100   000    Old_age   Always       -       0
184 End-to-End_Error        0x0032   100   100   099    Old_age   Always       -       0
187 Reported_Uncorrect      0x0032   100   100   000    Old_age   Always       -       0
188 Command_Timeout         0x0032   100   100   000    Old_age   Always       -       0
189 High_Fly_Writes         0x003a   100   100   000    Old_age   Always       -       0
190 Airflow_Temperature_Cel 0x0022   075   052   040    Old_age   Always       -       25 (Min/Max 25/40)
191 G-Sense_Error_Rate      0x0032   100   100   000    Old_age   Always       -       0
192 Power-Off_Retract_Count 0x0032   100   100   000    Old_age   Always       -       19
193 Load_Cycle_Count        0x0032   100   100   000    Old_age   Always       -       77
194 Temperature_Celsius     0x0022   025   048   000    Old_age   Always       -       25 (0 18 0 0 0)
195 Hardware_ECC_Recovered  0x001a   076   069   000    Old_age   Always       -       44189864
197 Current_Pending_Sector  0x0012   100   100   000    Old_age   Always       -       0
198 Offline_Uncorrectable   0x0010   100   100   000    Old_age   Offline      -       0
199 UDMA_CRC_Error_Count    0x003e   200   200   000    Old_age   Always       -       0
240 Head_Flying_Hours       0x0000   100   253   000    Old_age   Offline      -       37 (147 102 0)
241 Total_LBAs_Written      0x0000   100   253   000    Old_age   Offline      -       3925279266
242 Total_LBAs_Read         0x0000   100   253   000    Old_age   Offline      -       3612908854
254 Free_Fall_Sensor        0x0032   100   100   000    Old_age   Always       -       0

SMART Error Log Version: 1
No Errors Logged

SMART Self-test log structure revision number 1
No self-tests have been logged.  [To run self-tests, use: smartctl -t]

SMART Selective self-test log data structure revision number 1
 SPAN  MIN_LBA  MAX_LBA  CURRENT_TEST_STATUS
    1        0        0  Not_testing
    2        0        0  Not_testing
    3        0        0  Not_testing
    4        0        0  Not_testing
    5        0        0  Not_testing
Selective self-test flags (0x0):
  After scanning selected spans, do NOT read-scan remainder of disk.
If Selective self-test is pending on power-up, resume after 0 minute delay.

We are almost there. We need SMART mon tools to be configure for setting up the spindown timer when the drive is connected to the Raspi (or the system is rebooted).

Setup a UDEV rule for setting the automatic spindown on inactivity

udev service will be the one handling the connecting of the USB drive, and as such, we can create a custom rule to automatically configure the spindown time.

The following command will create a file in the udev files folder and configure a 300 seconds spindown time (standby parameter represents a 5 seconds factor) for any "sdX" disk that is attached to the Raspi:

cat >/etc/udev/rules.d/69-usbstandby.rules <<EOF
ACTION=="add|change", KERNEL=="sd[a-z]", ATTR{queue/rotational}=="1", RUN+="/usr/sbin/smartctl --set standby,60 -d sat /dev/%k"
EOF

Everything is ready and OK. You can check wheter this is working properly if, after 5 minutes (in my config) you can check that the drive is in standby mode. This can be done executing the following command:

sudo smartctl --nocheck standby -i /dev/sda -d sat | grep "STANDBY"
Device is in STANDBY mode, exit(2)

If you can see the response as in the example, your drive has been spinned down successfully.

Please note the --nocheck param as this will avoid smartctl spinning up the disk for SMART queries.

One of the useful thing we can do with our "Raspberries if to use them as WiFi access points. This will allow us to have signal in some places where our connection does not reach properly.

Fortunately, if we have a Raspberry Pi 3 or later and an Ethernet cable in the zone we want to provide signal to, we can configure it as an access point with the hostap software following these simple instructions (ensure you are following them using a Ethernet connection or the Raspi console or you will lose connectivity).

Install hostapd

First of all we need to install hostapd package. If our Raspberry PI OS is updated, we can just do it as follows:

sudo apt-get install hostapd

And enable the service to start with the system:

sudo systemctl unmask hostapd
sudo systemctl enable hostapd

Create bridge device between ethernet and WiFi

We need to create a network device that will allow network packets to flow between WiFi and Ethernet.

sudo vi /etc/systemd/network/bridge-br0.netdev

And insert inside:

[NetDev]
Name=br0
Kind=bridge

Now, we can add the members to the bridge:

sudo vi /etc/systemd/network/br0-member-eth0.network

And insert:

[Match]
Name=eth0

[Network]
Bridge=br0

Disable dhcp client for eth0

sudo vi /etc/dhcpcd.conf

At the end, add the following line:

denyinterfaces eth0 wlan0

Config br0 interface

sudo vi /etc/network/interfaces.d/br0

And insert:

auto br0
 
# Bridge setup
iface br0 inet dhcp
    bridge_ports eth0

Enable the networkd service

sudo systemctl enable systemd-networkd

Configure the access point

sudo vi /etc/hostapd/hostapd.conf

And in the content, change at least the values for the SSID name and passphrase

interface=wlan0
bridge=br0
driver=nl80211
ssid=MonkeyIsland3
auth_algs=1
wpa=2
wpa_passphrase=torpeo123
wpa_key_mgmt=WPA-PSK
wpa_pairwise=TKIP
rsn_pairwise=CCMP

country_code=ES
macaddr_acl=0
ignore_broadcast_ssid=0

# N
hw_mode=g
ieee80211n=1
wmm_enabled=1
require_ht=1
channel=8
ht_capab=[SHORT-GI-20][HT40][DSSS_CCK-40]

Secure the file:

sudo chown root:root /etc/hostapd/hostapd.conf
sudo chmod 600 /etc/hostapd/hostapd.conf

Start the network for the bridge to be created and restart network

sudo systemctl start systemd-networkd && sudo systemctl restart networking

Final restart
Your Wifi Access Point is working in bridge mode, however, a last shutdown is advisable to ensure that the software is started automatically when the system start.

sudo shutdown -r now

Ensure that after restarting you can see the SSID in your nearby WiFis

Performance
I would like to share one last word in this article regarding the performance. Please, have always in mind the limitations that both the Ethernet interface and/or WiFi interface of our beloved Raspberri has depending on the model (Ethernet port in older models is limited by its link speed and interface to the main SoC, WiFi is limited by kind of standard supported, g,n,a, etc...) and so, this is a good use for older models (or newer if you want) but if you need high performance, you could need either to tweak the hostapd.conf parameters or even buy a dedicated HW for this.

As we acquire the new Raspi models, old ones can be very useful for small tasks but, we should also update the OS version to the latest one.

One very good thing of Raspberry Foundation is that they keep backwards compatibility with older Raspi models. In this article, we will start from scratch (empty SD), in 2021, to configure a Rasp 3 with the base OS and in following articles, add new features from a Linux computer.

1 - Download the base OS

First, we need the base image. In this article, I will use the lite version and we will install later whatever packages we could need.

Go to Raspberry PI Download page and get the image.

2 - Write image to SD

Now, the image needs to be written to a SD.

WARNING: ALL DATA IN THE SD WILL BE DESTROYED AFTER EXECUTING THE FOLLOWING COMMAND.

First, check what device name has been asigned to the SD. As this is a very important step, I recommend extracting and reinserting the SD and check what device name is assigned, for example:

We can see the device is named sdc, and so, we can proceed writting the OS image.

unzip -p PATH_TO_THE_DOWNLOADED_FILE | sudo dd bs=1M of=YOUR_SD_DEVICE_NAME

After a while, the image will be completly written and you should get a message like this:

Eject the device to ensure all buffers and cache if written to the SD.

sudo eject /dev/sdc

3 - Prepare for first boot. Enable ssh access and disable auto resize

We would like to use the Raspi with SSH as soon as it boots and we would like to avoid automatic SD resizing (as we could like to repartition with our own partition scheme).

To do so, first, reinsert the SD to the Linux where we're configuring the image and ensure the "boot" partition is mounted:

ls -al YOUR_MOUNT_PATH/boot

You should see something like this:

Enable automatic SSH start by creating and empty file named "ssh":

touch YOUR_MOUNT_PATH/boot/ssh

And disable automatic resizing:

sed -i 's| init=/usr/lib/raspi-config/init_resize.sh||' YOUR_MOUNT_PATH/boot/cmdline.txt

You can eject again the SD:

sudo eject /dev/sdc

4 - Insert the SD on the Raspberry and boot it for the first time

The Rasp will boot (give it a couple of minutes) and then we should be able to login using SSH (the IP you'll get will vary based in your local network configuration):

ssh pi@YOUR_RASP_IP

As this is the first time we connect to it, SSH will warn us about connecting to an unknown device and add list to the known hosts list (type yes, and use as password "raspberry" that is the default one):

5 - Add your user and disable pi default user

We need to secure a little the Raspi. First, create your own user, set it with a secure password and disable the "pi" one:

sudo adduser YOUR_USER_NAME
sudo cp /etc/sudoers.d/010_pi-nopasswd /etc/sudoers.d/010_custom-nopasswd
sudo sed -i 's/^pi /YOUR_USER_NAME /g' /etc/sudoers.d/010_custom-nopasswd

Logout and relogin but this time with your new user and the new password:

ssh YOUR_USER_NAME@YOUR_RASP_IP

Disable the pi default user:

sudo usermod -L pi

Also, I strongly recommend setting a public key for SSH authentication and avoid using a password. You can do that easily, provided you're in a computer with Linux and the private key just logging out of the Raspi and executing, from your desktop computer:

ssh-copy-id YOUR_USER_NAME@YOUR_RASP_IP

If there is no error, you will be able to log in to the Raspi without using the password.

6 - Basic post-installation actions

Your Raspi is up and running, you can SSH to it and do many things, but, commontly, it is recommended to go to the raspi-config utility:

sudo raspi-config

and configuring at least:

• System options -> Wireless LAN: Set your country to be able to use WLAN (do not set SSID if you don't want to connect using WLAN yet)
• Localisation options -> Timezone: Set your timezone so the Rasp can show the localtime
• Localisation options -> Keyboard: Set your prefered keymap so you can use an attached keyboard if you need to

After doing this, raspi-config will ask to reboot, select yes and the device will restart with the new settings.

Microsoft Visual Studio Code is a general purpose programming IDE that, thanks to plugins, can be used to develop in several languages, and in this case, for several devices.

NodeMCU is a device that, using a ESP8266, can be programmed using USB, and easily connect several IoT devices (like temperature and humidity sensors) and connect to a WiFi network to send data using the standard TCP or UDP protocol.

In this post, we will be configuring VSCode (we will assume it is already installed in the computer) to be able to upload an small C program to the device.

Start the IDE
Start VSCode. A window similar to this one should open:

Install the Platformio Extension

The base installation of VSCode does not include support for IoT devices. We will use the Platformio Extension for VSCode for this.
To install it, select the extensions icon in the left sidebar of the VSCode window and in the editbox for searching Extensions, write "platformio".

Click on the install button for, in this case, the first result.

To ensure the extension will be working properly, restart VSCode

Create a new ESP8266 project

After restarting, a new icon in the left sidebar should appear, this is our new extension. Click on it and then "open" to start IDE.

Click on "New Project". A popup window will ask you for the project data. In this post, we will create a project named "THSensor", board will be NodeMCU 1.0.
Also, you could choose a folder for the project (I'm leaving it as default).

The first time a project is created, an Internet connection is required as PlatformIO needs some setup to be done, wait until it finishes preparing the environment and your project is opened in the main window.

You can now go to the left tree window, expand src and double click on main.cpp.

We got a scaffoldmain where we can code whatever we want.

Code your program

Now we're ready to code our C program. As an example, we will be coding a program that will be blinking one of the NodeMCU leds every 5 seconds and keep it turned on for 500ms.

Change your main.cpp to be like this:

#include <Arduino.h>

#define LED D4

void setup() {
  Serial.begin(74880);
  pinMode(LED, OUTPUT);
}

void loop() {
  //Turn off the led
  Serial.println("OFF\r\n");
  digitalWrite(LED, HIGH);

  //Wait for 5 seconds
  delay(5000);

  //Turn on the led
  Serial.println("ON\r\n");
  digitalWrite(LED, LOW);

  //Leave it on for 500ms
  delay(500);
}

Enable our Linux user to be able to use the serial ports

Communitation to the NodeMCU uses a system device that is configured when the device is connected. For being able to upload code to the device (or files) we need to ensure our user is in the "dialout" group. You can check issuing the following command from a terminal:

id

If in the response groups "dialout" group is not listed, add your user to it using the following command:

sudo usermod -a -G dialout $USER

You will need to close your current session and log in again (check with the id command that your user is now in the dialout group).

In my case (using Ubuntu 20.04.1 LTS) I had to restart the user.slice service so that GDM is restarted and my user groups gets refreshed

sudo systemctl restart user.slice

Configure monitor speed

NodeMCU defaults to 74880 bps. To be able to use the serial monitor and see log messages, we need to change the default 9600 that PlatformIO has to this value.

Click on the PlatformIO icon in the left sidebar, then, in "Quick Access", click "Projects & Configuration". Our project will be listed, click on "Configure":

Then, click on the 3 dots and select "Common configuration"

In the "New Option" editbox, type "monitor_speed" and set to 74880

Click Save (accept the warning regarding the configuration that will be overwritten).

Connect the NodeMCU

Connect a USB cable to the NodeMCU micro USB port and to your computer port. The NodeMCU will blink briefly and in your computer a new USB should be reported:

dmesg | tail
[ 4782.927702] usb 3-4: new full-speed USB device number 9 using xhci_hcd
[ 4783.076786] usb 3-4: New USB device found, idVendor=1a86, idProduct=7523, bcdDevice= 2.54
[ 4783.076790] usb 3-4: New USB device strings: Mfr=0, Product=2, SerialNumber=0
[ 4783.076793] usb 3-4: Product: USB2.0-Serial
[ 4783.078991] ch341 3-4:1.0: ch341-uart converter detected
[ 4783.079448] usb 3-4: ch341-uart converter now attached to ttyUSB0

The NodeMCU is ready on /dev/ttyUSB0

Click on the Serial Monitor icon in VSCode bottom icon bar (looks like an electrical plug). A task will be started in VSCode that will show a window like this one:

Now, hit the "RST" button in the NodeMCU, the serial monitor will receive the startup log information from the NodeMCU similar to this one:

Compile and upload our program

We're ready to compile and upload our test program. Click on the "->" icon to compile and upload our test program.

The led should blink as we programmed and the serial monitor will show "ON" and "OFF" strings with the defined cadence.

We've got the basics here. Now we can program more usefull tasks in other little NodeMCU.

Google has been evolving Appengine for long time and now, they changed some of the Terms Of Service for it. Now, you need to include a billing method even to use the free tiers and I would prefer not to risk to unwanted charges.

For some time, I've been thinking on evolving to another blog solution. Time has change, and now, many people, like me will have a 24x7 Raspberry Pi at home.

This computing wonder allow us to evolve to our own hosted blog platform.

I would like to use this first post to document and describe how I configured Ghost in docker in my Raspberry. I have several services running on it and I prefer all of them to be dockerized (this way, they are OS version independent and gives additional layers of security).

Following, I detail the step I've followed to have Ghost working this way.

1. Check prebuilt docker images available and select a version.
   You can see in your browser using DockerHub

2. Predownload the image. Altought this step can be avoided and will be automatically downloaded when we do the docker run below, I always prefer to ensure manual image preloading.

Execute:

docker pull ghost:3.40.4-alpine

And, after a while, you will get an output similar to:

3.40.4-alpine: Pulling from library/ghost
c58e8a26a840: Pull complete
11349be5853d: Pull complete
7b0d5f9228ff: Pull complete
4bf7dcdc3956: Pull complete
129c46fed0ed: Pull complete
fc05e34f99ff: Pull complete
02266fbbd074: Pull complete
23048f263933: Pull complete
f30021ef7671: Pull complete
Digest: sha256:95f54fd8ca13df328f54e39879a729cfb122504f4bfb897c6c3a658f230a4e5a
Status: Downloaded newer image for ghost:3.40.4-alpine

3. Prepare the persistence folder. As we will be running ghost from a dockerized service, we want to ensure our posts and data is persisted even if the container is detroyed (or upgraded) and so, create a folder that will store the Ghosts DBs.

mkdir ~/ghost

This will create a folder in your home folder named "ghost"

4. We're ready to drop the systemd script to control this docker as any other service (I'm running Raspbian 10, but the script should be similar for your distribution).

sudo vi /etc/systemd/system/ghost-docker.service

Insert the following in the file (edit the values you may want to be different like TCP port and similar):

[Unit]
Description=Ghost docker
Requires=docker.service
After=docker.service

[Service]
Restart=always
ExecStartPre=-/usr/bin/docker stop %n
ExecStartPre=-/usr/bin/docker rm %n
ExecStart=/usr/bin/docker run --name=%n \
  -v <PERSISTENT_FOLDER>:/var/lib/ghost/content \
  -e url=http://<YOUR_HOST_NAME>:2368 \
  -p 2368:2368 \
  ghost:3.40.4-alpine

ExecStop=/usr/bin/docker rm -f %n

Please ensure you set the values for <PERSISTENT_FOLDER> (with full path) and <YOUR_HOST_NAME> correctly

5. Start the service:

sudo systemctl start ghost-docker

You can check if the docker container has correctly started using docker ps command. You should see something similar to:

 docker ps
CONTAINER ID        IMAGE                   COMMAND                  CREATED             STATUS              PORTS                                       NAMES
1857012d8c3c        ghost:3.40.4-alpine     "docker-entrypoint.s…"   2 seconds ago       Up 1 second         0.0.0.0:2368->2368/tcp                      ghost-docker.service

6. Check access to the ghost service and to the management API. In your browser check that you can access:

http://<YOUR_HOST_NAME>:2368

And

http://<YOUR_HOST_NAME>:2368/ghost

7. Now you can configure and create your admin user for ghost. I recommend reading the official Ghost documentation

8. Finally, I've not found any automated means to migrate Vosao content to Ghost and so, I "copied & pasted" the content from the old site to the new one.

Long time, no see, blog failure...

For some time, the FMSDevel BLOG has been rendering the pages really wrong. As I frequently check for new issues/improvements of the CPC emulator for Android, I saw this problem some time ago.

Finally, I had the time to check for the cause and it's this

After wondering how is possible that, suddenly, a method is not found in the StringUtil class, I looked at Google APPEngine issues and found out that many others had the same problem. It seems like Google has decided to remove the isEmpty method from the Java library that the applications use to run on their servers.

This made all static files (CSS, JPG, etc..) failing being sent to the client, and so, HTML rendering was not working.

The problem was that Vosao (the open source CMS used for this BLOG) used that method internally (had been working previously without a problem) and checked for an update.

Vosao 0.9 solves this problem and you can have again FMSDevel online!

If you're interested in starting your own website/BLOG/etc... I encourage you to check Vosao (and Google AppEngine) and deploy an application to publish your contents with this great CMS and Google's free application hosting.

Missing those great games you remember from your youth? Do you remember those pixelated graphics and the hours you spent playing those games? Now you can enjoy them again on your Android phone.

Based on PSPCAP32 by Zx81 (http://zx81.zx81.free.fr) and using Pelya SDL Android Port and official NDK, the new CPCDroid allows full emulation of the CPC machines (464, 6128, etc...).

Version 1.5.1 features:

- Screenshot support

- Snapshot support (5 slots per loaded disk name)

- Disk A & B Support

- Autodetection of start file inside loaded DSK image (the program should start automatically after insertion of disk if not disabled in settings)

- Comments for games

- Cheats

- Keyboard remapping (saving, loading, etc..) to ease use of CPC Keyboard with SDL touchscreen virtual buttons

- Joystick remap (as in keyboard remapping)

- Settings support (for changing emulator parameters as rendering mode, skip fps in slow or older phones, etc...)

- Configuration menú can be used without losing CPC emulation state

- Text virtual keyboard can be used in the emulator (press "AB" virtual key on screen upper left side)

- Onscreen virtual keypad with 6 buttons (configurable in the main menu) for controlling CPC programs.

Installation guide:

- First, please check that your phone is configured to accept installation of non-market apks (Settings -> Applications -> Unknown sources)

- Download apk from link below. The browser should start a background download

   -OR-

- Put the downloaded APK in the phone SDCard.

- Install the APK (either by clicking in the download or in the APK from any Android File Manager) and accept permissions (Modify SD card for loading roms and saving snapshots), Internet communitacion for downloading of emulator data and Phone calls (read phone state and identity) used by SDL.

- The emulator is installed and ready to use.

Usage:

First time you start CPCDroid, SDL will uncompress (and download if necessary) CPC Data (ROMs, etc...). This will only be done the first time the emulator is started:

The main menu screen will be drawn and here you can navigate using the on-screen controls (arrows and buttons from 1 to 6 and "AB" for text input):

The emulator can run most of the prexistent CPC Software. If must be in DSK format and should be loaded using the "Load disk A" in the main menu.

If you have any roms, snapshots (PSPCAP32 and CAPRICE32 are compatible with CPCDroid), put them in the /sdcard/app-data/com.fms.cpcdroid subfolders as appropiate (DSK images in disk subfolder, snapshots in snap subfolder, etc...)

The emulator has a HELP option included in the main menu.

At any moment, press "MENU" button on the phone to go back. If in main menu, the "MENU" button will go to CPC emulator and if pressed in CPC emulator, the "MENU" button will show the main menu again.

Links:

Install package:

- Primary download site:

CPCDroid.apk (v1.5.1)

- Automatic direct download site (in case the file is not available at the moment in megaupload or download directly to your phone):

CPCDroid.apk (v1.5.1)

Source code:

CPCDroid.tgz (v1.5.1)

Please, feel free to leave your questions, suggestions or opinions in the contact me option.

Enjoy again those CPC programs!