With some research for PCB manufacturer online, JLCPCB has caught my attention. Simply search “JLCPCB” on Youtube, you can find a lot of reviews from various channels. But the most catchy point of JLCPCB is that you can actually make you own PCB for $2 dollars. In this article, I will share some of my experience on getting a manufactured PCB, hopefully it will benefit and encourage you to try manufacture your first PCB.

To manufacture your PCB, first you need to design your own PCB layout. In this case, I am using the KiCad to design. This is also my first time using the KiCad tools as oppose to the Eagle. But I will not go into details regarding the design tools. Anyway, the layout looks as the figure below.

While you are excited to design your layout, do not forget to check the capabilities of your PCB manufacturer. Each manufacturer has different capabilities that they can achieve. Some of the things that you want to look for such as the minimum trace width, spacing, dimension, layer, drill hole size and etc. Checking this before your design and use them in your design rules to make sure you do not violate any of them. If you noticed that violate any of these rules at the late stage of design, it might requires you to redesign your layout, which can be time consuming and troublesome.

Once the layout is complete, you need to send the design files to the PCB manufacturer. There are various design tools available, each might have different output files. Instead of having the PCB manufacturer to have all the tools to open the files, Gerber file is used. A quick search on Wiki, a Gerber is the standard used to describe the printed circuit boards such as the copper layers, solder mask, and etc.

Since this was my first time, I wasn’t too sure about generating the required gerber files for manufacturing. Luckily, there is a guide provided by JLCPCB at the end of the home page. On the most left side image below, there are several guides, which are useful for reference. Since I am using the KiCad, I would refer to the “KiCad PCB to gerber files“. If you are using other tools (eg. Eagle, Altium) guide is also available. From there, steps-by-steps guide is provided to show you how to generate the necessary Gerber and Drill files.

Once you followed all the steps provided, you will end up with a .zip file that contains the Gerber and drill files. In my case, the necessary files to be included in the Gerber are the Top and Bottom copper layer, silkscreen layer, solder mask layer and the edge cut. Below are simple explanations to the files and what it means:

• Copper layer: Contains all the copper traces and pads on the PCB
• Silkscreen layer: Contains all the silkscreen printings which could be the ref des of components and etc.
• Solder mask layer: Describe which area should be covered by solder mask (usually green) and mask away the pads which required for soldering.
• Edge cut: Describe the edge of the PCB (eg. what shape and how big it is).

Once the design file is ready, head over to the JLCPCB website, and go for a fast quote. In this page, there are various options that you can choose with, such as the PCB quantity, dimension, PCB solder mask colour and etc. For your info, even without a design files, you can still play around with the options and get an instant quote to estimate how much does your board costs. This is also useful if you are trying to compare among various vendors.

Earlier in this article, I mentioned you can manufacture your PCB for $2 dollar. In order to eligible for this offer, take note on these few things:

• The board dimension must not exceed 100mm x 100mm. Anything less than that is eligible for the offer.
• Board order quantity at maximum 10 pieces. The $2 dollar is valid for 5 and 10 pieces, but anything above will cost a lot more extra charge.
• Use the default options such as the PCB colour, surface finish and etc.

Although there are some constraints, but for simple DIY project, I think this is sufficient and the best offer you can get to prototype your PCB. To make your order, upload the .zip files you created. Once the file is uploaded, the dimension will be automatically updated to reflect your actual design. When you are satisfied, save to cart and make the payment, it is that easy. It seems that for first time purchase, JLCPCB is generous enough to provide a free DHL shipping which shortens the time to receive the PCB. I am suspecting the first time free, as when I tried for the second time, they are no longer free.

[Update 02-Jan] It is confirmed that free shipping for your first order with JLCPCB. However, it will not available these few days due to maintenance. Mostly will be available on next few days.

After the payment is made, it took a few days for them to process and manufacture the PCB. I made my order during the weekend, and checked the status everyday after that. They do not work during the weekend, but once the working week starts, the processing speed was fast. By the end of Wednesday when I checked, the board has completed and shipped. Since the shipping uses DHL delivery, I received my PCB on the next day. From the ordering until receiving the PCB, it took less than a week, I am impressed.

The package came with a box with the label JLCPCB. Opening the box, there is another yellow envelope that contains a wall of bubble wrap.

And finally, the PCB are well protected in the envelope with extra layer of vacuum sealed bubble wrap. There are three layers of protection to the PCB, to make sure boards are received in good condition.

And here is what it looks like from behind.

I ordered ten PCBs, and from visual inspection they looks good to me.

A closer look at the bottom side of PCB. There is no issue with all the traces and pads. The silkscreen also looks clear. For the signal trace, I am using trace width of 0.25mm, whereas power and GND trace uses 1mm trace width. So far they look good, but will test them out once everything is soldered in.

A few more photos to share.

Noticed that on the top of white rectangle (included by intentional), there is a small line of numbering added by JLCPCB. It is probably used for referencing in the production.

Overall, the process of ordering your own PCB is not difficult as what I imagined initially. JLCPCB is definitely a good choice if you want to go beyond homebrew PCB. It offers prototyping at low cost and fast manufacturing time. With the low cost option to manufacture PCB, you can create as many prototype as you like. The quality of the PCB is also decent, everything

In the meantime, I am still waiting for my components to arrive before I can complete the PCB and test it. Once they are done, I will cover more about the function of this board in the coming article.

Happy new year to you and have a great year ahead!

