⛏️ Mining Monero on a Pi 5, and what the AI HAT cannot do · ขุด Monero บน Pi 5 กับสิ่งที่ AI HAT ทำไม่ได้ · 用 Pi 5 挖 Monero，以及 AI HAT 做不到的事

1 What RandomX asks for · RandomX ต้องการอะไร · RandomX 要的是什么

📄 NEW FILE · whatis1.py

"""whatis1.py — what does this machine actually offer a RandomX miner?

RandomX is the algorithm Monero uses. It was designed on purpose to run
well on an ordinary processor and badly on anything else. This reads the
four things it cares about, on whatever you run it on.
"""
import os
import platform
import sys
from pathlib import Path

# RandomX keeps a 2 GB table in memory and reads it at random. With room
# for it, the miner runs fast mode. Without, it falls back to light mode,
# which is many times slower.
DATASET_GB = 2.08
sys.stdout.reconfigure(encoding="utf-8")


def cpu_flags():
    """The processor's feature list, where the system will tell us."""
    cpuinfo = Path("/proc/cpuinfo")
    if cpuinfo.exists():
        text = cpuinfo.read_text(encoding="utf-8", errors="replace")
        for line in text.splitlines():
            if line.lower().startswith(("flags", "features")):
                return set(line.split(":", 1)[1].split())
    return set()


def total_ram_gb():
    """How much memory the processor can actually use."""
    pages = getattr(os, "sysconf_names", {}).get("SC_PHYS_PAGES")
    if pages:
        return os.sysconf("SC_PHYS_PAGES") * os.sysconf("SC_PAGE_SIZE") / 1e9
    # Windows has no sysconf. Ask the kernel directly.
    import ctypes

    class Status(ctypes.Structure):
        _fields_ = [("dwLength", ctypes.c_ulong),
                    ("dwMemoryLoad", ctypes.c_ulong),
                    ("ullTotalPhys", ctypes.c_ulonglong),
                    ("ullAvailPhys", ctypes.c_ulonglong),
                    ("ullTotalPageFile", ctypes.c_ulonglong),
                    ("ullAvailPageFile", ctypes.c_ulonglong),
                    ("ullTotalVirtual", ctypes.c_ulonglong),
                    ("ullAvailVirtual", ctypes.c_ulonglong),
                    ("ullAvailExtendedVirtual", ctypes.c_ulonglong)]

    status = Status()
    status.dwLength = ctypes.sizeof(Status)
    ctypes.windll.kernel32.GlobalMemoryStatusEx(ctypes.byref(status))
    return status.ullTotalPhys / 1e9


def main():
    flags = cpu_flags()
    ram = total_ram_gb()
    cores = os.cpu_count() or 0

    print("machine       ", platform.machine(), "-", platform.system())
    print("cores         ", cores)
    print(f"memory         {ram:.1f} GB")

    # Hardware AES is the single biggest difference. Without it RandomX
    # does the same work in software, several times slower.
    aes = bool(flags & {"aes", "aes_ni", "pmull", "sha2"})
    print("hardware AES  ", "yes" if aes else ("no" if flags else "cannot tell here"))

    print()
    if ram >= DATASET_GB + 1:
        print(f"fast mode      yes, {DATASET_GB} GB table fits with room to spare")
    else:
        print(f"fast mode      no, needs about {DATASET_GB} GB free just for the table")

    # Huge pages let the processor find that table with fewer lookups.
    # On Linux this is a number you can change; it is worth a third more.
    huge = Path("/proc/sys/vm/nr_hugepages")
    if huge.exists():
        print("huge pages    ", huge.read_text().strip(), "(want 1280 or more)")
    else:
        print("huge pages     not a setting on this system")

    print()
    print("What none of this asks about: any accelerator you have plugged in.")
    print("RandomX runs on the processor. There is nowhere else for it to go.")


if __name__ == "__main__":
    main()

🖥️ ON AN ARM64 MACHINE · the same architecture family as a Pi 5

machine        aarch64 - Linux
cores          20
memory         130.7 GB
hardware AES   yes

fast mode      yes, 2.08 GB table fits with room to spare
huge pages     0 (want 1280 or more)

What none of this asks about: any accelerator you have plugged in.
RandomX runs on the processor. There is nowhere else for it to go.

