Posted on Leave a comment

ESP8266 Secure AP mode

Quite often we take shortcut to make things simple. That that sometimes will come and bite you back. To make sure you always consider security in mind at everything you do. Password is to keep something secure, and not to be forgotten.

In this post, I am trying to show how simple the security can be implemented to ensure that we always have security in mind. There is nothing worse than having a fully working system and then get hacked. This will cause unnecessary stress later.

If you are using ESP8266 in AP mode to setup the WIFI configuration, don’t forget to set the password and make sure you keep it secure by remembering it and not tell anyone.

In order to do this you can set the password when setting the ESP as and AP, this is done using the following code:


The second line in the above code passed in “AP_PASS” variable, this will ensure that you can connect to the ESP using the password. You can also leave the second parameter blank to leave it open, but then anyone can connect to it and messed up with your setting. Things to note, the password will need to be more than 8 Characters, otherwise, the function call will fail. The best way to check this is to check the Serial Monitor and modify the above code to be as follow:

Serial.print("Starting AP mode:");
Serial.println(WiFi.softAP(WIFI_AP_NAME, AP_PASS)? "Ready": "Failed!");

When the AP is started, you can see in the Serial monitor window whether the function call WiFi.softAP is success or not. The simple code describing the above can be found below.

   Copyright (c) 2015, Majenko Technologies
   All rights reserved.
   Redistribution and use in source and binary forms, with or without modification,
   are permitted provided that the following conditions are met:
 * * Redistributions of source code must retain the above copyright notice, this
     list of conditions and the following disclaimer.
 * * Redistributions in binary form must reproduce the above copyright notice, this
     list of conditions and the following disclaimer in the documentation and/or
     other materials provided with the distribution.
 * * Neither the name of Majenko Technologies nor the names of its
     contributors may be used to endorse or promote products derived from
     this software without specific prior written permission.

/* Create a WiFi access point and provide a web server on it. */


#ifndef APSSID
#define APSSID "ESPap"
#define APPSK  "thereisnospoon"

/* Set these to your desired credentials. */
const char *ssid = APSSID;
const char *password = APPSK;

ESP8266WebServer server(80);

/* Just a little test message.  Go to in a web browser
   connected to this access point to see it.
void handleRoot() {
  server.send(200, "text/html", "You are connected");

void setup() {
  Serial.print("Configuring access point...");
  /* You can remove the password parameter if you want the AP to be open. */
  WiFi.softAP(ssid, password);

  IPAddress myIP = WiFi.softAPIP();
  Serial.print("AP IP address: ");
  server.on("/", handleRoot);
  Serial.println("HTTP server started");