A brief introduction to LabVIEW, according to Wiki, LabVIEW is a system design platform and development environment using graphical programming made by National Instruments. In other words, it can be used for various purposes such as creating graphical user interface (GUI), programming and simulation, hardware interface and data acquisition (DAQ).

Even though there are many platforms or tools available that can be used to create GUI for Arduino, my personal preference is using LabVIEW, mainly is due to the my previous experience with LabVIEW. The graphical programming is also an advantage as it eliminates the need to learn a new programming language. Creating user interface is also an easy task as LabVIEW was designed to enable engineers without heavy programming background to easily configure and display measurements from DAQ devices.

To get started, I will explain what is actually going on in Arduino. In this project, I am using an Arduino Nano to acquire signals and send the data to PC. As mentioned earlier, two analog input channels (A0 & A1) will be used to measure input signals. To ensure an accurate measurement is performed at fixed sample rate, the Arduino is configured to wait the predefined interval before taking a measurement and send to PC serially. The concept used is similar to the BlinkWithoutDelay example in Arduino. The benefit of using this method is that there is a while loop that always checks if it has crossed the desired interval. If it is reached, it will take the measurement, else it will skip and you can make it to work on other task.

Here is the code for Arduino, it is also available at my github.

/*==========================================
 * Arduino Labview Voltage Display
 * Created by zxlee (iamzxlee.wordpress.com)
 *
 * Demonstrate how to display Arduino analog
 * inputs, A0 and A1 to Labview using Serial
 * communication
============================================*/

#define input0 A0
#define input1 A1

unsigned long previousCount = 0;

/**==========================================
 * Constants for interval between samples
 * 50000 microseconds = 50 milliseconds
 * equivalent to 20 samples per second
 *
 * Sample rate is controlled using the
 * method similar to example BlinkWithoutDelay
============================================*/

const unsigned long interval = 50000;

void setup()
{
 Serial.begin(115200);
 delay(1000);
}

void loop()
{
 unsigned long currentCount = micros();

//Calculates the time difference since last serial data sent
 unsigned long countDiff = currentCount - previousCount;

 if(countDiff >= interval)
 {
 //Create a buffer to store string
 char buffer[50];

//Format the data into string
 sprintf(buffer, "$%d,%d,%u\r\n", analogRead(input0), analogRead(input1), countDiff);

 //Write string into COM port
 Serial.write(buffer);

//Update new previous count
 previousCount = currentCount;
 }

}

In this code, Arduino will continuously check the microseconds since the beginning of program using micros() and compare to a previous checkpoint if it is greater than interval defined. This time interval is the sample period, Ts desired in microseconds. The figure below is used to describe the concept of sampling (you can skip this part as it is not required to interface Arduino and LabVIEW, but I feel that it is interesting to introduce the concept of  fixed sampling on Arduino here).

Sample period, Ts is the time interval between each successive measurement. Taking the reciprocal of sample period is the sample rate or sample frequency. Sample rate, fs is a measure of how many samples is taken in 1 second. From the diagram at t = 0s, the first sample is taken. Then it will wait for a time given by the sample period before taking the second measurement at t = Ts. Similarly, after the second sample, the third sample will occur at t = 2Ts. For a measurement, it is desired to have a fixed sample rate so that we can know what is really happening at the exact time and also able to reconstruct the actual signal.

Back to the code, I have configured the Arduino to measure at the sample rate of 20 samples per second (S/s). With that it is also important to note that this sample rate is only able to reconstruct any signals at half of the sample frequency given by Nyquist Shannon sampling theorem. In simpler words, if my sample rate is 20S/s, I am only able to measure signals up to 10Hz. Beyond that, aliasing will occur where higher frequency signal appear as lower frequency content.

Once the measurement on analog input A0 & A1 is made, this measurement together with the actual time interval is formatted into a string stored in the buffer[] variable. This buffer has a header, ‘$’ and terminates with ‘\r\n’ which is used to move the cursor to the beginning of new line. Within this string, the information is stored in the position in the <>. Finally, this buffer is written serially to the COM port using Serial.write() and we are ready to move on to LabVIEW.

For this project, I am using LabVIEW 2015 to develop the VI. VI or virtual instrument is the file format used to store the program routine developed. In order to interface with Arduino through serial communication, you also need to install the NI-VISA driver. VISA allows you to communicate with instrumentation busses such as USB, Serial or Ethernet.

To give you a big picture of what it looks like for the GUI design, the front panel looks like this.

Breakdown of the elements in front panel:

• COM Port – used to select the COM port of devices that you would like to open
• Loop iterations – indicate the nth loop in the Labview
• Loop period (ms) – how long it takes to execute each loop in Labview
• Bytes remaining – how many bytes of data left in the PC serial buffer
• New Serial Data – the latest string read from COM port, configured to terminate at ‘\r\n’
• Arduino sample rate – the actual time interval sent from Arduino is used to measure the actual sample rate
• Serial monitor – a display mimic the functionality of Serial Monitor from Arduino IDE
• Error Out – display any error and it’s error message
• Input waveform – a chart to reconstruct the waveform based on the samples measured by Arduino
• Stop – used to halt the VI

And here is the block diagram of the VI. A block diagram is where you ‘draw’ your program using blocks and connect them using wires. This looks a bit complicated or scary, don’t worry, I am just adding a bunch of comments (blocks in yellow with text) to describe each section.

The program start from left to right according the flow of wires. Starting at the left, the COM port is configured with baud rate 115200, 8 bit mode with no parity. The serial communication has a timeout of 10s. And since I had defined the string format, the serial interface is set to read until every termination character and dump for further process.