2 What it earns, against what it costs · หาได้เท่าไหร่ เทียบกับจ่ายเท่าไหร่ · 赚多少，对上花多少

📄 NEW FILE · money1.py

"""money1.py — what a given hashrate earns, against what the power costs.

Every number that moves is fetched now. Put your own measured hashrate in
and the answer is about your machine, not about a forum post from 2021.
"""
import json
import sys
import urllib.request

NETWORK = "https://localmonero.co/blocks/api/get_stats"
PRICE = "https://api.coingecko.com/api/v3/simple/price?ids=monero&vs_currencies=usd,thb"

# Measure yours with: xmrig --bench=1M
HASHRATE = float(sys.argv[1]) if len(sys.argv) > 1 else 500.0

# A Pi 5 working all four cores. Measure yours with a plug meter; this is
# the number most worth replacing with your own.
WATTS = float(sys.argv[2]) if len(sys.argv) > 2 else 9.0

# Thai household electricity, baht per kilowatt hour.
BAHT_PER_KWH = float(sys.argv[3]) if len(sys.argv) > 3 else 4.5

# Monero aims at one block every two minutes.
BLOCKS_A_DAY = 720
ATOMIC = 1e12

sys.stdout.reconfigure(encoding="utf-8")


def get(url):
    request = urllib.request.Request(url, headers={"User-Agent": "a lesson"})
    with urllib.request.urlopen(request, timeout=30) as response:
        return json.load(response)


def main():
    chain = get(NETWORK)
    price = get(PRICE)["monero"]

    network = chain["hashrate"]
    reward = chain["last_reward"] / ATOMIC

    print(f"network hashrate   {network / 1e9:10.2f} GH/s")
    print(f"block reward       {reward:10.4f} XMR")
    print(f"XMR price          {price['usd']:10.2f} USD   "
          f"{price['thb']:,.0f} THB")
    print(f"your hashrate      {HASHRATE:10.0f} H/s")
    print()

    # Mining is a lottery with tickets in proportion to work done. Over a
    # long enough time your share of the reward is your share of the work.
    share = HASHRATE / network
    xmr_a_day = BLOCKS_A_DAY * reward * share

    baht_a_day = xmr_a_day * price["thb"]
    power_kwh = WATTS * 24 / 1000
    power_baht = power_kwh * BAHT_PER_KWH

    print(f"your share of the network   1 in {1 / share:,.0f}")
    print(f"earns per day               {xmr_a_day:.8f} XMR   "
          f"{baht_a_day:6.2f} baht")
    print(f"electricity per day         {power_kwh:.3f} kWh        "
          f"{power_baht:6.2f} baht   ({WATTS:.0f} W)")
    print()

    net = baht_a_day - power_baht
    word = "makes" if net >= 0 else "loses"
    print(f"so it {word} {abs(net):.2f} baht a day, "
          f"{abs(net) * 365:.0f} baht a year")

    if net < 0:
        # The honest way to put it: how much cheaper would power have to be?
        needed = baht_a_day / power_kwh if power_kwh else 0
        print(f"to break even, electricity would have to cost "
              f"{needed:.2f} baht per kWh")
        print(f"you are paying {BAHT_PER_KWH:.2f}")


if __name__ == "__main__":
    main()

🖥️ WHAT IT PRINTED · live, at 500 H/s and 4.50 baht a unit

network hashrate         6.04 GH/s
block reward           0.6007 XMR
XMR price              556.06 USD   18,610 THB
your hashrate             500 H/s

your share of the network   1 in 12,085,486
earns per day               0.00003579 XMR     0.67 baht
electricity per day         0.216 kWh          0.97 baht   (9 W)

so it loses 0.31 baht a day, 112 baht a year
to break even, electricity would have to cost 3.08 baht per kWh
you are paying 4.50

3 Actually running it · ลงมือรันจริง · 真的把它跑起来

💻 ON THE PI · build the miner, then measure before you commit

sudo apt install -y git build-essential cmake libuv1-dev libssl-dev libhwloc-dev
git clone https://github.com/xmrig/xmrig && cd xmrig
mkdir build && cd build && cmake .. && make -j4

# Huge pages first. Without them you lose about a third.
sudo sysctl -w vm.nr_hugepages=1280

# The number this whole page is waiting for:
./xmrig --bench=1M

