Add files via upload

03. Hardware Implementation/LoRa Communication/Testing/Reciever2_LoRa.txt

@@ -0,0 +1,68 @@
+# SPDX-FileCopyrightText: 2021 ladyada for Adafruit Industries
+# SPDX-License-Identifier: MIT
+
+# Simple demo of sending and recieving data with the RFM95 LoRa radio.
+# Author: Tony DiCola
+import board
+import busio
+import digitalio
+
+import adafruit_rfm9x
+
+
+# Define radio parameters.
+RADIO_FREQ_MHZ = 433.0  # Frequency of the radio in Mhz. Must match your
+# module! Can be a value like 915.0, 433.0, etc.
+
+# Define pins connected to the chip, use these if wiring up the breakout according to the guide:
+CS = digitalio.DigitalInOut(board.CE1)
+RESET = digitalio.DigitalInOut(board.D22)
+
+# Initialize SPI bus.
+spi = busio.SPI(board.SCK, MOSI=board.MOSI, MISO=board.MISO)
+
+# Initialze RFM radio
+rfm9x = adafruit_rfm9x.RFM9x(spi, CS, RESET, RADIO_FREQ_MHZ, baudrate=100000)
+
+# Note that the radio is configured in LoRa mode so you can't control sync
+# word, encryption, frequency deviation, or other settings!
+
+# You can however adjust the transmit power (in dB).  The default is 13 dB but
+# high power radios like the RFM95 can go up to 23 dB:
+rfm9x.tx_power = 23
+
+# Send a packet.  Note you can only send a packet up to 252 bytes in length.
+# This is a limitation of the radio packet size, so if you need to send larger
+# amounts of data you will need to break it into smaller send calls.  Each send
+# call will wait for the previous one to finish before continuing.
+rfm9x.send(bytes("Hello world!\r\n", "utf-8"))
+print("Sent Hello World message!")
+
+# Wait to receive packets.  Note that this library can't receive data at a fast
+# rate, in fact it can only receive and process one 252 byte packet at a time.
+# This means you should only use this for low bandwidth scenarios, like sending
+# and receiving a single message at a time.
+print("Waiting for packets...")
+
+while True:
+    #packet = rfm9x.receive()
+    # Optionally change the receive timeout from its default of 0.5 seconds:
+    packet = rfm9x.receive(timeout=5.0,with_header=True)
+    # If no packet was received during the timeout then None is returned.
+    if packet is None:
+        # Packet has not been received
+        print("Received nothing! Listening again...")
+    else:
+        # Received a packet!
+        # Print out the raw bytes of the packet:
+        print("Received (raw bytes): {0}".format(packet))
+        # And decode to ASCII text and print it too.  Note that you always
+        # receive raw bytes and need to convert to a text format like ASCII
+        # if you intend to do string processing on your data.  Make sure the
+        # sending side is sending ASCII data before you try to decode!
+        packet_text = str(packet, "ascii")
+        print("Received (ASCII): {0}".format(packet_text))
+        # Also read the RSSI (signal strength) of the last received message and
+        # print it.
+        rssi = rfm9x.last_rssi
+        print("Received signal strength: {0} dB".format(rssi))

03. Hardware Implementation/LoRa Communication/Testing/SPI_Test.txt

@@ -0,0 +1,11 @@
+import spidev
+
+spi = spidev.SpiDev()
+spi.open(0, 0)  # CE0 is bus 0, device 0
+spi.max_speed_hz = 5000000
+try:
+    data = spi.xfer2([0x42])  # Dummy read
+    print(f"SPI Response: {data}")
+except Exception as e:
+    print(f"SPI Error: {e}")
+spi.close()

03. Hardware Implementation/LoRa Communication/Testing/Sender_LoRa.txt

@@ -0,0 +1,41 @@
+# Import Python System Libraries
+import time
+
+# Import RFM9x
+import adafruit_rfm9x
+
+# Configure LoRa Radio
+# Import Blinka Libraries
+import busio
+from digitalio import DigitalInOut, Direction, Pull
+import board
+
+RADIO_FREQ_MHZ = 433.0
+
+print("Board:", end=": ") 
+print(board.CE0)
+
+CS = DigitalInOut(board.CE1)
+RESET = DigitalInOut(board.D22)
+spi = busio.SPI(board.SCK, MOSI=board.MOSI, MISO=board.MISO)
+rfm9x = adafruit_rfm9x.RFM9x(spi, CS, RESET, RADIO_FREQ_MHZ)
+
+rfm9x.tx_power = 20
+rfm9x.signal_bandwidth = 125000
+rfm9x.coding_rate = 8
+rfm9x.spreading_factor = 12
+rfm9x.enable_crc = True
+
+count = 0
+
+while True:
+	data=bytes(f"Packet {count}","utf-8")
+	rfm9x.send(data)
+	print(f"data sent: {data.decode()}")
+
+	if(count >= 9):
+		count = 0
+	else:
+		count += 1
+
+	time.sleep(2)

03. Hardware Implementation/LoRa Communication/Testing/Transmitter.txt

@@ -0,0 +1,63 @@
+# SPDX-FileCopyrightText: 2021 ladyada for Adafruit Industries
+# SPDX-License-Identifier: MIT
+
+# Example to send a packet periodically
+# Author: Jerry Needell
+#
+import time
+import board
+import busio
+import digitalio
+import adafruit_rfm9x
+
+# set the time interval (seconds) for sending packets
+transmit_interval = 10
+
+# Define radio parameters.
+RADIO_FREQ_MHZ = 433.0  # Frequency of the radio in Mhz. Must match your
+# module! Can be a value like 915.0, 433.0, etc.
+
+# Define pins connected to the chip.
+CS = digitalio.DigitalInOut(board.CE1)
+RESET = digitalio.DigitalInOut(board.D25)
+
+# Initialize SPI bus.
+spi = busio.SPI(board.SCK, MOSI=board.MOSI, MISO=board.MISO)
+
+# Initialze RFM radio
+rfm9x = adafruit_rfm9x.RFM9x(spi, CS, RESET, RADIO_FREQ_MHZ)
+
+# Note that the radio is configured in LoRa mode so you can't control sync
+# word, encryption, frequency deviation, or other settings!
+
+# You can however adjust the transmit power (in dB).  The default is 13 dB but
+# high power radios like the RFM95 can go up to 23 dB:
+rfm9x.tx_power = 23
+
+
+# initialize counter
+counter = 0
+# send a broadcast mesage
+rfm9x.send(bytes("message number {}".format(counter), "UTF-8"))
+
+# Wait to receive packets.
+print("Waiting for packets...")
+# initialize flag and timer
+send_reading = False
+time_now = time.monotonic()
+while True:
+    # Look for a new packet - wait up to 5 seconds:
+    packet = rfm9x.receive(timeout=5.0)
+    # If no packet was received during the timeout then None is returned.
+    if packet is not None:
+        # Received a packet!
+        # Print out the raw bytes of the packet:
+        print("Received (raw bytes): {0}".format(packet))
+        # send reading after any packet received
+    if time.monotonic() - time_now > transmit_interval:
+        # reset timeer
+        time_now = time.monotonic()
+        # clear flag to send data
+        send_reading = False
+        counter = counter + 1
+        rfm9x.send(bytes("message number {}".format(counter), "UTF-8"))