Once the serial port is configured, the main loop will read 1000 bytes from the COM port. However, since it was configured to read anything until the term char, it will always return only the string specified. Then a property node is used to check how many bytes remaining in the serial buffer. Ideally, this should be 0 or at least some bounded value. If this value is growing, sooner or later, overflow will occur and some data will be lost. This will happen if the serial device is sending faster than it is read from the PC buffer.

The data read from the serial buffer is passed to a ‘Scan from string’ block. This block will convert the string input based on the format specified and return the individual values from the string. In this case, you can see that two signed 16 bit integer (I16) and an unsigned 32 bit integer (U32) are read. The two I16 corresponds to the two reading from analog inputs and U32 is the time interval taken by Arduino loop.

After the two variables are read from the string, they are combined into a cluster to display on the graph. It’s that simple.

To show how the system works, I am using a myDAQ to generate signals to the Arduino analog inputs. I will cover more on myDAQ in the future article. For now, myDAQ will act as a function generator using the analog output feature. Arduino A0 is fed with a sine wave with 2V peak to peak at 0.5Hz with 2.5V offset and A1 is fed with a sine wave with 1V peak to peak at 1Hz with 2.5V offset. The overall system diagram is as below.

Once the VI is executed, this is how the front panel looks like. You can see that there are two sine wave from the graph indicate by two different colours. Besides that, the graph is also set to display actual samples points. In digital domain, the actual samples are just the individual points. The ‘analog’ waveform seen is actually an interpolation and reconstruction by the software to visualise the actual signal measured.

All the Arduino codes and Labview files are available at https://github.com/zxlee/arduino-labview-voltage-display. Basically this is how you can create and visualise your Arduino data easily using LabVIEW. In my opinion, both Arduino and LabVIEW are very powerful tools which you can consider in your next projects. I hope this has covers much of the details needed for you to create your own. If you have any questions, feel free to drop me a comment below.

If you find this article is useful, give a thumbs up so I know what my readers actually interested and share this article with your friends.

In fact, I am also new to Github, so will continue to learn how to use it along the way. There are quite a number of readers who always interested to have the project files so they can try on their own. By having all the files in my Github, I hope this will also ease readers to get the required files and understand it. It also serve a proper platform to document and control all my projects.

Last but not least, here is my Github link: https://github.com/zxlee. Feel free to check out my first repo on the previous project, https://github.com/zxlee/bridge-monitoring-system.

The figure above shows the high level block diagram of this system. There are three sensor nodes which are controlled by an Arduino Nano. Each sensor node are equipped with various sensors and they are exactly the same as other sensor node. All these sensor nodes will communicate with the central hub using the nRF24L01 wireless module. Sitting at the central hub is the CT-ARM, this is where all the sensor measurement are sent and processed. All the measurement obtained are also sent to a Host PC for display through UART communication. On the Host PC, LabVIEW is used to create a nice user interface to view all the sensor measurements.

Let us look into more details for the central hub. As mentioned previously, the central hub is comprised of the Cytron ARM Cortex M0 (CT-ARM). CT-ARM is an Arduino compatible which uses the 32-bit Nuvoton NUC131LD2AE as the microcontroller. It operates at 50MHz clock speed, has 64KB Flash memory (twice of Arduino Nano) and 8KB SRAM (four times of Arduino Nano). CT-ARM is in charge to control and communicate the sensor nodes through wireless communication with nRF24L01 module. It is interfaced through the SPI communication. As mentioned previously, all the data acquired is sent to the Host PC through UART communication.

Next, the sensor node block diagram is presented here. The microcontroller used was the Arduino Nano which uses Atmega328P chip. There are three disaster monitoring at the sensor node, they are the bridge health monitoring, earthquake monitoring and sea level monitoring. Besides, there is also a simulated actuator, which is made up of a micro servo motor. Similar to the central hub, nRF24L01 module is used for the wireless communication.

Following next is the bridge structure monitoring, load cell is used to simulate sensors on bridge that is used to monitor any bridge structural change. This information can provide early information to the operator at base station about bridge health. The load cell is measured by the HX-711, a 24-bit ADC which is commonly used for weighing scale sensor. The voltage change of load cell with respect to the stress and strain is relatively small, this is why 24-bit ADC is required in this case. The Arduino interface with HX711 ADC through two wire interface (TWI).

Moving on is the earthquake monitoring, where the earth movement is measured by a three-axis accelerometer, ADXL335 from Analog Device. Instead of using the internal ADC of microcontroller, we are required to use an external ADC for measurement, in this case, TI ADS1115 16-bit ADC is used. This ADC provides four single ended input or can also be configured to dual differential input measurement. It uses the inter-integrated circuit (I2C) communication for configuration and data acquisition.

The third monitoring is more straightforward, which is the sea water level monitoring. Water level sensor is used to measure water level, which simulates any high rise/abnormal water level. This sensor is measured directly by the Arduino Nano internal ADC.

One of the challenging part for this project was to implement a many-to-one network topology among  the sensor nodes and central hub. There are various wireless modules that are available such as Wifi, bluetooth, Zigbee and other RF module. The most suitable candidate would be Zigbee protocol as it can offer true mesh network. Xbee by Digi International offers variety of module with Zigbee protocol. However, they are too costly for this project, so other alternative has to be used. After some search, nRF24L01+ is selected as it is low cost and able to achieve tree topology network with the help from library. The RF24Network by tmrh20 plays an important role to make this networking happen.

