Lopy with pytrack, how connect/use GPS?

livius

@zceld said in Lopy with pytrack, how connect/use GPS?:
touple is not buffered
you need bytes you can try to cast this as bytes() but for lora better is using pack.
look at samples about lora in official docs https://docs.pycom.io/

Time you can update from wifi connection
by e.g.

rtc.ntp_sync("pool.ntp.org")

or retrive it from GPS
or some external device for DCF or MSF

crumble

@zceld

But and the altitude?
The time can be updated?

If you look into the code of the library you will see, that only the coordinates are read from the GPS. No altitude and no dateTime.

The time information is read from WiFi. You will need access to an NTP server.

The sentence which is used to get the coordinates contains the time as well, but not the date. If you need only the time, you can simply add this to the library.

For date and time you have to add support for parsing additional NMEA sentences.

livius

@crumble
better use existing one
https://github.com/livius2/micropyGPS
and exctend it if needed

zceld

@livius
Thank you very much for the recommendation but using 'microGPS' gives me a lack of memory again.

On the other hand I do not know if to take advantage of this post or open another one. It is on the subject LoRa that I do not understand very well the programming examples. I am using this one.

Using a board in sending mode, and another in receiver mode, I do not understand why there are messages sent by LoRa that are lost or not picked up by the receiver.
This captur reciver:

transmitter:
print:
identifier-identifier-counter-longitude-latitude

As you can see in the image of the receiver, it goes from counter 7 to 10 and has lost message 8 and 9

issuer code:

import machine
import math
import network
import os
import time
import utime
import pycom
from machine import RTC
from machine import SD
from machine import Timer
from L76GNSS import L76GNSS
from pytrack import Pytrack

from network import LoRa
import socket                                                                 
lora = LoRa(mode=LoRa.LORA)                                                  
s = socket.socket(socket.AF_LORA, socket.SOCK_RAW)                   
# setup as a station

import gc

time.sleep(2)
gc.enable()

# setup rtc
rtc = machine.RTC()
rtc.ntp_sync("pool.ntp.org")
utime.sleep_ms(750)
print('\nRTC Set from NTP to UTC:', rtc.now())
utime.timezone(7200)
print('Adjusted from UTC to EST timezone', utime.localtime(), '\n')
py = Pytrack()
l76 = L76GNSS(py, timeout=30)
chrono = Timer.Chrono()
chrono.start()
j=0 #accountant
while (True):

    coord = l76.coordinates()

    #Codigo Personalizado para enviar por LoRa Posicon:
    x = "witeklab-"+"12345678Z-"+str(j)+"-"+str(coord[0]) + "-"+str(coord[1])
    s.setblocking(True)
    s.send(x)
    print(x)
    time.sleep(2) #Pausa entre toma de coordenadas.
    j=1+j

receiver code:

from network import LoRa
import socket
import machine
import time
import pycom

# initialize LoRa in LORA mode
# more params can also be given, like frequency, tx power and spreading factor
lora = LoRa(mode=LoRa.LORA)

# create a raw LoRa socket
s = socket.socket(socket.AF_LORA, socket.SOCK_RAW)

while True:
    # send some data
    for x in range(5):

      s.setblocking(False)
      data = s.recv(64)
      time.sleep(0.1)
      print(data)

crumble

@zceld LoRa is like a radio in citizen band. Anyone can send messages around and all have to listen to them. So you may receive data from other devices as well.

