go coap Unduh - go coap Unduh kode sumber

go coap

Kategori lainnya

v3.3.6

Unduh

Go-CoAP

Constrained Application Protocol (CoAP) adalah protokol transfer web khusus untuk digunakan dengan node yang dibatasi dan jaringan yang dibatasi di Internet of Things. Protokol ini dirancang untuk aplikasi mesin-ke-mesin (M2M) seperti energi pintar dan otomatisasi gedung.

Go-coap menyediakan server dan klien untuk DTLS, TCP-TLS, UDP, TCP dalam bahasa golang.

Fitur

CoAP melalui UDP RFC 7252.
CoAP melalui TCP/TLS RFC 8232
Amati sumber daya di CoAP RFC 7641
Transfer berdasarkan blok di CoAP RFC 7959
meminta multiplekser
multicast
Opsi CoAP NoResponse di CoAP RFC 7967
CoAP melalui DTLS pion/dtls
Terlalu banyak permintaan kode respons RFC 8516

Persyaratan

Gunakan 1,20 atau lebih tinggi

Sampel

Sederhana

Server UDP/TCP

    // Server

    // Middleware function, which will be called for each request.
    func loggingMiddleware ( next mux. Handler ) mux. Handler {
        return mux . HandlerFunc ( func ( w mux. ResponseWriter , r * mux. Message ) {
            log . Printf ( "ClientAddress %v, %v n " , w . Conn (). RemoteAddr (), r . String ())
            next . ServeCOAP ( w , r )
        })
    }

    // See /examples/simple/server/main.go
    func handleA ( w mux. ResponseWriter , req * mux. Message ) {
        err := w . SetResponse ( codes . GET , message . TextPlain , bytes . NewReader ([] byte ( "hello world" )))
        if err != nil {
            log . Printf ( "cannot set response: %v" , err )
        }
    }

    func main () {
        r := mux . NewRouter ()
        r . Use ( loggingMiddleware )
        r . Handle ( "/a" , mux . HandlerFunc ( handleA ))
        r . Handle ( "/b" , mux . HandlerFunc ( handleB ))

        log . Fatal ( coap . ListenAndServe ( "udp" , ":5688" , r ))


        // for tcp
        // log.Fatal(coap.ListenAndServe("tcp", ":5688",  r))

        // for tcp-tls
        // log.Fatal(coap.ListenAndServeTLS("tcp", ":5688", &tls.Config{...}, r))

        // for udp-dtls
        // log.Fatal(coap.ListenAndServeDTLS("udp", ":5688", &dtls.Config{...}, r))
    }

Klien

    // Client
    // See /examples/simpler/client/main.go
    func main () {
        co , err := udp . Dial ( "localhost:5688" )

        // for tcp
        // co, err := tcp.Dial("localhost:5688")

        // for tcp-tls
        // co, err := tcp.Dial("localhost:5688", tcp.WithTLS(&tls.Config{...}))

        // for dtls
        // co, err := dtls.Dial("localhost:5688", &dtls.Config{...}))

        if err != nil {
            log . Fatalf ( "Error dialing: %v" , err )
        }
        ctx , cancel := context . WithTimeout ( context . Background (), time . Second )
        defer cancel ()
        resp , err := co . Get ( ctx , "/a" )
        if err != nil {
            log . Fatalf ( "Cannot get response: %v" , err )
            return
        }
        log . Printf ( "Response: %+v" , resp )
    }