The image above shows the network that can be achieved by the RF24Network library. Image credit to http://tmrh20.github.io/RF24Network/Tuning.html. A lot of useful information is available from tmrh20 github, so do check it out for more info. In this project, since there are only three sensor nodes, so only first level addressing is used. The central hub would be the CT-ARM while the end nodes are all the Arduino Nano.

This was my first time hands on with nRF24L01+ module, a lot of time was spent to just make this thing work at the beginning. One of the important lesson learnt, which is also mentioned many time by other user, was the importance of decoupling cap. There is never too much of decoupling capacitor for this power sensitive module. I used the breakout board which I made long ago, check it out here. This breakout board has a 10uF electrolytic cap. I also manually soldered 0.1uF ceramic capacitor across the Vdd and GND on top of the module. With all these, I saved more time troubleshooting and focus on the programming.

Since there are three sensor nodes that will be communicating with the central hub, it is impossible for them to send the data all the time. So, in order to solve this problem, the transmission is controlled by central hub. The overall system timing diagram is shown as the figure below. At frame 1, the hub starts to ping (PING) the node 1, and at the same time all three nodes start to acquire data from various sensors. Once the node 1 acknowledge and data is ready, it will transmit (TX) the data back to the hub for processing (PSx). After host PC processed the data, it will send data packet to the Host PC to update the data monitoring dashboard. When the central hub completes for one node, it will repeat the same process for the subsequent node.

To send the data from CT-ARM to Host PC, all the sensor measurements are packed into a self defined string format. ‘$’ is used as the header of the string while the end of string is terminated by the ‘\r\n’ character. The first info in the data packet is the node address identifier, which will be used by the vi to identify which packet received does it belongs to. The rest of the string contains all the measured value processed at the central hub.

To create the user interface, there are several tools available such as Visual Studio, Serial monitor of Arduino and etc. However, this project uses LabVIEW due to several reasons. LabVIEW is an easy tool that can be used to create a user interface to view data. Besides, it also has various drivers and tools available to interface between PC and hardware. Another highlight of LabVIEW is that graphical programming is used, unlike any other conventional text based programming. This powerful tool commonly used by the engineers in industry to solve complex engineering challenge.

To read all the serial data coming into the COM port of PC, VISA driver is used. VISA is a driver that is used to provide programming interface between hardware and development environment. Using the string functionality from Labview, the data packet sent by the CT-ARM can be easily breakdown into individual information.

The image above shows how the front panel looks like. Brief descriptions of each section as below:

#1 Three meter indicator is used to show the state of water level from each node.

#2 Sensor node indicates which node that has detected an error.

#3 Boolean indicator to show which error warning is detected.

#4 Real time display and serial monitor similar to Arduino is created to view the data coming in.

#5 Three graphs to display each axis accelerometer reading. Within each graph, 3 waveform displays the reading from each node.

#6 Graph to display the load cell reading from each node.

If you are interested to look into the code and build your own bridge monitoring system, the project files for Labview and Arduino is available at https://github.com/zxlee/bridge-monitoring-system .

The prototype for sensor node and central hub are all built on breadboard as shown in the images below.

The image below shows that when the accelerometer reading exceed a defined threshold, the sensor node status will indicate which node is in danger and also display which warning is detected. In this case, the sensor node 3 x axis reading which can be seen from the lower left graph has exceeded the threshold.

The second image shows that tsunami warning is detected. Based on the water level monitoring (upper left) section, sensor node 2 is in the critical level (3) and warning is issued and the gate is closed.

Last but not least, the reading from load cell is used to determine the bridge/structure health which is shown in the graph at the lower right. Whenever the reading exceeded the safe level, it is detected as a warning and the structure warning will turn red.

There are so many new things that I have learnt from this project. This was the first time I actually involved in a project which requires multiple processor communicate with each other through wireless communication. Besides it was also my first time to interface between an Arduino and LabVIEW which allows me to create a nice GUI easily and visualise all the sensor measurement. I hope this covers all the details for you to understand about this project. If you have any questions to know more about this project, feel free to drop me a comment below.

Last but not least, I would like to thanks to all my team members and also friends who gave their support to this project.

This item comes in a package which includes the USB Logic Analyzer, USB cable and a 10 dupont line jumper. At the top of enclosure, there is a sticker which labelled Saleae logic, but of course this are not the original one. Besides that, there is also a pin labelling for the 10 pins Box header.

As mentioned previously, since this is a counterfeit of the original Saleae product, the seller does not provide any software tools to use it. Instead, they will redirect you to download the software from the Saleae website, detailed instructions will be shown later in this article.

I have listed down the specifications of this logic analyzer from the product page as below.

The supported sampling rate is capped at 24MHz and it can be adjusted in the software. They also clearly specified the acceptable input voltage range. For those who are not familiar with this specification, it is usually associated with most of the digital input device to state the input voltage level as shown in figure below.

In this case, any voltage falls between -0.5V to 0.8V is interpret as LOW and from 2V to 5.25V is interpret as HIGH. What about in between (0.8V to 2V)? There is no guarantee on how the device interpret it, it is in a INVALID state.

The enclosure of USB logic analyzer is simple that it can be easily opened. Due to curiosity, I have opened up the enclosure and not surprised that everything was fitted onto one single PCB.

Let us look into more details for the parts on the PCB. There are several surface mount ICs which are CY7C68013A – USB microcontroller from Cypress, 74HC245 –  Octal bus transceiver and AT24C02B – Serial EEPROM.

CY7C68013A is an enhanced 8051 microprocessor with integrated USB 2.0 transceiver, operating at 3.3V with 5V tolerant inputs. It also has integrated I2C controller which can communicates with the external AT24C02B EEPROM chip. Referring to this blog, the EEPROM chip contains the Vendor ID and Product ID for the device to be identified as the Saleae USB Logic Analyzer.

The board features a green LED as the power on indicator and also a red LED as the Channel 1 input indicator. These two LEDs allows user to easily determine if the logic analyzer is working correctly.

Anyway, I don’t really like the dupont lines provided as I have to connect 10 individual jumper into the box header if I need to use it. I decided to make some modifications onto the jumper so that I can easily plug in and out from the logic analyzer. The solution is to make one end of the dupont line into a IDC female header.

To use the logic analyzer, you need to download the software from Saleae download site. I am using the latest version of software, version 1.1.15. Installation is required before the USB logic analyzer can be used with host PC. After installation completed, plug in the USB logic analyzer to your host PC. Windows might attempt to search for update for the device driver, in this case, I just cancelled and let it search locally.

If everything works perfectly, when you launch the Saleae Logic software tool, you will notice [Connected] on the top bar. This shows that you are able to use your logic analyzer. On the other hand, if it is [Disconnected], you can only run in simulation mode.

On the first drop down menu, you can choose the number of samples to capture. Depending on the signals you are capturing and the rate of signal change, set the number of samples so you can capture all your desired data.

As I mentioned previously, you can select the sampling rate of the logic analyzer from the drop down menu.

In order to test the functionality of this new USB logic analyzer, I quickly hook up an Arduino Pro Mini and program an 8-bit binary up counter. With this program, I am able to test all the 8 channels of logic analyzer. The user can set four different triggering method, rising edge, falling edge, signal HIGH or signal LOW for each channel. Next, click on the “Start” to begin acquiring signal.

You can see from the figure below that the logic analyzer captures the signal perfectly.

Besides that, the software tool also allows measurement of signal such as pulse width, period, duty cycle, frequency, etc. Just hover your mouse over the signal, it will directly display the measurements on the upper right corner.

The logic analyzer can also be reprogrammed to use for the USBee instead of Saleae Logic. By tweaking the VID/PID in the EEPROM, it allows the logic analyzer to impersonate either Saleae or USBee. Read more on the reference at the end of article if you are interested.

Consideration whether to buy this logic analyzer, or not?

• Yes, if you are looking for a low cost logic analyzer which helps a lot in debugging your project. Being a hobbyist, sometimes we look for lower budget tools for our project, as we couldn’t afford buying high end tools at home.
• No, if you would like support on the original, which you are encouraged to. What I meant with supporting the original is to buy the logic analyzer from Saleae. They have developers that work hard to realize both the hardware and software for this. Their software is what makes it so good in using this. Furthermore, another feature that is only available from Saleae logic analyzer is the ability to sample analog input.

In a nutshell, this USB logic analyzer is a definitely a low cost solution for a hobbyist to have a logic analyzer at home. Hopefully this will be useful in debugging any projects in the future. Stay tuned for future projects on how I will be using this logic analyzer.

Reference

1. Saleae Logic Analyser Clone Teardown and Reprogramming

First, let us look at the specifications for Pro Mini, specifically Arduino Pro Mini 328 5V/16MHz:

• Microcontroller: Atmega328P (TQFP)
• Operating voltage: 5V
• Input voltage: 5V ~ 12V
• Digital I/O pins: 14
• Analog Input pins: 8
• Clock speed: 16MHz
• Comes with on board power and status LED

Note: There are a few versions of Arduino Pro Mini available. They are 5V/16M with Atmega328, 3.3V/8M with Atmega328, 5V/16M with Atmega168 and 3.3V/8M with Atmega168.

After a research on the microcontroller used in Pro Mini, which is Atmega328P, out of my surprise it has 8 analog pins as compared to regular Arduino Uno (6 Analog pins). Although both Uno and Pro Mini are using the same microcontroller, but according to the Atmega328P datasheet, there are 8 channel of 10 bits ADC in TQFP and QFN/MLF package. This is one of the highlights in Arduino Pro Mini.

Arduino Pro Mini comes in a compact form factor with its dimension 33mm x 17mm (less than quarter Arduino Uno size). This can be useful in projects where size matters, as it can be easily fitted into enclosure.

 I have also created a board labelling for the Pro Mini. The top and bottom row of I/O pins are breadboard friendly, which allows prototyping directly onto breadboard. However, there are 4 Analog Pins which are not breadboard friendly, therefore you will need to solder the header on top of PCB instead of bottom.

The Raw Input Voltage pin is used for external power supply ranging 5V ~ 12V. The on board regulator will produce regulated 5V output. If the circuit is “power hungry”, it is advisable to use external regulator to prevent any damage to the Pro Mini.

Now, I am going to show the unboxing of Arduino Pro Mini that I have received. Each of them comes with a separate packing, which consists of:

• 1x Arduino Pro Mini board
• 2x 20 pins male pin header
• 1x 6 pins right angle pin header

Since the Pro Mini comes un-soldered, it gives the user the flexibility of pin connections desired, be it using the pin headers provided or other header connections. So I am going to use the pin headers provided on Pro Mini.

On first power up, the board is preloaded with the standard blink sketch. If everything works perfectly, the status LED will blink every one second.

To test its functionality, I will upload another simple sketch to test whether it works or not.

