LoRaWAN
uzun menzilli IoT ağı.

Link Budget (dB) = TX Güç - Kablo Kayıpları + TX Anten Kazancı
                 + RX Anten Kazancı - Alıcı Hassasiyeti

Örnek (SX1276, SF12, 125 kHz):
  TX Güç           = +20 dBm  (SX1276 max)
  TX Anten         = +2 dBi   (dipole)
  Kablo kayıpları  = -1 dB
  RX Hassasiyet    = -137 dBm (SF12)
  RX Anten         = +2 dBi

  Link Budget = 20 - 1 + 2 + 2 - (-137) = 160 dB

Serbest alan yol kaybı (FSPL) formülü:
  FSPL(dB) = 20*log10(d) + 20*log10(f) + 92.45
  (d=km, f=GHz)

  868 MHz, 10 km: FSPL = 20*log10(10) + 20*log10(0.868) + 92.45
                       = 20 + (-1.23) + 92.45 = 111.2 dB

  Link margin = 160 - 111.2 = 48.8 dB  → güçlü bağlantı

/* ABP parametreleri — üretimde güvenli depolama kullanın! */
#define DEVADDR   0x26011234   /* 32-bit, NS tarafından atanır */
#define NWKSKEY   { 0x2B,0x7E,0x15,0x16,0x28,0xAE,0xD2,0xA6, \
                    0xAB,0xF7,0x15,0x88,0x09,0xCF,0x4F,0x3C }
#define APPSKEY   { 0x00,0x11,0x22,0x33,0x44,0x55,0x66,0x77, \
                    0x88,0x99,0xAA,0xBB,0xCC,0xDD,0xEE,0xFF }

## /boot/config.txt veya raspi-config ile SPI aç
echo "dtparam=spi=on" >> /boot/config.txt
reboot

## SPI aygıtını doğrula
ls /dev/spidev*
# /dev/spidev0.0  /dev/spidev0.1

## SPI hızını test et
spi-config -d /dev/spidev0.0 -s 1000000 -q

#!/usr/bin/env python3
"""
pip install RPi.GPIO spidev pySX127x
"""
from SX127x.LoRa import *
from SX127x.board_config import BOARD

BOARD.setup()

class LoRaReceiver(LoRa):
    def __init__(self, verbose=False):
        super().__init__(verbose)
        self.set_mode(MODE.SLEEP)
        self.set_dio_mapping([0] * 6)

    def start(self):
        self.reset_ptr_rx()
        self.set_mode(MODE.RXCONT)    # sürekli alım

        print("Dinleniyor... (Ctrl+C ile dur)")
        while True:
            pass   # IRQ callback beklenir

    def on_rx_done(self):
        print("\n--- Paket alındı ---")
        payload = self.read_payload(nocheck=True)
        print(f"Payload : {bytes(payload).hex()}")
        print(f"RSSI    : {self.get_pkt_rssi_value()} dBm")
        print(f"SNR     : {self.get_pkt_snr_value()} dB")
        self.set_mode(MODE.SLEEP)
        self.reset_ptr_rx()
        self.set_mode(MODE.RXCONT)

lora = LoRaReceiver(verbose=False)

# SF9, BW 125 kHz, CR 4/5
lora.set_freq(868.1)            # MHz
lora.set_spreading_factor(9)
lora.set_bw(BW.BW125)
lora.set_coding_rate(CODING_RATE.CR4_5)
lora.set_preamble(8)
lora.set_rx_crc(True)

try:
    lora.start()
except KeyboardInterrupt:
    lora.set_mode(MODE.SLEEP)
    BOARD.teardown()
    print("\nDurduruldu.")

git clone https://github.com/Lora-net/sx1302_hal.git
cd sx1302_hal
make

## Örnek packet forwarder yapılandırması
cp tools/reset_lgw.sh .
cp packet_forwarder/global_conf.json.sx1250.EU868 \
   packet_forwarder/global_conf.json

## Gateway EUI al
./packet_forwarder/lora_pkt_fwd -c packet_forwarder/global_conf.json

## ttn-lw-cli kurulumu ve giriş
brew install ttn-lw-cli   # macOS
ttn-lw-cli login

## Uygulama oluştur
ttn-lw-cli applications create \
    --application-id my-sensor-app \
    --name "Sensör Uygulaması"

## OTAA cihazı kaydet
ttn-lw-cli end-devices create \
    --application-id my-sensor-app \
    --device-id sensor-01 \
    --dev-eui 0011223344556677 \
    --app-eui 70B3D57ED0000000 \
    --app-key AABBCCDDEEFF00112233445566778899 \
    --lorawan-version MAC_V1_0_2 \
    --frequency-plan-id EU_863_870_TTN

#!/usr/bin/env python3
import paho.mqtt.client as mqtt
import json, base64

APP_ID    = "my-sensor-app"
API_KEY   = "NNSXS.xxx..."   # TTN konsolundan al
TTN_HOST  = "eu1.cloud.thethings.network"

def on_connect(client, userdata, flags, rc):
    print(f"Bağlandı: {rc}")
    client.subscribe(f"v3/{APP_ID}@ttn/devices/+/up")

def on_message(client, userdata, msg):
    data = json.loads(msg.payload)
    dev_id  = data["end_device_ids"]["device_id"]
    raw_b64 = data["uplink_message"]["frm_payload"]
    payload = base64.b64decode(raw_b64)
    rssi    = data["uplink_message"]["rx_metadata"][0]["rssi"]
    snr     = data["uplink_message"]["rx_metadata"][0]["snr"]

    print(f"[{dev_id}] payload={payload.hex()}  RSSI={rssi}  SNR={snr}")

client = mqtt.Client()
client.username_pw_set(f"{APP_ID}@ttn", API_KEY)
client.tls_set()
client.on_connect = on_connect
client.on_message = on_message
client.connect(TTN_HOST, 8883, 60)
client.loop_forever()

// TTN Console → Application → Payload Formatters → Uplink
function decodeUplink(input) {
    var bytes = input.bytes;
    var decoded = {};

    // Özel format: [2B sıcaklık x10, 2B nem x10, 2B basınç x10]
    if (bytes.length >= 6) {
        decoded.temperature = ((bytes[0] << 8) | bytes[1]) / 10.0;
        decoded.humidity    = ((bytes[2] << 8) | bytes[3]) / 10.0;
        decoded.pressure    = ((bytes[4] << 8) | bytes[5]) / 10.0;
    }

    return {
        data: decoded,
        warnings: [],
        errors: []
    };
}

// CayenneLPP için hazır çözüm:
// npm install cayennelpp
// TTN konsolunda "CayenneLPP" seçeneği doğrudan kullanılabilir.

version: "3"

services:
  chirpstack:
    image: chirpstack/chirpstack:4
    environment:
      - POSTGRESQL__DSN=postgres://chirpstack:chirpstack@postgresql/chirpstack?sslmode=disable
      - REDIS__SERVERS[0]=redis://redis:6379
      - NETWORK__NET_IDS[0]=000000
      - REGIONS[0]=eu868
    ports:
      - "8080:8080"     # Web UI
    depends_on:
      - postgresql
      - redis

  chirpstack-gateway-bridge:
    image: chirpstack/chirpstack-gateway-bridge:4
    ports:
      - "1700:1700/udp"   # Gateway UDP
    environment:
      - INTEGRATION__MQTT__EVENT_TOPIC_TEMPLATE=eu868/gateway/{{ .GatewayID }}/event/{{ .EventType }}

  postgresql:
    image: postgres:14
    environment:
      - POSTGRES_PASSWORD=chirpstack
      - POSTGRES_USER=chirpstack
      - POSTGRES_DB=chirpstack
    volumes:
      - pgdata:/var/lib/postgresql/data

  redis:
    image: redis:7
    volumes:
      - redisdata:/data

  mosquitto:
    image: eclipse-mosquitto:2
    ports:
      - "1883:1883"

  grafana:
    image: grafana/grafana:10
    ports:
      - "3000:3000"
    volumes:
      - grafanadata:/var/lib/grafana

