from machine import Pin, I2C,ADC,Timer
from ir_rx import NEC_16
from neopixel import NeoPixel
from time import sleep
import random

ldr = ADC(Pin(26))

rgb_led_num =   22
rgb_led_pin =   Pin(rgb_led_num, Pin.OUT)
rgb_led     =   NeoPixel(rgb_led_pin, 1) 


led = Pin(25,Pin.OUT)

isLDRActive = False

ldr_timer = Timer()

def remoteSwitch(data, addr, ctrl):
    global readCount, isLDRActive
    if data > 0:
        if data == 0xa2:
            if  rgb_led[0]==(0,0,0):
                LightSwitchOn()
            else:
                LightSwitchOff()

        if data == 0xa8:
            if led.value() == 1:
                led.value(0)
                print("LDR OFF")
                isLDRActive = False
            else:
                led.value(1)
                print("LDR ON")
                isLDRActive = True
                # Start the timer to periodically check LDR conditions
                ldr_timer.init(period=2000, mode=Timer.PERIODIC, callback=readLDR)

        print('data {:02x}'.format(data))



ir = NEC_16(Pin(28,Pin.IN),remoteSwitch)




def LightSwitchOff():
  rgb_led[0]=(0,0,0)
  rgb_led.write()


def LightSwitchOn():
     
    r= random.randint(0, 255)
    g = random.randint(0, 255)
    b =random.randint(0, 255)

    print("r", r)
    print("g", g)
    print("b", b)

    rgb_led[0]=(r,g,b) 
    rgb_led.write() 
    r=0
    g=0
    b=0
            


def readLDR(timer):
    global isLDRActive
    if isLDRActive:
        voltage = ldr.read_u16() * 3.3 / 65535
        x = int(voltage)
        if x > 0:
            LightSwitchOn()
            print("reading ", ":", "night")
        else:
            LightSwitchOff()
            print("reading ", ":", "Day")
    else:
        # Turn off LDR and stop the timer after exiting the loop
        led.value(0)
        ldr_timer.deinit()
        print("LDR Switch OFF")
        

    





main.py

diagram.json

# MicroPython SSD1306 OLED driver, I2C and SPI interfaces

from micropython import const
import framebuf


# register definitions
SET_CONTRAST = const(0x81)
SET_ENTIRE_ON = const(0xA4)
SET_NORM_INV = const(0xA6)
SET_DISP = const(0xAE)
SET_MEM_ADDR = const(0x20)
SET_COL_ADDR = const(0x21)
SET_PAGE_ADDR = const(0x22)
SET_DISP_START_LINE = const(0x40)
SET_SEG_REMAP = const(0xA0)
SET_MUX_RATIO = const(0xA8)
SET_COM_OUT_DIR = const(0xC0)
SET_DISP_OFFSET = const(0xD3)
SET_COM_PIN_CFG = const(0xDA)
SET_DISP_CLK_DIV = const(0xD5)
SET_PRECHARGE = const(0xD9)
SET_VCOM_DESEL = const(0xDB)
SET_CHARGE_PUMP = const(0x8D)