Since the Pro Mini comes without any USB-to-Serial converter, thus you will need an external converter to program the Arduino. Here I am using a FT232RL USB-to-Serial converter breakout board to program the Arduino Pro Mini.

Before uploading the sketch to Pro Mini, remember to change the Board settings in Arduino IDE, Tools>Board>Arduino Pro or Pro Mini (5V, 16MHz) w/ Atmega328.

I’ve uploaded a simple sketch to blink the LED at a faster rate and everything works perfectly.

To sum up this review, I have list down some of the key points which could be useful when you need to use Arduino Pro Mini.

• Small and compact (Size matters)
• Comes without programmer, require external programmer to upload sketch
• Available at lower cost (since it does not include programmer)
• Two additional Analog Input pins (A6, A7) compared to Arduino Uno
• Unable to use Arduino Shield directly

Before entering into SPICE, there are signboards for direction to Penang International Science Fair.

At the centre of arena, there is a showcase of Google Map Camera Car. This is the car that is used to create the street view in Google Map.

In the Penang International Science Fair, there are quite a number of booths, where secondary school students showing their project for Young Innovate Competition. It is great to see that they are able to make creative projects at these young age.

I have seen computers made from 7400 Series logic from the Internet. But this was my first time to see an actual 8 bit computer made from TTL logic. Isn’t it cool?

In the Mini Maker Faire, there is a booth displaying mini robots such as the one shown below, a two wheel balancing robot. The size of this robot is slightly larger than palm size. It is fascinating to see such a complex robot is able to made into this small.

Intel also has their own booth in the Penang Mini Maker Faire. This booth focuses on the Internet of Things using Intel Edison. Some of the projects from Intel booth are home automation control, color detection and many more.

Santac has a booth in Penang Mini Maker Faire promoting the Toner Transfer method to create your own PCB.

What is the technology used before transistor is invented? The answer is Vacuum tube. There is this maker booth displaying audio amplifier made from vacuum tube. If you are looking for high quality audio amplifier, maybe you can have a try with vacuum tube audio amplifier.

And then there is this booth showing LED cubes with the size 8x8x8 and 4x4x4. I think LED cubes are awesome that I could stare at it for whole day (probably). I would like to try making one LED cube if I have free time.

During PMMF, a maker from Japan, Sho Yoshida is here to promote the Shellmo Project. This project promotes more people into making robot by providing open source 3D printable body and much more. I didn’t managed to take photo of the robots but you can check them from the Gallery of Shellmo.

Origami, paper art is also part of the Penang Mini Maker Faire showcase.

On the second day of PMMF, I registered myself on a 3D printing and design workshop by iMakerzone. This was my first time to design a 3D printing object. I learnt how to design using TinkerCAD.

I also had a chance to hands on in soldering the Maker Faire Robot. The circuit is a astable multivibrator that controls the “eye” of robot.

Besides attending the 3D printing and design workshop, I have also attended the Arduino + Zigbee workshop by SD Liew. This workshop explained the basics of  using Zigbee with XCTU. Hopefully the information gained from this workshop is useful in my future project.

It was my first time to see Rero in action during the Penang International Science Fair. For your information, Rero is a reconfigurable robot, allowing kids to expose themselves to robotics in earlier age. This is a product designed and made in Malaysia.

Overall, I think this is an eye opening experience to me as this was my first time attending a Mini Maker Faire. Hopefully, we will see more similar events happening all around Malaysia with the growing number of makers among the community.

After my entry was eligible for the contest, I was excited, hoping to get my CIKU as soon as possible. I received the CIKU on the next day my entry was qualified. In the parcel received, there is a packaging box containing CIKU and also a small note from Cytron.

First look on CIKU, it has the same shape and dimension as Arduino Uno. All the pin headers are designed exactly the same as standard Arduino Uno. This feature allows the user to use most of the existing Arduino shield with CIKU. The microcontroller used for CIKU is PIC18F4550 from Microchip. The chip is provided together with the CIKU. Besides that, there is also a pin labelling on top of the PIC18F4550 microcontroller.

The board comes with a mini USB connection, a power jack and PICkit header. On the top layer of PCB, each pin is labelled in a similar manner as Arduino Uno. On the other side, each pin is labelled to its respective pin as specified in datasheet.

Some of the features of CIKU:

• Pre-programmed PIC18F4550 with USB bootloader
• On board 5V 800mA (Max 1A) voltage regulator
• On board 3.3V 500mA (Max 500mA) voltage regulator
• 20 digital I/O pins (of which 6 provide analog input, 2 provide PWM output)
• Standard Arduino Uno R3 Header, compatibility with standard Arduino shield
• Program with MPLAB X IDE and XC8 compiler
• Has PICkit standard ICSP 6 way pads

A comparison between CIKU and Arduino Uno on several aspects are summarized as the table below.

Now let us focus more into details on the microcontroller used in CIKU. As mentioned previously, it uses Microchip PIC18F4550 microcontroller. This microcontroller support full speed USB 2.0 (12Mbit/s) interface, and since CIKU pre-programmed with Microchip USB HID Bootloader, no external programmer is required.  Unlike Arduino, CIKU does not require any FTDI USB-to-serial driver chip (in older version of Arduino) or Atmega16U2 as USB-to-serial converter (in current version of Arduino).

For CIKU, it has 14 digital I/O pins which allows you to use digitalRead() and digitalWrite() functions. Two of the 14 digital I/O (pin 5&6) can be used for PWM output (analogWrite() function). Another six pins (A0-A5) allow you to use AnalogIn() function. However, it is also possible to use the analog input pin as standard digital I/O.

Besides that, PIC18F4550 has four Timer modules which consists of one 8 bit Timer and three 16 bit Timer. As compared to Atmega328P used in Arduino Uno, Atmega328P only has two 8 bit Timer and one 16 bit Timer. This could be one of the advantage of using CIKU for project that requires more Timer for precise timing control.

Another feature that I would like to highlight for the microcontroller used in CIKU is that it has three external interrupt pins. More interrupt pins are useful to handle time critical input such as rotary encoder or monitoring other I/O modules. However, if you are using I2C bus (SDA and SCL), you are going to lose two external interrupt pins as they are sharing the same pin with I2C bus. This can’t be helped as the architecture is designed by Microchip to share the functions on the same pin.

While looking through the datasheet of PIC18F4550, I noticed that it has up to 13 channel, 10 bit Analog-to-Digital Converter (A/D). Six of them are wired as Analog In (A0-A5), which makes me wonder if the user could use the other seven channels A/D available. But probably user would have to configure themselves as the provided library might not include this.

So far I have cover on the hardware and microcontroller of CIKU, how about programming the CIKU? In order to use CIKU, you need to install MPLAB X IDE and XC8 compiler. For those of you who are not familiar with MPLAB X IDE, it is a software program created by Microchip to develop applications on Microchip microcontroller. Besides that, you also need to download CIKU library developed by Cytron to fully utilize its function. The library allows you to use functions such as pinMode, digitalWrite, digitalRead and etc. In my opinion, I think these functions make it easier for new starters to get familiarize with Microchip microcontroller.

I guess I have covered most of the basics of CIKU and probably will take some free time to play around with CIKU.

What are the parts needed to reuse a laptop LCD independently? You will need a controller board for your monitor. Each laptop’s monitor has a specific controller board. Thus, the first step before you get your controller board is to take apart the LCD and identify the model number.

The model for my monitor is Sharp LQ150X1LBS2.

After identifying the model number of the monitor, I order a controller board from ebay seller, e-qstore. Throughout my research to reuse an old laptop LCD, a lot of users suggested e-qstore to purchase the controller board as it is reliable. Based on e-qstore ebay page, they displayed quite a number of customer photo showing a working LCD.

The next step I took was to send a picture of the back of LCD with the model number. They need the model number to prepare the required controller board and firmware for the LCD. I got the reply from e-qstore quite fast after sending the model number to them and they suggested this controller board for me.

Well, I ordered the controller board as soon as I got the reply from e-qstore. I can’t wait to test the LCD and make a second monitor for my existing laptop. The controller board cost me $38.18 (approx RM 133.63) and also free shipping. It took around one month to travel from Shenzhen, China to Malaysia. Besides that, the seller also provide tracking number for the shipment.

Inside the parcel received, there are three PCBs which consists of the controller board, inverter and keypad. A documentation is provided by the seller as requested. I wanted to understand more about the controller board, but too bad most of the details are written in Chinese. (I can read Chinese but I just couldn’t understand the technical terms in Chinese.) This is the documentation provided.

There are several output ports available from the controller board such as VGA port, HDMI port, RCA jack, and audio out. Besides that, there is a USB input based on my understanding from the documentation.

To setup the controller board with the LCD, I followed the instructions provided by e-qstore.

Besides a controller board, the seller also suggested a 12V, 4A adapter for the controller board. However, I only have a 12V, 1A adapter, so why not try it out and see if the LCD works or not? After power up the controller board, I was so excited to see the monitor works. But, out of my expectation, the LCD works with a dark display without the backlight. I am worried if I damaged either the controller board or the LCD.

After searching through the internet results, from here, I tried to understand how the backlight of LCD works and found out that I forgot to connect the LCD to the inverter. The LCD inverter is responsible to convert the DC into AC which is required to power up the cathode fluorescent lamp in LCD panel. Be extra careful when handling with the inverter as AC is involved. Any accident with AC will cause electrocution. Also, becareful with the fluorescent lamp as it contains a small amount of mercury.

Finally, after everything was connected, the monitor works fine and I am able to extend my display onto this new monitor. However, I still need to confirm whether there is a need to use 12V, 4A adapter as suggested. Therefore, I tried to measure the current usage of the controller board. I measure the current in three different states which are power up, display on and display off.

I was quite happy with the results of current usage. On power up, the current drawn by the controller board is 0.1A. When the display is turned on, the current drawn is peak at 0.82A whereas when the display is turned off, only 0.25A is used. This results proved that it is sufficient to use a 12V, 1A adapter to supply the controller board. The seller suggested 12V, 4A probably is to support all range of LCD as their power consumption might be different.

The firmware of the controller board provides a user interface for settings just like a normal monitor. After everything was setup correctly, I noticed that there are some defects on the monitor which are shown by the pictures below. This may cause by some shock on the monitor when after the laptop is no longer in used.

The defect doesn’t cause a lot of problems to me, at least it still able to display everything and it is not as serious as having black spots or horizontal/vertical lines on monitor. I am very satisfied with my new monitor partly because it is uniquely made from an old laptop. Not to mention, the overall cost to revive this monitor is only around RM134 for the controller board. The cost of LCD and power adapter is not considered as I was reusing some old parts that I have.

For this amount of money spent and hack onto an old laptop, I can have a 15″ XGA TFT display, a nice experience of hacking a laptop and making a monitor and also more understanding on the monitor operation, that’s worth it. The improvement that I could make on this monitor is to add a frame and stand to display on my desk. Now I could make use of two monitors to work on different task or maybe one for entertainment, the other for work purpose or to constantly check on my blog perhaps. Good luck and have fun hacking.

