Customising device shadow

import socket
import json
import time

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect(("localhost", 5050))


# Constructs a payload and sends it over TCP to uplink
def send_data(s, payload):
    send = json.dumps(payload) + "\n"
    s.sendall(bytes(send, encoding="utf-8"))


# Add more parameters to device shadow
def send_device_shadow(s, sequence):
    timestamp = int(time.time() * 1000)
    payload = {
        "stream": "device_shadow",
        "sequence": sequence,
        "timestamp": timestamp,
        "device_name": "Beaglebone Black Rev. C",
        "arch": "armv7",
    }
    print(payload)
    send_data(s, payload)


print("Starting Uplink Bridge App")

sequence = 1
while True:
    time.sleep(10)
    send_device_shadow(s, sequence)
    sequence += 1

const net = require("net");

// Connect to the server
const client = new net.Socket();
client.connect(5050, "localhost", () => {
  console.log("Connected to server");
});

// Constructs a payload and sends it over TCP to uplink
function sendData(payload) {
  const send = JSON.stringify(payload) + "\n";
  client.write(send);
}

// Send device shadow data
function sendDeviceShadow(sequence) {
  let timestamp = Date.now();
  let payload = {
    stream: "device_shadow",
    sequence: sequence,
    timestamp: timestamp,
    device_name: "Beaglebone Black Rev. C",
    arch: "armv7",
  };
  console.log(payload);
  sendData(payload);
}

console.log("Starting Uplink Bridge App");

let sequence = 1;
setInterval(() => {
  sendDeviceShadow(sequence);
  sequence++;
}, 10000);

use std::net::TcpStream;
use std::io::{Read, Write};
use std::thread;
use std::time::{Duration, SystemTime};
use serde_json::{Value, json};

async fn send_data(mut stream: &TcpStream, payload: serde_json::Value) {
    let send = format!("{}\n", payload.to_string());
    stream.write_all(send.as_bytes()).await.unwrap();
}

async fn send_device_shadow(mut stream: &TcpStream, sequence: u64) {
    let timestamp = SystemTime::now()
        .duration_since(SystemTime::UNIX_EPOCH)
        .unwrap()
        .as_millis();

    let payload = json!({
        "stream": "device_shadow",
        "sequence": sequence,
        "timestamp": timestamp,
        "device_name": "Beaglebone Black Rev. C",
        "arch": "armv7"
    });

    println!("{:?}", payload);
    send_data(&mut stream, payload).await;
}

#[tokio::main]
async fn main() {
    let addr = "localhost:5050";
    let mut stream = TcpStream::connect(&addr).await.unwrap();

    println!("Starting Uplink Bridge App");

    let mut sequence = 1;
    loop {
        thread::sleep(Duration::from_secs(5));
        send_device_shadow(&mut stream, sequence);
        sequence += 1;
    }
}

package main

import (
	"encoding/json"
	"fmt"
	"net"
	"os"
	"strconv"
	"time"
)

// DeviceShadow represents the payload structure
type DeviceShadow struct {
	Stream      string `json:"stream"`
	Sequence    int    `json:"sequence"`
	Timestamp   int64  `json:"timestamp"`
	DeviceName  string `json:"device_name"`
	Arch        string `json:"arch"`
}

func sendData(conn net.Conn, payload interface{}) {
	data, _ := json.Marshal(payload)
	fmt.Println(string(data))
	conn.Write(append(data, '\n'))
}

// sendDeviceShadow constructs and sends a device shadow payload
func sendDeviceShadow(conn net.Conn, sequence int) {
	t := time.Now().UnixNano() / int64(time.Millisecond)
	payload := DeviceShadow{
			Stream:      "device_shadow",
			Sequence:    sequence,
			Timestamp:   t,
			DeviceName:  "Beaglebone Black Rev. C",
			Arch:        "armv7",
	}
	fmt.Println(payload)
	sendData(conn, payload)(conn, payload)
}

func main() {
	conn, err := net.Dial("tcp", "localhost:5050")
	if err != nil {
			fmt.Println("Error connecting:", err.Error())
			os.Exit(1)
	}
	defer conn.Close()

	fmt.Println("Starting Uplink Bridge App")

	sequence := 1
	for {
			time.Sleep(5 * time.Second)
			sendDeviceShadow(conn, sequence)
			sequence++
	}
}