📄 NEW FILE · pool.json

{
  "autosave": true,
  "cpu": {
    "enabled": true,
    "huge-pages": true,
    "max-threads-hint": 75,
    "priority": 1
  },
  "opencl": false,
  "cuda": false,
  "randomx": {
    "mode": "fast",
    "1gb-pages": false
  },
  "pools": [
    {
      "url": "pool.supportxmr.com:3333",
      "user": "YOUR_MONERO_ADDRESS",
      "pass": "pi5",
      "keepalive": true,
      "tls": true
    }
  ]
}

4 Try first. The answers are folded away. · ลองเองก่อน เฉลยพับซ่อนไว้ · 先自己试。答案折起来放着。

"""solo1.py — challenge 1: how long until you find a block on your own?

Mining into a pool pays you a steady trickle. Mining alone pays nothing
at all until you find a whole block, and then it pays everything. This is
the wait, and it is the number that decides which you should do.
"""
import json
import math
import sys
import urllib.request

NETWORK = "https://localmonero.co/blocks/api/get_stats"
HASHRATE = float(sys.argv[1]) if len(sys.argv) > 1 else 500.0

sys.stdout.reconfigure(encoding="utf-8")


def main():
    request = urllib.request.Request(NETWORK, headers={"User-Agent": "a lesson"})
    with urllib.request.urlopen(request, timeout=30) as response:
        chain = json.load(response)

    difficulty = chain["difficulty"]

    # Difficulty is how many hashes the whole network expects to try per
    # block. Divide by your own rate and you get your own expected wait.
    seconds = difficulty / HASHRATE
    years = seconds / (365.25 * 24 * 3600)

    print(f"difficulty        {difficulty:,}")
    print(f"your hashrate     {HASHRATE:,.0f} H/s")
    print(f"expected wait     {years:,.1f} years")
    print()

    # It is not a countdown. Every attempt is independent, so the chance
    # of having found one by a given date follows this curve.
    print("chance of having found a block by then:")
    for months in (1, 12, 60, 120):
        chance = 1 - math.exp(-(months * 30.4 * 24 * 3600) / seconds)
        label = f"{months} month" + ("s" if months > 1 else "")
        print(f"   after {label:10}  {chance * 100:7.4f}%")

    print()
    print("A pool splits the reward by work done, so you are paid the")
    print("average instead of waiting for the whole thing.")


if __name__ == "__main__":
    main()

difficulty        725,129,170,594
your hashrate     500 H/s
expected wait     46.0 years

chance of having found a block by then:
   after 1 month      0.1809%
   after 12 months    2.1499%
   after 60 months   10.2970%
   after 120 months  19.5337%

"""payback1.py — challenge 2: how long until the hardware pays for itself?

The mining arithmetic in step 4 ignored what the machine cost. This does
not. It also asks the other question: what would the same money have
bought if you had simply used it to buy the coin.
"""
import json
import sys
import urllib.request

NETWORK = "https://localmonero.co/blocks/api/get_stats"
PRICE = "https://api.coingecko.com/api/v3/simple/price?ids=monero&vs_currencies=usd,thb"

# What the parts cost, in US dollars, at list price.
PARTS = {"Raspberry Pi 5, 8GB": 80.0,
         "AI HAT+ 2, 8GB": 130.0,
         "power supply, case, card": 40.0}

HASHRATE = float(sys.argv[1]) if len(sys.argv) > 1 else 500.0
WATTS = float(sys.argv[2]) if len(sys.argv) > 2 else 9.0
BAHT_PER_KWH = 4.5
BLOCKS_A_DAY = 720
ATOMIC = 1e12

sys.stdout.reconfigure(encoding="utf-8")


def get(url):
    request = urllib.request.Request(url, headers={"User-Agent": "a lesson"})
    with urllib.request.urlopen(request, timeout=30) as response:
        return json.load(response)