# Subclassing FrameBuffer provides support for graphics primitives
# http://docs.micropython.org/en/latest/pyboard/library/framebuf.html
class SSD1306(framebuf.FrameBuffer):
    def __init__(self, width, height, external_vcc):
        self.width = width
        self.height = height
        self.external_vcc = external_vcc
        self.pages = self.height // 8
        self.buffer = bytearray(self.pages * self.width)
        super().__init__(self.buffer, self.width, self.height, framebuf.MONO_VLSB)
        self.init_display()

    def init_display(self):
        for cmd in (
            SET_DISP | 0x00,  # off
            # address setting
            SET_MEM_ADDR,
            0x00,  # horizontal
            # resolution and layout
            SET_DISP_START_LINE | 0x00,
            SET_SEG_REMAP | 0x01,  # column addr 127 mapped to SEG0
            SET_MUX_RATIO,
            self.height - 1,
            SET_COM_OUT_DIR | 0x08,  # scan from COM[N] to COM0
            SET_DISP_OFFSET,
            0x00,
            SET_COM_PIN_CFG,
            0x02 if self.width > 2 * self.height else 0x12,
            # timing and driving scheme
            SET_DISP_CLK_DIV,
            0x80,
            SET_PRECHARGE,
            0x22 if self.external_vcc else 0xF1,
            SET_VCOM_DESEL,
            0x30,  # 0.83*Vcc
            # display
            SET_CONTRAST,
            0xFF,  # maximum
            SET_ENTIRE_ON,  # output follows RAM contents
            SET_NORM_INV,  # not inverted
            # charge pump
            SET_CHARGE_PUMP,
            0x10 if self.external_vcc else 0x14,
            SET_DISP | 0x01,
        ):  # on
            self.write_cmd(cmd)
        self.fill(0)
        self.show()

    def poweroff(self):
        self.write_cmd(SET_DISP | 0x00)

    def poweron(self):
        self.write_cmd(SET_DISP | 0x01)

    def contrast(self, contrast):
        self.write_cmd(SET_CONTRAST)
        self.write_cmd(contrast)

    def invert(self, invert):
        self.write_cmd(SET_NORM_INV | (invert & 1))

    def show(self):
        x0 = 0
        x1 = self.width - 1
        if self.width == 64:
            # displays with width of 64 pixels are shifted by 32
            x0 += 32
            x1 += 32
        self.write_cmd(SET_COL_ADDR)
        self.write_cmd(x0)
        self.write_cmd(x1)
        self.write_cmd(SET_PAGE_ADDR)
        self.write_cmd(0)
        self.write_cmd(self.pages - 1)
        self.write_data(self.buffer)


class SSD1306_I2C(SSD1306):
    def __init__(self, width, height, i2c, addr=0x3C, external_vcc=False):
        self.i2c = i2c
        self.addr = addr
        self.temp = bytearray(2)
        self.write_list = [b"\x40", None]  # Co=0, D/C#=1
        super().__init__(width, height, external_vcc)

    def write_cmd(self, cmd):
        self.temp[0] = 0x80  # Co=1, D/C#=0
        self.temp[1] = cmd
        self.i2c.writeto(self.addr, self.temp)

    def write_data(self, buf):
        self.write_list[1] = buf
        self.i2c.writevto(self.addr, self.write_list)


class SSD1306_SPI(SSD1306):
    def __init__(self, width, height, spi, dc, res, cs, external_vcc=False):
        self.rate = 10 * 1024 * 1024
        dc.init(dc.OUT, value=0)
        res.init(res.OUT, value=0)
        cs.init(cs.OUT, value=1)
        self.spi = spi
        self.dc = dc
        self.res = res
        self.cs = cs
        import time

        self.res(1)
        time.sleep_ms(1)
        self.res(0)
        time.sleep_ms(10)
        self.res(1)
        super().__init__(width, height, external_vcc)

    def write_cmd(self, cmd):
        self.spi.init(baudrate=self.rate, polarity=0, phase=0)
        self.cs(1)
        self.dc(0)
        self.cs(0)
        self.spi.write(bytearray([cmd]))
        self.cs(1)

    def write_data(self, buf):
        self.spi.init(baudrate=self.rate, polarity=0, phase=0)
        self.cs(1)
        self.dc(1)
        self.cs(0)
        self.spi.write(buf)
        self.cs(1)

ssd1306.py

picozero.py

# MIT License
# 
# Copyright (c) 2020 Peter Hinch
# 
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
# 
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
# 
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.

# Author: Peter Hinch
# Copyright Peter Hinch 2020-2021 Released under the MIT license
# http://github.com/peterhinch/micropython_ir

from machine import Pin
from machine import Timer
from array import array
from utime import ticks_us
from utime import ticks_diff

# Save RAM
# from micropython import alloc_emergency_exception_buf
# alloc_emergency_exception_buf(100)


# On 1st edge start a block timer. While the timer is running, record the time
# of each edge. When the timer times out decode the data. Duration must exceed
# the worst case block transmission time, but be less than the interval between
# a block start and a repeat code start (~108ms depending on protocol)

