def  uart_hash():
	#  initialize UART(6) to output TX on Pin Y1
	uart = UART(6)
	while True:
		uart.init(9600, bits=8, parity = 0, stop = 2)
		uart.writechar(ord('#'))		# letter '#'
		pyb.delay(5)					# delay by 5ms

class lcd():
    def __init__(self,uart=3):
        #UART serial
        self.lcd = UART(uart, 115200)  # init with given baudrate

        #set lcd to same baudrate
        b = bytearray(3)
        b[0] = 0x7C
        b[1] = 0x07
        b[2] = 0x36
        self.lcd.write(b)

        #set background duty
        b = bytearray(3)
        b[0] = 0x7C
        b[1] = 0x02
        b[2] = 80
        self.lcd.write(b)

    def clear(self):
        b = bytearray(2)
        b[0] = 0x7c
        b[1] = 0x00
        self.lcd.write(b)

    def send(self,string):
        self.lcd.write(string)

    def replace(self,string):
        self.clear()
        self.lcd.write(string)

def init():
	print ("Initializing")

	# Initialize GPS
	# UART(1) is on PB: 
	# (TX,  RX) 
	# (X9,  X10)
	# (PB6, PB7)
	uart = UART(1, 9600)
	# Maybe add read_buf_len=128?
	# Maybe add timeout_char=200
	uart.init(9600, bits=8, stop=1, parity=None, timeout=5000)


	# Initialize Radio (RFM69)
	# SPI(1) is on PA:
	# (DIO0, RESET, NSS, SCK, MISO, MOSI) 
	# (X3,   X4,    X5,  X6,  X7,   X8) 
	# (PA2,  PA3,   PA4, PA5, PA6,  PA7)
	rfm69 = RFM69.RFM69()
	sleep(1)
	# Check version
	if (rfm69.getVersion() == 0x24):
		print ("RFM69 Version Valid: 0x24")
	else:
		print ("RFM69 Version Invalid!")
		return "FAULT"

	return "GPS_ACQ"

class MTC():

  def __init__(self):
      self.clock = {'frames':0, 'seconds':0, 'mins':0, 'hours':0, 'mode':0}
      self.frame_count = 1
      self.uart1 = UART(1)

      self.message = [-1] * 8
      self.uart1.init(31250, parity=None, stop=1,read_buf_len=1)
      print(dir(self.uart1))

  def saveClock(self):
      self.clock['frames'] = (self.message[1] << 4) + self.message[0] # 2 half bytes 000f ffff
      self.clock['seconds'] = (self.message[3] << 4) + self.message[2] # 2 half bytes 00ss ssss
      self.clock['mins'] =  (self.message[5] << 4) + self.message[4] # 2 half bytes 00mm mmmm
      self.clock['hours'] = ((self.message[7] & 1) << 4) + self.message[6] # 2 half bytes 0rrh hhhh the msb has to be masked as it contains the mode
      self.clock['mode'] = ((self.message[7] & 6) >> 1) # get the fps mode by masking 0rrh with 0110 (6)

  def getMs(self):

      self.readFrame()
      mins = ((self.clock['hours'] * 60) + self.clock['mins'])
      seconds = (mins * 60) + self.clock['seconds']
      frames = (seconds * 25) + self.clock['frames']
      milliseconds = frames * 40
      return milliseconds

  def readFrame(self):


      indice = 0
      self.message = [-1] * 8

      while True:

          data = self.uart1.read(1)

          if data != None:

              if ord(data) == 241:              # if Byte for quater frame message

                  try: mes = ord(self.uart1.read(1))        # Read next byte
                  except: continue

                  piece = mes >> 4             # Get which part of the message it is (e.g seconds mins)

                  if piece == indice:
                      self.message[piece] = mes & 15    # store message using '&' to mask the bit type
                      indice += 1

          if indice > 7:
              self.saveClock()
              break

      #self.uart1.deinit()
      return self.clock

class ESP8266(object):

    def __init__(self):
        self.uart = UART(6, 115200)
    
    def write(self, command):
        self.uart.write(command)
        count = 5
        while count >= 0:
            if self.uart.any():
                print(self.uart.readall().decode('utf-8'))
            time.sleep(0.1)
            count-=1