Too solve your specific problem you shall set in your receiver blocking to true. This will wait until you reveived a message. If it is false it will not wait to receive a message in line `data = s.recv(64)
So it will continue with an empty string, because it has not received a message.

Setting blocking mode to false is useful, if you want to run your loop until you received a certain message. Setting it to true is useful if you want to start the loop after you received a message.

If you have only nonblocking calls and you want to wait for a message, you have to call it in a loop until something receives. This will need a lot of battery power.

If you want to run a loop until you receive a certain message and you have only blocking calls, you have to use multi threading to solve this problem. This will not consume much battery power, but it makes your code more complex.

livius

@zceld said in Lopy with pytrack, how connect/use GPS?:

Thank you very much for the recommendation but using 'microGPS' gives me a lack of memory again.

When and where do you create microGPS object instance?

zceld

@crumble
I am very interested in what you say, because what really interests me is that the Lora system is in a listening mode until I receive a message, when we receive a message we can do something specific.

So a possible solution would be changing s.setblocking (True) like this?:

from network import LoRa
import socket
import machine
import time
import os
import pycom

lora = LoRa(mode=LoRa.LORA)

while True:
      s.setblocking(True)
      data = s.recv(64) 
      print(data)

zceld

@livius

Well no, I just ran microGPS as if it were the main. So you want to say that microGPS is a library and that to give me the coordinates I should develop a code like this one but with the library 'microGPS'?

Example code:

import machine
import math
import network
import os
import time
import utime
import pycom
from machine import RTC
from machine import SD
from machine import Timer
from L76GNSS import L76GNSS
from pytrack import Pytrack
#send with LoRa:
from network import LoRa
import socket                                                    
lora = LoRa(mode=LoRa.LORA)                                                  
s = socket.socket(socket.AF_LORA, socket.SOCK_RAW)                

# setup as a station
import gc
gc.enable()

# setup rtc
rtc = machine.RTC()
rtc.ntp_sync("pool.ntp.org")
utime.sleep_ms(750)
print('\nRTC Set from NTP to UTC:', rtc.now())
utime.timezone(7200)
print('Adjusted from UTC to EST timezone', utime.localtime(), '\n')
py = Pytrack()
l76 = L76GNSS(py, timeout=30)
chrono = Timer.Chrono()
chrono.start()

while (True):

    coord = l76.coordinates()

crumble

@zceld said in Lopy with pytrack, how connect/use GPS?:

So a possible solution would be changing s.setblocking (True) like this?:

Yes. You need to set it only once outside the loop:

s = socket.socket(socket.AF_LORA, socket.SOCK_RAW)
s.setblocking(True)
while True:
   data = s.recv(64) 
   print(data)

zceld

@crumble

Great! thank you very much. Now I just need to be able to connect via Wi-Fi directly to Lopy, I do not know what the password is:

crumble

@zceld

here you will find the passowrd

https://docs.pycom.io/chapter/toolsandfeatures/repl/telnet.html

zceld

good morning everyone

I already have a question in the ink, I've been looking and I have not seen anything clear about the plate. Therefore I take my post of doubts.

Someone could explain to me what changes if you have write the function:

s.setblocking (True)
#or
s.setblocking (False)

??

Thanks, greetings in advance!

By the way, I already managed to connect via wifi @crumble

zceld

On the other hand, I have the insecurity that I never know how long it will take to find GPS the pytrack ... sometimes they connect in 2 minutes, other times in 15 and then cases like today that I have been without signal for the whole afternoon...

Code:

import machine
import math
import network
import os
import time
import utime
import pycom
from machine import RTC
from machine import SD
from machine import Timer
from L76GNSS import L76GNSS
from pytrack import Pytrack
#send with LoRa:
from network import LoRa
import socket                                                    
lora = LoRa(mode=LoRa.LORA)                                                  
s = socket.socket(socket.AF_LORA, socket.SOCK_RAW)                

# setup as a station
import gc
gc.enable()

# setup rtc
rtc = machine.RTC()
rtc.ntp_sync("pool.ntp.org")
utime.sleep_ms(750)
print('\nRTC Set from NTP to UTC:', rtc.now())
utime.timezone(7200)
print('Adjusted from UTC to EST timezone', utime.localtime(), '\n')
py = Pytrack()
l76 = L76GNSS(py, timeout=30)
chrono = Timer.Chrono()
chrono.start()

while (True):

    coord = l76.coordinates()

Result:

crumble

@zceld You are inside a building, right? In this case you are lucky, that you receive enough signals. So bad weather conditions, more people in the floors above you, other radio signals, other set of satalites visible for your device, will influence, if you get a signal.

Without an external antenna you have to ways to solve this problem.

Move the device to a place with better signal quality
Add a layer to your program, so you can choose between real sensor data and test data.

Or try a soft reboot (ctrl-d). The last time I tested it, the GPS chip got a fix after reboot. Maybe it was only a coincidence ;)

zceld

@crumble
If in it is quite unlikely to get a good signal inside a building, in fact with the smartphone many times it is not able to catch coverage. But since the LoPy with the Pytrack has always ended up taking me, it was strange to me that today I do not.

I tried the ctrl + d but it has not had an effect. Thank you very much for the info.

On the subject of :
s.setblocking (True)
#or
s.setblocking (False)

would you explain to me how it works?
I have done these tests but they do not convince me:

while (True):
    s.setblocking(True)
    coord = l76.coordinates()

    x = "hi-"+str(j)+"-"+"12345678Z-"+str(coord[0]) + "-"+str(coord[1])
    p = str(coord[0])
    if p =='None':
        pycom.rgbled(0x7f0000)
        time.sleep(0.5)
        pycom.heartbeat(False)
        print("Buscando -",nintentos)
        nintentos+=1
    else:
        s.send(x)
        pycom.rgbled(0xfffe02)
        time.sleep(0.1)
        pycom.heartbeat(False)
        print(x)
        j+=1    
        time.sleep(20) #Pausa entre toma de coordenadas.


    alertas=[]
    s.setblocking(False)
    data = s.recv(64)
    time.sleep(3) 


    
      
    ide =data.decode("utf-8")  
    ide = ide.split('-')
    if ide[0] == 'alerta':
        for x in range (1,3):
            pycom.rgbled(0xC011EB)#Lila  
            time.sleep(0.1)  
            pycom.heartbeat(False)
            time.sleep(0.1) 
        if ide[1] not in alertas:
            alertas.append(ide[1])
            for x in range (1,3):
                pycom.rgbled(0x0007F)#Azul
                time.sleep(1)
                pycom.heartbeat(False)
                time.sleep(0.1)

The idea of operation is that every 20 seconds approximately, make one get the GPS position and send it by LoRa.

time.sleep(20)

Done that you hear if you are sending a message then I put s.setblocking (False) that I understand that in this mode will listen for 3 seconds:

    alertas=[]
    s.setblocking(False)
    data = s.recv(64)
    time.sleep(3)

Surely you have a better approach to programming or a different method, and that is what I have been able to do with what I think each command s.setblocking () does

crumble

@zceld

If you have something like

while True:
    result = s.recv(256)
    print(result)

and you run it in setblocking(True) mode, the program will wait on the line result = s.resv(256) until it received a message and will then continue. So result will always contains someting you received from the aether. Either from your LoPy or another device. So you shall not forget to check the content before controling some other hardware like servos, etc.

if you run the same loop with setblocking(False) it will not wait. It will directly go to the next line. So you will most of the time get your empty lines, because no one has send someting.

You can use this for easy control your program. If you want to open a door when someone sends a message you will use setblocking(True)

s.setblocking(True)
while True:
    result = s.recv(256)
    if result.equals('Open door'):
         OpenTheDoor()

If you use this with setblocking(False) it will not be that dangerous, because the if guards the door unless someone sends the right message. But it will use a lot of power, because it will run the loop without any pause. This can be really bad, if you run your device by battery. So you may have to charge your device every day instead of once a week,

If you want to stop something when someone sends you a stop message you would to something like this:

s.setblocking(False)
stopMessage = ''
while stopMessage != 'stop'
    toggleLED()
    stopMessage = s.recv(256)

setblocking(True) would be a bad idea, becaus the recv call would wait until someone sends a message. So your LED would change only its state when someone is sending a messages. With setblocking(False) you will see it blinking until someone sends the right message.

zceld

@crumble

Thank you very much! , very kind, you got me out of doubt.
There would be a way to program it to stay listening in mode:

x = "no messages"
s.setblocking (true)
data = s.recv (256)
time.sleep (20)

if data! = ''
    print (data)
else
    s.send (x)

In plan, be listening if there is any message for 20 seconds. but at the end of this time, make another function and then listen again.

crumble

@zceld
this code will wait infinite for a message and wait additional 20 (milli?)seconds. If you want to use blocking sockets, you have to set the timeout for a socket. I never used them by myself. Browse in the documentation for:

socket.settimeout(value)

Or you use it as nonblocking and use the receive together with the sleep in a loop.

zceld

@crumble
On the subject server, I had this code that I would say that I used to run and be able to access Lopy via Filezilla FTP but today it does not work for me.

There may be something I'm missing or what can it be?


import network
import time
from network import WLAN
# setup as a station
wlan = network.WLAN(mode=network.WLAN.STA)
wlan.init(mode=WLAN.AP, ssid='Gateway', auth=(WLAN.WPA2,'witeklab@2018'), channel=7, antenna=WLAN.INT_ANT)

zceld

@crumble @livius @seb

Recommendation of the process to be programmed (I am noob):
Ok, I explain the situation. With the chip Lopy and Pytrack I pick up the gps position of a vehicle and send it through LoRa to another board located at home that collects the data by LoRa and saves it to me in a file.txt.

From the board at home I have activated server mode to connect by FTP and download the file.txt that is accumulating positions and that I download on my computer and from a file.php that saves the data in an array to track .

So I know how to do it like that, but it's a tedious job to have to connect, download the file. the ideal idea would be to automate it but I can not think of how.

I do not know if I could program by php / JavaScript or any language that will connect to the FTP of the Lopy every 'x' time and download and read the file atomically or vice versa that Lopy will send an IP of the network that connects this file every some time.

What do you recommend or what options can I take to automate the process?

Thank you very much as always you are fantastic !.

Explore Pybytes | Official Documentation | Report a Firmware Bug/Issue | GitHub

Lopy with pytrack, how connect/use GPS?

Pycom on Twitter