PINE64 - RockPro64 Projects, Ideas and Tutorials

Anyone require a apple-sleek NAS case, w/ ample passive cooling & mutliple ssds?

Fri, 19 Jan 2024 20:17:25 +0000

I hadn't realized but I had spent an inordinate amount of time on a project for my rockpro64 NAS. So much so, that I thought it maybe of use to others since, through its many iterations, it has become nicely refined, maybe to the extent of a viable product.

I designed it out of a block of aluminium.
it had to be passive cooled to be in a heavily dusty environment.
it would be working hard, and in a hot workshop. As a result it had to have ample cooling, for chips and ram.
It turned out rather sleek like, apple esc due to the nature of how I chose to passively cool it.
Had to house and protect 3 SSD's.

Do I have to host pics to post them here?

Logical Extensible Gizmo Organizing RockPro64 Enclosure

Mon, 07 Aug 2023 03:32:42 +0000

This meticulously engineered Logical Extensible Gizmo Organizing [LEGO] single-board computer enclosure utilizes a highly modular and agile construction medium, featuring an innovative, tool-less assembly design with snap-fit components, enabling effortless customization and reconfiguration of the external layout to accommodate diverse SBC form factors and peripheral expansions, ensuring seamless integration of advanced cooling solutions and optimizing thermal dissipation to achieve enhanced computational performance, and operational stability, while remaining dynamic and aesthetically pleasing. Possible variations include (but are not limited to) "castle," "city," "space," and "technic," (for senior engineers). Many of these materials<< Warning: errant block components may find their way to interior walking surfaces and illicit extreme reactions of pain and Extreme-Non-Human-Resource-Approved-Language [ENHRAL] from staff >>

IMG_6078.jpg (Size: 441.62 KB / Downloads: 419)
IMG_6079.jpg (Size: 411.47 KB / Downloads: 445)

edit: I'm far from the first person to do this, check out these old links for inspiration:
https://forum.pine64.org/showthread.php?...light=lego
https://forum.pine64.org/showthread.php?...light=lego

4-pin JST-XH connector specs and staggered HDD spinup with LSI SAS 9211-4i

Sun, 30 Jul 2023 11:01:59 +0000

Hello.

I would like to know what is the maximum amperage of the 4-pin JST-XH connector since I am planning on powering 4 HDDs by means of it as well as whether it is possible to set up a staggered spinup configuration with the LSI SAS 9211-4i host bus adapter.

If the 4-pin JST-XH connector output current allows it, the project would entail splicing together two Pine64 power splitters somewhere between the cable input connector and the (seeming) buck converters.

Any advice on a suitable 230V 50Hz AC/DC PSU would also be appreciated.

Thank you.

Home Server with RAID 1 SATA M2 SSDs

Sun, 19 Mar 2023 13:18:09 +0000

I have been using a Raspberry Pi Model B as a home server for a decade now. Mainly as an http/cronjob server, it has never failed on me (did a SD card upgrade at some point for additional disk space). Backup was just a couple of SDs ready to replace the failing one.

Now I need more CPU power so I got myself a RockPro64 4GB and plan to setup it with two M2 SSDs in RAID 1.

My current inventory:

- board

- 60W power adapter

- PCIE to M2 SATA adapter (two slots) based on the JMB582 chip

Items I am waiting for:

- heat sink (forgot to order it with the board)

