The GLCD has a 128×64 resolution. This equals about 8192 individual pixels that you can control as you wish. But how is this done? Let’s see how we reach a particular pixel on the screen.
The LCD screen is actually divided into 2 halves with one KS0108 IC for each half. Each KS0108 IC has the ability to control 64×64 pixels, so both of them side-by-side should be able to give you the complete resolution of 128×64. So, by choosing which one of the two ICs, you can narrow your pixel down to one of the two halves.
Next, each half containing 64×64 pixels has an addressing scheme using the Y address and X address as follows. Lets start with the columns. Each half has 64 columns numbered from 0 to 63. Straightforward enough, not too much to get confused about, each column is addressed using the Y address which ranges from 0 to 63. Continue reading
The GLCD (Graphics LCD) display that I’ll be using in this series is the JHD12864E. Here’s a picture of what it looks like (image stolen from http://extremeelectronics.co.in):
It’s a fairly standard 128×64 pixels display with a backlight. The part number aside, what really matters is the IC driver that is used in this display. The datasheet shows (more on this in a few mins) that it uses the S6B0108 display driver. After looking around on the net, I realised that this is similar to the KS0108 family display driver. So the general method of operation should be similar to the KS0108 but with a few minor differences here and there. Continue reading
This is going to be a mini-series on how to get started with a 128×64 LCD display. I’ll be going through all the steps that are involved in getting one of these damned things to work and I’ll post links and references wherever necessary.
“But”, you argue, “why do I need to learn this stuff? I can just whip out my Arduino and use the GLCD library and be just as cool!” Well, definitely. The purpose of doing this is not to be “cool”, but to gain an understanding into how this works and what kinds of problems you may face when working on something like this.
I won’t go too much into the pros and cons of which is a better approach. Obviously, libraries are there for a reason and if you’re using a specific development platform/board (Arduino, EasyPic) or a specific compiler for a certain project (AVR-GCC, MikroC, XC8) and you’re on a deadline and have a fairly straightforward task to accomplish, you should go ahead with that.
On the other hand, if LCD.Write(“Hello, World!”) doesn’t cut it anymore and you want to have complete control on a pixel to pixel basis, and/or be able to churn out your own library for a specific microcontroller that you’re currently using (8051, PIC, AVR, MSP) then you should read these series of posts.
On the whole, I will try to keep this series largely microcontroller agnostic. You should be able to read whatever is given here and transfer the learning to any microcontroller or development platform with a small amount of effort.
But for the sake of demonstration, I will be using a PIC16F886 microcontroller here. I have used both AVR and PIC and they’re both excellent microcontrollers in terms of performance, price and availability. But I’m going with a PIC here because I’m trying to learn more about these microcontrollers.
Here’s the table of contents. I will keep updating the links as I push content out:
- Intro – Getting started with a 128×64 Graphics LCD Display
- Part 1 – Getting started with a 128×64 Graphics LCD Display – JHD12864E (KS0108 family)
- Part 2 – Getting started with a 128×64 Graphics LCD Display – Screen resolution and locating pixels
- Part 3 – Getting started with a 128×64 Graphics LCD Display – Passing instructions
- Part 4 – Getting started with a 128×64 Graphics LCD Display – Pin configuration
- Part 5 – Getting started with a 128×64 Graphics LCD Display – Putting it together
- Part 6 – Getting started with a 128×64 Graphics LCD Display – Hello World!
- Part 7 – Getting started with a 128×64 Graphics LCD Display – Porting a bitmap to the GLCD
- Part 8 – Getting started with a 128×64 Graphics LCD Display – Fonts! Fonts! Fonts!
- Part 9 – Getting started with a 128×64 Graphics LCD Display – Pitfalls, debugging and troubleshooting
An excellent explanation on Scala Methods and Functions:
Apparently, Methods in Scala are different from Functions. From what I understand, a method is similar to a method in Java – it takes input and produces an output. But a Function is an object. Also takes an input and produces an output, but is an object. Here’s how they’re different:
def f1(x:Int):Int = x*2 //Method that doubles input
def f2 = (x:Int)=>x*2 //Function that doubles input
//f1.toString //Cannot be done!
f2.toString //Is perfectly valid
For more details, I’d suggest you take a look at Jim McBeath’s explanation.
In this part, we take functions a little further and discuss the following:
- Working with Lists of Functions
- Generated Functions
This builds a bit on the previous post on Functions in Scala, so if you haven’t seen it already, I’d highly suggest you take a look here: Working with Functions in Scala – Part 1
Scala treats functions as first class citizens. I keep forgetting the syntax for it, so putting it here as a handy reference. This post deals with the following features of Scala:
- Anonymous Functions
- Assigning Functions to variables
- Composite Functions
Please note that the term ‘function’ here is used to refer to both mathematical functions and programmatic functions. The key strength of Functional Programming languages is the ability to unify both.
Couple of months ago, a friend of mine drew my attention to Functional Programming in Scala, a course on Coursera. Having worked for years with the likes of PHP, C, C++, Java and not to mention BASIC before that, I didn’t think much of Functional Programming. Truth be told, when someone mentioned Functional Programming to me, I thought he was talking about C or rather non-OOP programming which didn’t involve Objects(Yes! I admit it! I was a brash naïve 22 year old fresh with a non-CS degree!). As a matter of fact, that was my perception until I took the course (Okay, there’s honesty and then there’s beating a dead horse!).
So, for the benefit of the uninitiated who happened to accidentally stumble upon my obscure and randomly technical blog, I’ll give the lowdown on Functional Programming … in my own words. Apart from the regular differences between Functional and Imperative programming, here’s my experience with it: