# Importar librerias  
import time
from machine import Pin, I2C, ADC 
from ssd1306 import SSD1306_I2C
WIDTH =128 
HEIGHT= 32
#      Canal 
i2c=I2C(1,scl=Pin(3),sda=Pin(2),freq=200000)
oled = SSD1306_I2C(WIDTH,HEIGHT,i2c)

# Definicion de Fucniones
def dectobin(num):
  textb=""
  ii=128
  for a in range(0,8,1):
    if num & ii ==0:
      textb=textb+"0"
    else:
      textb=textb+"1"
    ii=ii>>1
  return textb
def sensor_pir (pir_pin):
    pir = machine.Pin(pir_pin, machine.Pin.IN)
    movimiento = pir.value()

    return movimiento

def medir_distancia(trigger_pin, echo_pin):
    # Configurar pines
    trigger = machine.Pin(trigger_pin, machine.Pin.OUT)
    echo = machine.Pin(echo_pin, machine.Pin.IN)

    # Generar pulso de trigger
    trigger.value(0)
    #time.sleep_us(2)
    trigger.value(1)
    #time.sleep_us(5)
    trigger.value(0)

    # Esperar flanco de subida en el pin echo
    while echo.value() == 0:
        pulse_start = time.ticks_us()

    # Esperar flanco de bajada en el pin echo
    while echo.value() == 1:
        pulse_end = time.ticks_us()

    # Calcular duración del pulso
    pulse_duration = pulse_end - pulse_start

    # Calcular distancia en centímetros
    distancia = pulse_duration * 0.0343 / 2

    
    return distancia

def leer_sensor_ldr(ao_adc):
    GPIO.setmode(GPIO.BCM)
    GPIO.setup(ao_adc, GPIO.IN)

    valor = GPIO.input(ao_adc)
    return valor
def salp(num,lista):
  for pins in lista:
    Pin(pins,Pin.OUT)
  ii=128
  for pins in lista:
    if ((num & ii) !=0):
      Pin(pins,Pin.OUT).value(1)
    else:
      Pin(pins,Pin.OUT).value(0)
    ii=ii>>1

def dectobingraf(xx,yy,num):
  ii=128
  inc=0
  for a in range(0,8,1):
    if num & ii ==0:
      oled.rect(xx+inc, yy, 5, 5, 1)    
    else:
      oled.fill_rect(xx+inc, yy, 5, 5, 1)
    inc=inc+5
    ii=ii>>1
def triangle( x0, y0, x1, y1, x2, y2, color):
    # Triangle drawing function. Will draw a single pixel wide triangle
    # around the points (x0, y0), (x1, y1), and (x2, y2).
    oled.line(x0, y0, x1, y1, color)
    oled.line(x1, y1, x2, y2, color)
    oled.line(x2, y2, x0, y0, color)

def fill_triangle( x0, y0, x1, y1, x2, y2, color):
    # Filled triangle drawing function. Will draw a filled triangle around
    # the points (x0, y0), (x1, y1), and (x2, y2).
    if y0 > y1:
      y0, y1 = y1, y0
      x0, x1 = x1, x0
    if y1 > y2:
      y2, y1 = y1, y2
      x2, x1 = x1, x2
    if y0 > y1:
      y0, y1 = y1, y0
      x0, x1 = x1, x0
    a = 0
    b = 0
    y = 0
    last = 0
    if y0 == y2:
        a = x0
        b = x0
        if x1 < a:
          a = x1
        elif x1 > b:
          b = x1
        if x2 < a:
          a = x2
        elif x2 > b:
          b = x2
        oled.hline(a, y0, b-a+1, color)
        return
    dx01 = x1 - x0
    dy01 = y1 - y0
    dx02 = x2 - x0
    dy02 = y2 - y0
    dx12 = x2 - x1
    dy12 = y2 - y1
    if dy01 == 0:
      dy01 = 1
    if dy02 == 0:
      dy02 = 1
    if dy12 == 0:
      dy12 = 1
    sa = 0
    sb = 0
    if y1 == y2:
      last = y1
    else:
      last = y1-1
    for y in range(y0, last+1):
      a = x0 + sa // dy01
      b = x0 + sb // dy02
      sa += dx01
      sb += dx02
      if a > b:
        a, b = b, a
        oled.hline(a, y, b-a+1, color)
    sa = dx12 * (y - y1)
    sb = dx02 * (y - y0)
    while y <= y2:
      a = x1 + sa // dy12
      b = x0 + sb // dy02
      sa += dx12
      sb += dx02
      if a > b:
        a, b = b, a
        oled.hline(a, y, b-a+1, color)
        y += 1
def circle(x0, y0, radius, color):
    # Circle drawing function.  Will draw a single pixel wide circle with
    # center at x0, y0 and the specified radius.
    f = 1 - radius
    ddF_x = 1
    ddF_y = -2 * radius
    x = 0
    y = radius
    oled.pixel(x0, y0 + radius, color)
    oled.pixel(x0, y0 - radius, color)
    oled.pixel(x0 + radius, y0, color)
    oled.pixel(x0 - radius, y0, color)
    while x < y:
        if f >= 0:
            y -= 1
            ddF_y += 2
            f += ddF_y
        x += 1
        ddF_x += 2
        f += ddF_x
        oled.pixel(x0 + x, y0 + y, color)
        oled.pixel(x0 - x, y0 + y, color)
        oled.pixel(x0 + x, y0 - y, color)
        oled.pixel(x0 - x, y0 - y, color)
        oled.pixel(x0 + y, y0 + x, color)
        oled.pixel(x0 - y, y0 + x, color)
        oled.pixel(x0 + y, y0 - x, color)
        oled.pixel(x0 - y, y0 - x, color)

def fill_circle(x0, y0, radius, color):
    # Filled circle drawing function.  Will draw a filled circule with
    # center at x0, y0 and the specified radius.
    oled.vline(x0, y0 - radius, 2*radius + 1, color)
    f = 1 - radius
    ddF_x = 1
    ddF_y = -2 * radius
    x = 0
    y = radius
    while x < y:
        if f >= 0:
            y -= 1
            ddF_y += 2
            f += ddF_y
        x += 1
        ddF_x += 2
        f += ddF_x
        oled.vline(x0 + x, y0 - y, 2*y + 1, color)
        oled.vline(x0 + y, y0 - x, 2*x + 1, color)
        oled.vline(x0 - x, y0 - y, 2*y + 1, color)
        oled.vline(x0 - y, y0 - x, 2*x + 1, color)

def dectobingrafCir(xx,yy,num):
  ii=128
  inc=0
  for a in range(0,8,1):
    if num & ii ==0:
      circle(xx+inc, yy, 3, 1)    
    else:
      fill_circle(xx+inc, yy, 3, 1)
    inc=inc+8
    ii=ii>>1

def dectobingraftrian(xx,yy,num):
  ii=128
  for a in range(0,8,1):
    if num & ii ==0:
      triangle(xx,yy,xx+3,yy+5,xx-3,yy+5,1)   
    else:
      fill_triangle(xx,yy,xx+3,yy+5,xx-3,yy+5,1)
    xx=xx+8
    ii=ii>>1

def map_range(x, in_min, in_max, out_min, out_max):
  return (x - in_min) * (out_max - out_min) // (in_max - in_min) + out_min

def main():
  oled.fill(0)
  oled.text("OLED SSD1306", 0, 0)
  oled.text("GPIO ADC", 0, 10)
  oled.show()
  time.sleep(0.5)
#hola
#holaaa
# q tal
  # Configuraciones de recursos
  print("Ejemplo de lectura de ADC")
  leds = [4,5,6,7,8,9,10,11]
  vert_adc=ADC(0)
  hort_adc=ADC(1)
  temp_adc=ADC(4)
  ao_adc=ADC(2)
  trigger_pin = 14
  echo_pin = 15
  pir_pin = 16

  # inicializacion de Variables
  ii=0
  jj=0
  cont=128
  ca=0
  while True:
    vol_temp=temp_adc.read_u16()*3.3/65535
    ldr_sen=ao_adc.read_u16()
    temp= 27 - (vol_temp-0.7284)/0.001721
    valvert = int( map_range(vert_adc.read_u16(),0,65535,0,128))
    valhort = int( map_range(hort_adc.read_u16(),0,65535,0,128))
    valldr = int( map_range(ao_adc.read_u16(),0,65535,0,128))
    trigger = Pin(trigger_pin, Pin.OUT)
    echo = Pin(echo_pin, Pin.IN)
    distancia = int(medir_distancia(trigger_pin, echo_pin)/3.1)
    oled.fill(0)
    valorpir = sensor_pir(pir_pin)
    oled.text(str(temp), 10, 0)
    #oled.text(dectobin(valvert), 0, 0)
    oled.text(str(distancia), 80, 0)
    #oled.text(dectobin(valvert), 00, 10)
    oled.text(str(valvert), 80, 10)
    #oled.fill_rect(0,22,valvert,5,1)
    oled.fill_rect(0,22,distancia,5,1)
    #oled.fill_rect(0,28,valhort,5,1)
    oled.text(str(valldr),80, 20)
    oled.fill_rect(0,28,valldr,5,1)
    #dectobingraf(32,10,valvert)
    #dectobingrafCir(32,22,valvert) 
    #dectobingrafCir(32,28,valhort)  
    #dectobingraftrian(32,25,valvert)
    if valorpir == 1:
        print("hay presencia")
        oled.text("presencia", 0, 10)

    else:
        print("libre")
        oled.text("libre", 0, 10)
    oled.show()
    print(" Binario:", dectobin(valvert)," ADC vert","=",str(valvert)," Temp","=",str(temp) ,"ldr",str(valldr),"dist",str(distancia) )
    salp(cont,leds)
    if ca==0:
      cont=cont>>1
      if cont==0:
        cont=1
        ca=1
    if ca==1:
      cont=cont<<1
      if cont==256:
        cont=128
        ca=0         
    time.sleep(0.2)    

if __name__== '__main__':
  main()