void loop() {

Hopefully you will find this article useful to secure your IoT devices and saving you the headache of being hacked in the future. If you like this post, please share and don’t forget to subscribe the blog for more article about IoT and Arduino.

Posted on Leave a comment

Arduino LED Matrix “Game of Life”

I was reading a post about someone making a Thanos Gauntlet and simulating wiping off half of the population randomly. So I thought about the “Game of Life” simulation. If you want to know more about “Game of Life” you can read it all up here. So why not trying to make this simulation based on my previous build of the 8×8 LED Matrix. The circuit can be found below:

Using the previous build, I made a few adjustment to the code to simulate the game of life. The first thing to note is to initialise the 8×8 variable to hold the initial life form, the next variable is the next stage after the life form evolved, this is shown as below:

bool field[8][8] = {};
bool nextfield[8][8] = {};

When the program start, we randomly assign the 8×8 matrix with zeros and ones to simulate the initial stage, this is shown in the following code. The code will only be executed when the button is pressed longer than the threshold defined by variable debounce. I define this to be 50ms.

if (buttonpressed == HIGH && millis() - time > debounce){ // set random life
time = millis();
started = false;
for (int i = 0; i<8; i++) {
for (int j = 0; j<8; j++){
field[i][j] = random(2);
Serial.print("field["); Serial.print(i); Serial.print("]["); Serial.print(j);
started = !started; // start the Game of Life simulation

Right after the initialisation, the code will set the started variable to true. The program will calculate the next field at every iteration this is done by calling the fillNextField() function, shown in the following code.

}else if (started){
// calculate next field
if (millis() - 1000 > lastMillis) {// delay each iteration by 1000 ms
for (int x = 0; x<8; x++){
for (int y = 0; y<8; y++) {
field[x][y] = nextfield[x][y];
lastMillis = millis();

The rule of Game of Life is as below. Each cell’s existence depends on all the other 8 cells that are surrounding it.

  1. Any live cell with fewer than 2 live neighbours dies, as if by underpopulation
  2. Any live cell with two or three live neighbours lives on to the next generation (cycle)
  3. Any live cell with more than three live neighbours dies, as if by overpopulation.
  4. Any dead cell with exactly 3 live neighbours becomes a live cell, as if by reproduction.

Based on the logic above the getCellsNextState(int x, int y) function is being developed as shown below:

//returns the cell's next state, true if alive, false otherwise
bool getCellsNextState(int x, int y) {
bool shouldBeAlive = false;
shouldBeAlive |= (!field[y][x] && countAliveNeighbours(x, y) == 3);
shouldBeAlive |= (field[y][x] && countAliveNeighbours(x, y) == 3);
shouldBeAlive |= (field[y][x] && countAliveNeighbours(x, y) == 2);
return shouldBeAlive;

As you can see the CountAliveNeighbours(x,y) function will count the number of alive neighbours around the cell. This is done by simply iterating from the one cell before and after in x coordinate and one cell before and after in y coordinate. Then we define the boundary condition as per our LED matrix boundary, which is 8 cells x 8 cells. And finally we count how many live cells as per below function.

// counts the alive neighbours this step
int countAliveNeighbours(int x, int y) {
int retVal = 0;
for (int row = y - 1; row <= y + 1; row++) { for (int col = x - 1; col <= x + 1; col++) { if ((row == y && col == x) || (row < 0) || (row > 7) || (col < 0) || (col > 7)) continue;
if (field[row][col]) retVal++;
return retVal;

If all goes well, you should see the following Game of Life simulation similar to the following video.

Congratulations, how you are able to simulate this classic Game of Life and you can modify this to your heart’s content. What you can do next is to stop the simulation and wipe off half of the live form like what Thanos did, and feel the power of the Infinity Gauntlet.

Please share or comments if you like this post, and let me know if you have any questions related to this.

Posted on Leave a comment

Light Saber Build Part 2

This is the continuation of the Light Saber Build Part 1. You can check the previous post to see where I am up to. Just a quick recap from Part 1. I am connecting the DPPlayer to the Arduino Nano and also the saber on-off switch which is connected to D3 and ground as shown in the following circuit.

The next part is to connect the Gyro MPU6050 and the LED strip WS2811. My LED strip consist of 20 controller, each controller is controlling 3 LEDs. Before putting everything together in the case, we are testing to make sure the strip are lighting up properly and also when there is a sudden movement or “a hit” the hit sound effects are being played.

You can see the test result in the following video.

Things to note about the feature of the light saber:

  • Sound effect for saber on and off
  • Switching lightsaber colour when the button are pressed 3 times when the lightsaber is on
  • Toggle the humming sound effect on and off when the button are pressed 5 times when the lightsaber is on
  • Humming sound and special effects when the lightsaber hit an object or there is a change in the angle

Once we tested that the lightsaber are functioning correctly, as per the feature that we want, it is time that we put the case together. I found that this is the most difficult part to get the right combination for the part. I am a big believer in recycling, so I am trying hard to find some spare parts that are lying around that can be used to build the lightsaber. Stay tune for the next write up on the lightsaber case.

If you like this post, please share it, and don’t forget to subscribe and please let me know if you have any questions and I will try to answer them.

Posted on Leave a comment

Light Saber build part 1

Today is May Day, so I though to prepare and finish off my Light Saber build that had been sitting in my shelf for quite sometime. The idea is not new and the circuit is a modification of an existing circuit build by someone else. So it is not by any means original but still fun to build.

So here is the circuit, it is using Arduino nano as the “brain” and MPU6050 gyroscope to detect the movement. It also being equipped with DFPlayer mini for the light Saber effect. The light is using addressable LED strip (WS2811).

I had manage to wire up the circuit by recycling my previous build of Frankenbot. I have not wire up the LED and the gyroscope just yet, this is to ensure that everything is working before moving on to the next part.

Here are the Video of the special effects turning on and off. Stay tune for the part. If you like this, please subscribe and share the content.

Posted on Leave a comment

3 Step to use External Interrupt on ESP8266

I was in the middle of replicating my 433 MHz remote control using Arduino. The receiver circuit is quite simple and it is using Arduino pin 2 (interrupt) to detect the data signal from the receiver.

I was wondering whether I can do the same thing with ESP8266. After a short google, I found some information about Interrupt pin D3 (GPIO0) and also D0 (GPIO16). At a glance it seems do able.

Here are the steps to use the interrupt.

  1. Initialise IO pin as input
  2. Initialise IO with Interrupt Subroutine definition
  3. Interrupt Subroutine.

Here are the code that I stumble upon from the website.

const int interruptPin = 0; //GPIO 0 (Flash Button) STEP 1
const int LED=2; //On board blue LED
void setup() {
  pinMode(interruptPin, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(interruptPin), handleInterrupt, CHANGE); // STEP 2
void loop()
    digitalWrite(LED,HIGH); //LED off
    digitalWrite(LED,LOW); //LED on
//This program get executed when interrupt is occurs i.e.change of input state - STEP 3
void handleInterrupt() {
    Serial.println("Interrupt Detected");

I will try this tonight and report back whether the Interrupt detection works or not.

The Remote.

BAUHN Remote Control

The remote consist of 4 ON button and 4 OFF buttons, each one is labelled A, B, C and D.It works independently controlling the remote power point switch.

The power point needs to be sync against one of the button pair (A, B, C or D). In this experiment I am detecting button B.

Below are the connection between ESP8266 to the 433 MHz receiver. As you can see I only connected 3 cables. 3.3V Vcc for Power (red cable), GND (green cable) and Data (Yellow) connected to GPIO0 of ESP8266 (D3).

I had used a slightly different sketch which is utilising the rc-switch library, and it also can provide the same detection that I had done using Arduino Uno. Here are the sketch that I had used to detect the remote.

#include <RCSwitch.h>
RCSwitch mySwitch = RCSwitch();

void setup() {
mySwitch.enableReceive(0); // Receiver on interrupt 0 => that is pin GPIO0 or D3 in ESP8266

void loop() {
if (mySwitch.available()) {
Serial.print("Received ");
output(mySwitch.getReceivedValue(), mySwitch.getReceivedBitlength(), mySwitch.getReceivedDelay(), mySwitch.getReceivedRawdata(),mySwitch.getReceivedProtocol());

I had connect the receiver to Pin D3 on ESP8266, and getting the following result when I press the B-ON button.

Received Decimal: 9085236 (24Bit) Binary: 100010101010000100110100 Tri-State: not applicable PulseLength: 500 microseconds Protocol: 5
Raw data: 7036,1061,455,589,934,607,918,613,952,1071,454,575,955,1065,457,565,971,1033,509,509,1021,1022,506,526,995,542,981,548,977,543,979,1055,482,561,1057,466,1080,942,548,980,540,486,1067,956,552,484,1071,564,966,
Received Decimal: 9085236 (24Bit) Binary: 100010101010000100110100 Tri-State: not applicable PulseLength: 500 microseconds Protocol: 5
Raw data: 6969,1116,407,629,907,553,987,554,928,1085,445,593,924,1123,405,623,912,1122,403,625,901,1049,489,537,988,546,974,556,965,565,970,1045,483,561,944,559,969,1070,453,1073,453,578,949,1066,460,577,946,545,1021,

So I can conclude that the Interrupt definitely working ok. The next step would be to capture a few more data and trying to send it back via the 433MHz transmitter to try to replicate each of the button. Given that the ESP8266 can be connected to WIFI and also can server as a webserver this will make it possible to control the remote via internet as an IoT device.

Stay tune for the next article. Please share or subscribe if you like to see more of this article and feel free to drop me a comment.

Posted on Leave a comment

Connecting IoT Sensors data to Node-RED

This is the continuation of the Temperature sensor project in the previous post. The concept is to allow the data from sensors (temperature, motion) can be displayed in Apple Homekit, so that the user can interact with the information and control the IoT connected devices (Lights, Fan, etc). It is best described in the following picture.

The following instruction shows how to install Node-RED on a linux computer running Debian OS.

sudo npm install -g --unsafe-perm node-red

You will also need to install the mosquitto MQTT message broker, here are the command required

sudo apt-key add mosquitto-repo.gpg.key
sudo wget
sudo apt-get update
sudo apt-get install mosquitto

You will also need the latest Python library, so grab them using the following instruction

sudo apt-get install python-dev

Test the installation. In this example I was using Linux Debian, so typing the command node if you get the following in the command prompt, that means the installation is successful. So then you can exit node by typing .exit command in the prompt >.

If all goes well, you can run the node-red command in the command prompt. You should get the following message. This shows that the node-red is now running at

Node-RED Settings

Node-RED setting file called settings.js, on Linux it is located in the /usr/lib/node-modules/node-red folder. You will have another settings.js file in the .node-red folder in your home folder. This setting will be loaded by default.

Creating the flow in Node-RED

Now that you have a running Node-RED, it is time to create the flow. In this example we will create a simple flow to read temperature posted by our ESP8266. Let’s start by firing up your favourite browser and point to the following URL:

You will be presented with a blank screen similar to the following picture. Now to start creating a flow, drop an “Inject” node from input section. We will use this as a trigger to get the temperature reading. Once you dropped it in, double click to set the property. We call the node “timestamp” and we set the interval to repeat every 4 minutes.

The next step is to connect this with an “http” node, so drop an “http” node and configure this as http GET to call a server side script in the webserver. What the script needs to return is the temperature in JSON format as below:


So my data_store2.php script does exactly that, as shown in the following code:

 /* readtemperature file from temp.txt file    return the value back in JSON format for HomeKit  */ 
$theparam = $_GET;
$file = './temp.txt';
$temperature = file_get_contents($file);
echo '{"CurrentTemperature":'.$temperature.'}';

Now the final step is to connect to the “Homekit” node from the Advance nodes menu. Once you drop the “Homekit” node, you can double click to configure the property as below.

Once all had been connected, it is time to deploy the node. You can do this by clicking on the “Deploy” button at the top of the Node-RED window. You will need to click the “Deploy” button whenever you make any changes to the node. Sometime the deployment might stop the Node-RED server, so you just have to run the node-red command again in the command prompt.

If all goes well, you can now test this node by clicking on the button next to “timestamp” node, the temperature should be read from the webserver and displayed in Homekit, similar to the following picture.

That conclude this session on how to configure the Node-RED to work with our temperature sensor data from ESP8266. Please let me know if you have any questions related to this and don’t forget to subscribe for update on the similar projects. The next session we are going to connect this to the Apple homekit in IPhone or IPad.

Posted on Leave a comment

Download Microsoft Sharepoint List Attachments using Powershell script

I stumble across a problem when trying to download attachment from the Sharepoint List. The list have more than 50,000 rows, the problem with the big list is Windows explorer is not able to display the list in Explorer view, so there is a need to use the Powershell script to download all the attachment programmatically.

Step 1. Make sure you have the Sharepoint Client dll required as specified in the following code

[void][Reflection.Assembly]::LoadFrom("$env:CommonProgramFiles\Microsoft Shared\Web Server Extensions\15\ISAPI\Microsoft.SharePoint.Client.dll")
[void][Reflection.Assembly]::LoadFrom("$env:CommonProgramFiles\Microsoft Shared\Web Server Extensions\15\ISAPI\Microsoft.SharePoint.Client.Runtime.dll")

Step 2. Define the sharepoint site and the list library

The sharepoint site and the library is defined using the following $webUrl variable and $library respectively, also don’t forget to specify the local folder where the files will be downloaded.

$webUrl = "" 
$library = "SharepointLibrary"
Local Folder to dump files
$tempLocation = "C:\temp\"

Step 3. Define how many rows the CamlQuery should return on each iteration

The beauty of the PowerShell Script is that you can specify how many rows to return each time, so the script will not have a problem recursively going through a big list that are over 50,000 and being able to download all the attachment. The following code shows that we are limiting the query to return 3000 rows.

$camlQuery = New-Object Microsoft.SharePoint.Client.CamlQuery $camlQuery.ViewXml ="<View> <RowLimit>3000</RowLimit></View>"

Step 4. Define the folder structure to hold all the attachment to be downloaded

The following code is using the combination of Title and ID as the folder name to store the attachment. It also check whether the folder already exists prior to creating a new one.

    $destinationfolder = $tempLocation + "\"+ $folderName 

     #check if folder is exist or not, if not exist then create new
  if (!(Test-Path -path $destinationfolder))        
     $dest = New-Item $destinationfolder -type directory      
     Write-Host "Created Folder with Name:" $folderName    

The following is the full code to download the list attachments and put them in the local folder. The credential used is the user credential where the script is executed, that means the login user will need to have access to the SharePoint Site and able to download the attachement.

[void][Reflection.Assembly]::LoadFrom("$env:CommonProgramFiles\Microsoft Shared\Web Server Extensions\15\ISAPI\Microsoft.SharePoint.Client.dll")
[void][Reflection.Assembly]::LoadFrom("$env:CommonProgramFiles\Microsoft Shared\Web Server Extensions\15\ISAPI\Microsoft.SharePoint.Client.Runtime.dll")
#$cred = Get-Credential ""
#$credentials = New-Object Microsoft.Sharepoint.Client.SharePointOnlineCredentials($cred.Username, $cred.Password)
$webUrl = ""

$clientContext = New-Object Microsoft.Sharepoint.Client.ClientContext($webUrl)
Write-Host "Connecting To Site: " $webUrl   

 $username = "$env:USERDOMAIN\$env:USERNAME"

$library = "SharepointLibrary" 
#Local Folder to dump files
$tempLocation = "C:\temp\"    

$global:web = $clientContext.Web;
$global:site = $clientContext.Site;


$listRelItems = $clientContext.Web.Lists.GetByTitle($library)

Write-Host "list item count " $listRelItems.ItemCount

$camlQuery = New-Object Microsoft.SharePoint.Client.CamlQuery
$camlQuery.ViewXml =" 3000"
 $listCollection = New-Object System.Collections.Generic.List[string] 
 $count = 0
Do {
$camlQuery.ListItemCollectionPosition = $allItems.ListItemCollectionPosition
foreach ($listItem in $allItems)
    $destinationfolder = $tempLocation + "\"+ $folderName 

     #check if folder is exist or not, if not exist then create new
  if (!(Test-Path -path $destinationfolder))        
     $dest = New-Item $destinationfolder -type directory      
     Write-Host "Created Folder with Name:" $folderName    

    $attach = $listItem.AttachmentFiles
    if($attach -ne $null){
        Write-Host "No of attachment:" $attach.Count
        foreach ($attachitem in $attach){
            Write-Host "Downloading Attachements started: "   $attachitem.FileName
            $attachpath = $webUrl + "/Lists/"+ $library + "/Attachments/" + $listItem["ID"] + "/" + $attachitem.FileName
            Write-Host "path: " $attachpath 
            $path = $destinationfolder + "\" + $attachitem.FileName
            Write-Host "Saving to the location:"  $path

            $siteUri = [Uri]$attachpath
            $client = new-object System.Net.WebClient
                  $client.DownloadFile($attachpath, $path)
            } catch{
                write-error "Failed to download $url, $_ "

    }else {
     Write-Host   "For above current item don't have any attachments" 
Write-Host " List item" $count
} while ($camlQuery.ListItemCollectionPosition -ne $null)
     Write-Host   "Script execution done !" 

Please let me know if the above script is of useful to you and don’t forget to share or subscribe for more frequent update to the similar topic. You can also drop me a line or questions if you have any.

Posted on Leave a comment

4 Steps to download Microsoft Sharepoint Document Library recursively

I stumble across this problem when we try to decommissioning Microsoft Sharepoint. We had a huge document library and it is not possible to copy them from explorer view, so the solution is to use PowerShell script to do this automagically.

Step 1. Define the DLL that is required.

This is done through the following code snippets. It is crucial to have the 2 DLL to allow the copy function to work. The script will use the credential of the user login into the machine and executing the script. This removes the complexity having to enter the sharepoint credential into the script.

# Load the SharePoint 2013 .NET Framework Client Object Model libraries. # 

Step 2. Define the sharepoint site URL and the Document Library repository

You can simply enter the sharepoint URL by replacing the following $serverURL variable. Enter the document library by replacing the $DocumentLibrary variable and don’t forget to define the destination folder.

$serverURL = “http://sharepoint.url/sites/sitename”
$destination = "C:\temp\"
$DocumentLibary = "Document Library Name"

Step 3. Choose whether you only want specific folder to be downloaded from the Document Library

Change the folder name that you are interest in downloading, in the following example we are only interested in downloading folder “Payments” and all the folder underneath it.

function Parse-Lists ($Lists)
    foreach ($Folder in $Lists.RootFolder.Folders)
            if ($ -eq "Payments"){   #onlydownload selected folder
                recurse $Folder


Step 4. Execute the script via PowerShell window or from Command line.

To execute the script via command line you can execute the following Powershell command, with the assumption the name of the powershell script is “scriptname.ps1”

C:\Powershell.exe scriptname.ps1

Here are the full script to download the Sharepoint Document library, be careful the script will download the entire document library recursively, so please make sure you check Step 3 above. With great power comes great responsibility.

# Load the SharePoint 2013 .NET Framework Client Object Model libraries. # 

$serverURL = “http://sharepoint.url/sites/sitename”
#$siteUrl = $serverURL+"/documents”
$destination = "C:\temp\"
$DocumentLibary = "Document Library Name"
$downloadEnabled = $true
$versionEnabled = $false

# Authenticate with the SharePoint Online site. # 
#$username = ""
#$Password = ""
#$securePassword = ConvertTo-SecureString $Password -AsPlainText -Force  

$clientContext = New-Object Microsoft.SharePoint.Client.ClientContext($serverURL) 
#$credentials = New-Object Microsoft.SharePoint.Client.SharePointOnlineCredentials($username, $securePassword) 
#$clientContext.Credentials = $credentials 
if (!$clientContext.ServerObjectIsNull.Value) 
    Write-Output "Connected to SharePoint Online site: '$serverURL'"

function HTTPDownloadFile($ServerFileLocation, $DownloadPath)
#Download the file from the version's URL, download to the $DownloadPath location
    $webclient = New-Object System.Net.WebClient
    $webclient.credentials = $credentials
    Write-Output "Download From ->'$ServerFileLocation'"
    Write-Output "Write to->'$DownloadPath'"
    $webclient.Headers.Add("X-FORMS_BASED_AUTH_ACCEPTED", "f")

function DownloadFile($theFile, $DownloadPath)
    $fileRef = $theFile.ServerRelativeUrl;
    Write-Host $fileRef;
    $fileInfo = [Microsoft.sharepoint.client.File]::OpenBinaryDirect($clientContext, $fileRef);
    $fileStream = [System.IO.File]::Create($DownloadPath)

function Get-FileVersions ($file, $destinationFolder)
    foreach($version in $file.Versions)
        #Add version label to file in format: [Filename]_v[version#].[extension]
        $filesplit = $file.Name.split(".") 
        $fullname = $filesplit[0] 
        $fileext = $filesplit[1] 
        $FullFileName = $fullname+"_v"+$version.VersionLabel+"."+$fileext           

        #Can't create an SPFile object from historical versions, but CAN download via HTTP
        #Create the full File URL using the Website URL and version's URL
        $ServerFileLocation = $siteUrl+"/"+$version.Url

        #Full Download path including filename
        $DownloadPath = $destinationfolder+"\"+$FullFileName
        if($downloadenabled) {HTTPDownloadFile "$ServerFileLocation" "$DownloadPath"}


function Get-FolderFiles ($Folder)

    foreach ($file in $Folder.Files)

            $folderName = $Folder.ServerRelativeURL
            $folderName = $folderName -replace "/","\"
            $folderName = $destination + $folderName
            $fileName = $
            $fileURL = $file.ServerRelativeUrl
            if (!(Test-Path -path $folderName))
                $dest = New-Item $folderName -type directory 
            Write-Output "Destination -> '$folderName'\'$filename'"

            #Create the full File URL using the Website URL and version's URL
            $ServerFileLocation = $serverUrl+$file.ServerRelativeUrl

            #Full Download path including filename
            $DownloadPath = $folderName + "\" + $file.Name
            #if($downloadEnabled) {HTTPDownloadFile "$ServerFileLocation" "$DownloadPath"}
            if($downloadEnabled) {DownloadFile $file "$DownloadPath"}

            if($versionEnabled) {Get-FileVersions $file $folderName}

function Recurse($Folder) 
    $folderName = $Folder.Name
    $folderItemCount = $folder.ItemCount

    Write-Output "List Name ->'$folderName'"
    Write-Output "Number of List Items->'$folderItemCount'"

    if($ -ne "Forms")
            #Write-Host $Folder.Name
            Get-FolderFiles $Folder
    Write-Output $folder.ServerRelativeUrl
    $thisFolder = $clientContext.Web.GetFolderByServerRelativeUrl($folder.ServerRelativeUrl)
    foreach($subfolder in $thisFolder.Folders)
            Recurse $subfolder  

function Parse-Lists ($Lists)
    foreach ($Folder in $Lists.RootFolder.Folders)
            if ($ -eq "Payments"){   #onlydownload selected folder
                recurse $Folder


$rootWeb = $clientContext.Web
$LibLists = $rootWeb.lists.getByTitle($DocumentLibary)

Parse-Lists $LibLists


Please let me know if the above script is useful, feel free to subscribe to my blog, share this script or ask me any questions related to the script.

Posted on Leave a comment

Realtime Clock with 18F2550

I am trying to make use of the previous circuit on connecting LED display to 18F2550, and combining this with Real time clock module DS3231. So here are the diagram of the connection:

Here are the list of parts used in this project:

  • 18F2550 USB development board
  • Realtime clock DS3231
  • Button cell battery CR2032 (for realtime clock)
  • LCD Display
  • 10K ohm variable resistor (to control the brightness of LCD display)
  • 200 ohm pull up resistor

The 18F2550 USB development board can be shown below:

This board comes loaded with boot loader to allow easy loading of the firmware code. I am using the MPLAB IDE v8.92 to compile and build the code for the USB development board.

I am also using the previously ported LCD display code to use in this project.

Connect Everything together

First we connect the LCD Display to the Development board. We are only using 4 bit for the data transfer so here are the detail connection of the LCD Display:

  • RS LCD —- C6 Dev Board
  • EN LCD —- C7 Dev Board
  • D4 LCD —- A0 Dev Board
  • D5 LCD —- A1 Dev Board
  • D6 LCD —- A2 Dev Board
  • D7 LCD —- A3 Dev Board

You will also need to connect a pull up resistor to Anode pin of LCD display before connecting to +5V and Middle of 10k resistor to VO pin of LCD display, while the other ends of the 10K resistor is connected to VCC and GND respectively.

Test the LCD connection.

Once you had connected the LCD Display to 18F2550 development board you can load the demo display program. To load the demo program (C18-BOLT-LCD-MESSAGE-SCROLLING.HEX), you can use the loader program “MiEUSBHIDLoader.exe“. This program will display a scrolling Alphabet in the first row and numbers on the second row of the LCD Display, please make sure that this is working properly prior to continuing to the next step.

Connecting the Real time clock

First connect the button cell CR2032 to the realtime clock module DS3231. Then connect the DS3231 to the USB development board. To connect the real time clock DS3231 to the 18F2550 USB Development board use the following connection:

  • SDA RTC —- B0 Dev Board
  • SCL RTC —- B1 Dev Board

You will also need to connect the VCC of DS3231 to the 5V and GND to the ground of the 18F2550 Development board. Once this is done you can now upload the RTC clock program. You might want to recompile the code to set the date and time the first time you are loading the code

// uncomment the following to set the date and time
DS3231_SetDate(29,03,19); // setting the date to 29-Mar-2019
DS3231_SetTime(00,19,01); // setting the time to 00:19:01

Once the code is loaded, the date and time is now saved in the DS3231 module. As long as the button cell CR2032 is connected to the DS3231 module, the date and time will be retained. Now you need to recompile the code again with the above code uncommented, this is to ensure that every time you reset the USB development board, it will not reset the date and time of RTC module back to the date time above.

Please drop me a line and share this post if you like it, and let me know what I can improve on. Stay tune for the next revision that will include buttons to set the date and time.

Posted on Leave a comment

Connecting ESP8266 to P10 Display and displaying data from webserver

The concept is to have the ESP8266 driving the P10 display by reading the data from the webserver, this will ensure that the data can be updated automatically in the webserver via some automation and the P10 is being set to poll the data periodically and displaying it on the P10 display. You can see the concept in the following diagram:

Here are the connection diagram to connect to ESP8266 to P10 Display.


For simplicity here are the connection required from ESP8266 to the P10 header.

Coding preparation

What you will need is the Arduino IDE interface and loaded with the following library:

  1. DMD2 library can be downloaded via the link
  2. SPI library (this is usually already installed with Arduino)
  3. ESP8266WiFi library (you can search for this in the Arduino library via Sketch->Include Library->Manage Library and put ESP8266 in the search box)

The first step is to connect the ESP8266 to your WIFI, this is done in the following code

char ssid[] = "ssid"; //  your network SSID (name)
char pass[] = "password"; // your network password (use for WPA, or use as key for WEP)
void setup() {
WiFi.begin(ssid, pass);

Then assuming the data is located in the webserver path /arduino/message.json, we then need to initialise the location as below:

const char* webserver = "";      // webserver where the cloud is hosted
String messagePath = "/arduino/message.json"; // location of message data

Once the connection to webserver is established, the following function will parse the data and store in the local variable MESSAGE:

void readMessage(){
DebugLn("Connecting to " + String(webserver));
WiFiClient client;
const int httpPort = 80;
if (!client.connect(webserver, httpPort)) {
Serial.println("connection failed");
client.print(String("GET ") + messagePath + " HTTP/1.1\r\n" +
"Host: " + webserver + "\r\n" +
"Connection: keep-alive\r\n\r\n");
delay(500); // wait for server to respond
// read response
String section="header";
String line = client.readStringUntil('\r');
// Serial.print(line);
// we’ll parse the HTML body here
if (section=="header") { // headers..
if (line=="\n") { // skips the empty space at the beginning
else if (section=="json") { // print the good stuff
String result = line.substring(1);
// Parse JSON
int size = result.length() + 1;
char json[size];
result.toCharArray(json, size);
StaticJsonBuffer<200> jsonBuffer;
JsonObject& json_parsed = jsonBuffer.parseObject(json);
if (!json_parsed.success())
Serial.println("parseObject() failed");
// read the message
MESSAGE = json_parsed["message"];
Serial.println(MESSAGE); //display message in serial window
Serial.print("closing connection. ");

The last piece is to display the message to the screen with the following function:

void scrolling() {
const char next = MESSAGE; while (next) {
dmd.clearScreen();// clear screen
if (i != 0) {
box.print(*next); //print the led pannel
delay(800); // letters speed changing

The full source code can be downloaded via the following link.

Please don’t hesitate to let me know if you experience any issue with the code. You can buy me a coffee later if you like this post.