transferencia de repo lora

Author: sasilva1998

README.md

@@ -0,0 +1,91 @@
+Estos códigos han sido recopilados de otro repositorio con el fin de mejorar su uso, para que el único script que se maneje como librería sea lora.py, será mejorado con el tiempo.
+Referencia: https://github.com/lemariva/uPyLora
+
+En el repositorio se puede encontrar:
+
+* códigos: contiene todos los scripts utilizados para dar uso del chip sx1276
+
+  * config_lora.py
+
+  * controller.py
+
+  * controller_esp32.py
+
+  * esp32lora.bin
+
+  * sx127x.py
+
+  * lora.py
+
+    De los cuales en el que nos concentramos es el de lora.py el cual tiene la clase con sus métodos, facilitando el uso del chip. Para este caso se ha especificado que la frecuencia usada es de 915 MHz, configurado en el archivo `sx127x.py`, en caso de que se desee una frecuencia distinta es necesario que sea cambiado en el script y luego volver ha formar el .bin o tan solo ingresar los scripts necesarios en el ESP.
+
+* ejemplos: contiene ejemplos sobre como debe ser usada la clase, para enviar y recibir datos, además de la subida de datos a un servicio web como el de ubidots.
+
+# lora.py
+
+Principalmente este archivo, se ha creado para instanciar un objeto especificado como LoRa, el cual tendra todos los metodos necesarios para enviar y recibir código. Los pines que se usan para la comunicación con el chip de LoRa son los mismo especificados en la documentación de HelTec y TTGO los cuales hacen placas de desarrollo con el microcontrolador ESP32 agregandole un chip sx127x con antena. A continuación se encontrará como usar la librería con sus métodos:
+
+## Construcción de clase LoRa
+
+El script contiene a LoRa el cual es una clase para poder inicializar el uso del chip sx127x. Se puede inicializar de la siguiente manera:
+
+~~~~ python
+from lora import LoRa
+
+lora = LoRa()
+
+#si se desea un filtrado de los mensajes
+lora = LoRa(header='header')
+~~~~
+
+Además para la recepción de datos periódicas la cual se maneja con el metodo de wait_msg(), se puede especificar un periodo, para que despues de haber llegado un mensaje, especificar cuanto tiempo se quiere que pase hasta recibir uno nuevo, de la siguiente manera:
+
+
+~~~~ python
+#sin header
+lora = LoRa(period=2)
+
+#con header
+lora= LoRa(header='header',period=2)
+~~~~
+
+## Metodos
+
+### send('mensaje', spheader = 'headerespecifico')
+
+Es el método especificado para enviar datos, de manera que el primer parametro es para especificar que dato se quiere enviar y el segundo en caso que se quiera mandar con un header específico.
+~~~~ python
+#sin header especifico
+lora.send('hola')
+
+#con header especifico
+lora.send('hola', spheader = 'headersp')
+~~~~
+La variables de un header especifico ha sido agregado en caso de que en algún momento se necesite enviar un mensaje con un header distinto o especifico.
+
+### set_callback(cb)
+
+Al igual que un objeto de mqtt para un subscribe, utilizamos el mismo concepto para callbacks, de manera que una vez instanciado el objeto de lora, se especifica que funcion se quiere que se ejecute cuando llegue un mensaje:
+
+~~~~ python
+#cb corresponde al nombre de la funcion usada como callback
+#que debe tener como parametro una variable que sera el mensaje
+lora.set_callback(cb)
+~~~~
+
+### wait_msg()
+~~~~ python
+lora.wait_msg()
+~~~~
+Una vez que ya esta especificado nuestro callback, wait_msg se encarga para que en segundo plano se escuche los mensajes entrantes y que nuestro callback se ejecute. En el caso de que en al instanciar la clase LoRa, se especifique un valor para la variable period, una vez que se recibe un mensaje, tendra que pasar el tiempo (en segundos) especificado para que otro mensaje sea aceptado.
+
+### receive_msg()
+~~~~ python
+lora.receive_msg()
+~~~~
+Parecido a wait_msg() se encarga de recibir un mensaje en un momento especifico, por una sola vez y se ejecuta el callback cuando llegue el mensaje.
+
+
+# Licencia
+
+<a rel="license" href="http://creativecommons.org/licenses/by-sa/4.0/"><img alt="Licencia de Creative Commons" style="border-width:0" src="https://i.creativecommons.org/l/by-sa/4.0/88x31.png" /></a><br /><span xmlns:dct="http://purl.org/dc/terms/" property="dct:title">uPyLoRa</span> by <a xmlns:cc="http://creativecommons.org/ns#" href="https://github.com/FunPythonEC/LibreriasDesarrolladas/tree/master/uPyLoRa" property="cc:attributionName" rel="cc:attributionURL">Steven Silva</a> is licensed under a <a rel="license" href="http://creativecommons.org/licenses/by-sa/4.0/">Creative Commons Reconocimiento-CompartirIgual 4.0 Internacional License</a>.<br />Creado a partir de la obra en <a xmlns:dct="http://purl.org/dc/terms/" href="https://github.com/lemariva/uPyLora" rel="dct:source">https://github.com/lemariva/uPyLora</a>.

