Simple watch on MSP430

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



At hand was an old Siemens A65, who became a donor for my small project. We take out the screen from it and think how to connect it. After a short googling, I successfully ended up on the RadioCot forum threadwhere pinouts and initialization of screens were discussed. If anyone is faced with the task of connecting screens to the microcontroller, then he knows that it is not enough to know the connection diagram, since there is a controller in the screen, for communication 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 need less than 10. So, often datasheets cannot be found on the controllers, and in this case only reading the initialization of the screen during its operation on the phone helps . But I was lucky that the initialization and commands for my screen (in my case LPH8731-3C with the EPSON S1D15G14 controller) were not only dismantled, but I even found a datasheet on it.

And so, we look at the 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. There are 2 types of received data for the screen controller - command or data. A separate pin is used to select a data type. Otherwise, the data transfer procedure is the same.

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



Now we know how to send data to the controller (well, or at least have an idea). Fortunately, in the datasheet not only all the commands are described, but there is even an example of the initial initialization of the screen. In general, it can be divided into 3 stages: do a controller reset (hardware & software reset), set the initial 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 trash or a white / black screen. That's because the controller changes the state of the matrix relative to the internal memory, and turning it on, it will display everything that it “remembers”. To display any information (or change it), it is enough to change the memory and the controller will update the display (it updates the display constantly with a certain frequency set in the initial setting, the default update frequency is 85Hz). For example, to change the color of a pixel, you just need to write the new value into memory. But first you need to specify the address where to write the new value. If the computer simply sets the address of the memory cell and writes a new value, then you need to specify the memory range to which you can send data sequentially.

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

Having selected the area, we can now simply send data and they will be sequentially written to memory (and how (from left to right, from top to bottom or vice versa) will depend on the initial setting). For example, selecting a 40x40px region, we will need to send successively 1600 values ​​(though this is not entirely true, but more on that in order), which will be stored in memory and this region 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 in Chinese ...

We have already figured out how to turn on the display and even how to choose the area for drawing, but how do I 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 of red color, etc. 3 bits for red and green, and 2 bits for blue).
But in the case of 12-bit color, everything is a little more complicated. There are already 4 bits for each shade. I will give a picture from a datasheet.

As you can see, one and a half bytes are used to send one color. If you need to change only 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 just 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).

Where is the promised watch?

And now the hardest part is to draw a watch. As you can see, they are stylized as a segment indicator, so to display the clock just 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;).

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

And now let's remember about the choice of area for drawing. You can also specify a 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 will notice that it is almost completely filled with one color, except for the corners. So the algorithm for drawing a segment is quite simple: we start filling the memory with an empty color (unfortunately there is no transparency, so we fill it with the background color), add checks for the upper right and lower left corners, and fill the last pixel with the background color too. Likewise for vertical ones. And how to draw dots, I won’t 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 various digits (from 0 to 9). Substituting a digit into it, I get an array with 1/0 values ​​that controlled the rendering of segments. For example, 1 means that the segment needs to be drawn, and 0 means that it is not necessary (or draw it “inactive”). And knowing what and where to draw, to make a function is not difficult.



And so we come to the end of the article. I hope I was able to explain the principle of their work in as much detail as possible :) And for a snack a short video on how they work and blink “dots”.




PS
Perhaps spelling, grammar and punctuation errors are present in this article. If you find them, I kindly ask you to send me a message in PM, and not write a comment.
The article does not write about the implementation of watches as such because they are not completed :) Initially, it was planned to make a small gadget where the display, external flash memory and external clock-calendar would be used, but since I accidentally bought the wrong watch, everything got up :) Another reason - I wanted to use a larger display, but 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, I can share :) If anyone has questions about the implementation of the output of characters on the screen (print text) - I can also share the source code (I did not write about it, here seems to be an article about the clock: ), and also does not pull on a separate post). I can also share the library for working with the screen from Siemens CX75 (on the SSD-1286 controller, there is even a datasheet), I wrote for myself, but accidentally burned it.