Intelligentes Parksystem: Effiziente städtische Parklösungen

Komponenten und Zubehör

Raspberry Pi 3 Model B	×	1
Arduino Mega 2560	×	1
Ultraschallsensor HC-SR04	×	3

Apps und Online-Dienste

• Samsung ARTIK Cloud für IoT (inzwischen eingestellt – Alternativen: AWS IoT, Azure IoT, ThingsBoard)
• Google Maps API
• Arduino IDE

Über dieses Projekt

Einen freien Parkplatz in einer verstopften Stadt wie Bangalore zu finden, ist äußerst schwierig. Wer mit dem Auto losfährt, macht sich sofort Gedanken ums Parken. Oft fährt man zum Parkhaus, stellt fest, dass alles belegt ist, und muss weiter suchen – ein großes Ärgernis.

Deshalb habe ich ein cloud-basiertes intelligentes Parksystem entwickelt, das dieses Problem lösen kann. Mit diesem System kann ein Nutzer per Mobil- oder Web-App von überall einen freien Parkplatz finden. Die Parkdaten werden alle 30 Sekunden aktualisiert.

Als IoT-Plattform diente Samsung ARTIK Cloud (hinweis: der Dienst wurde 2020 eingestellt; für Neuimplementierungen empfiehlt sich AWS IoT Core, Azure IoT Hub oder Open-Source-Alternativen wie ThingsBoard).

Projektschritte

1. Gerät in ARTIK Cloud anlegen
2. Anwendung in ARTIK Cloud erstellen
3. Regel in ARTIK Cloud definieren
4. Arduino vorbereiten
5. Sensoren anschließen
6. Raspberry Pi vorbereiten
7. Web-Anwendung entwickeln

Schritt 1: Neues Gerät in ARTIK Cloud anlegen

Melden Sie sich mit Ihrem Samsung-Konto an, wählen Sie DEVELOPER → DEVICE TYPES → NEW. Vergeben Sie einen Anzeigenamen und einen eindeutigen Namen. Erstellen Sie ein Manifest mit einem Datenfeld (z. B. parking_slot, Typ Integer). Aktionen sind für dieses Projekt nicht erforderlich. Nach dem Speichern das Gerät verbinden und Device ID sowie Device Token notieren.

Schritt 2: Regel in ARTIK Cloud erstellen

Unter RULES → NEW RULE eine Bedingung definieren (z. B. „wenn parking_slot > 0“) und eine Aktion festlegen (z. B. Benachrichtigung senden).

Schritt 3: Arduino vorbereiten

Der Arduino Mega liest die Ultraschallsensoren an den Parkplätzen aus und sendet die Anzahl freier Plätze per Serial (USB) an den Raspberry Pi. Ein Arduino pro Parkstation; mehrere Arduinos können für verschiedene Stationen genutzt werden.

Schritt 4: Sensoren anschließen

Drei HC-SR04-Sensoren an digitale Pins des Arduino Mega (Trigger/Echo). Siehe Schaltplan.

Schritt 5: Raspberry Pi vorbereiten

Der Pi fungiert als WebSocket-Client zu ARTIK Cloud. Node.js wird benötigt (nicht vorinstalliert).

sudo apt-get update
sudo apt-get install nodejs npm
npm install --save ws
npm install serialport

Quellcode (staff-parking.js) von GitHub herunterladen, Device ID & Token eintragen, per FileZilla auf den Pi kopieren und starten:

sudo node staff-parking.js

Schritt 6: Web-Anwendung entwickeln

HTML/JavaScript mit WebSocket-Verbindung zu ARTIK Cloud und Google Maps API für die Kartenanzeige. websocket.html im Browser öffnen. Device ID & Token im Client-Code (websocket_client.js) anpassen.

Code

Raspberry Pi (staff-parking.js) – Node.js

