

Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Tutorial: Memantau kelembaban tanah dengan AWS IoT dan Raspberry Pi
<a name="iot-moisture-tutorial"></a>

Tutorial ini menunjukkan kepada Anda cara menggunakan [Raspberry Pi](https://www.raspberrypi.org/), sensor kelembaban, dan AWS IoT untuk memantau tingkat kelembaban tanah untuk tanaman rumah atau taman. Raspberry Pi menjalankan kode yang membaca tingkat kelembaban dan suhu dari sensor dan kemudian mengirimkan data ke AWS IoT. Anda membuat aturan AWS IoT yang mengirim email ke alamat yang berlangganan topik Amazon SNS saat tingkat kelembaban turun di bawah ambang batas.

**catatan**  
Tutorial ini mungkin tidak up to date. Beberapa referensi mungkin telah digantikan karena topik ini awalnya diterbitkan.

**Contents**
+ [Prasyarat](#iot-moisture-prereqs)
+ [Menyiapkan AWS IoT](iot-moisture-setup.md)
  + [Langkah 1: Buat AWS IoT kebijakan](iot-moisture-policy.md)
  + [Langkah 2: Buat AWS IoT benda, sertifikat, dan kunci pribadi](iot-moisture-create-thing.md)
  + [Langkah 3: Buat topik dan langganan Amazon SNS](iot-moisture-create-sns-topic.md)
  + [Langkah 4: Buat AWS IoT aturan untuk mengirim email](iot-moisture-create-rule.md)
+ [Menyiapkan Raspberry Pi dan sensor kelembaban](iot-moisture-raspi-setup.md)

## Prasyarat
<a name="iot-moisture-prereqs"></a>

Untuk menyelesaikan tutorial ini, Anda memerlukan:
+ Sebuah Akun AWS.
+ Pengguna IAM dengan izin administrator.
+ [Komputer pengembangan yang menjalankan Windows, macOS, Linux, atau Unix untuk mengakses konsol.AWS IoT](https://console.aws.amazon.com/iot/home)
+ [Raspberry Pi 3B atau 4B yang menjalankan OS](https://www.raspberrypi.com/products/) [Raspberry Pi](https://www.raspberrypi.com/software/operating-systems/) terbaru. Untuk petunjuk penginstalan, lihat [Menginstal sistem operasi](https://www.raspberrypi.com/documentation/computers/getting-started.html#installing-the-operating-system) di situs web Raspberry Pi. 
+ Monitor, keyboard, mouse, dan jaringan Wi-Fi atau koneksi Ethernet untuk Raspberry Pi Anda.
+ Sensor kelembaban yang kompatibel dengan Raspberry Pi. Sensor yang digunakan dalam tutorial ini adalah [Adafruit STEMMA I2C Capacitive Moisture Sensor](https://www.adafruit.com/product/4026) dengan header kabel soket 4-pin [JST](https://www.adafruit.com/product/3950) ke wanita. 

# Menyiapkan AWS IoT
<a name="iot-moisture-setup"></a>

Untuk menyelesaikan tutorial ini, Anda perlu membuat sumber daya berikut. Untuk menghubungkan perangkat AWS IoT, Anda membuat IoT, sertifikat perangkat, dan kebijakan. AWS IoT 
+  AWS IoT Sesuatu.

  Sesuatu mewakili perangkat fisik (dalam hal ini, Rasberry Pi Anda) dan berisi metadata statis tentang perangkat. 
+ Sertifikat perangkat.

  Semua perangkat harus memiliki sertifikat perangkat untuk terhubung dan mengautentikasi. AWS IoT
+ Sebuah AWS IoT kebijakan.

  Setiap sertifikat perangkat memiliki satu atau lebih AWS IoT kebijakan yang terkait dengannya. Kebijakan ini menentukan AWS IoT sumber daya mana yang dapat diakses perangkat. 
+ Sertifikat CA AWS IoT root.

  Perangkat dan klien lain menggunakan sertifikat CA AWS IoT root untuk mengautentikasi AWS IoT server yang dengannya mereka berkomunikasi. Untuk informasi selengkapnya, lihat [Otentikasi server](server-authentication.md).
+ Sebuah AWS IoT aturan.

  Aturan berisi kueri dan satu atau beberapa tindakan aturan. Kueri mengekstrak data dari pesan perangkat untuk menentukan apakah data pesan harus diproses. Tindakan aturan menentukan apa yang harus dilakukan jika data cocok dengan query.
+ Langganan topik dan topik Amazon SNS.

  Aturan mendengarkan data kelembaban dari Raspberry Pi Anda. Jika nilainya di bawah ambang batas, ia mengirim pesan ke topik Amazon SNS. Amazon SNS mengirimkan pesan itu ke semua alamat email yang berlangganan topik tersebut.

 



# Langkah 1: Buat AWS IoT kebijakan
<a name="iot-moisture-policy"></a>

Buat AWS IoT kebijakan yang memungkinkan Raspberry Pi Anda terhubung dan mengirim pesan AWS IoT.

1. Di [AWS IoT konsol](https://console.aws.amazon.com/iot), jika tombol **Mulai** muncul, pilih. Jika tidak, di panel navigasi, perluas **Keamanan**, lalu pilih **Kebijakan**.

1. Jika kotak dialog **Anda belum memiliki kebijakan apa pun** muncul, pilih **Buat kebijakan**. Jika tidak, pilih **Buat**.

1. Masukkan nama untuk AWS IoT kebijakan (misalnya,**MoistureSensorPolicy**).

1. Di bagian **Tambah pernyataan**, ganti kebijakan yang ada dengan JSON berikut. Ganti *region* dan *account* dengan Akun AWS nomor Wilayah AWS dan Anda.  
****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": "iot:Connect",
               "Resource": "arn:aws:iot:us-east-1:123456789012:client/RaspberryPi"
           },
           {
               "Effect": "Allow",
               "Action": "iot:Publish",
               "Resource": [
                   "arn:aws:iot:us-east-1:123456789012:topic/$aws/things/RaspberryPi/shadow/update",
                   "arn:aws:iot:us-east-1:123456789012:topic/$aws/things/RaspberryPi/shadow/delete",
                   "arn:aws:iot:us-east-1:123456789012:topic/$aws/things/RaspberryPi/shadow/get"
               ]
           },
           {
               "Effect": "Allow",
               "Action": "iot:Receive",
               "Resource": [
                   "arn:aws:iot:us-east-1:123456789012:topic/$aws/things/RaspberryPi/shadow/update/accepted",
                   "arn:aws:iot:us-east-1:123456789012:topic/$aws/things/RaspberryPi/shadow/delete/accepted",
                   "arn:aws:iot:us-east-1:123456789012:topic/$aws/things/RaspberryPi/shadow/get/accepted",
                   "arn:aws:iot:us-east-1:123456789012:topic/$aws/things/RaspberryPi/shadow/update/rejected",
                   "arn:aws:iot:us-east-1:123456789012:topic/$aws/things/RaspberryPi/shadow/delete/rejected"
               ]
           },
           {
               "Effect": "Allow",
               "Action": "iot:Subscribe",
               "Resource": [
                   "arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/RaspberryPi/shadow/update/accepted",
                   "arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/RaspberryPi/shadow/delete/accepted",
                   "arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/RaspberryPi/shadow/get/accepted",
                   "arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/RaspberryPi/shadow/update/rejected",
                   "arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/RaspberryPi/shadow/delete/rejected"
               ]
           },
           {
               "Effect": "Allow",
               "Action": [
                   "iot:GetThingShadow",
                   "iot:UpdateThingShadow",
                   "iot:DeleteThingShadow"
               ],
               "Resource": "arn:aws:iot:us-east-1:123456789012:thing/RaspberryPi"
           }
       ]
   }
   ```

1. Pilih **Buat**.

# Langkah 2: Buat AWS IoT benda, sertifikat, dan kunci pribadi
<a name="iot-moisture-create-thing"></a>

Buat sesuatu di AWS IoT registri untuk mewakili Raspberry Pi Anda.

1. Di [AWS IoT konsol](https://console.aws.amazon.com/iot/home), di panel navigasi, pilih **Kelola**, lalu pilih **Things**.

1. Jika kotak dialog **Anda belum memiliki hal apa pun** ditampilkan, pilih **Daftarkan sesuatu**. Jika tidak, pilih **Buat**.

1. Pada halaman **Creating AWS IoT things**, pilih **Create a single**.

1. **Pada halaman **Tambahkan perangkat Anda ke registri perangkat**, masukkan nama untuk hal IoT Anda (misalnya,**RaspberryPi**), lalu pilih Berikutnya.** Anda tidak dapat mengubah nama sesuatu setelah Anda membuatnya. Untuk mengubah nama hal, Anda harus membuat hal baru, memberikan nama baru, dan kemudian menghapus hal lama.

1. Pada halaman **Tambahkan sertifikat untuk hal Anda**, pilih **Buat sertifikat**.

1. Pilih tautan **Unduh** untuk mengunduh sertifikat, kunci pribadi, dan sertifikat root CA.
**penting**  
Ini adalah satu-satunya waktu Anda dapat mengunduh sertifikat dan kunci pribadi Anda.

1. Untuk mengaktifkan sertifikat, pilih **Aktifkan**. Sertifikat harus aktif agar perangkat dapat terhubung AWS IoT.

1. Pilih **Lampirkan kebijakan**.

1. Untuk **Tambahkan kebijakan untuk barang Anda**, pilih **MoistureSensorPolicy**, lalu pilih **Register Thing**.

# Langkah 3: Buat topik dan langganan Amazon SNS
<a name="iot-moisture-create-sns-topic"></a>

Buat topik dan langganan Amazon SNS.

1. Dari [konsol AWS SNS](https://console.aws.amazon.com/sns/home), di panel navigasi, pilih **Topik**, lalu pilih **Buat** topik.

1. Pilih ketik sebagai **Standar** dan masukkan nama untuk topik (misalnya,**MoistureSensorTopic**).

1. Masukkan nama tampilan untuk topik (misalnya,**Moisture Sensor Topic**). Ini adalah nama yang ditampilkan untuk topik Anda di konsol Amazon SNS.

1. Pilih **Buat topik**.

1. Di halaman detail topik Amazon SNS, pilih **Buat** langganan.

1. Untuk **Protokol**, pilih **Email**.

1. Untuk **Titik Akhir**, masukkan alamat email Anda.

1. Pilih **Buat langganan**.

1. Buka klien email Anda dan cari pesan dengan subjek**MoistureSensorTopic**. Buka email dan klik tautan **Konfirmasi berlangganan**.
**penting**  
Anda tidak akan menerima peringatan email apa pun dari topik Amazon SNS ini sampai Anda mengonfirmasi langganan.

Anda harus menerima pesan email dengan teks yang Anda ketik.

# Langkah 4: Buat AWS IoT aturan untuk mengirim email
<a name="iot-moisture-create-rule"></a>

 AWS IoT Aturan mendefinisikan kueri dan satu atau beberapa tindakan yang harus diambil saat pesan diterima dari perangkat. Mesin AWS IoT aturan mendengarkan pesan yang dikirim oleh perangkat dan menggunakan data dalam pesan untuk menentukan apakah beberapa tindakan harus diambil. Untuk informasi selengkapnya, lihat [Aturan untuk AWS IoT](iot-rules.md). 

Dalam tutorial ini, Raspberry Pi Anda menerbitkan pesan di`aws/things/RaspberryPi/shadow/update`. Ini adalah topik MQTT internal yang digunakan oleh perangkat dan layanan Thing Shadow. Raspberry Pi menerbitkan pesan yang memiliki bentuk berikut:

```
{
    "reported": {
        "moisture" : moisture-reading,
        "temp" : temperature-reading
    }
}
```

Anda membuat kueri yang mengekstrak data kelembaban dan suhu dari pesan yang masuk. Anda juga membuat tindakan Amazon SNS yang mengambil data dan mengirimkannya ke pelanggan topik Amazon SNS jika pembacaan kelembaban di bawah nilai ambang batas.

**Buat aturan Amazon SNS**

1. Di [AWS IoT konsol](https://console.aws.amazon.com/iot/home), pilih **Perutean pesan,** lalu pilih **Aturan**. Jika kotak dialog **Anda belum memiliki aturan apa pun** muncul, pilih **Buat aturan**. Jika tidak, pilih **Buat aturan**.

1. Di halaman **properti Aturan**, masukkan **nama Aturan** seperti**MoistureSensorRule**, dan berikan **deskripsi Aturan** singkat seperti**Sends an alert when soil moisture level readings are too low**.

1. Pilih **Berikutnya** dan konfigurasikan pernyataan SQL Anda. Pilih **versi SQL** sebagai **2016-03-23**, dan masukkan pernyataan query SQL berikut: AWS IoT 

   ```
   SELECT * FROM '$aws/things/RaspberryPi/shadow/update/accepted' WHERE state.reported.moisture < 400
   ```

   Pernyataan ini memicu tindakan aturan ketika `moisture` pembacaan kurang dari`400`.
**catatan**  
Anda mungkin harus menggunakan nilai yang berbeda. Setelah kode berjalan pada Raspberry Pi Anda, Anda dapat melihat nilai yang Anda dapatkan dari sensor Anda dengan menyentuh sensor, menempatkannya di air, atau menempatkannya di penanam. 

1. Pilih **Berikutnya** dan lampirkan tindakan aturan. Untuk **Tindakan 1**, pilih **Layanan Pemberitahuan Sederhana**. Deskripsi untuk tindakan aturan ini adalah **Kirim pesan sebagai pemberitahuan push SNS**.

1. Untuk **topik SNS**, pilih topik yang Anda buat [Langkah 3: Buat topik dan langganan Amazon SNS](iot-moisture-create-sns-topic.md) **MoistureSensorTopic**, dan biarkan **format Pesan** sebagai **RAW**. Untuk **Peran IAM**, pilih **Buat Peran Baru**. Masukkan nama untuk peran, misalnya**LowMoistureTopicRole**, lalu pilih **Buat peran**.

1. Pilih **Berikutnya** untuk meninjau dan kemudian pilih **Buat** untuk membuat aturan.

# Menyiapkan Raspberry Pi dan sensor kelembaban
<a name="iot-moisture-raspi-setup"></a>



Masukkan kartu microSD Anda ke Raspberry Pi, sambungkan monitor, keyboard, mouse, dan, jika Anda tidak menggunakan Wi-Fi, kabel Ethernet. Jangan sambungkan kabel daya dulu.

Hubungkan kabel jumper JST ke sensor kelembaban. Sisi lain dari jumper memiliki empat kabel:
+ Hijau: I2C SCL
+ Putih: I2C SDA
+ Merah: daya (3,5 V)
+ Hitam: tanah

Pegang Raspberry Pi dengan jack Ethernet di sebelah kanan. Dalam orientasi ini, ada dua baris pin GPIO di bagian atas. Hubungkan kabel dari sensor kelembaban ke baris bawah pin dengan urutan berikut. Mulai dari pin paling kiri, sambungkan merah (power), putih (SDA), dan hijau (SCL). Lewati satu pin, lalu hubungkan kabel hitam (ground). Untuk informasi selengkapnya, lihat Pengkabelan [Komputer Python](https://learn.adafruit.com/adafruit-stemma-soil-sensor-i2c-capacitive-moisture-sensor/python-circuitpython-test).

Pasang kabel daya ke Raspberry Pi dan colokkan ujung lainnya ke stopkontak untuk menyalakannya.

**Konfigurasikan Raspberry Pi Anda**

1. Pada **Selamat Datang di Raspberry Pi**, pilih **Berikutnya**.

1. Pilih negara, bahasa, zona waktu, dan tata letak keyboard Anda. Pilih **Berikutnya**.

1. Masukkan kata sandi untuk Raspberry Pi Anda, lalu pilih **Berikutnya**.

1. Pilih jaringan Wi-Fi Anda, lalu pilih **Berikutnya**. Jika Anda tidak menggunakan jaringan Wi-Fi, pilih **Lewati**.

1. Pilih **Berikutnya** untuk memeriksa pembaruan perangkat lunak. Ketika pembaruan selesai, pilih **Restart untuk memulai ulang** Raspberry Pi Anda.

Setelah Raspberry Pi Anda dimulai, aktifkan antarmuka I2C.

1. Di sudut kiri atas desktop Raspbian, klik ikon Raspberry, pilih **Preferences**, dan kemudian pilih **Raspberry Pi Configuration**.

1. **Pada tab **Antarmuka**, untuk **I2C**, pilih Aktifkan.**

1. Pilih **OK**.

Perpustakaan untuk sensor kelembaban Adafruit STEMMA ditulis untuk. CircuitPython Untuk menjalankannya di Raspberry Pi, Anda perlu menginstal versi terbaru Python 3.

1. Jalankan perintah berikut dari prompt perintah untuk memperbarui perangkat lunak Raspberry Pi Anda:

   `sudo apt-get update`

   `sudo apt-get upgrade`

1. Jalankan perintah berikut untuk memperbarui instalasi Python 3 Anda:

   `sudo pip3 install --upgrade setuptools`

1. Jalankan perintah berikut untuk menginstal perpustakaan Raspberry Pi GPIO:

   `pip3 install RPI.GPIO`

1. Jalankan perintah berikut untuk menginstal perpustakaan Adafruit Blinka:

   `pip3 install adafruit-blinka`

   Untuk informasi selengkapnya, lihat [Menginstal CircuitPython Pustaka di Raspberry Pi](https://learn.adafruit.com/circuitpython-on-raspberrypi-linux/installing-circuitpython-on-raspberry-pi).

1. Jalankan perintah berikut untuk menginstal perpustakaan Adafruit Seesaw:

   `sudo pip3 install adafruit-circuitpython-seesaw`

1. Jalankan perintah berikut untuk menginstal AWS IoT Device SDK untuk Python:

   `pip3 install AWSIoTPythonSDK`

Raspberry Pi Anda sekarang memiliki semua pustaka yang diperlukan. Buat file bernama **moistureSensor.py** dan salin kode Python berikut ke dalam file:

```
from adafruit_seesaw.seesaw import Seesaw
from AWSIoTPythonSDK.MQTTLib import AWSIoTMQTTShadowClient
from board import SCL, SDA

import logging
import time
import json
import argparse
import busio

# Shadow JSON schema:
#
# {
#   "state": {
#       "desired":{
#           "moisture":<INT VALUE>,
#           "temp":<INT VALUE>            
#       }
#   }
# }

# Function called when a shadow is updated
def customShadowCallback_Update(payload, responseStatus, token):

    # Display status and data from update request
    if responseStatus == "timeout":
        print("Update request " + token + " time out!")

    if responseStatus == "accepted":
        payloadDict = json.loads(payload)
        print("~~~~~~~~~~~~~~~~~~~~~~~")
        print("Update request with token: " + token + " accepted!")
        print("moisture: " + str(payloadDict["state"]["reported"]["moisture"]))
        print("temperature: " + str(payloadDict["state"]["reported"]["temp"]))
        print("~~~~~~~~~~~~~~~~~~~~~~~\n\n")

    if responseStatus == "rejected":
        print("Update request " + token + " rejected!")

# Function called when a shadow is deleted
def customShadowCallback_Delete(payload, responseStatus, token):

     # Display status and data from delete request
    if responseStatus == "timeout":
        print("Delete request " + token + " time out!")

    if responseStatus == "accepted":
        print("~~~~~~~~~~~~~~~~~~~~~~~")
        print("Delete request with token: " + token + " accepted!")
        print("~~~~~~~~~~~~~~~~~~~~~~~\n\n")

    if responseStatus == "rejected":
        print("Delete request " + token + " rejected!")


# Read in command-line parameters
def parseArgs():

    parser = argparse.ArgumentParser()
    parser.add_argument("-e", "--endpoint", action="store", required=True, dest="host", help="Your device data endpoint")
    parser.add_argument("-r", "--rootCA", action="store", required=True, dest="rootCAPath", help="Root CA file path")
    parser.add_argument("-c", "--cert", action="store", dest="certificatePath", help="Certificate file path")
    parser.add_argument("-k", "--key", action="store", dest="privateKeyPath", help="Private key file path")
    parser.add_argument("-p", "--port", action="store", dest="port", type=int, help="Port number override")
    parser.add_argument("-n", "--thingName", action="store", dest="thingName", default="Bot", help="Targeted thing name")
    parser.add_argument("-id", "--clientId", action="store", dest="clientId", default="basicShadowUpdater", help="Targeted client id")

    args = parser.parse_args()
    return args


# Configure logging
# AWSIoTMQTTShadowClient writes data to the log
def configureLogging():

    logger = logging.getLogger("AWSIoTPythonSDK.core")
    logger.setLevel(logging.DEBUG)
    streamHandler = logging.StreamHandler()
    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    streamHandler.setFormatter(formatter)
    logger.addHandler(streamHandler)


# Parse command line arguments
args = parseArgs()

if not args.certificatePath or not args.privateKeyPath:
    parser.error("Missing credentials for authentication.")
    exit(2)

# If no --port argument is passed, default to 8883
if not args.port: 
    args.port = 8883


# Init AWSIoTMQTTShadowClient
myAWSIoTMQTTShadowClient = None
myAWSIoTMQTTShadowClient = AWSIoTMQTTShadowClient(args.clientId)
myAWSIoTMQTTShadowClient.configureEndpoint(args.host, args.port)
myAWSIoTMQTTShadowClient.configureCredentials(args.rootCAPath, args.privateKeyPath, args.certificatePath)

# AWSIoTMQTTShadowClient connection configuration
myAWSIoTMQTTShadowClient.configureAutoReconnectBackoffTime(1, 32, 20)
myAWSIoTMQTTShadowClient.configureConnectDisconnectTimeout(10) # 10 sec
myAWSIoTMQTTShadowClient.configureMQTTOperationTimeout(5) # 5 sec

# Initialize Raspberry Pi's I2C interface
i2c_bus = busio.I2C(SCL, SDA)

# Intialize SeeSaw, Adafruit's Circuit Python library
ss = Seesaw(i2c_bus, addr=0x36)

# Connect to AWS IoT
myAWSIoTMQTTShadowClient.connect()

# Create a device shadow handler, use this to update and delete shadow document
deviceShadowHandler = myAWSIoTMQTTShadowClient.createShadowHandlerWithName(args.thingName, True)

# Delete current shadow JSON doc
deviceShadowHandler.shadowDelete(customShadowCallback_Delete, 5)

# Read data from moisture sensor and update shadow
while True:

    # read moisture level through capacitive touch pad
    moistureLevel = ss.moisture_read()

    # read temperature from the temperature sensor
    temp = ss.get_temp()

    # Display moisture and temp readings
    print("Moisture Level: {}".format(moistureLevel))
    print("Temperature: {}".format(temp))
    
    # Create message payload
    payload = {"state":{"reported":{"moisture":str(moistureLevel),"temp":str(temp)}}}

    # Update shadow
    deviceShadowHandler.shadowUpdate(json.dumps(payload), customShadowCallback_Update, 5)
    time.sleep(1)
```

Simpan file ke tempat Anda dapat menemukannya. Jalankan `moistureSensor.py` dari baris perintah dengan parameter berikut:

titik akhir  
 AWS IoT Titik akhir kustom Anda. Untuk informasi selengkapnya, lihat [Device Shadow REST API](device-shadow-rest-api.md).

rootCA  
Jalur lengkap ke sertifikat CA AWS IoT root Anda.

sertifikat  
Jalur lengkap ke sertifikat AWS IoT perangkat Anda.

kunci  
Jalur lengkap ke kunci pribadi sertifikat AWS IoT perangkat Anda.

thingName  
Nama barang Anda (dalam hal ini,`RaspberryPi`).

clientId  
ID klien MQTT. Gunakan `RaspberryPi`.

Baris perintah akan terlihat seperti ini:

`python3 moistureSensor.py --endpoint your-endpoint --rootCA ~/certs/AmazonRootCA1.pem --cert ~/certs/raspberrypi-certificate.pem.crt --key ~/certs/raspberrypi-private.pem.key --thingName RaspberryPi --clientId RaspberryPi`

Coba sentuh sensor, letakkan di penanam, atau masukkan ke dalam segelas air untuk melihat bagaimana sensor merespons berbagai tingkat kelembapan. Jika diperlukan, Anda dapat mengubah nilai ambang batas di`MoistureSensorRule`. Saat pembacaan sensor kelembaban berada di bawah nilai yang ditentukan dalam pernyataan kueri SQL aturan Anda, AWS IoT menerbitkan pesan ke topik Amazon SNS. Anda harus menerima pesan email yang berisi data kelembaban dan suhu.

Setelah Anda memverifikasi penerimaan pesan email dari Amazon SNS, tekan **CTRL\$1C** untuk menghentikan program Python. Tidak mungkin program Python akan mengirim pesan yang cukup untuk dikenakan biaya, tetapi ini adalah praktik terbaik untuk menghentikan program ketika Anda selesai.