- serial to usb adapter (because apparently you cannot install Debian without it as video fails: https://youtu.be/dENsLmDhq5Y)

- 2x SATA SSDs (1TB each)

Tried installing Debian 12 but (as per the linked YouTube video) I think I got this https://wiki.pine64.org/wiki/ROCKPro64#N..._on_Debian so now I need something to hook up to the uart (please let me know if I am wrong on this).

Manjaro worked great and I was able to at least confirm the SATA adapter is loaded fine:
$ lspci
00:00.0 PCI bridge: Rockchip Electronics Co., Ltd RK3399 PCI Express Root Port
01:00.0 SATA controller: Micron Technology Corp. JMB58x AHCI SATA controller

Mycroft/Picroft on Rockppro64

Sat, 14 Jan 2023 00:29:19 +0000

I was playing with picroft on my old RPI3 + AIY Voicehat and it was just too slow for some functions, so considering the difficulty obtaining an RPI4 w/o selling limbs, I wanted to try getting it up and running on the RockPro.

One of the reasons I grabbed the RockPro was the "PI-2" gpio connector that is, more or less, compatible with the Rpi 40 pin. I was hoping to reuse the Voicehat (which provides a nice mic array and amplified speaker output).

Installing the Mycroft software was easy enough but I soon discovered that the driver that was written for the "googlevoicehat-soundcard" was, for some inane reason, held in the sound/soc/bcm area of the kernel and it's dts claimed it needed the RPI BCM processor (it's a dac/adc/amp combo it shouldn't be tied to a specific processor.

The driver is in Raspi but I don't think it was ever in mainline kernel, or if it was, it was dropped before Linux 5.

So, not being a kernel hacker, I've walked away from that idea.

I have ordered an inexpensive USB Speakerphone and will see how that works and update here.

Smart TV & server

Sun, 12 Jun 2022 15:07:34 +0000

Hello!

What I would like to achieve is having a fanless server and smart TV all in one. I would like to host my personal website, torrent daemon, Nextcloud and Ampache for music. Additionally I would like to connect it to my 4K TV where I would then watch 4K movies and listen to music on my stereo system.

I know that RP64 is capable of being a server but what is the story with 4K videos? An additional challenge would be crash resistance of the graphical part. What do you think of my plan?

Assembling desktop setup for newbies?

Sat, 11 Jun 2022 03:27:01 +0000

I am thinking about buying a rockpro64, but I would specifically like to set it up as a desktop computer connected to the internet. (It would actually be a bit of a home server, but would probably see most of its use in me typing or programming things within xfce/i3.)

I have experience with the pinebook pro and pinephone so I somewhat know how these computers are put together and boot.
But my big problem is simply knowing what parts I need to order when the information in the shop is very sparse and sometimes doesn't even say what's included and not included.

(I also tried writing to info@pine64, but the person who wrote back did not seem to be well-versed enough in English to understand what my question was.)

I think that logically I probably need to have:
- a computer board
- an emmc?
- a wifi/bluetooth module? (I would mainly use this for things like a bluetooth mouse)
- an enclosure
- a heat sink?
- an AC adapter
- a SATA* ssd adapter? is that even possible, or is it only an NVMe ssd that works? (I do mainly mean inside the enclosure**.)
- an hdmi cable? can it use these? Yes, there is an HDMI port.
- Is there an ethernet jack? (I think so) Yes, there is an ethernet jack.

I would like to know if I may have forgotten any parts or any of these things are actually included with other items.
As well as what parts are shared with the pinebook pro — I'd guess this would mostly just be the emmc, as it looks like there are different specs on the power adapter.

I feel like there probably should have been some kind of "ready to go" store page where you could get the minimum set of parts needed for a desktop the way you could simply order an assembled pinebook pro or pinephone. (or realistically maybe a couple of these for different use cases?)
But the next best thing is a tutorial on what parts go together for what purposes.

(* The only reason I ask about SATA drives is I had a previous server whose main board seemed to be dying, and it would be convenient to simply reuse its drive for the rockpro64 — specifically, I would only need it to be available as storage after boot.
I would not really be upset to find out that in practice it's too much trouble or requires dangerous meddling with the firmware. I would just like to know if it's possible to do and "how hard it is" for everyone's future reference when they think about buying this computer.)

(** This brings in two extra details:
A) computers always have a teeny chance of getting bumped at my house, so I would want an ssd to be protected and secured to the table along with the computer box
B) if it's not impossible to use a SATA drive by the time I've said that, I'd like to know how big the enclosure has to be and if this changes how I would set up a heat sink / fan / any other parts inside the box.)

---

Confirmed parts

* computer board - https://pine64.com/product-category/rock...46c16e2e66
* emmc and/or sd card - https://pine64.com/product-category/rock...es/page/2/
* wifi/bluetooth module - https://pine64.com/product/rockpro64-1x1...5-0-module

---

Edited to add basic facts & confirmed parts 22/6/11.

Sources:
https://wiki.pine64.org/wiki/ROCKPro64

Umbrel Server

Thu, 05 May 2022 00:14:18 +0000

I bought this board in the hopes that i could spare myself the hassle of getting a raspberry pi 4 during a chip shortage on top of a scalping mania, and run umbrel on the rockpro64 board.

has anyone come across some good tutorials for this? I tried going through this tutorial but I contacted the author through twitter and he said the whole blog post is out of date, given umbrel's many updates since then.

they make it sound so easy to set up on the raspberry pi 4, and I went ahead and overpaid for one anyways, but I'd still like to be able to run umbrel on the rockpro64, since there have been reported power delivery problems with running multiple drives on a raspberry pi.

OMV 6 NAS - Image to use

Fri, 18 Mar 2022 10:32:03 +0000

Can someone be so kind to let me know what image should I use in order to install OMV 6.0 on top?

SkiffOS server with Docker ,NAS, Home assistant, Jellyfin, Snikket XMPP (tutorial)

Wed, 02 Feb 2022 21:44:44 +0000

Hi All,

So I've written another install tutorial this time using SkiffOS, the first one hopefully helped a few users. I discovered SkiffOS on the Rockpro64 software release page however I was surprised to see literally no posts in the forum about it. I contacted the developer on Discord and with his endless help and patience , I have a working server running Docker and several containers.

UPDATE 19 JUNE 2022: After a lot of debugging and a lot of hard work on part , the Rockpro64 is on the 5.18 kernel and great news , anyone who uses the Marvell 88SE9230 SATA card its now working perfectly out of the box with SkiffOS, the udev rule is no longer required as its included within the SkiffOS Rockpro64 config

UPDATE: is currently working on providing pre-built images , for users who want to try SkiffOS without compiling their own build, a link will be attached when the images are available

SkiffOS Github page

The Docker containers I have are

a Simple Samba container for a NAS
a Radicale container for caldav calendar and contacts sync
a Home assistant container for home automation
a EspHome container for managing my home automation Sonoff light switches
a Jellyfin container as a media server
a Caddy server container for my reverse proxy and lets encrypt certs renewal
a Snikket server container for a xmpp server thats simple an easy to get setup
and finally a Portainer container to manage all my containers with a nice UI

now this sounds like a lot of containers for an arm board, but at idle which is most of the time, the Rockpro64 sits at 1% CPU use.

Now before I begin, SkiffOS describes itself as:

Quote:SkiffOS is a lightweight operating system for any Linux-compatible computer, ranging from RPi, Odroid, NVIDIA Jetson, to Desktop PCs, Laptops (i.e. Apple MacBook), Phones (PinePhone), Containers, or Cloud VMs. It is:

Adoptable: any userspace can be imported/exported to/from container images.

Familiar: uses simple Makefile and KConfig language for configuration.

Flexible: supports all major OS distributions inside containers.

Portable: containers can be moved between machines of similar CPU type.

Reliable: changes inside user environments cannot break the host boot-up.

Reproducible: a given Skiff Git tree will always produce identical output.

Uses Buildroot to produce a minimal "single-file" host OS as a standardized base cross-platform operating system "shim" for hosting containers. Most Linux platforms have widely varying requirements for kernel, firmware, and additional hardware support packages. The immutable SkiffOS host system contains everything needed to support the hardware, cleanly separated from the applications

The main thing to focus on, I think is that it is based on Buildroot, this is an immutable OS, so you have to compile the build on your daily machine(i.e laptop or desktop) and add any additional software packages and configuration options at build time. The benefits of an immutable system are best described above, but the main thing is "once setup" you can reproduce the build with ease and it will barely need any tinkering once its up an and running, plus it provides the security that should anything go wrong a quick reboot will restore the System back to its initial boot state.

SkiffOS has a "persist" partition that stores all the files and folders that you want to persist after a reboot. This can be where all the docker configuration files and states reside.

SkiffOS also has the option for a CORE container this is a container that will provide an OS environment more familiar to most, making it easier to interact with the persist partition, you can choose between many core environments such as Alpine, Debian, Gentoo or even Ubuntu with a desktop environment. All this is best explained on the Github page, I however didn't need a core container as once setup the only interaction I need is with the containers themselves.

So lets begin! to start with I would create a Projects Directory on you daily machine, preferably in you Home directory and then Git Clone the repo from Github into the projects directory.

Code:
mkdir Projects 

cd Projects/

git clone https://github.com/skiffos/SkiffOS.git

Now I created a configuration directory that has all my docker container configs, files and scripts, I called it my_docker_config this allows me to export it as an option when compiling SkiffOS during build time but of course you could create these files and folders and copy and paste their contents one at a time to the persist partition after first boot, but this defeats the benefit of having a reproducible build. So a little work now, to create a config directory will really pay off.

I have a udev rule that allows my marvell 88SE9230 Sata card to work and a fan script that starts the fan and keeps it at a constant speed, these are best explained in my other tutorial, however these are the types of things I would also want to have in my configuration directory. I also have a couple of systemd .mount files to mount my ssd's on startup similar to how an "fstab" file would work.

This is how my my_docker_config directory tree looks

Code:
my_docker_config

    └── root_overlay

        ├── etc

        │   ├── skiff

        │   │   └── authorized_keys

        │   │       └── my-key.pub

        │   ├── systemd

        │   │   └── system

        │   │       ├── fan-speed.service

        │   │       ├── mnt-ssd1.mount

        │   │       ├── mnt-ssd2.mount

        │   │       └── multi-user.target.wants

        │   │           ├── fan-speed.service -> ../fan-speed.service

        │   │           ├── mnt-ssd1.mount -> ../mnt-ssd1.mount

        │   │           └── mnt-ssd2.mount -> ../mnt-ssd2.mount

        │   └── udev

        │       └── rules.d

        │           └── 99-marvell.rules

        └── opt

            ├── mydocker

            │   ├── caddy

            │   │   ├── caddy_data

            │   │   └── Caddyfile

            │   ├── docker-compose.yml

            │   ├── esphome

            │   │   └── config

            │   ├── homeassistant

            │   │   ├── automations.yaml

            │   │   ├── configuration.yaml

            │   │   ├── groups.yaml

            │   │   └── www

            │   │       ├── picone.PNG

            │   │       └── pictwo.PNG

            │   ├── jellyfin

            │   ├── radicale

            │   │   ├── config

            │   │   │   └── config

            │   │   ├── data

            │   │   └── log

            │   └── snikket

            │       ├── acme_challenges

            │       ├── snikket.conf

            │       └── snikket_data

            └── rockpro64_fan

                └── fan_script.sh

you can see I keep my docker configuration file in mydocker a fan script under "opt" and the rest of my config in "etc" this is all whats called a root overlay , all these file and directories will be overlaid upon boot and be placed in their respective folders in the live environment . You can also see I have "authorized_keys" under skiff this is where you can place your public ssh keys , so you have ssh access upon boot.

my udev rule named 99-marvell.rules looks like this
(This udev rule is no longer required it is included in SkiffOS config for the Rockpro64, its shown to inform only):

Code:
ACTION=="add", SUBSYSTEM=="pci", ATTR{vendor}=="0x1b4b", ATTR{device}=="0x9230", RUN+="/bin/bash -c 'echo %k > /sys/bus/pci/drivers/ahci/bind'"

My fan_script.sh looks like this:

Code:
#!/bin/bash

rmmod pwm-fan

echo 0 > /sys/class/pwm/pwmchip1/export

echo 110 > /sys/class/pwm/pwmchip1/pwm0/duty_cycle

echo 500 > /sys/class/pwm/pwmchip1/pwm0/period

echo 1 > /sys/class/pwm/pwmchip1/pwm0/enable

this will of course need a "fan speed service" to start from boot and a sym link to the service in the multi-user.target.wants directory as shown in the directory tree

the service aptly named fan-speed.service looks like this :

Code:
[Unit]

Description=change fan speed at startup 

After=basic.target

[Service]

Type=oneshot

RemainAfterExit=yes

ExecStart=/opt/rockpro64_fan/fan_script.sh

[Install]

WantedBy=multi-user.target

one of my SSD mount files looks like this:

(please note the name of the mount file must be the path to the mount point with each folder separated by a hyphen i.e /mnt/mydrive/here would be mnt-mydrive-here.mount)

(also note that a sym link to the .mount file must also be in multi-user.target.wants directory)

Code:
[Unit]

Description=mounting Files from SSD

[Mount]

Where=/mnt/ssd1

What=/dev/disk/by-label/storage1

[Install]

WantedBy=multi-user.target

here is the basic config for Radicale :

Code:
[server]

hosts = 0.0.0.0:5232

max_connections = 15

# 100 Megabyte

max_content_length = 100000000

# 30 seconds

timeout = 20

[auth]

# Average delay after failed login attempts in seconds

delay = 600

type = htpasswd

htpasswd_filename = /etc/radicale/users

# encryption method used in the htpasswd file

htpasswd_encryption = md5

[storage]

filesystem_folder = /data/collections

and the snikket.conf file please edit with your email and domain name for snikket (please leave the ports commented out until later) :

Code:
# The primary domain of your Snikket instance

SNIKKET_DOMAIN=mysnikket.duckdns.org

# An email address where the admin can be contacted

# (also used to register your Let's Encrypt account to obtain certificates)

SNIKKET_ADMIN_EMAIL=myemailaddress@mail.com

#SNIKKET_TWEAK_HTTP_PORT=5080

#SNIKKET_TWEAK_HTTPS_PORT=5443

and the Caddyfile required for caddy

Code:
(log_common) {

  log {

    output file /var/log/caddy/{args.0}.access.log

  }

}

myradicale.duckdns.org {

    handle_path /radicale* {

        reverse_proxy localhost:5232 {

            header_up X-Script-Name /radicale

        }

    }

    import log_common myradicales.duckdns.org

}

myhomeassistant.duckdns.org {

    reverse_proxy localhost:8123

    import log_common myhomeassistant.duckdns.org

}

http://mysnikket.duckdns.org,

http://groups.mysnikket.duckdns.org,

http://share.mysnikket.duckdns.org {

    reverse_proxy localhost:5080

    request_body {

      max_size 20M

      }

}

