Lopy GPS/DHT/RFiD

[gas]

Hi all
so now that I have my Lopy working with my own LoraWan network (based on RPi+ic880 and Loraserver+ mainflux)
I wanted to add sensors to the Lopy
is there already a DHT library
a GPS library ? I connected my GPS (I didn't get any pytrack yet) sensors through UART but there is no sentence support for the reading I found a python micropython lib called micropyGPS but I'm still having issue with the lib

any suggestion are welcome

I'll share some of the code later (from Lora or LoraWAN to mqtt server)

[affoltep]

@100rabhh : Just put these lines to your code:

from nmeaParser import NmeaParser

#Create NMEA structure
nmea = NmeaParser()

#..then send your uart input to the library
 if gps_uart.any():
        nmea.update(gps_uart.readline())

#...then you can access your data by
print ('Latitude: ' + str(nmea.latitude))
print ('Longitude: ' + str(nmea.longitude))
print('Altitude:'+ str(nmea.altitude))

#...there are several other data available, just check the parser code for more info

[100rabhh]

@affoltep Hi, How can i use it with my code?

Here is my simple receive code for Adafruit Ultimate Breakout GPS----

from machine import Pin
from machine import UART

#Interface definitons for GPS
gps_pps = Pin('P23', mode = Pin.IN)
gps_enable = Pin('P8', mode=Pin.OUT)
gps_enable(False)
#gps_uart = UART(2, 9600)
#gps_uart.init(9600, bits=8, parity=None, stop=1)
gps_uart = UART(2, baudrate=9600, bits=8, parity=None, stop=1, pins=('P10', 'P11'))
uart.write('abs')
gps_enable(True)
while True:
if gps_uart.any():
print(gps_uart.readline())

Here i am simply reading the strings from GPS Rx. Now how do i implement in your code to parse it? Please help...

[gas]

Cool the GPS part work well
Beside DHT11 that is reading all the time zero all the other are working well
PIR, RFId, GPS, Distnace , all this with Lora working to send the messages
Next is accelerometer MPU 92/65

[affoltep]

@johnmcdnz Cool, thanks - in case it still doesn't work, feel free to come to this quarter, spring is starting here ;o)

[johnmcdnz]

@affoltep The NmeaParser codes works really well (almost) :-)

I've been using it this weekend, and discovered a minor flaw, and have fix for you.
The code ignores the S/W hemispheres, so will only be correct for 1/4 of the planet.

This change provides the correction
# Update Object Data
self.latitude = lat_degs + (lat_mins/60)
if lat_hemi == 'S':
self.latitude = -self.latitude
self.longitude = lon_degs + (lon_mins/60)
if lon_hemi == 'W':
self.longitude = -self.longitude

Good job I can test in the Southern hemisphere and spot the problem!

Once I have my project working I'll post on github.

[johnmcdnz]

@Movsun I changed the name to DHT22RinusW-call.py. Described in the readme.

[gas]

I never got the dht working I get always 28025 which is the zero values
not sure id there are other action or I'm missing soemthing from teh library DHT itself

>>> import DHT
>>> dht_pin=Pin('P19', Pin.OPEN_DRAIN)
>>> dht_pin(1)
>>> temp, hum = DHT.DHT11(dht_pin)
>>> temp_str = '{}.2{}'.format(temp//10,temp%10)
>>> hum_str = '{}.2{}'.format(hum//10,hum%10)
>>> print("sending Temp/Hum : %s/%s" % (temp_str,hum_str))
sending Temp/Hum : 280.25/280.25

[Movsun]

@johnmcdnz
Hello, I look into your github repository. But I count not find DHT22RinusW.py file.
Where can I find the file? Thank you in advance.

[affoltep]

@gas I wrote a minimalistic NMEA parser, based on micropyGPS, which parses just the GPGGA messages. This message delivers lon, lat, alt, hdop and UTC. Feel free to use it.

#Minimalistic NMEA-0183 message parser, based on micropyGPS
#Version 0.1 - January 2017
#Autor: Peter Affolter
import utime


class NmeaParser(object):
    """NMEA Sentence Parser. Creates object that stores all relevant GPS data and statistics.
    Parses sentences using update(). """
    
    def __init__(self):
        """Setup GPS Object Status Flags, Internal Data Registers, etc"""

        #####################
        # Data From Sentences
        # Time
        self.utc = (0)
        
        # Object Status Flags
        self.fix_time = 0
        self.valid_sentence = False

        # Position/Motion
        self.latitude = 0.0
        self.longitude = 0.0
        self.altitude = 0.0

        # GPS Info
        self.satellites_in_use = 0
        self.hdop = 0.0
        self.fix_stat = 0
        
        #raw data segments
        self.nmea_segments = []

    def update(self,  sentence):
        self.valid_sentence = False
        self.nmea_segments = str(sentence).split(',')
       
        #Parse GPGGA
        if (self.nmea_segments[0] == "b'$GPGGA"):
            self.valid_sentence = True
            try:
                # UTC Timestamp
                 utc_string = self.nmea_segments[1]
                 
                # Skip timestamp if receiver doesn't have on yet
                 if utc_string:
                    hours = int(utc_string[0:2])
                    minutes = int(utc_string[2:4])
                    seconds = float(utc_string[4:])
                 else:
                    hours = 0
                    minutes = 0
                    seconds = 0.0
                    
                 # Number of Satellites in Use
                 satellites_in_use = int(self.nmea_segments[7])

                 # Horizontal Dilution of Precision
                 hdop = float(self.nmea_segments[8])

                 # Get Fix Status
                 fix_stat = int(self.nmea_segments[6])
            except ValueError:
                return False
            
         # Process Location and Speed Data if Fix is GOOD
            if fix_stat:
                # Longitude / Latitude
                try:
                    # Latitude
                    l_string = self.nmea_segments[2]
                    lat_degs = float(l_string[0:2])
                    lat_mins = float(l_string[2:])

                    # Longitude
                    l_string = self.nmea_segments[4]
                    lon_degs = float(l_string[0:3])
                    lon_mins = float(l_string[3:])
                except ValueError:
                    return False
        
                # Altitude / Height Above Geoid
                try:
                    altitude = float(self.nmea_segments[9])
                    geoid_height = float(self.nmea_segments[11])
                except ValueError:
                    return False
                    
                # Update Object Data
                self.latitude = lat_degs + (lat_mins/60)
                self.longitude = lon_degs + (lon_mins/60)
                self.altitude = altitude
                self.geoid_height = geoid_height
                
            # Update Object Data
            self.timestamp = (hours, minutes, seconds)
            self.satellites_in_use = satellites_in_use
            self.hdop = hdop
            self.fix_stat = fix_stat
        
            # If Fix is GOOD, update fix timestamp
            if fix_stat:
                self.fix_time = utime.time()

            return True

[johnmcdnz]

I have connected the DHT22 sensor and had working very well. My code and description is here. Pay attention to the sample size change I made and that I had to adjust the bit sampling. Using the print statements to debug and understanding the one wire protocol can help in fine tuning the data conversion. Hope this helps.
https://github.com/johnmcdnz/LoPy-DHT-transmission