codigos/config_lora.py

@@ -0,0 +1,18 @@
+import sys
+import os
+import time
+import machine
+import ubinascii
+
+def mac2eui(mac):
+    mac = mac[0:6] + 'fffe' + mac[6:]
+    return hex(int(mac[0:2], 16) ^ 2)[2:] + mac[2:]
+
+def get_millis():
+    millisecond = time.ticks_ms()
+    return millisecond
+
+def get_nodename():
+    uuid = ubinascii.hexlify(machine.unique_id()).decode()
+    node_name = "ESP_" + uuid
+    return node_name

codigos/controller.py

@@ -0,0 +1,126 @@
+from time import sleep
+
+
+class Controller:
+
+    class Mock:
+        pass
+
+    ON_BOARD_LED_PIN_NO = None
+    ON_BOARD_LED_HIGH_IS_ON = True
+    GPIO_PINS = []
+
+    PIN_ID_FOR_LORA_RESET = None
+
+    PIN_ID_FOR_LORA_SS = None
+    PIN_ID_SCK = None
+    PIN_ID_MOSI = None
+    PIN_ID_MISO = None
+
+    PIN_ID_FOR_LORA_DIO0 = None
+    PIN_ID_FOR_LORA_DIO1 = None
+    PIN_ID_FOR_LORA_DIO2 = None
+    PIN_ID_FOR_LORA_DIO3 = None
+    PIN_ID_FOR_LORA_DIO4 = None
+    PIN_ID_FOR_LORA_DIO5 = None
+
+
+    def __init__(self,
+                 pin_id_led = ON_BOARD_LED_PIN_NO,
+                 on_board_led_high_is_on = ON_BOARD_LED_HIGH_IS_ON,
+                 pin_id_reset = PIN_ID_FOR_LORA_RESET,
+                 blink_on_start = (2, 0.5, 0.5)):
+
+        self.pin_led = self.prepare_pin(pin_id_led)
+        self.on_board_led_high_is_on = on_board_led_high_is_on
+        self.pin_reset = self.prepare_pin(pin_id_reset)
+        self.reset_pin(self.pin_reset)
+        self.transceivers = {}
+        self.blink_led(*blink_on_start)
+
+
+    def add_transceiver(self,
+                        transceiver,
+                        pin_id_ss = PIN_ID_FOR_LORA_SS,
+                        pin_id_RxDone = PIN_ID_FOR_LORA_DIO0,
+                        pin_id_RxTimeout = PIN_ID_FOR_LORA_DIO1,
+                        pin_id_ValidHeader = PIN_ID_FOR_LORA_DIO2,
+                        pin_id_CadDone = PIN_ID_FOR_LORA_DIO3,
+                        pin_id_CadDetected = PIN_ID_FOR_LORA_DIO4,
+                        pin_id_PayloadCrcError = PIN_ID_FOR_LORA_DIO5):
+        transceiver.blink_led = self.blink_led
+        transceiver.pin_ss = self.prepare_pin(pin_id_ss)
+        transceiver.pin_RxDone = self.prepare_irq_pin(pin_id_RxDone)
+        transceiver.pin_RxTimeout = self.prepare_irq_pin(pin_id_RxTimeout)
+        transceiver.pin_ValidHeader = self.prepare_irq_pin(pin_id_ValidHeader)
+        transceiver.pin_CadDone = self.prepare_irq_pin(pin_id_CadDone)
+        transceiver.pin_CadDetected = self.prepare_irq_pin(pin_id_CadDetected)
+        transceiver.pin_PayloadCrcError = self.prepare_irq_pin(pin_id_PayloadCrcError)
+
+        self.spi = self.prepare_spi(self.get_spi())
+        transceiver.transfer = self.spi.transfer
+
+        transceiver.init()
+
+        self.transceivers[transceiver.name] = transceiver
+        return transceiver
+
+
+    def prepare_pin(self, pin_id, in_out = None):
+        reason = '''
+            # a pin should provide:
+            # .pin_id
+            # .low()
+            # .high()
+            # .value()  # read input.
+            # .irq()    # (ESP8266/ESP32 only) ref to the irq function of real pin object.
+        '''
+        raise NotImplementedError(reason)
+
+
+    def prepare_irq_pin(self, pin_id):
+        reason = '''
+            # a irq_pin should provide:
+            # .set_handler_for_irq_on_rising_edge()  # to set trigger and handler.
+            # .detach_irq()
+        '''
+        raise NotImplementedError(reason)
+
+
+    def get_spi(self):
+        reason = '''
+            # initialize SPI interface
+        '''
+        raise NotImplementedError(reason)
+
+
+    def prepare_spi(self, spi):
+        reason = '''
+            # a spi should provide:
+            # .close()
+            # .transfer(pin_ss, address, value = 0x00)
+        '''
+        raise NotImplementedError(reason)
+
+
+    def led_on(self, on = True):
+        self.pin_led.high() if self.on_board_led_high_is_on == on else self.pin_led.low()
+
+
+    def blink_led(self, times = 1, on_seconds = 0.1, off_seconds = 0.1):
+        for i in range(times):
+            self.led_on(True)
+            sleep(on_seconds)
+            self.led_on(False)
+            sleep(off_seconds)
+
+
+    def reset_pin(self, pin, duration_low = 0.05, duration_high = 0.05):
+        pin.low()
+        sleep(duration_low)
+        pin.high()
+        sleep(duration_high)
+
+
+    def __exit__(self):
+        self.spi.close()