mysnikket.duckdns.org,

groups.mysnikket.duckdns.org,

share.mysnikket.duckdns.org {

        tls /snikket/letsencrypt/live/mysnikket.duckdns.org/fullchain.pem /snikket/letsencrypt/live/mysnikket.duckdns.org/privkey.pem

    reverse_proxy https://localhost:5443 {

        transport http {

                tls_insecure_skip_verify

            }

        }

        request_body {

      max_size 20M

      }

}

(please edit the above with the domain names you have chosen for your services)

and finally my docker-compose.yml file for all my containers apart from Portainer which needs to access the docker daemon via a unix socket

(please edit to suit your needs):

Code:
version: '3.7'

services:

  caddy:

    depends_on:

      - radicale

      - homeassistant 

    image: caddy:latest

    container_name: caddy_reverse_proxy

    volumes:

      - /mnt/persist/mydocker/caddy/caddy_data:/data

      - /mnt/persist/mydocker/caddy/Caddyfile:/etc/caddy/Caddyfile

      - /mnt/persist/mydocker/snikket/snikket_data:/snikket:ro 

      - /mnt/persist/mydocker/caddy/logs:/var/log/caddy/

    environment:

      - TZ=Europe/London  

    restart: unless-stopped

    network_mode: host

  radicale:

    image: tomsquest/docker-radicale

    container_name: radicale

    ports:

      - 127.0.0.1:5232:5232

    init: true

    read_only: true

    security_opt:

      - no-new-privileges:true

    cap_drop:

      - ALL

    cap_add:

      - SETUID

      - SETGID

      - CHOWN

      - KILL

    healthcheck:

      test: curl -f http://127.0.0.1:5232 || exit 1

      interval: 30s

      retries: 3

    restart: unless-stopped

    volumes:

      - /mnt/persist/mydocker/radicale/data:/data

      - /mnt/persist/mydocker/radicale/config:/config:ro

      - /mnt/persist/mydocker/radicale/users:/etc/radicale/users

      - /mnt/persist/mydocker/radicale/log:/var/log/radicale/log

    environment:

      - TZ=Europe/London 

  homeassistant:

    container_name: home-assistant

    image: homeassistant/home-assistant:stable

    volumes:

      - /mnt/persist/mydocker/homeassistant:/config

    environment:

      - TZ=Europe/London

    restart: unless-stopped

    network_mode: host

  esphome:

    image: esphome/esphome

    volumes:

      - /mnt/persist/mydocker/esphome/config:/config:rw

    environment:

      - TZ=Europe/London

    network_mode: host

    restart: unless-stopped

  snikket_proxy:

    container_name: snikket-proxy

    image: snikket/snikket-web-proxy:beta

    env_file: /mnt/persist/mydocker/snikket/snikket.conf

    network_mode: host

    volumes:

      - /mnt/persist/mydocker/snikket/snikket_data:/snikket

      - /mnt/persist/mydocker/snikket/acme_challenges:/var/www/html/.well-known/acme-challenge

    restart: unless-stopped

  snikket_certs:

    container_name: snikket-certs

    image: snikket/snikket-cert-manager:beta

    env_file: /mnt/persist/mydocker/snikket/snikket.conf

    volumes:

      - /mnt/persist/mydocker/snikket/snikket_data:/snikket

      - /mnt/persist/mydocker/snikket/acme_challenges:/var/www/.well-known/acme-challenge

    restart: unless-stopped

  snikket_portal:

    container_name: snikket-portal

    image: snikket/snikket-web-portal:beta

    network_mode: host

    env_file: /mnt/persist/mydocker/snikket/snikket.conf

    restart: unless-stopped

  snikket_server:

    container_name: snikket

    image: snikket/snikket-server:beta

    network_mode: host

    volumes:

      - /mnt/persist/mydocker/snikket/snikket_data:/snikket

    env_file: /mnt/persist/mydocker/snikket/snikket.conf

    restart: unless-stopped

  samba:

    build: .

    image: servercontainers/samba

    container_name: samba-server

    restart: unless-stopped

    network_mode: host

    environment:

      WSDD2_DISABLE: 1

      AVAHI_DISABLE: 1

      ACCOUNT_user1: "user1:1000:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX:DF56ET792A681E1A23E0F75695:[U          ]:LCT-4502WT5:"

      UID_user1: 1020

      GROUPS_user1: users

      ACCOUNT_user2: "user2:1000:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX:29395D100D389TEB9E295A747E420:[U          ]:LCT-521D03D5:"

      UID_user2: 1021

      GROUPS_user2: users

      GROUP_users: 100

      SAMBA_VOLUME_CONFIG_Foldername: "[Foldername Share]; path=/shares/Foldername; valid users = user1, user2; guest ok = no; force group = users; read only = no; browseable = yes"

      SAMBA_VOLUME_CONFIG_media: "[media Share]; path=/shares/media; valid users = user1, user2; guest ok = no; force group = users; read only = no; browseable = yes"

    volumes:

      - /mnt/ssd1/Foldername:/shares/Foldername

      - /mnt/ssd2/media:/shares/media

  jellyfin:

    image: linuxserver/jellyfin:latest

    container_name: jellyfin

    network_mode: host

    volumes:

      - /mnt/persist/mydocker/jellyfin/config:/config

      - /mnt/persist/mydocker/jellyfin/cache:/cache

      - /mnt/ssd2/media:/media

    restart: unless-stopped

    environment:

      - TZ=Europe/London

