Simple clock on MSP430

Having read a huge number of articles about Arduino / LaunchPad wanted to buy a similar toy. The choice fell on the MSP430, since its price is much more attractive to start in the world of microcontrollers.
After a tedious 5 days of waiting, the magic box was in my hands. After playing about 10 minutes with LEDs, I wanted to do something more interesting ... For example, watch!



At hand was an old Siemens A65, which became a donor for my small project. We take the screen out of it and think how to connect it. After a short googling, I successfully got to the branch of the RadioKot forum, where pinouts and initialization of screens were discussed. If someone faced the task of connecting a small screen to a microcontroller, then he knows that it is not enough to know the connection scheme, since there is a controller on the screen, to communicate with which you need to know the commands. For example, to turn on the screen and display garbage from memory, some controllers need to send several dozen commands, and some have less than 10. So, often datasheets on the controllers are not found, and in that case only reading the screen initialization helps during its operation on the phone . But I was lucky, the initialization and commands for my small screen (in my case LPH8731-3C with the EPSON S1D15G14 controller) were not only disassembled, but even datashit was found on it.

And so, we look pinout, solder the wiring and connect to the microcontroller.
')

We get a "barrel organ"

Now we need to figure out how to communicate with the controller. For a screen controller, there are 2 types of received data - a command or data. To select the type of data used a separate pin. As for the rest, the data transfer procedure is the same.

The procedure for transferring data to the controller, taken from the datasheet. Here, for some reason, the status of the RS / CD pin is not indicated. By the way, if during the data transmission the state of CS changes to Low -> High, the data reception will stop. But at the end of the data transfer, it is not necessary to pull the CS up (but it is recommended).



Now we know how to send data to the controller (or at least we have an idea). Fortunately, the datasheet not only describes all the commands, but even has an example of the initial screen initialization. In general, it can be divided into 3 stages: we do a controller reset (hardware & software reset), set the initial parameter settings, turn on the display.

Our address is not a house or a street, our address is ...

Turning on the display, we will see either garbage or a white / black screen. This is because the controller changes the state of the matrix relative to the internal memory, and by turning it on, it will display everything that it “remembers”. To display any information (or its changes), it is enough to change the memory and the controller updates the display (it updates the display constantly with a certain frequency specified in the initial setting, by default the refresh rate is 85Hz). For example, to change the color of a pixel, you just need to write a new value in memory. But first you need to specify the address where to write the new value. If the computer simply sets the memory address and writes a new value, then you must specify the range of memory to which you can send data sequentially.

For example, to fill the entire screen you need to select the beginning of the recording area (x0, y0) and the end (x101, y80). And if you need to change the color of only one pixel, then respectively set the area [x, y] [x + 1, y + 1].

Having chosen a region, we can now simply send data and they will be sequentially stored in memory (and how exactly (from left to right, from top to bottom or vice versa) will depend on the initial setting). For example, choosing the area 40x40px, we will need to send 1600 consecutive values ​​(although this is not quite so, but in order), which will be stored in the memory and this area will be completely updated. And if you continue to send values, the update will continue from the next pixel (in this case, from the first).

Letter for you! True to Chinese ...

We have already figured out how to turn on the display and even how to choose an area for drawing, but how to send the color? The display can work with 2 color palettes:

• 8bit (256 colors)
• 12bit (4096 colors)

In the case of 8-bit color, everything is simple - just send 8 bits for each color (namely R2R1R0G2G1G0B1B0, where R2R1R0 is 3 bits red and so on. Red and green are 3 bits, and blue is 2 bits).
But in the case of 12-bit color everything is dumb harder. There are already 4 bits for each shade. I will result a picture from.

As you can see, one and a half bytes is used to send one color. If you only need to change 1 pixel, then 2 bytes of information are sent, where in the second byte D3-D0 will not be used. And if you need to change 2 pixels, then it is enough to send 3 bytes (where D3-D0 of the second byte will be the beginning, and D7-D0 of the third byte will be the continuation of the color for the second pixel).

And where is the promised watch?

And now the most difficult thing is to draw a watch. As you can see, they are stylized as a segment indicator, so to display the clock, it is enough to draw 2 types of segments (vertical and horizontal) in different places.
First you need to decide on the design. Thanks to the great program from MS - Paint, it really helped me with this;).

Here's what I got. Each segment is 12x4px in size (and vertical, respectively, on the contrary - 4x12px).

And now let's remember about the choice of the drawing area. You can also set the 12x4 area in the right place and draw a segment without redrawing the entire screen. If you take a closer look at the segment, you can see that it is almost completely filled with one color, except for the corners. So the segment drawing algorithm is quite simple: we start filling the memory with an empty color (unfortunately there is no transparency here, so we fill it with a background color), add checks for the upper right and lower left corner, and fill the last pixel with the background color too. Similarly, for vertical. And how to draw dots, I will not even tell :).



Now you need to turn the number into a set of segments (for example, to display 1, you need to draw only the right vertical segments). I decided this quite simply - I created an array of segment values ​​for different digits (from 0 to 9). Substituting a digit into it, I get an array with values ​​of 1/0 that controlled the drawing of the segments. For example, 1 means that the segment needs to be drawn, and 0 means that it is not necessary (or render it “inactive”). And knowing what and where to draw, make the function is not difficult.



And here we come to the end of the article. Hopefully, I was able to explain the principle of their work as thoroughly as possible :) And for a snack, a small video of how they work and blink “dots”.




PS
Perhaps this article contains spelling, grammatical and punctuation errors. If you find them, I urge you to send me a message in a personal, and not to write a comment.
The article is not written about the implementation of watches as such because they are not completed :) It was originally planned to make a small gadget, where the display, external flash memory and external calendar clock would be used, but since I accidentally bought the wrong watch, everything got up :) One more reason - I wanted to use a larger display, but I could not buy a suitable one, for example from the Chinese Nokla n95 8gb. Can someone tell me where to buy one?
If someone needs the source code - contact me, I can share it :) If anyone has any questions about the implementation of displaying characters on the screen (printing text), I can also share the source code (I didn’t write about it, here’s an article about watches: ), and on a separate post also does not pull). I can also share the library for working with the screen from Siemens CX75 (on the controller SSD-1286, there is even a datasheet), I wrote for myself, but accidentally burned it.