def main():
    chain = get(NETWORK)
    price = get(PRICE)["monero"]
    baht_per_usd = price["thb"] / price["usd"]

    spent = sum(PARTS.values())
    for what, cost in PARTS.items():
        print(f"  {what:28} {cost:7.2f} USD")
    print(f"  {'total':28} {spent:7.2f} USD  "
          f"= {spent * baht_per_usd:,.0f} baht")
    print()

    share = HASHRATE / chain["hashrate"]
    xmr_a_year = BLOCKS_A_DAY * 365 * (chain["last_reward"] / ATOMIC) * share
    earns = xmr_a_year * price["thb"]
    power = WATTS * 24 * 365 / 1000 * BAHT_PER_KWH
    net = earns - power

    print(f"mines per year    {xmr_a_year:.6f} XMR = {earns:,.0f} baht")
    print(f"power per year    {power:,.0f} baht")
    print(f"net per year      {net:,.0f} baht")
    print()

    if net <= 0:
        print("It never pays for itself. It goes backwards.")
    else:
        print(f"pays for the hardware in {spent * baht_per_usd / net:,.0f} years")

    print()
    # The comparison nobody runs. The money is the same money.
    bought = spent / price["usd"]
    print(f"The same {spent:.0f} USD spent on the coin itself buys "
          f"{bought:.4f} XMR today.")
    if xmr_a_year > 0:
        print(f"The machine mines that much in {bought / xmr_a_year:,.0f} years.")


if __name__ == "__main__":
    main()

  Raspberry Pi 5, 8GB            80.00 USD
  AI HAT+ 2, 8GB                130.00 USD
  power supply, case, card       40.00 USD
  total                         250.00 USD  = 8,367 baht

mines per year    0.013062 XMR = 243 baht
power per year    355 baht
net per year      -112 baht

It never pays for itself. It goes backwards.

The same 250 USD spent on the coin itself buys 0.4496 XMR today.
The machine mines that much in 34 years.

"""breakeven1.py — challenge 3: what would have to be true for this to pay?

Rather than arguing about whether it is worth it, solve for the number.
Three of the four things are fixed by the world. Ask what each one would
have to become, with the others left alone.
"""
import json
import sys
import urllib.request

NETWORK = "https://localmonero.co/blocks/api/get_stats"
PRICE = "https://api.coingecko.com/api/v3/simple/price?ids=monero&vs_currencies=usd,thb"

HASHRATE = 500.0
WATTS = 9.0
BAHT_PER_KWH = 4.5
BLOCKS_A_DAY = 720
ATOMIC = 1e12

sys.stdout.reconfigure(encoding="utf-8")


def get(url):
    request = urllib.request.Request(url, headers={"User-Agent": "a lesson"})
    with urllib.request.urlopen(request, timeout=30) as response:
        return json.load(response)


def main():
    chain = get(NETWORK)
    price = get(PRICE)["monero"]
    network, reward = chain["hashrate"], chain["last_reward"] / ATOMIC

    power_a_day = WATTS * 24 / 1000 * BAHT_PER_KWH
    earns_per_hash = BLOCKS_A_DAY * reward * price["thb"] / network
    earns_a_day = HASHRATE * earns_per_hash

    print(f"as things stand      earns {earns_a_day:.2f} baht a day, "
          f"power costs {power_a_day:.2f}")
    print()

    # Each of these leaves everything else exactly where it is.
    need_hashrate = power_a_day / earns_per_hash
    print(f"hashrate needed      {need_hashrate:,.0f} H/s   "
          f"({need_hashrate / HASHRATE:.1f} times a Pi 5)")

    xmr_a_day = BLOCKS_A_DAY * reward * (HASHRATE / network)
    need_price = power_a_day / xmr_a_day
    print(f"XMR price needed     {need_price:,.0f} baht   "
          f"({need_price / price['thb']:.1f} times today)")

    need_power = earns_a_day / (WATTS * 24 / 1000)
    print(f"electricity needed   {need_power:.2f} baht per kWh   "
          f"(you pay {BAHT_PER_KWH:.2f})")

    need_watts = earns_a_day / (24 / 1000 * BAHT_PER_KWH)
    print(f"or the same work at  {need_watts:.1f} W   "
          f"(a Pi 5 under load draws about {WATTS:.0f})")

    print()
    print("None of those four is a small change. That is the answer.")


if __name__ == "__main__":
    main()

as things stand      earns 0.67 baht a day, power costs 0.97

hashrate needed      729 H/s   (1.5 times a Pi 5)
XMR price needed     27,162 baht   (1.5 times today)
electricity needed   3.09 baht per kWh   (you pay 4.50)
or the same work at  6.2 W   (a Pi 5 under load draws about 9)