after you have your configuration directory you can move it to /Projects/SkiffOS/configs/apps/ this will make it an exportable option in the next step.

So on to the installation!

Hopefully you still in the Projects directory with the freshly git cloned SkiffOS and your custom config directory moved to its place in the apps folder. As per the instruction on the SkiffOs github page you need to export all the options you want for the build, I have my board requirement, docker compose (which also installs docker) and my custom config directory.

this looks like this :

Code:
cd SkiffOS

export SKIFF_CONFIG=pine64/rockpro64,apps/compose,apps/my_docker_config

OK so I should mention that if you require any additional software such as "htop" installed then now is the time to select it this is done by typing

Code:
make br/menuconfig

please note! all these commands will only work if you are in the the SkiffOS directory located in the previously created Projects directory

This make command will create an ncurses menu that will allow you to select additional software, system configs kernel options .etc

The target packages option will allow you to select additional packages such as htop.

The / key will allow you to search all the options and space will allow you to select the option current highlighted . (remember to save before you exit the ncurses menu)

Now to finish up the build process.

Code:
make configure

make compile

This last command will begin the compiling process, this can take some time depending on your hardware, so now is the time to get a coffee!

(please note that when you recompile, for example after an update to SkiffOS this will be alot shorter timespan, as a previously compiled image will exist and only updated options and packages will be compiled )