volumes:
  pgdata:
  redisdata:
  grafanadata:

docker compose up -d

## Web UI
xdg-open http://localhost:8080
## Varsayılan giriş: admin / admin

## Gateway kaydı için EUI gerekli:
## Gateway → "Add gateway" → Gateway EUI gir

## MQTT topic izle
mosquitto_sub -h localhost -t "eu868/gateway/#" -v

#!/usr/bin/env python3
"""
pip install chirpstack-api grpcio
"""
import grpc
from chirpstack_api import api

server  = "localhost:8080"
api_key = "eyJ0..."  # ChirpStack API key

channel = grpc.insecure_channel(server)
auth    = [("authorization", f"Bearer {api_key}")]

# Cihaz listesini al
device_client = api.DeviceServiceStub(channel)
req = api.ListDevicesRequest(application_id="my-app-uuid", limit=100)
resp = device_client.List(req, metadata=auth)

for item in resp.result:
    print(f"{item.dev_eui}  {item.name}  lastSeen={item.last_seen_at}")

// Node-RED flow (JSON dışa aktarma)
[
  { "id": "mqtt-in",   "type": "mqtt in",
    "topic": "eu868/gateway/+/event/up",
    "broker": "localhost" },
  { "id": "parse",     "type": "function",
    "func": "var d=JSON.parse(msg.payload);\nmsg.payload={temperature:d.rxInfo[0].rssi};\nreturn msg;" },
  { "id": "influx-out","type": "influxdb out",
    "measurement": "lorawan_rx" }
]

#!/bin/bash

## SX1302 HAL derle
sudo apt install -y git gcc make libssl-dev
git clone https://github.com/Lora-net/sx1302_hal.git
cd sx1302_hal && make

## Paket forwarder konfigürasyonu (EU868)
cat > packet_forwarder/global_conf.json <<'EOF'
{
  "SX130x_conf": {
    "spidev_path": "/dev/spidev0.0",
    "lorawan_public": true,
    "clksrc": 0,
    "chan_multiSF_0": {"enable": true, "radio": 0, "if": -400000},
    "chan_multiSF_1": {"enable": true, "radio": 0, "if": -200000},
    "chan_multiSF_2": {"enable": true, "radio": 0, "if":       0},
    "chan_multiSF_3": {"enable": true, "radio": 1, "if": -400000},
    "chan_multiSF_4": {"enable": true, "radio": 1, "if": -200000},
    "chan_multiSF_5": {"enable": true, "radio": 1, "if":       0},
    "chan_multiSF_6": {"enable": true, "radio": 0, "if":  200000},
    "chan_multiSF_7": {"enable": true, "radio": 0, "if":  400000},
    "chan_Lora_std":  {"enable": true, "radio": 1, "if":  200000,
                       "bandwidth": 250000, "spread_factor": 7},
    "chan_FSK":       {"enable": false},
    "radio_0": {"enable": true, "type": "SX1250", "freq": 867500000,
                "rssi_offset": -215.4, "tx_enable": true},
    "radio_1": {"enable": true, "type": "SX1250", "freq": 868500000,
                "rssi_offset": -215.4, "tx_enable": false}
  },
  "gateway_conf": {
    "gateway_ID": "AA555A0000000000",
    "server_address": "eu1.cloud.thethings.network",
    "serv_port_up": 1700,
    "serv_port_down": 1700,
    "keepalive_interval": 10,
    "stat_interval": 30,
    "push_timeout_ms": 100,
    "forward_crc_valid": true,
    "forward_crc_error": false,
    "forward_crc_disabled": false
  }
}
EOF

## Gateway EUI al ve TTN'ye kaydet
echo "Gateway EUI: $(cat /sys/class/net/eth0/address | sed 's/://g' | head -c 6)FFFE$(cat /sys/class/net/eth0/address | sed 's/://g' | tail -c +7)"

## Çalıştır
./tools/reset_lgw.sh start
./packet_forwarder/lora_pkt_fwd -c packet_forwarder/global_conf.json