class UART_Port:
    """Implements a port which can send or receive commands with a bioloid
    device using the pyboard UART class. This particular class takes
    advantage of some features which are only available on the STM32F4xx processors.
    """

    def __init__(self, uart_num, baud):
        self.uart = UART(uart_num)
        self.baud = 0
        self.set_baud(baud)
        base_str = 'USART{}'.format(uart_num)
        if not hasattr(stm, base_str):
            base_str = 'UART{}'.format(uart_num)
        self.uart_base = getattr(stm, base_str)

        # Set HDSEL (bit 3) in CR3 - which puts the UART in half-duplex
        # mode. This connects Rx to Tx internally, and only enables the
        # transmitter when there is data to send.
        stm.mem16[self.uart_base + stm.USART_CR3] |= (1 << 3)

    def any(self):
        return self.uart.any()

    def read_byte(self):
        """Reads a byte from the bus.

        This function will return None if no character was read within the
        designated timeout (set when we call self.uart.init).
        """
        byte = self.uart.readchar()
        if byte >= 0:
            return byte

    def set_baud(self, baud):
        """Sets the baud rate.

        Note, the pyb.UART class doesn't have a method for setting the baud
        rate, so we need to reinitialize the uart object.
        """
        if self.baud != baud:
            self.baud = baud
            # The max Return Delay Time is 254 * 2 usec = 508 usec. The default
            # is 500 usec. So using a timeout of 2 ensures that we wait for
            # at least 1 msec before considering a timeout.
            self.uart.init(baudrate=baud, timeout=2)

    def write_packet(self, packet_data):
        """Writes an entire packet to the serial port."""
        _write_packet(self.uart_base, packet_data, len(packet_data))

    def __init__(self, uart_port):
        self.sbus = UART(uart_port, 100000)
        self.sbus.init(100000, bits=8, parity=0, stop=2, timeout_char=3, read_buf_len=250)

        # constants
        self.START_BYTE = b'0f'
        self.END_BYTE = b'00'
        self.SBUS_FRAME_LEN = 25
        self.SBUS_NUM_CHAN = 18
        self.OUT_OF_SYNC_THD = 10
        self.SBUS_NUM_CHANNELS = 18
        self.SBUS_SIGNAL_OK = 0
        self.SBUS_SIGNAL_LOST = 1
        self.SBUS_SIGNAL_FAILSAFE = 2

        # Stack Variables initialization
        self.validSbusFrame = 0
        self.lostSbusFrame = 0
        self.frameIndex = 0
        self.resyncEvent = 0
        self.outOfSyncCounter = 0
        self.sbusBuff = bytearray(1)  # single byte used for sync
        self.sbusFrame = bytearray(25)  # single SBUS Frame
        self.sbusChannels = array.array('H', [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])  # RC Channels
        self.isSync = False
        self.startByteFound = False
        self.failSafeStatus = self.SBUS_SIGNAL_FAILSAFE

  def __init__(self):
      self.clock = {'frames':0, 'seconds':0, 'mins':0, 'hours':0, 'mode':0}
      self.frame_count = 1
      self.uart1 = UART(1)

      self.message = [-1] * 8
      self.uart1.init(31250, parity=None, stop=1,read_buf_len=1)
      print(dir(self.uart1))

 def __init__(self, uart_num, pin_rw, dev_id):
     self.error = []
     self.uart = UART(uart_num)
     self.uart.init(57600, bits=8, parity=0, timeout=10, read_buf_len=64)
     self.pin_rw = Pin(pin_rw)
     self.pin_rw.init(Pin.OUT_PP)
     self.pin_rw.value(0)
     self.dev_id = dev_id
     
     self.file_parts = 0
     self.file_parts_i = 1
     self.file_is_open = False

 def init(self, type=BLE_SHIELD):
     self.deinit()
     if type==self.BLE_SHIELD:
         self.rst=Pin("P7",Pin.OUT_OD,Pin.PULL_NONE)
         self.uart=UART(3,115200,timeout_char=1000)
         self.type=self.BLE_SHIELD
         self.rst.low()
         sleep(100)
         self.rst.high()
         sleep(100)
         self.uart.write("set sy c m machine\r\nsave\r\nreboot\r\n")
         sleep(1000)
         self.uart.readall() # clear