// staff-parking.js – Datenübertragung an ARTIK Cloud
var webSocketUrl = "wss://api.artik.cloud/v1.1/websocket?ack=true";
var device_id = "IHR_DEVICE_ID";
var device_token = "IHR_DEVICE_TOKEN";

var WebSocket = require('ws');
var serialport = require("serialport");
var SerialPort = serialport.SerialPort;

var sp = new SerialPort("/dev/ttyACM0", {
  baudrate: 9600,
  parser: serialport.parsers.readline("\n")
});

function getTimeMillis() { return parseInt(Date.now().toString()); }

function start() {
  var ws = new WebSocket(webSocketUrl);
  ws.on('open', function() {
    console.log("WebSocket verbunden");
    register(ws);
  });
  ws.on('message', function(data) { handleRcvMsg(data); });
  ws.on('close', function() { console.log("WebSocket geschlossen"); });
}

function register(ws) {
  var msg = '{"type":"register","sdid":"' + device_id + '","Authorization":"bearer ' + device_token + '","cid":"' + getTimeMillis() + '"}';
  ws.send(msg, {mask: true});
}

function handleRcvMsg(msg) { /* Aktionen verarbeiten */ }

function sendStateToArtikCloud(ws, parking_slot) {
  var payload = '{"sdid":"' + device_id + '","ts":' + getTimeMillis() + ',"data":{"parking_slot":' + parking_slot + '},"cid":"' + getTimeMillis() + '"}';
  ws.send(payload, {mask: true});
}

start();

sp.on("open", function() {
  sp.on('data', function(data) {
    var slot = parseInt(data);
    sendStateToArtikCloud(ws, slot);
  });
});

Arduino (sonar.ino) – C/C++

#define echoPin1 2
#define trigPin1 3
#define echoPin2 4
#define trigPin2 5
#define echoPin3 6
#define trigPin3 7

long duration1, distance1;
long duration2, distance2;
long duration3, distance3;
int freeSlot = 0;

void setup() {
  Serial.begin(9600);
  pinMode(trigPin1, OUTPUT); pinMode(echoPin1, INPUT);
  pinMode(trigPin2, OUTPUT); pinMode(echoPin2, INPUT);
  pinMode(trigPin3, OUTPUT); pinMode(echoPin3, INPUT);
}

void loop() {
  // Sensor 1
  digitalWrite(trigPin1, LOW); delayMicroseconds(2);
  digitalWrite(trigPin1, HIGH); delayMicroseconds(10);
  digitalWrite(trigPin1, LOW);
  duration1 = pulseIn(echoPin1, HIGH);
  distance1 = duration1 / 58.2;
  distance1 = (distance1 < 10) ? 1 : 0;

  // Sensor 2
  digitalWrite(trigPin2, LOW); delayMicroseconds(2);
  digitalWrite(trigPin2, HIGH); delayMicroseconds(10);
  digitalWrite(trigPin2, LOW);
  duration2 = pulseIn(echoPin2, HIGH);
  distance2 = duration2 / 58.2;
  distance2 = (distance2 < 10) ? 1 : 0;

  // Sensor 3
  digitalWrite(trigPin3, LOW); delayMicroseconds(2);
  digitalWrite(trigPin3, HIGH); delayMicroseconds(10);
  digitalWrite(trigPin3, LOW);
  duration3 = pulseIn(echoPin3, HIGH);
  distance3 = duration3 / 58.2;
  distance3 = (distance3 < 10) ? 1 : 0;

  int occupied = distance1 + distance2 + distance3;
  freeSlot = 3 - occupied;
  Serial.println(freeSlot);
  delay(5000);  // Alle 30 Sekunden im Original, hier 5s für Demo
}

Web-App (HTML + JavaScript)

Die Web-App besteht aus websocket.html (Frontend mit Google Maps) und websocket_client.js (WebSocket-Client). Beide Dateien im GitHub-Repository.

Quellcode-Repository

Alle Dateien: GitHub: Smart-Car-Parking

Schaltpläne