#!/usr/bin/env micropython
"""
Gereksinimler:
  pip install mpremote
  mpremote mip install micropython-lora
  Bağlantı: SX1276 → SPI0 (SCK=18, MOSI=19, MISO=16, CS=17)
             RST=20, DIO0=15 / DHT22 → GP22
"""
import machine, time, struct
import dht
from lora import SX1276, LoRaWAN, SF9, BW125

# DHT22 sensörü
dht_pin = machine.Pin(22)
sensor  = dht.DHT22(dht_pin)

# SX1276 SPI kurulumu
spi = machine.SPI(0, baudrate=1_000_000,
                  sck=machine.Pin(18), mosi=machine.Pin(19),
                  miso=machine.Pin(16))
lora_radio = SX1276(spi,
                    cs=machine.Pin(17),
                    rst=machine.Pin(20),
                    dio0=machine.Pin(15))

# LoRaWAN OTAA parametreleri (TTN konsolundan kopyala)
DEV_EUI = bytes.fromhex("0011223344556677")
APP_EUI = bytes.fromhex("70B3D57ED0000000")
APP_KEY = bytes.fromhex("AABBCCDDEEFF00112233445566778899")

lorawan = LoRaWAN(lora_radio, dev_eui=DEV_EUI,
                  app_eui=APP_EUI, app_key=APP_KEY,
                  region="EU868")

print("OTAA join başlıyor...")
while not lorawan.joined():
    if lorawan.join():
        print("Join başarılı!")
        break
    print("Join başarısız, 30s bekleniyor...")
    time.sleep(30)

def encode_payload(temp_c, hum_pct):
    """Sıcaklık ve nemi 4 byte'a sıkıştır (x10 ölçeği)"""
    t = int(temp_c * 10)
    h = int(hum_pct * 10)
    return struct.pack(">hH", t, h)

# Ana döngü: her 60 saniyede bir ölç ve gönder
while True:
    try:
        sensor.measure()
        temp = sensor.temperature()
        humi = sensor.humidity()
        print(f"Sıcaklık: {temp:.1f} °C  Nem: {humi:.1f} %")

        payload = encode_payload(temp, humi)
        lorawan.send(payload, port=1)
        print(f"Gönderildi: {payload.hex()}")
    except Exception as e:
        print(f"Hata: {e}")

    time.sleep(60)   # 60 saniye uyku (duty cycle uyumu)

#!/usr/bin/env python3
import paho.mqtt.client as mqtt
import json, base64, struct

APP_ID  = "my-sensor-app"
API_KEY = "NNSXS.xxx..."

def decode_dht22(payload_b64):
    raw = base64.b64decode(payload_b64)
    if len(raw) >= 4:
        temp, humi = struct.unpack(">hH", raw[:4])
        return temp / 10.0, humi / 10.0
    return None, None

def on_message(client, userdata, msg):
    data    = json.loads(msg.payload)
    dev_id  = data["end_device_ids"]["device_id"]
    uplink  = data["uplink_message"]
    temp, humi = decode_dht22(uplink["frm_payload"])
    rssi    = uplink["rx_metadata"][0]["rssi"]
    snr     = uplink["rx_metadata"][0]["snr"]
    sf      = uplink["settings"]["data_rate"]["lora"]["spreading_factor"]

    print(f"[{dev_id}]  {temp:.1f}°C  {humi:.1f}%  "
          f"RSSI={rssi} SNR={snr} SF{sf}")

client = mqtt.Client()
client.username_pw_set(f"{APP_ID}@ttn", API_KEY)
client.tls_set()
client.on_message = on_message
client.connect("eu1.cloud.thethings.network", 8883, 60)
client.subscribe(f"v3/{APP_ID}@ttn/devices/+/up")

print("TTN'den veri bekleniyor...")
client.loop_forever()

[sensor-01]  23.4°C  61.2%  RSSI=-87 SNR=8.5 SF9
[sensor-01]  23.5°C  61.0%  RSSI=-88 SNR=8.2 SF9
[sensor-01]  23.4°C  61.5%  RSSI=-86 SNR=9.1 SF9