codigos/controller_esp32.py

@@ -0,0 +1,110 @@
+from machine import Pin, SPI, reset
+from controller import Controller
+
+
+class ESP32Controller(Controller):
+
+    # LoRa config
+    PIN_ID_FOR_LORA_RESET = 14
+
+    PIN_ID_FOR_LORA_SS = 18
+    PIN_ID_SCK = 5
+    PIN_ID_MOSI = 27
+    PIN_ID_MISO = 19
+
+    PIN_ID_FOR_LORA_DIO0 = 26
+    PIN_ID_FOR_LORA_DIO1 = None
+    PIN_ID_FOR_LORA_DIO2 = None
+    PIN_ID_FOR_LORA_DIO3 = None
+    PIN_ID_FOR_LORA_DIO4 = None
+    PIN_ID_FOR_LORA_DIO5 = None
+
+
+    # ESP config
+    ON_BOARD_LED_PIN_NO = 2
+    ON_BOARD_LED_HIGH_IS_ON = True
+    GPIO_PINS = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
+                 12, 13, 14, 15, 16, 17, 18, 19, 21, 22,
+                 23, 25, 26, 27, 32, 34, 35, 36, 37, 38, 39)
+
+
+    def __init__(self,
+                 pin_id_led = ON_BOARD_LED_PIN_NO,
+                 on_board_led_high_is_on = ON_BOARD_LED_HIGH_IS_ON,
+                 pin_id_reset = PIN_ID_FOR_LORA_RESET,
+                 blink_on_start = (2, 0.5, 0.5)):
+
+        super().__init__(pin_id_led,
+                         on_board_led_high_is_on,
+                         pin_id_reset,
+                         blink_on_start)
+
+
+    def prepare_pin(self, pin_id, in_out = Pin.OUT):
+        if pin_id is not None:
+            pin = Pin(pin_id, in_out)
+            new_pin = Controller.Mock()
+            new_pin.pin_id = pin_id
+            new_pin.value = pin.value
+
+            if in_out == Pin.OUT:
+                new_pin.low = lambda : pin.value(0)
+                new_pin.high = lambda : pin.value(1)
+            else:
+                new_pin.irq = pin.irq
+
+            return new_pin
+
+
+    def prepare_irq_pin(self, pin_id):
+        pin = self.prepare_pin(pin_id, Pin.IN)
+        if pin:
+            pin.set_handler_for_irq_on_rising_edge = lambda handler: pin.irq(handler = handler, trigger = Pin.IRQ_RISING)
+            pin.detach_irq = lambda : pin.irq(handler = None, trigger = 0)
+            return pin
+
+
+    def get_spi(self):
+        spi = None
+
+        try:
+            spi = SPI(baudrate = 10000000, polarity = 0, phase = 0, bits = 8, firstbit = SPI.MSB,
+                      sck = Pin(self.PIN_ID_SCK, Pin.OUT, Pin.PULL_DOWN),
+                      mosi = Pin(self.PIN_ID_MOSI, Pin.OUT, Pin.PULL_UP),
+                      miso = Pin(self.PIN_ID_MISO, Pin.IN, Pin.PULL_UP))
+            #spi.init()
+
+        except Exception as e:
+            print(e)
+            if spi:
+                spi.deinit()
+                spi = None
+            reset()  # in case SPI is already in use, need to reset.
+
+        return spi
+
+
+    def prepare_spi(self, spi):
+
+        if spi:
+            new_spi = Controller.Mock()
+
+            def transfer(pin_ss, address, value = 0x00):
+                response = bytearray(1)
+
+                pin_ss.low()
+
+                spi.write(bytes([address]))
+                spi.write_readinto(bytes([value]), response)
+
+                pin_ss.high()
+
+                return response
+
+            new_spi.transfer = transfer
+            new_spi.close = spi.deinit
+            return new_spi
+
+
+    def __exit__(self):
+        self.spi.close()