def  uart_hashtag():
	the_word = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
	#  initialize X5 as  trigger output
	uart = UART(6)
	uart.init(9600, bits=8, parity = None, stop = 2)
	while True:
	#  initialize UART(6) to output TX on Pin Y1
		for i in range(36):
			uart.writechar(ord(the_word[i]))
		uart.writechar(13)
		uart.writechar(10)
		pyb.delay(1000)

    def __init__(self,uart=3):
        #UART serial
        self.lcd = UART(uart, 115200)  # init with given baudrate

        #set lcd to same baudrate
        b = bytearray(3)
        b[0] = 0x7C
        b[1] = 0x07
        b[2] = 0x36
        self.lcd.write(b)

        #set background duty
        b = bytearray(3)
        b[0] = 0x7C
        b[1] = 0x02
        b[2] = 80
        self.lcd.write(b)

class WIFI:
  """docstring for wifi"""

  def __init__(self, uart, baudrate = 115200):
    """ uart = uart #1-6, baudrate must match what is set on the ESP8266. """
    self._uart = UART(uart, baudrate)

  def write( self, aMsg ) :
    self._uart.write(aMsg)
    res = self._uart.readall()
    if res:
      print(res.decode("utf-8"))

  def read( self ) : return self._uart.readall().decode("utf-8")

  def _cmd( self, cmd ) :
    """ Send AT command, wait a bit then return results. """
    self._uart.write("AT+" + cmd + "\r\n")
    udelay(500)
    return self.read()

  @property
  def IP(self): return self._cmd("CIFSR")

  @property
  def networks( self ) : return self._cmd("CWLAP")

  @property
  def baudrate(self): return self._cmd("CIOBAUD?")

  @baudrate.setter
  def baudrate(self, value): return self._cmd("CIOBAUD=" + str(value))

  @property
  def mode(self): return self._cmd("CWMODE?")

  @mode.setter
  def mode(self, value): self._cmd("CWMODE=" + str(value))

  def connect( self, ssid, password = "" ) :
    """ Connect to the given network ssid with the given password """
    constr = "CWJAP=\"" + ssid + "\",\"" + password + "\""
    return self._cmd(constr)

  def disconnect( self ) : return self._cmd("CWQAP")

  def reset( self ) : return self._cmd("RST")

def  remote():

	#initialise UART communication
	uart = UART(6)
	uart.init(9600, bits=8, parity = None, stop = 2)

	# define various I/O pins for ADC
	adc_1 = ADC(Pin('X19'))
	adc_2 = ADC(Pin('X20'))

	# set up motor with PWM and timer control
	A1 = Pin('Y9',Pin.OUT_PP)
	A2 = Pin('Y10',Pin.OUT_PP)
	pwm_out = Pin('X1')
	tim = Timer(2, freq = 1000)
	motor = tim.channel(1, Timer.PWM, pin = pwm_out)

	# Motor in idle state
	A1.high()	
	A2.high()	
	speed = 0
	DEADZONE = 5

	# Use keypad U and D keys to control speed
	while True:				# loop forever until CTRL-C
		while (uart.any()!=10):    #wait we get 10 chars
			n = uart.any()
		command = uart.read(10)
		if command[2]==ord('5'):
			if speed < 96:
				speed = speed + 5
				print(speed)
		elif command[2]==ord('6'):
			if speed > - 96:
				speed = speed - 5
				print(speed)
		if (speed >= DEADZONE):		# forward
			A1.high()
			A2.low()
			motor.pulse_width_percent(speed)
		elif (speed <= -DEADZONE):
			A1.low()		# backward
			A2.high()
			motor.pulse_width_percent(-speed)
		else:
			A1.low()		# idle
			A2.low()		

def  keypad():
	key = ('1','2','3','4','U','D','L','R')
	uart = UART(6)
	uart.init(9600, bits=8, parity = None, stop = 2)
	while True:
		while (uart.any()!=10):    #wait we get 10 chars
			n = uart.any()
		command = uart.read(10)
		key_index = command[2]-ord('1')
		if (0 <= key_index <= 7) :
			key_press = key[key_index]
		if command[3]==ord('1'):
			action = 'pressed'
		elif command[3]==ord('0'):
			action = 'released'
		else:
			action = 'nothing pressed'
		print('Key',key_press,' ',action)

