diff --git a/docs/psoc6/quickref.rst b/docs/psoc6/quickref.rst
index 2b9143be6cea3..8e2574e620d71 100644
--- a/docs/psoc6/quickref.rst
+++ b/docs/psoc6/quickref.rst
@@ -44,45 +44,6 @@ The :mod:`machine` module::
 
     machine.freq()          # get the current frequency of the CPU
 
-::
-
-    from machine import bitstream
-    
-    timing = [1000, 7000, 5000, 2500]          # timing (high_time_0, low_time_0, high_time_1, low_time_1)in ns
-    buf = bytearray([0xAB])                    # buffer data 
-    bitstream('P13_6', 0, timing, buf)         # bitstrem buffer data with timing through pin P13_6
-
-.. note::
-    Bitstream is set for the CPU frequency of 100MHz. At other clock frequencies, the timing will not fit.
-    All timings greater than 1500 ns work and the accuracy of the timing is +/- 400 ns. 
-    Supported timing_ns ranges below 1500 ns are [500, 1125, 800, 750], [400, 850, 800, 450], [300, 900, 600, 600] and [800, 1700, 1600, 900].
-
-NeoPixel driver
----------------
-
-The [NeoPixel library](https://docs.micropython.org/en/latest/library/neopixel.html) for controlling various addressable LEDs (like WS2812B, SK6812, ...) is supported in this port. The library can be installed using [mip](https://docs.micropython.org/en/latest/reference/packages.html). 
-
-::
-
-    import mip
-    mip.install('neopixel')
-
-The NeoPixel driver can be used as follows (see the :mod:`neopixel` for more details):
-
-::
-
-    import neopixel
-    from machine import Pin
-    data = Pin('P9_1', Pin.OUT, value=0)   # set P9_1 to output to control NeoPixels
-    np = neopixel.NeoPixel(data, 8, bpp=3) # create NeoPixel object on pin P9_1 with 8 pixels and 3 bytes per pixel with default timing=1
-    np[0] = (255, 255, 255)                # set the first pixel to white
-    np.write()                             # write data to all pixels
-
-.. note::
-   - The timing parameter can be used in the `NeoPixel()` constructor with timing tuples supported by the `machine.bitstream()` module. The timing parameter is optional and by default set to 1 which is the default timing [400, 850, 800, 450] for WS2812B LEDs at 800kHz.
-   - Use timing = 0 for WS2812B LEDs at 400kHz ie, [800, 1700, 1600, 900].
-   - Use timing = [300, 900, 600, 600] for SK6812 LEDs. 
-
 Delay and timing
 ----------------
 
@@ -98,6 +59,41 @@ Use the :mod:`time <time>` module::
     start = time.ticks_us() # get microsecond counter
     delta = time.ticks_diff(time.ticks_us(), start) # compute time difference
 
+Watch dog timer (WDT)
+---------------------
+
+See :ref:`machine.WDT <machine.WDT>`: ::
+
+    from machine import WDT
+
+    wdt = WDT(timeout=2000) # initialise wdt with id = 0 (default),
+                            # timeout in milliseconds
+    wdt.feed() # Feed the WDT. Do this periodically before the timeout.
+
+.. note::
+    The minimum timeout is 1 millisecond and the maximum timeout is 6000 milliseconds.
+
+Timers
+------
+
+This port supports hardware timers, which can be used for timing-related applications.
+
+Use the :mod:`machine.Timer` class::
+
+    from machine import Timer
+    import time
+    tim0 = Timer(0, period=1000, mode=Timer.ONE_SHOT, callback=lambda t:print("One shot timer triggered")) #Default assignment: period=9999, frequency=10000
+    tim1 = Timer(1, period=3000, mode=Timer.PERIODIC, callback=lambda t:print("Periodic timer triggered"))
+
+    tim0.deinit() # Deinitialise the timer
+    tim1.deinit() # Deinitialise the timer
+
+Here, id can take values between 0 and 31 as a maximum of 32 hardware timers is supported.
+
+.. note::
+    Virtual timers are not supported in this port.
+
+
 Pins and GPIO
 -------------
 
@@ -189,149 +185,6 @@ using ``Signal.on()`` or ``Signal.value(1)``.
 
     The :ref:`machine.Signal value()<machine.Signal>` getter functionality is not supported in this port, and the returned value is undefined. This is the same behavior as the :ref:`machine.Pin value()<machine.Pin>` for Pin.OUT mode, which is the object supporting the Signal object.
 
-Software I2C bus
-----------------
-Software I2C (using bit-banging) works on all output-capable pins, and is
-accessed via :ref:`machine.SoftI2C <machine.SoftI2C>`. ::
-
-    from machine import Pin, SoftI2C
-
-    i2c = SoftI2C(scl='P5_0', sda='P5_1', freq=100000)
-
-    i2c.scan()              # scan for devices
-
-    i2c.readfrom(0x3a, 4)   # read 4 bytes from device with address 0x3a
-    i2c.writeto(0x3a, '12') # write '12' to device with address 0x3a
-
-    buf = bytearray(10)     # create a buffer with 10 bytes
-    i2c.writeto(0x3a, buf)  # write the given buffer to the peripheral
-
-
-Hardware I2C bus
-----------------
-The driver is accessed via :ref:`machine.I2C <machine.I2C>`.
-
-The constructor
-^^^^^^^^^^^^^^^
-An instance of the :mod:`machine.I2C` class can be created by invoking the constructor with all the 
-necessary parameters to fully configure the ``I2C``. By invoking the constructor, I2C peripheral is 
-initialised and configured to work in master mode. The maximum supported frequency is 1 MHz.
-
-::
-    
-    from machine import I2C
-    i2c = I2C(scl='P6_0', sda='P6_1', freq=400000)
-
-The ``scl`` and ``sda`` pins are the only mandatory arguments. Refer board-specific datasheets `here <https://ifx-micropython.readthedocs.io/en/document-review/psoc6/general.html>`_
-for details regarding all the I2C-capable pins. The frequency argument is optional, and if not passed will be set to 400KHz by default.
-
-.. note::
-    The ``timeout`` option is currently not implemented in this port.
-
-::
-
-    from machine import I2C
-    i2c = I2C(scl='P6_0', sda='P6_1')  #I2C is initialised & configured with default frequency
-
-::
-
-    from machine import I2C
-    i2c = I2C(scl='P9_0', sda='P9_1', freq=400000)  #I2C is initialised & configured with given scl, sda pins & frequency
-
-Methods
-^^^^^^^
-All the methods(functions) given in :ref:`machine.I2C <machine.I2C>` class have been implemented in this port except:
-
-.. method:: I2C.init()
-
-All the initialisation & configurations are handled by the constructor. Hence ``init()`` is not required.
-
-Hardware I2C bus slave
-----------------------
-
-The PSoC6™ port offers an additional class to implement an I2C slave device. An I2C master node connected to the slave can exchange data over I2C for the configured slave address and frequency.
-
-.. warning:: 
-    This is not part of the core MicroPython libraries. Therefore, not mapping any existing machine class API and is not supported by other ports.
-
-.. note:: 
-    | Part of the functionality of the I2C slave is based on hardware interrupts and callbacks. 
-    | As explained in this :ref:`section <isr_rules>`, writing interrupts handlers in MicroPython is subject to multiple considerations depending on the actual hardware capabilities and limitations, the specific port implementation, and the overall application design and implementation.
-    | These must kept in mind when implementing accurate timing and event synchronization between master and slave. 
-
-The constructor
-^^^^^^^^^^^^^^^
-
-.. class:: I2CSlave(scl, sda, addr, freq)
-
-    Constructs and returns a new I2C slave object using the following parameters.
-   
-    Required arguments: 
-      - *scl* should be a pin name supporting the SCL functionality.
-      - *sda* should be a pin name supporting the SDA functionality.
-      - *addr* should be an 8-bit unsigned integer. 
-
-    Optional arguments:
-      - *freq* should be an integer that sets the maximum frequency
-        for SCL. If not passed, by default it is set to 400KHz.
-
-    Example:
-        ::
-            
-            from machine import I2CSlave
-            
-            i2c_slave = I2CSlave(scl="P6_0", sda="P6_1", addr=0x45)
-
-Methods
-^^^^^^^
-
-.. method:: I2CSlave.deinit()
-
-    Deinitialises the I2C slave.
-
-.. method:: I2CSlave.conf_receive_buffer(buf)
-
-    Configures the reception *buf* on an I2C slave. This is the buffer to which the master writes data to. 
-    The user needs to setup a new buffer every time the buffer has been used up.
-
-.. method:: I2CSlave.conf_transmit_buffer(buf)
-
-    Configures the transmission *buf* on an I2C slave. This is the buffer from which the master reads data from.
-    The user needs to setup a new buffer every time the buffer has been used up.
-
-.. method:: I2CSlave.irq(callback, events, priority)
-
-    Enables interrupts and the function handlers to be called upon different I2C bus events.
-
-    Required arguments: 
-      - *callback* should be a function handler that will be executed upon an interrupt event. The callback takes one argument which is the event causing the interrupt.
-      - *events* are the I2C bus events that will be triggering the interrupt. Multiple ones can be configured by ORing the following constants:
-
-        .. data:: I2CSlave.RD_EVENT
-                I2CSlave.WR_EVENT
-                I2CSlave.RD_BUF_IN_FIFO_EVENT
-                I2CSlave.RD_BUF_EMPTY_EVENT
-                I2CSlave.RD_CMPLT_EVENT
-                I2CSlave.WR_CMPLT_EVENT
-                I2CSlave.ERR_EVENT
-
-    Optional arguments:
-      - *priority* should be an unsigned integer with the priority of the interrupt.
-
-    Example:
-        ::
-
-            def cback(event):
-                if event == (event & I2CSlave.WR_EVENT):
-                    print("i2c wr event")
-
-            i2c_slave.irq(callback=cback, events=(I2CSlave.WR_EVENT | I2CSlave.WR_CMPLT_EVENT), priority=1)
-
-.. method:: I2CSlave.irq_disable()
-
-    Disables the I2C slave interrupts.
-
-
 Real time clock (RTC)
 ---------------------
 
@@ -380,154 +233,188 @@ See :ref:`machine.RTC <machine.RTC>`: ::
     or may not work accurately. Also, the PSoC6 RTC has a precision of seconds. Hence for any alarm, the minimum period can be 1 second.
 
 
-Watch dog timer (WDT)
----------------------
+PWM (pulse width modulation)
+----------------------------
 
-See :ref:`machine.WDT <machine.WDT>`: ::
+PWM can be enabled on all output-capable pins. The frequency can range from 1Hz to 100MHz. As the frequency
+increases the PWM resolution decreases. Refer to datasheets `here <https://ifx-micropython.readthedocs.io/en/document-review/psoc6/general.html>`_
+for additional details regarding board-specific PWM.
 
-    from machine import WDT
+Use the :ref:`machine.PWM <machine.PWM>` class: 
+
+The constructor can be called by passing the required arguments. All initialisation and configurations are handled by the constructor. Create a PWM object using 
+
+::  
+
+    pwm = PWM('P9_0', freq=50, duty_u16=8192) # PWM is initialised for the given pin with respective frequency & duty cycle given as raw value.
+    pwm1 = PWM('P9_1', freq=50, duty_ns=1000)  # PWM is initialised for the given pin with respective frequency & duty cycle given in nanoseconds.
+
+    All four arguments have to be passed mandatorily to create a PWM object. duty_u16 or duty_ns should be specified at a time.  
+
+::
+
+    from machine import PWM
+
+    pwm = PWM('P9_0', freq=50, duty_u16=8192) 
+    print(pwm)                                # view PWM settings
+
+    pwm.freq()                                # get current frequency
+    pwm.freq(100)                             # Set PWM frequency to 100 Hz
+
+    pwm.duty_u16()                            # get current duty cycle, range 0-65535
+    pwm.duty_u16(8192)                        # Set duty cycle from 0 to 65535 as a ratio of duty_u16/65535, now 25%
+    
+    pwm.duty_ns()                             # get current pulse width in ns
+    pwm.duty_ns(1000)                         # Set the current pulse width in ns from 0 to 1000000000/freq
+
+    pwm.init(freq=90,duty_ns=100)             # Modify the settings of PWM object
+    pwm.deinit()                              # Deinitialisation of PWM pin
 
-    wdt = WDT(timeout=2000) # initialise wdt with id = 0 (default),
-                            # timeout in milliseconds
-    wdt.feed() # Feed the WDT. Do this periodically before the timeout.
 
 .. note::
-    The minimum timeout is 1 millisecond and the maximum timeout is 6000 milliseconds.
+    invert functionality is not enabled in this port.
 
-Network Module
---------------
+Software I2C bus
+----------------
+Software I2C (using bit-banging) works on all output-capable pins, and is
+accessed via :ref:`machine.SoftI2C <machine.SoftI2C>`. ::
 
-The :mod:`network` module.
+    from machine import Pin, SoftI2C
 
-See :ref:`network.WLAN <network.WLAN>`:
+    i2c = SoftI2C(scl='P5_0', sda='P5_1', freq=100000)
 
-For some methods and constants, the PSoC6 network port implements certain specializations and slightly different behaviour. This is explained in this section.
+    i2c.scan()              # scan for devices
 
-Methods
-^^^^^^^
+    i2c.readfrom(0x3a, 4)   # read 4 bytes from device with address 0x3a
+    i2c.writeto(0x3a, '12') # write '12' to device with address 0x3a
 
-.. method:: WLAN.scan(ssid=None, bssid=None)
+    buf = bytearray(10)     # create a buffer with 10 bytes
+    i2c.writeto(0x3a, buf)  # write the given buffer to the peripheral
 
-    The scan option accepts the following filters as keyword arguments, removing from scan results any network not matching these parameters values:
 
-    * ``ssid``
-    * ``bssid``
+Hardware I2C bus
+----------------
+The driver is accessed via :ref:`machine.I2C <machine.I2C>`.
 
-.. method:: WLAN.status('param')
+The constructor
+^^^^^^^^^^^^^^^
+An instance of the :mod:`machine.I2C` class can be created by invoking the constructor with all the 
+necessary parameters to fully configure the ``I2C``. By invoking the constructor, I2C peripheral is 
+initialised and configured to work in master mode. The maximum supported frequency is 1 MHz.
 
-    .. warning:: 
-        The function does not provide the status of the connection. Use the ``active()`` for that purpose. Any errors or failures are communicated when using the corresponding enable/disable or connect/disconnect functions.
+::
+    
+    from machine import I2C
+    i2c = I2C(scl='P6_0', sda='P6_1', freq=400000)
 
-    The following query parameters are allowed:
-        * ``rssi``. Only for STA.
-        * ``stations``. List of connected stations (only for AP).
+The ``scl`` and ``sda`` pins are the only mandatory arguments. Refer board-specific datasheets `here <https://ifx-micropython.readthedocs.io/en/document-review/psoc6/general.html>`_
+for details regarding all the I2C-capable pins. The frequency argument is optional, and if not passed will be set to 400KHz by default.
 
-.. method:: WLAN.config('param')
-            WLAN.config(param=value, ...)
+.. note::
+    The ``timeout`` option is currently not implemented in this port.
 
-    Among the suggested parameters of the general network WLAN API, for this port, only these are available:
+::
 
-    * AP & STA query parameters
+    from machine import I2C
+    i2c = I2C(scl='P6_0', sda='P6_1')  #I2C is initialised & configured with default frequency
 
-        - ``channel``
-        - ``ssid``
-        - ``security```
-        - ``key/password``. Only for default AP key.
-        - ``mac``
-    * AP set parameters
+::
 
-        - ``channel``
-        - ``ssid``
-        - ``security```
-        - ``key/password``. Only for default AP key.
-        
-    * STA has no configurable parameter.
+    from machine import I2C
+    i2c = I2C(scl='P9_0', sda='P9_1', freq=400000)  #I2C is initialised & configured with given scl, sda pins & frequency
 
-Constants
-^^^^^^^^^
+Methods
+^^^^^^^
+All the methods(functions) given in :ref:`machine.I2C <machine.I2C>` class have been implemented in this port except:
 
-Security modes constants:
+.. method:: I2C.init()
 
-.. data:: WLAN.OPEN
-        WLAN.WEP
-        WLAN.WPA
-        WLAN.WPA2
-        WLAN.WPA3
-        WLAN.WPA2_WPA_PSK
-        WLAN.SEC_UNKNOWN
+All the initialisation & configurations are handled by the constructor. Hence ``init()`` is not required.
+
+Hardware I2C bus slave
+----------------------
+
+The PSoC6™ port offers an additional class to implement an I2C slave device. An I2C master node connected to the slave can exchange data over I2C for the configured slave address and frequency.
+
+.. warning:: 
+    This is not part of the core MicroPython libraries. Therefore, not mapping any existing machine class API and is not supported by other ports.
+
+.. note:: 
+    | Part of the functionality of the I2C slave is based on hardware interrupts and callbacks. 
+    | As explained in this :ref:`section <isr_rules>`, writing interrupts handlers in MicroPython is subject to multiple considerations depending on the actual hardware capabilities and limitations, the specific port implementation, and the overall application design and implementation.
+    | These must kept in mind when implementing accurate timing and event synchronization between master and slave. 
 
-.. note::
-    Power modes configuration not implemented.
-     
-Here is a function you can run (or put in your boot.py file) to automatically connect to your Wi-Fi network:
+The constructor
+^^^^^^^^^^^^^^^
 
-::
+.. class:: I2CSlave(scl, sda, addr, freq)
 
-    def network_connect() :
-        import network
-        from utime import sleep,sleep_ms
-        wlan = network.WLAN(network.STA_IF)
-        if wlan.isconnected():
-            print('[Network] already connected')
-            return
+    Constructs and returns a new I2C slave object using the following parameters.
+   
+    Required arguments: 
+      - *scl* should be a pin name supporting the SCL functionality.
+      - *sda* should be a pin name supporting the SDA functionality.
+      - *addr* should be an 8-bit unsigned integer. 
 
-        # enable and connect wlan
-        wlan.active(True)
-        wlan.connect('<ssid>','<key>')
+    Optional arguments:
+      - *freq* should be an integer that sets the maximum frequency
+        for SCL. If not passed, by default it is set to 400KHz.
 
-        # wait for the connection to establish
-        sleep(5)
-        for i in range(0,100):
-            if not wlan.isconnected() and wlan.status() >= 0:
-                print("[Network] Waiting to connect..")
-                sleep(2)
+    Example:
+        ::
+            
+            from machine import I2CSlave
+            
+            i2c_slave = I2CSlave(scl="P6_0", sda="P6_1", addr=0x45)
 
-        # check connection
-        if not wlan.isconnected():
-            print("[Network] Connection failed!")
-        else:
-            print(wlan.ifconfig())
+Methods
+^^^^^^^
 
-PWM (pulse width modulation)
-----------------------------
+.. method:: I2CSlave.deinit()
 
-PWM can be enabled on all output-capable pins. The frequency can range from 1Hz to 100MHz. As the frequency
-increases the PWM resolution decreases. Refer to datasheets `here <https://ifx-micropython.readthedocs.io/en/document-review/psoc6/general.html>`_
-for additional details regarding board-specific PWM.
+    Deinitialises the I2C slave.
 
-Use the :ref:`machine.PWM <machine.PWM>` class: 
+.. method:: I2CSlave.conf_receive_buffer(buf)
 
-The constructor can be called by passing the required arguments. All initialisation and configurations are handled by the constructor. Create a PWM object using 
+    Configures the reception *buf* on an I2C slave. This is the buffer to which the master writes data to. 
+    The user needs to setup a new buffer every time the buffer has been used up.
 
-::  
+.. method:: I2CSlave.conf_transmit_buffer(buf)
 
-    pwm = PWM('P9_0', freq=50, duty_u16=8192) # PWM is initialised for the given pin with respective frequency & duty cycle given as raw value.
-    pwm1 = PWM('P9_1', freq=50, duty_ns=1000)  # PWM is initialised for the given pin with respective frequency & duty cycle given in nanoseconds.
+    Configures the transmission *buf* on an I2C slave. This is the buffer from which the master reads data from.
+    The user needs to setup a new buffer every time the buffer has been used up.
 
-    All four arguments have to be passed mandatorily to create a PWM object. duty_u16 or duty_ns should be specified at a time.  
+.. method:: I2CSlave.irq(callback, events, priority)
 
-::
+    Enables interrupts and the function handlers to be called upon different I2C bus events.
 
-    from machine import PWM
+    Required arguments: 
+      - *callback* should be a function handler that will be executed upon an interrupt event. The callback takes one argument which is the event causing the interrupt.
+      - *events* are the I2C bus events that will be triggering the interrupt. Multiple ones can be configured by ORing the following constants:
 
-    pwm = PWM('P9_0', freq=50, duty_u16=8192) 
-    print(pwm)                                # view PWM settings
+        .. data:: I2CSlave.RD_EVENT
+                I2CSlave.WR_EVENT
+                I2CSlave.RD_BUF_IN_FIFO_EVENT
+                I2CSlave.RD_BUF_EMPTY_EVENT
+                I2CSlave.RD_CMPLT_EVENT
+                I2CSlave.WR_CMPLT_EVENT
+                I2CSlave.ERR_EVENT
 
-    pwm.freq()                                # get current frequency
-    pwm.freq(100)                             # Set PWM frequency to 100 Hz
+    Optional arguments:
+      - *priority* should be an unsigned integer with the priority of the interrupt.
 
-    pwm.duty_u16()                            # get current duty cycle, range 0-65535
-    pwm.duty_u16(8192)                        # Set duty cycle from 0 to 65535 as a ratio of duty_u16/65535, now 25%
-    
-    pwm.duty_ns()                             # get current pulse width in ns
-    pwm.duty_ns(1000)                         # Set the current pulse width in ns from 0 to 1000000000/freq
+    Example:
+        ::
 
-    pwm.init(freq=90,duty_ns=100)             # Modify the settings of PWM object
-    pwm.deinit()                              # Deinitialisation of PWM pin
+            def cback(event):
+                if event == (event & I2CSlave.WR_EVENT):
+                    print("i2c wr event")
 
+            i2c_slave.irq(callback=cback, events=(I2CSlave.WR_EVENT | I2CSlave.WR_CMPLT_EVENT), priority=1)
 
-.. note::
-    invert functionality is not enabled in this port.
+.. method:: I2CSlave.irq_disable()
+
+    Disables the I2C slave interrupts.
 
 Software SPI bus
 ----------------
@@ -622,27 +509,6 @@ Methods
     
     Returns ``None``.
 
-
-Timers
-------
-
-This port supports hardware timers, which can be used for timing-related applications.
-
-Use the :mod:`machine.Timer` class::
-
-    from machine import Timer
-    import time
-    tim0 = Timer(0, period=1000, mode=Timer.ONE_SHOT, callback=lambda t:print("One shot timer triggered")) #Default assignment: period=9999, frequency=10000
-    tim1 = Timer(1, period=3000, mode=Timer.PERIODIC, callback=lambda t:print("Periodic timer triggered"))
-
-    tim0.deinit() # Deinitialise the timer
-    tim1.deinit() # Deinitialise the timer
-
-Here, id can take values between 0 and 31 as a maximum of 32 hardware timers is supported.
-
-.. note::
-    Virtual timers are not supported in this port.
-
 ADC (analog to digital conversion)
 ----------------------------------
 
@@ -874,4 +740,139 @@ Methods
         print(read_data)
 
     bdev.deinit()
+
+Bitstream
+---------
+
+::
+
+    from machine import bitstream
+    
+    timing = [1000, 7000, 5000, 2500]          # timing (high_time_0, low_time_0, high_time_1, low_time_1)in ns
+    buf = bytearray([0xAB])                    # buffer data 
+    bitstream('P13_6', 0, timing, buf)         # bitstrem buffer data with timing through pin P13_6
+
+.. note::
+    Bitstream is set for the CPU frequency of 100MHz. At other clock frequencies, the timing will not fit.
+    All timings greater than 1500 ns work and the accuracy of the timing is +/- 400 ns. 
+    Supported timing_ns ranges below 1500 ns are [500, 1125, 800, 750], [400, 850, 800, 450], [300, 900, 600, 600] and [800, 1700, 1600, 900].
             
+Network Module
+--------------
+
+The :mod:`network` module.
+
+See :ref:`network.WLAN <network.WLAN>`:
+
+For some methods and constants, the PSoC6 network port implements certain specializations and slightly different behaviour. This is explained in this section.
+
+Methods
+^^^^^^^
+
+.. method:: WLAN.scan(ssid=None, bssid=None)
+
+    The scan option accepts the following filters as keyword arguments, removing from scan results any network not matching these parameters values:
+
+    * ``ssid``
+    * ``bssid``
+
+.. method:: WLAN.status('param')
+
+    .. warning:: 
+        The function does not provide the status of the connection. Use the ``active()`` for that purpose. Any errors or failures are communicated when using the corresponding enable/disable or connect/disconnect functions.
+
+    The following query parameters are allowed:
+        * ``rssi``. Only for STA.
+        * ``stations``. List of connected stations (only for AP).
+
+.. method:: WLAN.config('param')
+            WLAN.config(param=value, ...)
+
+    Among the suggested parameters of the general network WLAN API, for this port, only these are available:
+
+    * AP & STA query parameters
+
+        - ``channel``
+        - ``ssid``
+        - ``security```
+        - ``key/password``. Only for default AP key.
+        - ``mac``
+    * AP set parameters
+
+        - ``channel``
+        - ``ssid``
+        - ``security```
+        - ``key/password``. Only for default AP key.
+        
+    * STA has no configurable parameter.
+
+Constants
+^^^^^^^^^
+
+Security modes constants:
+
+.. data:: WLAN.OPEN
+        WLAN.WEP
+        WLAN.WPA
+        WLAN.WPA2
+        WLAN.WPA3
+        WLAN.WPA2_WPA_PSK
+        WLAN.SEC_UNKNOWN
+
+.. note::
+    Power modes configuration not implemented.
+     
+Here is a function you can run (or put in your boot.py file) to automatically connect to your Wi-Fi network:
+
+::
+
+    def network_connect() :
+        import network
+        from utime import sleep,sleep_ms
+        wlan = network.WLAN(network.STA_IF)
+        if wlan.isconnected():
+            print('[Network] already connected')
+            return
+
+        # enable and connect wlan
+        wlan.active(True)
+        wlan.connect('<ssid>','<key>')
+
+        # wait for the connection to establish
+        sleep(5)
+        for i in range(0,100):
+            if not wlan.isconnected() and wlan.status() >= 0:
+                print("[Network] Waiting to connect..")
+                sleep(2)
+
+        # check connection
+        if not wlan.isconnected():
+            print("[Network] Connection failed!")
+        else:
+            print(wlan.ifconfig())
+
+NeoPixel driver
+---------------
+
+The [NeoPixel library](https://docs.micropython.org/en/latest/library/neopixel.html) for controlling various addressable LEDs (like WS2812B, SK6812, ...) is supported in this port. The library can be installed using [mip](https://docs.micropython.org/en/latest/reference/packages.html). 
+
+::
+
+    import mip
+    mip.install('neopixel')
+
+The NeoPixel driver can be used as follows (see the :mod:`neopixel` for more details):
+
+::
+
+    import neopixel
+    from machine import Pin
+    data = Pin('P9_1', Pin.OUT, value=0)   # set P9_1 to output to control NeoPixels
+    np = neopixel.NeoPixel(data, 8, bpp=3) # create NeoPixel object on pin P9_1 with 8 pixels and 3 bytes per pixel with default timing=1
+    np[0] = (255, 255, 255)                # set the first pixel to white
+    np.write()                             # write data to all pixels
+
+.. note::
+   - The timing parameter can be used in the `NeoPixel()` constructor with timing tuples supported by the `machine.bitstream()` module. The timing parameter is optional and by default set to 1 which is the default timing [400, 850, 800, 450] for WS2812B LEDs at 800kHz.
+   - Use timing = 0 for WS2812B LEDs at 400kHz ie, [800, 1700, 1600, 900].
+   - Use timing = [300, 900, 600, 600] for SK6812 LEDs. 
\ No newline at end of file