Połączenie Arduino GSM Shield z sieciami komórkowymi
Published: 2024-01-12 10:12:34

**Zasady opisane w tym blogu z naszego archiwum są nadal aktualne, ale konkretne przykłady użyte w tym artykule dotyczą GPRS, który nie jest dostępny we wszystkich krajach. Należy o tym pamiętać, wykonując czynności opisane w tym samouczku**

W przeszłości prezentowaliśmy inteligentny dom sterowany przez PubNub Arduino na targach CES i innych konferencjach, a często zadawanym pytaniem było, czy PubNub działa w sieciach GSM/GPRS. Czy mogę podłączyć mój Arduino GSM/GPRS shield do Internetu, aby [przesyłać dane dwukierunkowo](https://www.pubnub.com/solutions/data-streaming/)? Wiedzieliśmy, że to zadziała, ale nigdy tego nie wdrożyliśmy.

Aż do teraz...

W tym wpisie na blogu przeprowadzimy prostą demonstrację PubNub z GSM/GPRS. Innymi słowy, zamierzamy łatwo podłączyć nasze Arduino do mobilnej sieci komórkowej. Jest to niezwykle ekscytujące i otwiera drzwi dla mobilnych [aplikacji IoT](https://www.pubnub.com/solutions/iot-device-control/), takich jak połączone samochody lub drony, lub aplikacji bez dostępu do sygnału WiFi, takich jak stacje pogodowe lub systemy zraszaczy.

Zaczynajmy więc!

[![GRPS SLD_04](https://images.ctfassets.net/3prze68gbwl1/asset-17suaysk1qa1hpg/748bdd937c0bc4de3db714a44c5d7c84/GRPS-SLD_04.jpg "GRPS SLD_04")](https://images.ctfassets.net/3prze68gbwl1/asset-17suaysk1qa1hpg/748bdd937c0bc4de3db714a44c5d7c84/GRPS-SLD_04.jpg)

### Lista części Arduino GSM/GPRS

Oto czego użyłem:

-   Arduino UNO Rev3
-   Seeed Studio GPRS Shield V2.0
-   Karta SIM (samodzielna)
-   Baterie rozmiaru C (x5)
-   Uchwyt baterii rozmiaru C (x5)
-   Smartfon akceptujący fizyczną kartę SIM
-   Laptop

Kupiłem GPRS Shield i kartę SIM AT&T od Amazon; mają sekcję dla uniwersalnych kart SIM. Może być trudno znaleźć samodzielną kartę SIM w innych sklepach detalicznych.

### Konfiguracja karty SIM

Najpierw należy odblokować kartę SIM i dołączyć do niej plan taryfowy. Dlatego na liście części znajduje się smartfon.

Włóż kartę SIM do telefonu i przeczytaj instrukcje zawarte w opakowaniu. W przypadku karty SIM AT&T, którą zakupiłem, wybrałem serię numerów w telefonie, aby aktywować kartę, a następnie skonfigurowałem plan online. Upewnij się, że Twój plan taryfowy obsługuje transfer danych, a nie tylko połączenia i SMS-y.

Po aktywacji karty SIM spróbuj połączyć się z witryną internetową na telefonie komórkowym. Jeśli się powiedzie, masz dane i będą one działać w Arduino.

### Konfiguracja Arduino GPRS

Weź Arduino GPRS Shield i podłącz kartę SIM. Seeed Studio ma [świetny samouczek na temat tego, jak to](https://wiki.seeedstudio.com/GPRS_Shield_V2.0/) zrobić. Postępuj zgodnie z tym samouczkiem, ale zatrzymaj się i wróć tutaj przed załadowaniem kodu w "Test Setup".

[![Arduino GPRS GSM](https://images.ctfassets.net/3prze68gbwl1/asset-17suaysk1qa1hph/9cb2b3cc0d462bd0ccce25f4696c360c/Arduino-GPRS-GSM.png "Arduino GPRS GSM")](https://images.ctfassets.net/3prze68gbwl1/asset-17suaysk1qa1hph/9cb2b3cc0d462bd0ccce25f4696c360c/Arduino-GPRS-GSM.png)

### Biblioteki Arduino

Będziesz potrzebował całej sterty bibliotek, aby skonfigurować to na Arduino, ale zaufaj mi, to znacznie ułatwia sprawę. Sam próbowałem je napisać!

[Specyficzne biblioteki dla Seeed Studio GPRS Shield V2 można znaleźć tutaj](https://github.com/Seeed-Studio/GPRS_Shield_Suli). Zwróć uwagę na dokumentację, potrzebujesz 3 bibliotek, aby uruchomić to maleństwo:

-   [GPRS\_Shield\_Suli](https://github.com/Seeed-Studio/GPRS_Shield_Suli) - Biblioteka modułu GPRS,
-   SoftwareSerial - używamy oprogramowania szeregowego do komunikacji z modułem GPRS
-   [Suli\_Arduino](https://github.com/Seeed-Studio/Suli) - interfejs zunifikowanej biblioteki Seeed.

Zaimportuj wszystkie trzy biblioteki do swojej konfiguracji Arduino.

### Software Serial

Teraz czas na zabawę. Tarcza i środowisko Arduino są już skonfigurowane. Pobawmy się więc sieciami komórkowymi.

Po pierwsze, potrzebujemy sposobu na rozmowę z chipem SIM900 na Arduino. Moglibyśmy użyć sprzętowego portu szeregowego i rozmawiać z nim bezpośrednio, ale to trudne, więc użyjmy po prostu programowego portu szeregowego Arduino.

Otwórz przykład "SIM\_900\_Serial\_Debug" z folderu przykładów Arduino.

[![
Connect Arduino GSM/GPRS](https://images.ctfassets.net/3prze68gbwl1/asset-17suaysk1qa1hpi/0b0470d16b584924954410e4fe312d6e/687474703a2f2f692e696d6775722e636f6d2f3658483531466f2e706e67.png "
Connect Arduino GSM/GPRS")](https://images.ctfassets.net/3prze68gbwl1/asset-17suaysk1qa1hpi/0b0470d16b584924954410e4fe312d6e/687474703a2f2f692e696d6775722e636f6d2f3658483531466f2e706e67.png)

Ten przykład jest prosty, po prostu proxy danych szeregowych z portu szeregowego Arduino do SIM900. To pozwala nam używać wbudowanego narzędzia do debugowania Arduino Serial do interakcji z naszym SIM900.

```js
void loop(){
  if(gprs.available()){
    Serial.write(gprs.read());
  }
  if(Serial.available()){     
    gprs.write(Serial.read()); 
  }
}
```

### Zadzwoń do siebie

Spróbujmy zadzwonić do siebie za pomocą Arduino GSM shield, aby wszystko przetestować. Załaduj przykład Software Serial na Arduino i otwórz Serial Debugger. Upewnij się, że włączyłeś kartę SIM na Arduino GPRS shield za pomocą przycisku z boku.

_Włącz zasilanie SIM900, naciskając przycisk zasilania przez około 2 sekundy. Czerwona dioda LED zaświeci się. Zielona dioda obok niej będzie migać. Jeśli tarcza pomyślnie połączy się z siecią, zielona dioda LED będzie migać co 3 sekundy._

Upewnij się, że włożyłeś starą kartę SMS z powrotem do telefonu po przetestowaniu karty SIM Arduino!

Teraz wpisz następujące polecenie w oknie szeregowym Arduino:

```js
AT
```

Wyjście szeregowe powinno pokazać coś takiego:

```js
RDY
+CFUN: 1
+CPIN: READY
+PACSP: 0
Call Ready
```

Jeśli nie widzisz wiadomości w monitorze szeregowym, powinieneś kliknąć opcję "send new", która doda powrót karetki na końcu polecenia AT, a następnie wysłać polecenie AT "AT+IPR=19200", aby ustawić szybkość transmisji SIM900.

Teraz spróbuj zadzwonić do siebie. Wprowadź następujące polecenie, zastępując "1\*\*\*8675309" własnym numerem.

```js
ATD1***8675309;
```

Jeśli się powiedzie, pojawi się komunikat "ATH OK", jak na poniższym obrazku. W przeciwnym razie pojawi się komunikat "No CARRIER". Powodem może być nieistniejący numer telefonu lub nieprawidłowy format polecenia.

### Połączenie z Internetem

Pomyślnie skonfigurowaliśmy nasz projekt Arduino do pracy przez GSM. Teraz podłączmy go do Internetu.

_Upewnij się, że szybkość transmisji SIM900 wynosi 9600! Możesz użyć komendy AT (AT+IPR=9600), aby ustawić ją poprzez SerialDebug_

Załaduj przykład GPRS\_TCPConnection z GPRS\_Shield\_Suli. Ten przykład wykonuje proste żądanie do "mbed.org/media/uploads/mbed\_official/hello.txt HTTP/1.0".  
  

Jednak prawdopodobnie nie uruchomi się po załadowaniu go na Arduino. Dzieje się tak, ponieważ nie jest on skonfigurowany do pracy z konkretną siecią komórkową.

W moim przypadku korzystam z AT&T, więc musiałem zmienić następujące linie, aby skonfigurować połączenie gprs:

```js
GPRS gprs(PIN_TX, PIN_RX, BAUDRATE,"cmnet");
```

Ta linia nie jest wystarczająca w większości przypadków. Musimy również podać APN, nazwę użytkownika i hasło. Parametry te zostały pominięte w przykładzie, ale można je po prostu podać samodzielnie. Odpowiedni kod można znaleźć [tutaj](https://github.com/Seeed-Studio/GPRS_Shield_Suli/blob/master/GPRS_Shield_Arduino.h).

```js
GPRS(int tx, int rx, uint32_t baudRate = 9600, const char* apn = NULL, const char* userName = NULL, const char *passWord = NULL);
```

Aby połączyć się z AT&T, użyj następującej konfiguracji:

```js
GPRS gprs(PIN_TX, PIN_RX, BAUDRATE, "wap.cingular", "WAP@CINGULARGPRS.COM", "CINGULAR1");
```

Teraz uruchom kod. Powinieneś być w stanie uzyskać IP i wysłać żądanie. Jednak aplikacja prawdopodobnie ulegnie awarii (SIM wyłączy się) po wysłaniu żądania. Może to być mylące, ale można to łatwo naprawić.

### Baterie

Seeed Studio i wiele innych shieldów reklamuje się jako "plug and play" z Arduino, ale nie zawsze tak jest. Ten shield w szczególności nie ma wystarczającej mocy z pojedynczego zasilania USB 5 V, aby pomyślnie wykonać żądania TCP.

Jest to jednak dość łatwe do naprawienia, wszystko co musimy zrobić, to dać mu więcej mocy! Fora internetowe sugerują dodanie 5 baterii C do zasilania chipu GSM, co właśnie zrobiłem.

[![Connect Arduino GSM/GPRS](https://images.ctfassets.net/3prze68gbwl1/asset-17suaysk1qa1hpk/229a1ccaccf1df92b657be3c095b068f/687474703a2f2f692e696d6775722e636f6d2f45486a7942684b2e6a7067-1024x681.jpg "Connect Arduino GSM/GPRS")](https://images.ctfassets.net/3prze68gbwl1/asset-17suaysk1qa1hpj/523b7d13b8c3b81ff0c49733d501b432/687474703a2f2f692e696d6775722e636f6d2f45486a7942684b2e6a7067.jpg)

Baterie powinny być podłączone szeregowo, z dodatnim końcem podłączonym do wejścia VIN i ujemnym podłączonym do GND.

Po dodaniu baterii spróbuj ponownie wykonać przykład. Połączenie powinno się udać.

Świetnie! Teraz jesteśmy gotowi do sygnalizowania za pomocą PubNub.

### Wdrażanie PubNub do Signal

Teraz, gdy jesteśmy w pełni zasileni, przejdźmy do zabawnej części. Załaduj poniższy przykład na swoją płytkę, zmieniając konfigurację "GPRS gprs()", jak wspomniano wcześniej.

```js
#include <GPRS_Shield_Arduino.h>
  #include <SoftwareSerial.h>
  #include <Wire.h>
  #include <Suli.h>
  #define PIN_TX    7
  #define PIN_RX    8
  //make sure that the baud rate of SIM900 is 9600!
  //you can use the AT Command(AT+IPR=9600) to set it through SerialDebug
  #define BAUDRATE  9600
  GPRS gprs(PIN_TX, PIN_RX, BAUDRATE, "wap.cingular", "WAP@CINGULARGPRS.COM", "CINGULAR1");
  void publishData(String data) {
    Serial.println("attempting to publish");
    while (false == gprs.join()) {
      Serial.println("gprs join network error");
      delay(2000);
    }
    String str = "GET /publish/demo/demo/0/pubnub_gprs/0/\"" + data + "\" HTTP/1.0\r\n\r\n";
    // Length (with one extra character for the null terminator)
    int str_len = str.length() + 1; 
    // Prepare the character array (the buffer) 
    char http_cmd[str_len];
    // Copy it over 
    str.toCharArray(http_cmd, str_len);
    char buffer[512];
    if (false == gprs.connect(TCP, "pubsub.pubnub.com", 80)) {
      Serial.println("connect error");
    } else {
      Serial.println("publish success");
      Serial.println(data);
    }
    gprs.send(http_cmd, sizeof(http_cmd) - 1);
    gprs.close();
  }
  int counter = 0;
  void setup() {
    Serial.println("starting");
    Serial.begin(9600);
    // use DHCP
    gprs.init();
    // attempt DHCP
    while(true){
      publishData(String(counter));
      counter++;
      delay(1000);
    }
    gprs.disconnect();
  }
  void loop() {
  }
```

[](https://www.pubnub.com/docs/general/basics/initialize-pubnub)

[Na początku może to być mylące, ale rozłóżmy to na czynniki pierwsze.](https://www.pubnub.com/docs/general/basics/initialize-pubnub) Adres[url jest sformatowany zgodnie](https://www.pubnub.com/docs/general/basics/initialize-pubnub) z[PubNub REST Push API](https://pubnub.com/docs/rest-api).

```js
http://pubsub.pubnub.com
/publish
/pub-key
/sub-key
/signature
/channel
/callback
/message
```

Domena "pubsub.pubnub.com" jest zdefiniowana w dalszej części funkcji. Klucz "publish" odnosi się do polecenia pubnub (można również subskrybować). Klucze "pub-key" i "sub-key" pochodzą z własnego [konta PubNub](https://www.pubnub.com/docs/general/basics/set-up-your-account), ale na razie można użyć kluczy "demo". Nie martw się o podpis.

"Kanał" jest naprawdę ważny. Jest to kanał IRC, na którym urządzenia PubNub mogą ze sobą rozmawiać.

### Pokaż mi dane

Ponieważ nie mamy żadnego innego urządzenia nasłuchującego wiadomości z Arduino, użyjmy [konsoli Pub](https://www.pubnub.com/docs/console/) Nub, aby obserwować aktywność naszego kanału.

Jeśli demo jest uruchomione, w panelu "message" powinna pojawić się liczba 1, 2, 3, 4.

[![Connect Arduino GSM/GPRS](https://images.ctfassets.net/3prze68gbwl1/asset-17suaysk1qa1hpm/f98dab6173290ad076b29dc1c0b1ad48/687474703a2f2f692e696d6775722e636f6d2f77474c463865652e706e67-1024x468.png "Connect Arduino GSM/GPRS")](https://images.ctfassets.net/3prze68gbwl1/asset-17suaysk1qa1hpl/938e26e4848e88a0f3e2aaeb114f7589/687474703a2f2f692e696d6775722e636f6d2f77474c463865652e706e67.png)

Jesteśmy w stanie wyświetlić dane wychodzące z Arduino, ponieważ podłączyliśmy ten sam klucz publikowania i subskrypcji do konsoli PubNub, co do Arduino. Ponieważ używamy kluczy "demo", kanał jest udostępniany publicznie, ale jeśli utworzysz własne konto, dane zostaną sprywatyzowane.

Jak PubNub może ci pomóc?
=========================

Ten artykuł został pierwotnie opublikowany na [PubNub.com](https://www.pubnub.com/blog/connect-arduino-gsm-shield-with-cellular-networks/)

Nasza platforma pomaga programistom tworzyć, dostarczać i zarządzać interaktywnością w czasie rzeczywistym dla aplikacji internetowych, aplikacji mobilnych i urządzeń IoT.

Podstawą naszej platformy jest największa w branży i najbardziej skalowalna sieć komunikacyjna w czasie rzeczywistym. Dzięki ponad 15 punktom obecności na całym świecie obsługującym 800 milionów aktywnych użytkowników miesięcznie i niezawodności na poziomie 99,999%, nigdy nie będziesz musiał martwić się o przestoje, limity współbieżności lub jakiekolwiek opóźnienia spowodowane skokami ruchu.

Poznaj PubNub
-------------

Sprawdź [Live Tour](https://www.pubnub.com/tour/introduction/), aby zrozumieć podstawowe koncepcje każdej aplikacji opartej na PubNub w mniej niż 5 minut.

Rozpocznij konfigurację
-----------------------

Załóż [konto](https://admin.pubnub.com/signup/) PubNub, aby uzyskać natychmiastowy i bezpłatny dostęp do kluczy PubNub.

Rozpocznij
----------

[Dokumenty](https://www.pubnub.com/docs) PubNub pozwolą Ci rozpocząć pracę, niezależnie od przypadku użycia lub [zestawu SDK](https://www.pubnub.com/docs).