continue
print("Connected to", str(esp.ssid, 'utf-8'), "\tRSSI:", esp.rssi)
# Initialize a requests object with a socket and esp32spi interface
requests.set_socket(socket, esp)
# setting up lora ....
import adafruit_rfm9x
TIMEOUT = 5
cs = digitalio.DigitalInOut(board.A5)
reset = digitalio.DigitalInOut(board.A4)
rfm9x = adafruit_rfm9x.RFM9x(esp_spi, cs, reset, 915.0)
# setting up an indicator LED for the itsy on-board red LED on pin 13
led = digitalio.DigitalInOut(board.D13)
led.direction = digitalio.Direction.OUTPUT
led.value = False
# main loop
attemptCount = 0
while True:
gc.collect()
try:
else:
return False
else:
if abs(prevOrigins[0][0] - currOrigin[0]) < pixels and abs(
prevOrigins[0][1] - currOrigin[1]) < pixels:
prevOrigins[0] = currOrigin
return True
else:
return shouldntTransmit(prevOrigins[1:], currOrigin) or False
# Configure LoRa Radio
CS = DigitalInOut(board.CE1)
RESET = DigitalInOut(board.D25)
spi = busio.SPI(board.SCK, MOSI=board.MOSI, MISO=board.MISO)
rfm9x = adafruit_rfm9x.RFM9x(spi, CS, RESET, 915.0)
rfm9x.tx_power = 23
prev_packet = None
#ADDED FOR DUPLICATION CORRECTION
prevOrigins = []
currOrigin = tuple()
isDuplicate = False
#Instatiate a global variable 'persons_counter' to determine number of people detected
#Starting at 0 upon main call
persons_counter = 0
def classify_frame(net, inputQueue, outputQueue):
# keep looping
import digitalio
import adafruit_rfm9x
# Define radio parameters.
RADIO_FREQ_MHZ = 915.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.
# set GPIO pins as necessary - this example is for Raspberry Pi
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)
# enable CRC checking
rfm9x.enable_crc = True
# set delay before transmitting ACK (seconds)
rfm9x.ack_delay = 0.1
# set node addresses
rfm9x.node = 2
rfm9x.destination = 1
# initialize counter
counter = 0
ack_failed_counter = 0
# Wait to receive packets.
print("Waiting for packets...")
while True:
# Initialize a requests object with a socket and esp32spi interface
requests.set_socket(socket, esp)
# lora
import adafruit_rfm9x
TIMEOUT = 5
lora_spi = busio.SPI(board.D13, MOSI=board.D11, MISO=board.D12)
cs = digitalio.DigitalInOut(board.D5)
reset = digitalio.DigitalInOut(board.D7)
rfm9x = adafruit_rfm9x.RFM9x(lora_spi, cs, reset, 915.0)
# bme280
i2c = busio.I2C(board.SCL, board.SDA)
bme280 = adafruit_bme280.Adafruit_BME280_I2C(i2c)
# change this to match the location's pressure (hPa) at sea level
bme280.sea_level_pressure = 1013.25
# main loop
index = 0
while True:
print("radio waiting ...")
import board
import time
import busio, digitalio
import adafruit_rfm9x
# Configure SD card (b/c it's on the the same SPI bus as radios)
sdcs = digitalio.DigitalInOut(board.CS_SD)
sdcs.switch_to_output(value=True)
# Define radios
rf_cs1 = digitalio.DigitalInOut(board.RF1_CS)
rf_rst1 = digitalio.DigitalInOut(board.RF1_RST)
rf_cs1.switch_to_output(value=True)
rf_rst1.switch_to_output(value=True)
rf_cs2 = digitalio.DigitalInOut(board.RF2_CS)
rf_rst2 = digitalio.DigitalInOut(board.RF2_RST)
rf_cs2.switch_to_output(value=True)
rf_rst2.switch_to_output(value=True)
# Setup SPI bus
spi = busio.SPI(board.SCK,MOSI=board.MOSI,MISO=board.MISO)
# Initialize radio
try:
radio1 = adafruit_rfm9x.RFM9x(spi, rf_cs2, rf_rst2, 433.0)
except Exception as e:
print('[ERROR][RADIO 1]',e)
count = 0
radio1.tx_power = 23
while True:
radio1.send('hello world {}'.format(count))
count += 1
print(count)
time.sleep(1)
if speed > 0:
speed += MIN_SPEED
elif speed < 0:
speed -= MIN_SPEED
return speed * self.speed_multiplier
def set_wheel_speed(self, signed_control_byte):
self.motor.throttle = self.convert_byte_to_throttle(signed_control_byte)
i2c = board.I2C()
servokit = ServoKit(channels=16)
#initialize LoRa radio
spi = busio.SPI(board.SCK, MOSI=board.MOSI, MISO=board.MISO)
radio_nss = DigitalInOut(board.A5)
radio_reset = DigitalInOut(board.A4)
radio = adafruit_rfm9x.RFM9x(spi, radio_nss, radio_reset, 915.0)
##initialize left gripper
left_gripper_sensor = DigitalInOut(board.D12)
left_gripper_sensor.direction = Direction.INPUT
left_gripper_sensor.pull = Pull.DOWN
left_gripper = Gripper(servokit.servo[LEFT_GRIPPER_SERVO],left_gripper_sensor)
##initialize right gripper
right_gripper_sensor = DigitalInOut(board.D13)
right_gripper_sensor.direction = Direction.INPUT
right_gripper_sensor.pull = Pull.DOWN
right_gripper = Gripper(servokit.servo[RIGHT_GRIPPER_SERVO],right_gripper_sensor)
##initialize wheel motors
ain1 = pulseio.PWMOut(board.D5)
import random import threading RADIO_FREQ_MHZT = 868.0 # Frequency of the radio in Mhz. Must match your RADIO_FREQ_MHZR = 869.0 CS = digitalio.DigitalInOut(board.CE1) RESET = digitalio.DigitalInOut(board.D25) CS2 = digitalio.DigitalInOut(board.D17) RESET2 = digitalio.DigitalInOut(board.D5) spiR = busio.SPI(board.SCK, MOSI=board.MOSI, MISO=board.MISO) spiT = busio.SPI(board.D21, MOSI=board.D20, MISO=board.D19) rfm9xR = adafruit_rfm9x.RFM9x(spiR, CS, RESET, RADIO_FREQ_MHZR) rfm9xT = adafruit_rfm9x.RFM9x(spiT, CS2, RESET2, RADIO_FREQ_MHZT) # Radio 1: Transmitter # enable CRC checking #rfm9xT.enable_crc = True rfm9xT.node = 4 rfm9xT.destination = 3 rfm9xT.tx_power = 5 rfm9xT.spreading_factor = 10 rfm9xT.ack_retries = 1 #rfm9xT.signal_bandwidth = 125000 counterT = 0 # Radio 2: Receiver NOT WOKRING # enable CRC checking
'passwd': config['APRS']['Passcode'],
'host': config['APRS'].get('Host', fallback='rotate.aprs.net'),
'port': config['APRS'].getint('Port', fallback=14580)
}
AIS = APRS_IS(config['APRS']['Callsign'], **connect_kwargs)
try:
# Configure LoRA model pins
CS = digitalio.DigitalInOut(
getattr(board, config['LORA'].get("PinCS", "CE0")))
RESET = digitalio.DigitalInOut(
getattr(board, config['LORA'].get("PinReset", "D25")))
spi = busio.SPI(board.SCK, MOSI=board.MOSI, MISO=board.MISO)
# Create LoRa modem connection and configure it
rfm9x = adafruit_rfm9x.RFM9x(
spi, CS, RESET, config['LORA'].getfloat('Frequency', fallback=433.775))
rfm9x.signal_bandwidth = config['LORA'].getfloat('Bandwidth',
fallback=125000)
rfm9x.spreading_factor = config['LORA'].getint('SpreadingFactor',
fallback=12)
rfm9x.coding_rate = config['LORA'].getint('CodingRate', fallback=5)
rfm9x.enable_crc = True
# connect to APRS iGate
AIS.connect(blocking=True)
time.sleep(1)
gwpos = create_gateway_announcement()
logger.info('Announce Gateway: "%s"', gwpos)
AIS.sendall(gwpos) # TODO: announce regularly
#CS and reset are correct (we checked with meters)
cs = digitalio.DigitalInOut(board.P2_31)
reset = digitalio.DigitalInOut(board.P2_8)
mypin = digitalio.DigitalInOut(board.P2_25)
"""
mypin.direction = digitalio.Direction.OUTPUT
mypin.value = False
print("Should be low right now")
time.sleep(1)
mypin.value = True
"""
print(repr(board))
print(repr(adafruit_blinka.board.beagleboard.beaglebone_pocketbeagle))
sck = board.SCLK_1 #board.P2_29
mosi = board.MOSI_1 #board.P2_25
miso = board.MISO_1 #board.P2_27
spi = busio.SPI(sck, mosi, MISO=miso)
rfm9x = adafruit_rfm9x.RFM9x(spi, cs, reset, RADIO_FREQ_MHZ, baudrate=9600)
print(rfm9x)
rfm9x.node = ord("t")
while True:
packet = rfm9x.receive(keep_listening=True, with_header=True)
#receive(*, keep_listening=True, with_header=False, with_ack=False, timeout=None)
if packet is not None:
print("Received a pak")
else:
print("Packet was not recieved")
print(packet)
time.sleep(1)
# Define pins connected to the chip, use these if wiring up the breakout according to the guide:
CS = digitalio.DigitalInOut(board.D5)
RESET = digitalio.DigitalInOut(board.D6)
INT = digitalio.DigitalInOut(board.D24)
# Or uncomment and instead use these if using a Feather M0 RFM9x board and the appropriate
# CircuitPython build:
# CS = digitalio.DigitalInOut(board.RFM9X_CS)
# RESET = digitalio.DigitalInOut(board.RFM9X_RST)
# Define the onboard LED
LED = digitalio.DigitalInOut(board.D13)
LED.direction = digitalio.Direction.OUTPUT
# Initialze RFM radio
# Assume that CS is connected to channel 1, pin 7
rfm9x = adafruit_rfm9x.RFM9x(RESET, INT, 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
# 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!')
def __init__(self):
self.hardware = {
'IMU': False,
'Radio1': False,
'Radio2': False,
'SDcard': False,
'GPS': False,
'MRAM': False,
'WDT': False,
'USB': False,
'PWR': False,
}
# Define burn wires:
self._relayA = digitalio.DigitalInOut(board.RELAY_A)
self._relayA.switch_to_output(
drive_mode=digitalio.DriveMode.OPEN_DRAIN)
self._deployA = False
# Define battery voltage
self._vbatt = analogio.AnalogIn(board.BATTERY)
# Define MPPT charge current measurement
self._ichrg = analogio.AnalogIn(board.L1PROG)
# Define SPI,I2C,UART
self.i2c = busio.I2C(board.SCL, board.SDA)
self.spi = busio.SPI(board.SCK, MOSI=board.MOSI, MISO=board.MISO)
self.uart = busio.UART(board.TX, board.RX, baudrate=9600, timeout=10)
# Define GPS
self.en_gps = digitalio.DigitalInOut(board.EN_GPS)
self.en_gps.switch_to_output()
# Define sdcard
self._sdcs = digitalio.DigitalInOut(board.xSDCS)
self._sdcs.switch_to_output(value=True)
# Define radio
self._rf_cs1 = digitalio.DigitalInOut(board.RF1_CS)
self._rf_rst1 = digitalio.DigitalInOut(board.RF1_RST)
self._rf_cs1.switch_to_output(value=True)
self._rf_rst1.switch_to_output(value=True)
self._rf_cs2 = digitalio.DigitalInOut(board.RF2_CS)
self._rf_rst2 = digitalio.DigitalInOut(board.RF2_RST)
self._rf_cs2.switch_to_output(value=True)
self._rf_rst2.switch_to_output(value=True)
# Define MRAM (manual-mode)
# self._mram_cs = digitalio.DigitalInOut(microcontroller.pin.PB11)
# self._mram_cs.switch_to_output(value=True)
# Initialize Neopixel
try:
self.neopixel = neopixel.NeoPixel(board.NEOPIXEL,
1,
brightness=0.2,
pixel_order=neopixel.GRBW)
self.neopixel[0] = (0, 0, 0)
self.hardware['Neopixel'] = True
except Exception as e:
print('[WARNING][Neopixel]', e)
# Initialize USB charger
try:
self.usb = bq25883.BQ25883(self.i2c)
self.usb.charging = False
self.usb.wdt = False
self.usb.led = False
self.usb_charging = False
self.hardware['USB'] = True
except Exception as e:
print('[ERROR][USB Charger]', e)
# Initialize sdcard
try:
self._sd = adafruit_sdcard.SDCard(self.spi, self._sdcs)
self._vfs = storage.VfsFat(self._sd)
storage.mount(self._vfs, "/sd")
sys.path.append("/sd")
self.hardware['SDcard'] = True
except Exception as e:
print('[ERROR][SD Card]', e)
# Initialize Power Monitor
try:
self.pwr = adm1176.ADM1176(self.i2c)
self.pwr.sense_resistor = 1
self.hardware['PWR'] = True
except Exception as e:
print('[ERROR][Power Monitor]', e)
# Initialize IMU
try:
self.IMU = bmx160.BMX160_I2C(self.i2c)
self.hardware['IMU'] = True
except Exception as e:
print('[ERROR]', e)
# Initialize radio(s)
try:
self.radio1 = adafruit_rfm9x.RFM9x(self.spi, self._rf_cs1,
self._rf_rst1, 433.0)
self.hardware['Radio1'] = True
except Exception as e:
print('[ERROR][RADIO 1]', e)
try:
self.radio2 = adafruit_rfm9x.RFM9x(self.spi, self._rf_cs2,
self._rf_rst2, 433.0)
self.hardware['Radio2'] = True
except Exception as e:
print('[ERROR][RADIO 2]', e)
import board
# Import the SSD1306 module.
#import adafruit_ssd1306
# Import the RFM9x radio module.
import adafruit_rfm9x
import serial, string
CS = DigitalInOut(board.CE1)
RESET = DigitalInOut(board.D25)
spi = busio.SPI(board.SCK, MOSI=board.MOSI, MISO=board.MISO)
# spi.max_speed_hz=5000000
# while not spi.try_lock():
# pass
# spi.try_lock()
# spi.configure(baudrate=433000000, phase=0, polarity=0)
rfm9x = adafruit_rfm9x.RFM9x(spi, CS, RESET, 915.0, baudrate=1000000)
rfm9x.tx_power = 20
prev_packet = None
msg_count = 0;
output = " "
ser = serial.Serial('/dev/ttyACM0', 115200, 8, 'N', 1, timeout=1)
while True:
# packet = rfm9x.receive()
# ife_string = str(formula_electric)
data = bytes("ife_string", "utf-8")
output = ser.readline()
if output != " ":
print ("send " + str(msg_count))
rfm9x.send(output)