Some of the features of PCF8574A IO Expander:

• Operating supply voltage 2.5V to 6V
• Open drain interrupt output
• I2C port to parallel port expander
• Address by 3 hardware address pins for use up to 8 devices (or even more, details will be covered later)

Obtained from PCF8574 Datasheet

PCF8574A I/O expander is available in three different packages, namely Dual In-line Package (DIP16), Small Outline Package (SO16) and Shirnk Small Outline Package (SSOP20). I am going to use the DIP16 package since its easier for prototyping on breadboard.

The pinout diagram for PCF8574A is shown as image below.

Pin explanation

Pin 1,2 and 3 is used for hardware pin addressing. With three addressing pin, you can control up to eight of the same chip as mentioned previously. For example, you can connect all three pins to ground which makes the A2,A1,A0 to (000) while connecting pin 1 to HIGH and the other two to LOW will make A2,A1,A0 to (001) and so on. The address reference is shown as below.

Although I am using PCF8574A, there is another variant for this IC, which is PCF8574. The difference between these two ICs is the first four bit of address, for PCF8574 is 0100 whereas PCF8574A is 0111. Therefore, if you are using both of the ICs, you can expand to a maximum of 128 I/O ports.

Pin 4 to 7, 9 to 12 is the bidirectional input and output pins. You can configure these eight pins as either input or output pins.

Pin 13 is the open drain interrupt output. This can be used to inform the microcontroller if there is any incoming data on the ports.

Pin 14 and 15 is the I2C bus clock and data line. (Note that I2C data lines are open drain output). One of the advantages of using I2C bus for this chip is that you can control eight different ICs by manipulating pin 1,2,3, yet still using only two data lines. This is also the special features of I2C where you can control up to 128 devices on the same bus with 7 bit addressing.(If you not sure what I meant about the I2C addressing and the 128 devices , refer to the table below)

I have mentioned open drain output a few times during the pin explanation, so what does it really means? Open drain output means the line able to drive it’s output to LOW, but unable to drive it HIGH. In order to drive the output high, pull up resistor has to be connected at the drain output. Usually I will use 10k ohm resistor for pull up purpose on I2C bus. Even though you have multiple devices on I2C bus, you need only one pull up resistor on each line.

With a pull up resistor, when the gate input is LOW, the drain output is pull up to Vdd by the pull up resistor. Whenever the gate input is HIGH, the drain output will be connected to ground, implying a LOW on the output. The operation is similar to a resistive load MOS inverter.

So far I have covered the basics of the chip itself, let us focus on how to use the chip with Arduino. To interface PCF8574A using Arduino is easier with the Arduino built in library for I2c, <Wire.h>. This library will take care of the I2C protocol, so you don’t need too much of details to use I2C.

I am going to show two simple applications using PCF8574A. First, using PCF8574A as eight output pins and second, read inputs from PCF8574A and output from PCF8574A as well.

First, I will show how to set PCF8574A as output pins expander. The PCF8574A connections is shown as figure below. Eight LEDs are connected such that PCF8574A act as a current sink. In order to light up the LED, the output pin has to pull to ground.

Some of the images of breadboard setup.

This is the code which I used to test the PCF8574A. The PCF8574A address is defined initially in the program. To output data to PCF8574A using Arduino, first, you need to begin the transmission to its address. Then write the desired output data. Finally, end the transmission to the address. Its quite easy to interface with PCF8574A to output data.

The program below will sweep through each output line of PCF8574A every loop. This is quite similar to a LED knight rider.

//coded by zxlee
//iamzxlee.wordpress.com

#include <Wire.h>

#define PCF_address B0111000 //A2 = A1 = A0 = 0

void setup()
{
Wire.begin();
}

void loop()
{
for(short temp=1;temp<=128;temp<<=1)
{
Wire.beginTransmission(PCF_address);
Wire.write(~temp);
Wire.endTransmission();
delay(500);
}
}

Next, I will show how to use PCF8574A as both input and output pins expander. Now, the lower nibble (P0 – P3) will be used as output pins to LEDs whereas the upper nibble (P4 – P7) will be used as input pins from DIP switches. Pull up resistor of 10k is used for each input line of DIP switch.

The program for PCF8574A is almost the same as being used as output pins. All you need to do is request data from PCF8574A, and read the data and store it in a variable. Then the data is used to control the output pins.

However, there is a little trick in reading data from PCF8574A. The input pins (P4-P7) cannot be pulled to ground. So in your program, you need to send HIGH to the input pins so that you can read from your switch. Refer to line 19 in the program below, where I pull the input lines to HIGH.

//coded by zxlee
//iamzxlee.wordpress.com

#include <Wire.h>

#define PCF_address B0111000

void setup()
{
Wire.begin();
Serial.begin(9600);
}

void loop()
{
byte temp=0;
Wire.requestFrom(PCF_address,1);
if(Wire.available())
temp=Wire.read();
Serial.print(temp);
Serial.print("\t");
temp=(temp>>4)|0xF0;
Serial.println(temp);

Wire.beginTransmission(PCF_address);
Wire.write(temp);
Wire.endTransmission();

}

PCF8574A can be very useful especially when you are running out of I/O pins from Arduino. I have used it in my previous projects such as Digital Clock on 7 Segment Display for keypad and Wall Following Robot for LCD. In the future, I will show how to use PCF8574A for keypad and LCD.