class IR_RX():
    # Result/error codes
    # Repeat button code
    REPEAT = -1
    # Error codes
    BADSTART = -2
    BADBLOCK = -3
    BADREP = -4
    OVERRUN = -5
    BADDATA = -6
    BADADDR = -7

    def __init__(self, pin, nedges, tblock, callback, *args):  # Optional args for callback
        self._pin = pin
        self._nedges = nedges
        self._tblock = tblock
        self.callback = callback
        self.args = args
        self._errf = lambda _ : None
        self.verbose = False

        self._times = array('i',  (0 for _ in range(nedges + 1)))  # +1 for overrun
        pin.irq(handler = self._cb_pin, trigger = (Pin.IRQ_FALLING | Pin.IRQ_RISING))
        self.edge = 0
        self.tim = Timer(-1)  # Sofware timer
        self.cb = self.decode

    # Pin interrupt. Save time of each edge for later decode.
    def _cb_pin(self, line):
        t = ticks_us()
        # On overrun ignore pulses until software timer times out
        if self.edge <= self._nedges:  # Allow 1 extra pulse to record overrun
            if not self.edge:  # First edge received
                self.tim.init(period=self._tblock , mode=Timer.ONE_SHOT, callback=self.cb)
            self._times[self.edge] = t
            self.edge += 1

    def do_callback(self, cmd, addr, ext, thresh=0):
        self.edge = 0
        if cmd >= thresh:
            self.callback(cmd, addr, ext, *self.args)
        else:
            self._errf(cmd)

    def error_function(self, func):
        self._errf = func

    def close(self):
        self._pin.irq(handler = None)
        self.tim.deinit()


class NEC_ABC(IR_RX):
    def __init__(self, pin, extended, callback, *args):
        # Block lasts <= 80ms (extended mode) and has 68 edges
        super().__init__(pin, 68, 80, callback, *args)
        self._extended = extended
        self._addr = 0

    def decode(self, _):
        try:
            if self.edge > 68:
                raise RuntimeError(self.OVERRUN)
            width = ticks_diff(self._times[1], self._times[0])
            if width < 4000:  # 9ms leading mark for all valid data
                raise RuntimeError(self.BADSTART)
            width = ticks_diff(self._times[2], self._times[1])
            if width > 3000:  # 4.5ms space for normal data
                if self.edge < 68:  # Haven't received the correct number of edges
                    raise RuntimeError(self.BADBLOCK)
                # Time spaces only (marks are always 562.5µs)
                # Space is 1.6875ms (1) or 562.5µs (0)
                # Skip last bit which is always 1
                val = 0
                for edge in range(3, 68 - 2, 2):
                    val >>= 1
                    if ticks_diff(self._times[edge + 1], self._times[edge]) > 1120:
                        val |= 0x80000000
            elif width > 1700: # 2.5ms space for a repeat code. Should have exactly 4 edges.
                raise RuntimeError(self.REPEAT if self.edge == 4 else self.BADREP)  # Treat REPEAT as error.
            else:
                raise RuntimeError(self.BADSTART)
            addr = val & 0xff  # 8 bit addr
            cmd = (val >> 16) & 0xff
            if cmd != (val >> 24) ^ 0xff:
                raise RuntimeError(self.BADDATA)
            if addr != ((val >> 8) ^ 0xff) & 0xff:  # 8 bit addr doesn't match check
                if not self._extended:
                    raise RuntimeError(self.BADADDR)
                addr |= val & 0xff00  # pass assumed 16 bit address to callback
            self._addr = addr
        except RuntimeError as e:
            cmd = e.args[0]
            addr = self._addr if cmd == self.REPEAT else 0  # REPEAT uses last address
        # Set up for new data burst and run user callback
        self.do_callback(cmd, addr, 0, self.REPEAT)

class NEC_8(NEC_ABC):
    def __init__(self, pin, callback, *args):
        super().__init__(pin, False, callback, *args)

class NEC_16(NEC_ABC):
    def __init__(self, pin, callback, *args):
        super().__init__(pin, True, callback, *args)


ir_rx.py

from machine import Pin,I2C
import framebuf
import time