To copy the compiled image to an SD card or emmc (although I currently haven't tested if emmc works)

You will need to be root to perform these next commands

Code:
sudo bash 

blkid  (this is to see  where the SD is located )

export PINE64_SD=/dev/mmcblk0  ( please edit this last part to suit where you SD is located)

make cmd/pine64/common/format  ( this formats the card , if you get an error with this command and your using Ubuntu please see note below)

make cmd/pine64/common/install ( this will copy the build to the sd card)

(Additional note whilst using Arch I had no issue with the format command above, however after switching to a Ubuntu based OS I noticed it failed with an error, the solution was to edit he formatting script and add a P to every partition and the fatlabel )

Code:
nano ~/Projects/SkiffOS/configs/pine64/common/scripts/format_sd.sh

see the addition of the p after every curly bracket

Code:
echo "Formatting boot partition..."

mkfs.vfat -F 32 ${PINE64_SD_SFX}p1

fatlabel ${PINE64_SD_SFX}p1 boot

echo "Formatting rootfs partition..."

$MKEXT4 -L "rootfs" ${PINE64_SD_SFX}p2

echo "Formatting persist partition..."

$MKEXT4 -L "persist" ${PINE64_SD_SFX}p3

now your ready to boot, but before you do I would create the Duckdns or other DDNS provider entries for the services you will expose to the internet (Please see my other tutorial for assistance), in my case Home assistant , Radicale and the Snikket XMPP server, so 3 entries in total.

I will point out for completeness sake that if your following along with this tutorial and you are wanting to trial Snikket as an XMPP server it is not recommended to use a Dynamic Domain Name Service, preferably you will require a static IP address from your internet provider and you should use the recommended DNS providers suggested on the Snikket website . I have a static IP but I am using Duckdns as a free DNS which works perfectly for my use case.

When you boot for the first time it may take a few minutes to provide SSH, if it doesnt provide SSH after 15 minutes, the SSH keys provided in the config file are either incorrect or you have an issue and the SD has failed to boot. (Connecting a serial console could help you resolve your issue see here )

After you have successfully booted move your mydocker config directory to the persist partition

Code:
mv /opt/mydocker /mnt/persist/

now to get Portainer up and running

Code:
docker run -d -p 9443:9443 --name portainer \

    --restart=always \

    -v /var/run/docker.sock:/var/run/docker.sock \

    -v portainer_data:/data \

    cr.portainer.io/portainer/portainer-ce:latest

You will need to setup Portainer to your requirements (This docker command will only get it installed and running)

Next pull all the container images for your services (This command will only work if your in the directory where your docker-compose file is located)

in my case:

Code:
cd /mnt/persist/mydocker/

docker-compose pull ( this will pull all images and can take some time )

So If your following along and are using the Radicale container, you will need to run a "one time" command to create a user password using htpasswd this can be done using a "temporary container", the container is removed after the command completes.

Code:
docker run -v /mnt/persist/mydocker/radicale:/radicale --rm -it alpine:edge sh -c "apk add apache2-utils && htpasswd -c /radicale/users calendar"

(this creates user "calendar" password)( the --rm remove the container after completion )

next if your using the samba container for a NAS and your would prefer to use password hashes rather than a plain text password, then run this docker command for each user and fill in the requested details.

This will print to screen a hash for the specified user which needs to be added to the docker-compose.yml file as shown above where it says ACCOUNT_username

Code:
docker run -ti --rm --entrypoint create-hash.sh servercontainers/samba

Now is the time to open the required ports on your router, Caddy only requires 80 and 443 for the reverse proxy service however Snikket requires quite a few port as shown here

Snikket requires a configuration file as shown above, however to use with a reverse proxy (Because Snikket gets its own lets encrypt certificates) you will need to change the ports in the .conf file (i.e uncomment) to something different from 80 and 443 which are in use by the Caddy container.

Before you uncomment these ports in the config I would start the Snikket containers, with out the reverse proxy running, that way the Snikket server can obtain its own lets encrypt certs without issue, the certs will renew without issue, with the newly altered ports in my case 5080 and 5443, from now on, no need to edit again.

Run these commands then edit the .conf file and uncomment the alternative ports.

Code:
docker-compose up snikket_proxy snikket_certs snikket_portal snikket_server

ctrl + c (to stop the containers )

nano /mnt/persist/mydocker/snikket/snikket.conf

OK so your almost there, If you have a backup of your Homeassistant install, now is the time to copy it to the homeassistant directory otherwise once started the home assistant container will be from scratch and will need to be setup from new.

Finally !

Code:
docker-compose up -d

This will start the containers in daemon mode (i.e in the background)

If all is working you should see the HomeAssistant login screen, the Radicale login screen and the Snikket admin login screen at the addresses you specified with you DNS. Of course you will see all other service via their local network address/IP

I would now create an admin invite for yourself to access the Snikket admin page

Code:
docker exec snikket create-invite --admin --group default

this will generate a URL for your first admin password setup

All services will need configuring/setup to suit your needs but all containers should be running and healthy, this can be checked in the Portainer UI.

Congrats!!

as a final note!

How to update SkiffOS, if there has been a new release or if you have changed the config on your build / require additional packages

Code:
cd Projects/SkiffOS

git pull --recurse-submodules

Note! you may need to re-build fully if too much has changed

(it which case the make clean command should be used before compiling):

Code:
make clean

Then compile:

Code:
make compile

Then push the updated image:

Code:
./scripts/push_image.sh root@SKIFFOS_IP_ADDRESS

3D Printed 2 SSD Vertical NAS Case

Sun, 12 Dec 2021 22:52:47 +0000

Made this vertical 2 SSD nas case that houses stock PCIe SATA card and 2 SSDs.

PINENAS.jpeg (Size: 320.79 KB / Downloads: 735)

https://www.thingiverse.com/thing:5162344

Still working on the top lid

RockPro64 programing GPIO by Rust

Thu, 25 Nov 2021 02:43:54 +0000

Hello,
For the Rust developer, I show the gpio led blinking program code for RockPro64.
You can use GPIO pin number or BCM number.

In project
cargo build --release
sudo target/release/gpio

LED connected Pin 16 blinks.

cargo.toml

------------------------------------
[dependencies]
sysfs_gpio = "0.6"

------------------------------------
main.rs
-----------------------------------------------------------------------------------
use sysfs_gpio::{Direction, Pin};
use std::thread:leep;
use std::time:uration;

// Define GPIO arrays
static BOARD_TO_ROCK: &'static [u8] = &[0, 0, 0, 52, 0, 53, 0, 152, 148, 0, 147, 54, 120, 50, 0, 33, 36, 0, 149, 40, 0, 39, 153, 41, 42, 0, 45, 43, 44, 155, 0, 156, 124, 125, 0, 122, 126, 121, 123, 0, 127];
static ROCK_VALID_CHANNELS: &'static [u8] = &[52, 53, 152, 54, 50, 33, 40, 39, 41, 43, 155, 156, 125, 122, 121, 148, 147, 120, 36, 149, 153, 42, 45, 44, 124, 126, 123, 127];
static BCM_TO_ROCK: &'static [u8] = &[43, 44, 52, 53, 152, 155, 156, 45, 42, 39, 40, 41, 124, 125, 148, 147, 124, 54, 120, 122, 123, 127, 33, 36, 149, 153, 121, 50];

fn main() {
let my_pin_num = 16;//gpio number: 36
let my_led = Pin::new(BOARD_TO_ROCK[my_pin_num].into()); // Pin 16 GPIO1_A4 gpio number 36 depends on chip, etc.
//let my_bcm_num = 23;//gpio number: 36
//let my_led = Pin::new(BCM_TO_ROCK[my_bcm_num].into()); // Pin 16 GPIO1_A4 gpio number 36 depends on chip, etc.
my_led.with_exported(|| {
my_led.set_direction(Direction::Out).unwrap();
loop {
my_led.set_value(0).unwrap();
sleep(Duration::from_millis(100));
my_led.set_value(1).unwrap();
sleep(Duration::from_millis(100));
println!("Blinking GPIO1_A4(36) Pin 16");
}
}).unwrap();
}

-------------------------------------------------------------------------------------------------

[Turorial] NAS Using A Recycled 1U Proliant Case

Sun, 30 May 2021 23:54:09 +0000

So you've just gotten your brand new Rockpro64, you're looking for a clean way to stuff a PSU and 4 HDD backplane into a box that fits nicely onto your network rack. What do you do? Well, you could get the official NAS case. But that only fits 2 disks, and how are you supposed to mount that on your rack? With a shelf?? Inconceivable.

Well here's what I did:

Having bought my home network equipment off eBay, I know retired enterprise gear can be had for dirt cheap. So after some quick searching, I came across the perfect 1U case, that happened to also have a Proliant DL160 server inside it. Perfect for a weekend project.

Steps to NAS:

1. Gut the server, leaving only the PSU, backplane, and fans.

2. If the original SAS controller works, great! If not, find a Rockpro64 compatible PCIe SAS controller. I used an IBM H1110.

3. An ATX breakout board is handy for connecting to the case's power supply. But if you prefer crimping wires, you do you. As a side note, I'm using the ATX supply to directly control power to the Rockpro. The Rockpro actually has some solder points for power control, near the power buttons, which could be used to improve on my design. I'll be adding that mod myself whenever I get around to it.

4. You'll need an Arduino as well, I like using Nano's. They're super cheap and fit nicely into just about any project.

5. Shove it all into the case. It should look something like this:

  Inside-2.jpg (Size: 34.2 KB / Downloads: 749)

6. You'll need to wire all those pieces together. I'm driving the LEDs directly from the Arduino GPIO, because I'm lazy I like to live dangerously. If you're more concerned about damaging your AVR than I am, you might want to buffer each of those LED lines with a transistor. I decided to wire the fancy buttons and blinkenlights on the front panel up to the Arduino for my NAS. You can put together a wiring harness to mate with the case connector, or be like me and shove your wires directly into the case connector. They're not going anywhere:

  DL160_Case.jpg (Size: 72.19 KB / Downloads: 644)

  DL160-Harness.jpg (Size: 21.06 KB / Downloads: 611)

7. The front panel has a 2 row, 2.5mm pitch female connector for the USB connections. Hack a connector onto couple USB cables. You can then use the hacked cables as an adapter between the case USB connector and the Rockpro USB inputs. My DL160 case only supports USB 2.0, so I can't take full advantage of the Rockpro's USB interface:

  USB-Harness.jpg (Size: 15.87 KB / Downloads: 642)

8. If you don't like your NAS to sound like a jet plane taking off, take out some fans. I've left just one fan. It's keeping everything nice and cool, and runs almost silently. To maintain proper airflow, stuff some packing foam in place of the old fans:

  Fans.jpg (Size: 28.55 KB / Downloads: 655)

9. You'll need to get some code onto the Arduino. This script handles power up/shutdown; fan control; and, just to look like a real enterprise grade server, blinking some lights:

Code:
#include 

#include 

#define PIN_UART_RX     1

#define PIN_PSU_ON      2

#define PIN_PANEL_PWR   3

#define PIN_SYS_LED_P1  4

#define PIN_NIC_LED_P   5

#define PIN_HDD_LED_P   6

#define PIN_BOARD_PWR   7

#define PIN_FAN_PWM     9

#define PIN_PWR_LED_GP_RN   12

#define PIN_PWR_LED_GN_RP   13

#define PIN_SYS_LED_G_N     19

#define PIN_SYS_LED_R_N     20

#define PIN_SYS_LED_P2      21

#define PWR_STATE_OFF           0   //PSU powered off

#define PWR_STATE_STARTUP       1   //PSU starting up, power button is still held

#define PWR_STATE_ON            2   //PSU powered up, button no longer held

#define PWR_STATE_SHUTDOWN_TMR  3   //PSU powered up, shutdown timer is counting

#define PWR_STATE_SHUTDOWN      4   //PSU shut down, button is still held

#define PWR_STATE_BOARD_OFF     5   //board shut down, PSU still on

#define BLINK_STATE_READY   0   //LED is not blinking

#define BLINK_STATE_ON      1   //LED is off

#define BLINK_STATE_OFF     2   //LED is on

#define UART_STATE_OK       0

#define UART_STATE_ERR      1

#define UART_WATCHDOG_TIMEOUT   10000

uint8_t power_state = PWR_STATE_OFF;

_Bool uart_state = UART_STATE_OK;

int blink_chance = 0;

elapsedMillis event_timer;

elapsedMillis uart_watchdog;

elapsedMillis blink_timer;

void setup() {

    // Configure PWM on pin 9 (and 10) @ 25 kHz.

    TCCR1A = 0;

    TCCR1B = 0;

    TCNT1  = 0;

    TCCR1A = _BV(COM1A1)

           | _BV(COM1B1)

           | _BV(WGM11);

    TCCR1B = _BV(WGM13)

           | _BV(CS10);

    ICR1   = 320;

    pinMode(PIN_UART_RX, INPUT);

    pinMode(PIN_PSU_ON, INPUT);

    pinMode(PIN_PANEL_PWR, INPUT_PULLUP);

    pinMode(PIN_SYS_LED_P1, OUTPUT);

    pinMode(PIN_NIC_LED_P, OUTPUT);

    pinMode(PIN_HDD_LED_P, OUTPUT);

    pinMode(PIN_BOARD_PWR, INPUT);

    pinMode(PIN_FAN_PWM, OUTPUT);

    pinMode(PIN_PWR_LED_GP_RN, OUTPUT);

    pinMode(PIN_PWR_LED_GN_RP, OUTPUT);

    pinMode(PIN_SYS_LED_G_N, OUTPUT);

    pinMode(PIN_SYS_LED_R_N, OUTPUT);

    pinMode(PIN_SYS_LED_P2, OUTPUT);

    digitalWrite(PIN_SYS_LED_P1, HIGH);

    digitalWrite(PIN_NIC_LED_P, LOW);

    digitalWrite(PIN_HDD_LED_P, LOW);

    analogWrite(PIN_FAN_PWM, 0);

    digitalWrite(PIN_PWR_LED_GP_RN, LOW);

    digitalWrite(PIN_PWR_LED_GN_RP, LOW);

    digitalWrite(PIN_SYS_LED_G_N, LOW);

    digitalWrite(PIN_SYS_LED_R_N, HIGH);

    digitalWrite(PIN_SYS_LED_P2, HIGH);

    Serial.setTimeout(50);

}

void loop() {

/*********************************************

 * handle system power

 *********************************************/

    switch(power_state)

    {

        case PWR_STATE_OFF:

        {

            if( (digitalRead(PIN_PANEL_PWR) == LOW) || (PIN_BOARD_PWR == HIGH) )

            {

                power_state = PWR_STATE_STARTUP;

                pinMode(PIN_PSU_ON, OUTPUT);

                digitalWrite(PIN_PSU_ON, LOW);

                //turn on the GREEN power LED

                pinMode(PIN_PWR_LED_GP_RN, OUTPUT);

                pinMode(PIN_PWR_LED_GN_RP, OUTPUT);

                digitalWrite(PIN_PWR_LED_GN_RP, LOW);

                digitalWrite(PIN_PWR_LED_GP_RN, HIGH);

                event_timer = 0;

            }

        } break;

        case PWR_STATE_STARTUP:

        {

            //after button is released, wait 5 seconds for startup

            if( (digitalRead(PIN_PANEL_PWR) == HIGH) && (event_timer > 5000) )

            {

                power_state = PWR_STATE_ON;

            }

        } break;

        case PWR_STATE_ON:

        {

            if(digitalRead(PIN_PANEL_PWR) == LOW)

            {

                event_timer = 0;

                power_state = PWR_STATE_SHUTDOWN_TMR;

            }

            else if(digitalRead(PIN_BOARD_PWR) == LOW)

            {

                event_timer = 0;

                power_state = PWR_STATE_BOARD_OFF;

            }

        } break;

        case PWR_STATE_SHUTDOWN_TMR:

        {

            if(digitalRead(PIN_PANEL_PWR) == LOW)

            {

                //button was held for 3 seconds, shut down

                if( event_timer > 3000 )

                {

                    //tri-state the power pin

                    power_state = PWR_STATE_SHUTDOWN;

                    pinMode(PIN_PSU_ON, INPUT);

                    //turn on the RED power LED

                    digitalWrite(PIN_PWR_LED_GP_RN, LOW);

                    digitalWrite(PIN_PWR_LED_GN_RP, HIGH);

                    //disconnect UART

                    Serial.end();

                    pinMode(PIN_UART_RX, INPUT);

                }

            }

            else

            {

                power_state = PWR_STATE_ON;

            }

        } break;

        case PWR_STATE_SHUTDOWN:

        {

            //wait until button is released

            if(digitalRead(PIN_PANEL_PWR) == HIGH)

            {

                power_state = PWR_STATE_OFF;

            }

        } break;

        case PWR_STATE_BOARD_OFF:

        {

            if(digitalRead(PIN_BOARD_PWR) == LOW)

            {

                //board was off for 3 seconds, shut down

                if( event_timer > 3000 )

                {

                    //tri-state the power pin

                    power_state = PWR_STATE_SHUTDOWN;

                    pinMode(PIN_PSU_ON, INPUT);

                    //turn on the RED power LED

                    digitalWrite(PIN_PWR_LED_GP_RN, LOW);

                    digitalWrite(PIN_PWR_LED_GN_RP, HIGH);

                    //disconnect UART

                    Serial.end();

                    pinMode(PIN_UART_RX, INPUT);

                }

            }

            else

            {

                power_state = PWR_STATE_ON;

            }

        } break;

        default:

            break;

    }

/*********************************************

 * blink Eth0 LED

 *********************************************/

    // 100 megabit blinks fastest

    #define BLINK_MAX_CHANCE    100000000

    #define BLINK_MILLIS        30

    static uint8_t blink_state = BLINK_STATE_READY;

    if( (power_state == PWR_STATE_ON) &&

        (uart_state == UART_STATE_OK) )

    {

        switch(blink_state)

        {

            case BLINK_STATE_READY:

            {

                // blink the eth0 LED randomly, with a frequency based

                // on the network traffic

                if( (blink_chance != 0) &&

                    ( (random(0,BLINK_MAX_CHANCE) < blink_chance) || 

                    (random(0,2000) == 0) ) 

                    )

                {

                    blink_state = BLINK_STATE_ON;

                    blink_timer = 0;

                    digitalWrite(PIN_NIC_LED_P, HIGH);

                }

            } break;

            case BLINK_STATE_ON:

            {

                if(blink_timer > BLINK_MILLIS)

                {

                    blink_state = BLINK_STATE_OFF;

                    blink_timer = 0;

                    digitalWrite(PIN_NIC_LED_P, LOW);

                }

            } break;

            case BLINK_STATE_OFF:

            {

                if(blink_timer > (BLINK_MILLIS/2))

                {

                    blink_state = BLINK_STATE_READY;

                }

            } break;

            default:

            {

                    blink_state = BLINK_STATE_READY;

                    blink_timer = 0;

                    digitalWrite(PIN_NIC_LED_P, LOW);

            }

        }

    }

    #undef BLINK_MAX_CHANCE 

    #undef BLINK_TICKS         

/*********************************************

 * handle UART commands

 *********************************************/

    #define UART_IDENTIFIER_IDX  0

    #define UART_CMD_IDX         9

    /* enable/reset UART */

    // keep UART off until board is powered up

    if(power_state != PWR_STATE_ON)

    {

        uart_watchdog = 0;

    }

    // no commands received in timeout period, reset UART

    else if(uart_watchdog > UART_WATCHDOG_TIMEOUT)

    {

        Serial.end();

        Serial.begin(115200);

        uart_watchdog = 0;

        uart_state = UART_STATE_ERR;

        //set warning LED

        digitalWrite(PIN_SYS_LED_G_N, HIGH);

        digitalWrite(PIN_SYS_LED_R_N, LOW);

    }

    /* monitor the console output */

    if (Serial.available() > 0) {

        String command;

        int argument = 0;

        // monitor the serial port for the identifier string

        command = Serial.readStringUntil('\n');

        if(command.substring(UART_IDENTIFIER_IDX, UART_CMD_IDX)

            .equals("SimonSays"))

        {

            // reset the watchdog timer

            uart_watchdog = 0;

            uart_state = UART_STATE_OK;

            // system OK

            digitalWrite(PIN_SYS_LED_R_N, HIGH);

            digitalWrite(PIN_SYS_LED_G_N, LOW);

            // parse the command

            command.remove(UART_IDENTIFIER_IDX, UART_CMD_IDX);

            command.trim();

            int arg_idx = command.lastIndexOf(' ')+1;

            if(arg_idx > 0)

            {

                argument = command.substring(arg_idx).toInt();

                command.remove(arg_idx);

                command.trim();

            }

        }

        /* commands */

        // change the fan speed

        if(command.equals("SET FAN"))

        {

            analogWrite(PIN_FAN_PWM, argument);

        }

        // blink the eth0 LED

        else if(command.equals("SET NET LED"))

        {

            blink_chance = argument;

        }

    }

    #undef UART_IDENTIFIER_IDX

    #undef UART_CMD_IDX

}

10. Now you'll need something on the Rockpro side to help with fan and light control. This script uses a wake word to send commands to the Arduino over the UART console. You'll want to add this python script to systemd so it runs automagically on boot:

Code:
#!/usr/bin/python3

import io

import time

import psutil

import os

net_traffic_prev = 0

os.system("stty -F /dev/ttyS2 ospeed 115200")

while True:

    temp_file1 = open("/sys/class/thermal/thermal_zone0/temp", "r")

    temp_file2 = open("/sys/class/thermal/thermal_zone1/temp", "r")

    temp1 = temp_file1.readline()

    temp2 = temp_file2.readline()

    temp_file1.close()

    temp_file2.close()

    if temp1 > temp2:

        hightemp = int(temp1)

    else:

        hightemp = int(temp2)

    if hightemp < 40000:

        pwm = 0

    else:

        pwm = int(( (hightemp-40000) / 40000 ) * 255)

    net_counters = psutil.net_io_counters()

    net_traffic_curr = (net_counters.bytes_sent + net_counters.bytes_recv)

    net_traffic = str(net_traffic_curr - net_traffic_prev)

    net_traffic_prev = net_traffic_curr

    uart_out = open("/dev/ttyS2", "w")

    uart_out.writelines("\nSimonSays SET FAN "+str(pwm)+"\n")

    uart_out.writelines("\nSimonSays SET NET LED "+str(net_traffic)+"\n")

    uart_out.close()

    time.sleep(2)

11. Now put it onto your rack, and make all your friends jealous of your new ultra-quiet ultra-low-power 1U server!

I promised earlier that I'd post my project if I got some useful help from this forum, so I hope I didn't disappoint!

My scripts and schematic can also be found on my github page. Feel free to send me a pull request with any suggestions.

PINE AIO - All in ones - 28" 32" 1080p, + touch screen ones

Sun, 25 Apr 2021 07:10:17 +0000

I realized that there is no 32" AIO offer in the market when my sister asked me to select one for her.
There was some Intel and AMD based ones from Lenovo and HP with good price / performance and I opted for an HP one with an AMD APU inside.

The Dunning-Kruger effect 1999, nobel price 2000 applied to this, is that not company engineers no tinkers think people, would prefer AIO, as other options are cheaper and easier to repair, and yet AIO are a sell success being most of the models overpriced a lot.

I think that a cheap offer of Pine AIO would be a success

With replaceable PCBs to upgrade them if needed in the future - in 28" 16:9, as it seems is the most demanded market size, plus 32" that I think is the most valuable size for a desktop, and even 40" ones to be TV and big desktop - real AIO -

And bigger Smart TVs with replaceable PCB and the latest Android TV AOSP - It is rare that a TVbox with Android would upgrade to the next version - .

And 28" and 32" touch screen ones for bars, restaurants, and many other businesses to act as a register case and split the screen for internet leisure if it is not an everyday full business, or whatever.

GNU/Linux, Chromium OS or Android in ARM are good solutions for most of the SOHO and business tasks, and they are usually much cheaper than X86, adding a PCB and some connections to an already good a cheap 1080p (or 720p if price difference is noticeable or 4k if price difference is not or offering price gamma if the market is big enough) 32" monitor - no need to be IPS, VA, is cheaper and good enough - and 28" and 40 50 and 60 with TV tuners - at least as an option - would be a great product to have in the market.

Even if is just because they produce less noise than their competence.

Last but not least, integrated 1080p webcam, with a privacy switch, can start a landline phone replacement to a TV based video call replacement if paired with a free or cheap service provided by asterisk installing IP phone software on every device with this 1080p webcams - not only this AIOs - and I think that a one-year free trial, plus perhaps a 12 USD/year price, would make that service a good business with a great value add for customers - not just pine hardware ones -.

Thanks for reading this suggestion.

Small Ceph Cluster

Fri, 09 Apr 2021 06:55:57 +0000

baddass1.jpg (Size: 269.3 KB / Downloads: 582) For a long time I have wanted to build a small but highly available piece of storage.

The RockPro64 has finally allowed me to achieve this and, as a bonus, quite neatly using some Sun F80s I managed to get off ebay.

I'll write a full tutorial later, for now I just wanted to share the achievement.

root@ceph2:~# ceph -s
cluster:
id: e86bf5ce-cd1e-4449-8051-dc1b45ed0ead
health: HEALTH_OK

services:
mon: 3 daemons, quorum ceph1,ceph2,ceph3
mgr: ceph2(active), standbys: ceph3, ceph1
osd: 12 osds: 12 up, 12 in

data:

Happy days