class BLE:
    BLE_NONE=0
    BLE_SHIELD=1

    def command(self, cmd):
        if self.type==self.BLE_SHIELD:
            self.uart.write(cmd)
            self.uart.write("\r\n")
            r=self.uart.read(9)
            if r[0]!=82: raise OSError("Response corrupted!")
            if r[1]==49: raise OSError("Command failed!")
            if r[1]==50: raise OSError("Parse error!")
            if r[1]==51: raise OSError("Unknown command!")
            if r[1]==52: raise OSError("Too few args!")
            if r[1]==53: raise OSError("Too many args!")
            if r[1]==54: raise OSError("Unknown variable or option!")
            if r[1]==55: raise OSError("Invalid argument!")
            if r[1]==56: raise OSError("Timeout!")
            if r[1]==57: raise OSError("Security mismatch!")
            if r[1]!=48: raise OSError("Response corrupted!")
            for i in range(2,6):
                if r[i]<48 or 57<r[i]: raise OSError("Response corrupted!")
            if r[7]!=13 or r[8]!=10: raise OSError("Response corrupted!")
            l=((r[2]-48)*10000)+\
              ((r[3]-48)*1000)+\
              ((r[4]-48)*100)+\
              ((r[5]-48)*10)+\
              ((r[6]-48)*1)
            if not l: return None
            if l==1 or l==2: raise OSError("Response corrupted!")
            response=self.uart.read(l-2)
            if self.uart.readchar()!=13: raise OSError("Response corrupted!")
            if self.uart.readchar()!=10: raise OSError("Response corrupted!")
            return response

    def deinit(self):
        if self.type==self.BLE_SHIELD:
            self.uart.deinit()
            self.rst=None
            self.uart=None
            self.type=self.BLE_NONE

    def init(self, type=BLE_SHIELD):
        self.deinit()
        if type==self.BLE_SHIELD:
            self.rst=Pin("P7",Pin.OUT_OD,Pin.PULL_NONE)
            self.uart=UART(3,115200,timeout_char=1000)
            self.type=self.BLE_SHIELD
            self.rst.low()
            sleep(100)
            self.rst.high()
            sleep(100)
            self.uart.write("set sy c m machine\r\nsave\r\nreboot\r\n")
            sleep(1000)
            self.uart.readall() # clear

    def uart(self):
        if self.type==self.BLE_SHIELD: return self.uart

    def type(self):
        if self.type==self.BLE_SHIELD: return self.BLE_SHIELD

    def __init__(self):
        self.rst=None
        self.uart=None
        self.type=self.BLE_NONE

                   'dd_rtc':'0','wkd_rtc':'0','hr_rtc':'0','min_rtc':'0','footer':'###'}
       z = pickle.dumps(reset_dict).encode('utf8')
       bkram[0] = len(z)
       ba[4: 4+len(z)] = z
       restore_data()

    return pkl

def gestione_power_on():

    print("Power On")
    uart.write("Power On.")

 
#imposto setting seriale - set MCU serial port1  
uart = UART(1, 9600)                         
uart.init(9600, bits=8, parity=None, stop=1)
 
test=0

reason=upower.why()   # motivo dell'uscita da low power mode.
                      # see upower.py module documentation.

uart.write(str(reason) +'\n')

#reason='ALARM_B'     # solo per debug
try:
    if reason=='X1':
       verde.on()
       pyb.delay(3)
       verde.off()

gps = GPS(3)
# orientation = Orientation(4, 1)

servo1 = Servo(0, 1)
motor_a = Motor(1, 'X2', 'X3')

gps_indicator = pyb.LED(3)

new_data = False
def pps_callback(line):
    global new_data, gps_indicator
    new_data = True
    gps_indicator.toggle()
    

uart = UART(6, 9600, read_buf_len=1000)
pps_pin = pyb.Pin.board.X8
extint = pyb.ExtInt(pps_pin, pyb.ExtInt.IRQ_FALLING,
                    pyb.Pin.PULL_UP, pps_callback)

indicator = pyb.LED(4)
increase = True

sensor_queue = SensorQueue(tmp36,
                           mcp9808,
                           accel,
                           gps
                           )
command_pool = CommandPool(servo1, motor_a)

communicator = Communicator(sensor_queue, command_pool)

from pyb import UART

uart = UART(1)
uart = UART(1, 9600)
uart = UART(1, 9600, bits=8, stop=1, parity=None)
print(uart)

uart.init(1200)
print(uart)

uart.any()
uart.send(1, timeout=500)

 def __init__(self):
     self.uart = UART(6, 115200)