class OLED_1inch5(framebuf.FrameBuffer):
    def __init__(self,i2c_num=0,i2c_scl=9,i2c_sda=8,i2c_freq=400000):
        
        self.width  = 128
        self.height = 128
        
        self.rotate = 180 #only 0 and 180

        self.olde_addr = 0x3d

        self.i2c = I2C(id=i2c_num, scl=Pin(i2c_scl), sda=Pin(i2c_sda), freq=i2c_freq)
        

        self.temp = bytearray(2)
        self.buffer = bytearray(self.height * self.width//2)

        super().__init__(self.buffer, self.width, self.height, framebuf.GS4_HMSB)
        self.init_display()
        
        self.white =   0xf
        self.balck =   0x0000
        
    def write_cmd(self, cmd):
        self.temp[0] = 0x00 
        self.temp[1] = cmd
        self.i2c.writeto(self.olde_addr, self.temp)

    def write_data(self, buf):
        self.i2c.writeto(self.olde_addr, b'\x40'+buf)
        
    def init_display(self):
        """Initialize dispaly"""  
        
        self.write_cmd(0xae)     #--turn off oled panel

        self.write_cmd(0x15)     #  set column address
        self.write_cmd(0x00)     #  start column   0
        self.write_cmd(0x7f)     #  end column   127

        self.write_cmd(0x75)     #   set row address
        self.write_cmd(0x00)     #  start row   0
        self.write_cmd(0x7f)     #  end row   127

        self.write_cmd(0x81)     # set contrast control
        self.write_cmd(0x80) 

        self.write_cmd(0xa0)     # gment remap
        self.write_cmd(0x51)     #51

        self.write_cmd(0xa1)     # start line
        self.write_cmd(0x00) 

        self.write_cmd(0xa2)     # display offset
        self.write_cmd(0x00) 

        self.write_cmd(0xa4)     # rmal display
        self.write_cmd(0xa8)     # set multiplex ratio
        self.write_cmd(0x7f) 

        self.write_cmd(0xb1)     # set phase leghth
        self.write_cmd(0xf1) 

        self.write_cmd(0xb3)     # set dclk
        self.write_cmd(0x00)     #80Hz:0xc1 90Hz:0xe1   100Hz:0x00   110Hz:0x30 120Hz:0x50   130Hz:0x70     01
 
        self.write_cmd(0xab)     #
        self.write_cmd(0x01)     #

        self.write_cmd(0xb6)     # set phase leghth
        self.write_cmd(0x0f) 

        self.write_cmd(0xbe) 
        self.write_cmd(0x0f) 

        self.write_cmd(0xbc) 
        self.write_cmd(0x08) 

        self.write_cmd(0xd5) 
        self.write_cmd(0x62) 

        self.write_cmd(0xfd) 
        self.write_cmd(0x12) 

        time.sleep(0.1)
        self.write_cmd(0xAF);#--turn on oled panel
    def setwindows(self, Xstart, Ystart, Xend, Yend):
        if((Xstart > self.width) or (Ystart > self.height) or (Xend > self.width) or (Yend > self.height)):
            return
        self.write_cmd(0x15)
        self.write_cmd(Xstart//2)
        self.write_cmd(Xend//2 - 1)

        self.write_cmd(0x75)
        self.write_cmd(Ystart)
        self.write_cmd(Yend - 1)
        
    def show(self):
        self.setwindows(0, 0, 128, 128)
        self.write_data(self.buffer)
        # for i in range(0, self.height):
        #     for j in range(0, self.width//2):
        #             self.write_data(self.buffer[j+self.width//2*i])
        return

          
if __name__=='__main__':

    OLED = OLED_1inch5()
    OLED.fill(0x0) 
    OLED.text("128 x 128 Pixels",1,5,OLED.white)
    OLED.text("OLED-1.5-Demo",1,20,OLED.white)
    OLED.text("SSD1327",1,35,OLED.white)  
    OLED.line(0,0,127,0,OLED.white)
    OLED.fill_rect(0, 50,127,60,  2)
    OLED.fill_rect(0, 60,127,70,  4)
    OLED.fill_rect(0, 70,127,80,  6)
    OLED.fill_rect(0, 80,127,90,  8)
    OLED.fill_rect(0, 90,127,100, 10)
    OLED.fill_rect(0,100,127,110, 12)
    OLED.fill_rect(0,110,127,120, 14)
    OLED.fill_rect(0,120,127,128, 16)
    OLED.show()
    time.sleep(1)
    while True:
        pass

