Comment implémenter la transmission Bluetooth dans Golang

golang est un langage de programmation efficace, rapide et puissant qui offre un excellent support pour l'écriture d'applications Web et d'applications interactives. Dans le domaine de la transmission Bluetooth, Golang présente également d'excellentes performances. Dans cet article, nous présenterons comment utiliser Golang pour implémenter la transmission Bluetooth.

Avant de commencer cet article, nous devons comprendre quelques connaissances de base sur la transmission Bluetooth. Bluetooth est une technologie de communication sans fil à courte portée couramment utilisée pour connecter des appareils tels que des casques, des claviers et des souris sans fil. Il peut transmettre des données sans utiliser de câbles et sa portée typique est d'environ 10 mètres.

Pour implémenter la transmission Bluetooth, vous devez utiliser la bibliothèque Bluetooth de Golang. Cette bibliothèque fournit des fonctionnalités pour communiquer avec les appareils Bluetooth.

Tout d'abord, nous devons installer un adaptateur compatible Bluetooth sur notre ordinateur afin que notre code puisse accéder et communiquer avec le périphérique Bluetooth. Après avoir installé l'adaptateur, nous pouvons installer la bibliothèque Bluetooth de Golang.

Entrez la commande suivante dans la fenêtre de ligne de commande pour installer :

go get github.com/karalabe/gousb
go get github.com/raff/goble

Une fois l'installation terminée, nous devons importer la bibliothèque Bluetooth dans le code :

import "github.com/currantlabs/ble"

Ensuite, nous pouvons utiliser le code suivant pour rechercher le Bluetooth disponible devices :

// Set up BLE scanner
scanner, err := ble.NewScanner()
if err != nil {
    log.Fatalf("Failed to initialize BLE scanner: %s", err)
}
defer scanner.Close()

// Start scanning for 10 seconds
stopScan := make(chan struct{})
go func() {
    <-time.After(10 * time.Second)
    close(stopScan)
}()
devices := make(map[string]struct{})
scanner.Handler = ble.AdvertisementHandler(func(a ble.Advertisement) {
    devices[a.String()] = struct{}{}
})
if err := scanner.Scan(stopScan); err != nil {
    log.Fatalf("Failed to scan for devices: %s", err)
}
for device := range devices {
    log.Printf("Discovered device %s", device)
}

Le code ci-dessus analysera pendant 10 secondes et stockera les appareils découverts dans map[string]struct{}. Nous pouvons traiter davantage ces informations si nécessaire.

Nous pouvons également utiliser le code suivant pour nous connecter à un appareil Bluetooth :

targetMAC, err := ble.ParseMAC(targetAddr)
if err != nil {
    log.Fatalf("Failed to parse target MAC address %s: %s", targetAddr, err)
}
client, err := ble.NewClient(&ble.ClientParams{
    ConnectionParams: ble.ConnectionParams{
        Interval:         50 * time.Millisecond,
        Latency:          4,
        SupervisionTimeout: time.Second,
    },
    AutoConnect: true,
})
if err != nil {
    log.Fatalf("Failed to initialize BLE client: %s", err)
}
defer client.CancelConnection()
ctx := context.Background()
peripheral, err := client.Dial(ctx, targetMAC)
if err != nil {
    log.Fatalf("Failed to connect to peripheral: %s", err)
}
defer peripheral.CancelConnection()

Le code ci-dessus se connectera à l'appareil cible et s'annulera dès que la connexion sera terminée. Nous pouvons également rester connectés après la connexion et envoyer et recevoir des données. Voici un exemple :

for {
    peripheral := connect()
    if peripheral == nil {
        continue
    }
    if err := peripheral.WriteCharacteristic(characteristic, data, true); err != nil {
        log.Printf("Failed to send data: %s", err)
    }
    if err := peripheral.SetNotifyValue(characteristic, func(b []byte) {
        log.Printf("Received data: %v", b)
    }); err != nil {
        log.Printf("Failed to set notification: %s", err)
    }
    <-time.After(10 * time.Second)
}

Le code ci-dessus se connectera à l'appareil cible, enverra des données et obtiendra des données. Il se déconnectera également après 10 secondes et attendra un certain temps avant de se reconnecter. Vous pouvez modifier le code selon vos besoins et implémenter d'autres actions basées sur cet exemple.

Résumé :

Dans cet article, nous avons présenté comment utiliser la bibliothèque Bluetooth de Golang pour implémenter la transmission Bluetooth. Nous avons acquis des connaissances de base en matière de transmission Bluetooth et appris à rechercher des appareils, à nous connecter à des appareils, à envoyer et à recevoir des données. La bibliothèque Bluetooth de Golang offre une prise en charge étendue, rendant la mise en œuvre de la transmission Bluetooth simple et facile. Si vous êtes intéressé, essayez cette technologie dans votre prochain projet golang !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!