-
Notifications
You must be signed in to change notification settings - Fork 7
/
Copy pathoriginalCzech12864Library.py
1080 lines (826 loc) · 37.3 KB
/
originalCzech12864Library.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
#!/usr/bin/python
# -*- encoding: utf-8 -*-
# posledni uprava: 15.7.2013
# pripojeni displeje 12864ZW (128x64 bodu) SERIOVE:
# displej vyvod (vyznam) - pripojeno na ...
# 1 (GND) - RasPi (GPIO GND - pin 6)
# 2 (+ napajeni) - RasPi (GPIO +5V - pin 1)
# 3 VO -
# 4 (RS Data/Command) - +5V (CHIP SELECT - pri seriove komunikaci)
# 5 (R/W Read/Write) - RasPi (seriova data) - GPIO7 (pin26)
# 6 (E - Strobe) - RasPi (seriove hodiny) - GPIO8 (pin24)
# 7 (Data bit0) -
# 8 (Data bit1) -
# 9 (Data bit2) -
# 10 (Data bit3) -
# 11 (Data bit4) -
# 12 (Data bit5) -
# 13 (Data bit6) -
# 14 (Data bit7) -
# 15 (PSB) - GND - nastaveni seriove komunikace
# 16 (NC) -
# 17 (Reset) - RasPi - GPIO25(pin22)
# 18 (Vout) -
# 19 (Podsvet - A) - +5V (nebo nejaky regulator jasu LED - odber asi 60mA)
# 20 (Podsvet - K) - RasPi (GPIO GND - pin 6)
import time # ruzne operace s casem (pauzy)
import RPi.GPIO as GPIO # pouziva se jen pri pripojeni signalu E, nebo RS primo na GPIO v RasPi
import math # vyuziva se jen v prikladech pri kresleni kruznic
import random # vyuziva se jen v ukazce pro generovani nahodnych souradnic
# preklad ceskych znaku ze souboru s fontem
cz2={}
cz2[345] = 128 # r s hackem
cz2[237] = 129 # i s carkou
cz2[353] = 130 # s s hackem
cz2[382] = 131 # z s hackem
cz2[357] = 132 # t s hackem
cz2[269] = 133 # c s hackem
cz2[253] = 134 # y s carkou
cz2[367] = 135 # u s krouzkem
cz2[328] = 136 # n s hackem
cz2[250] = 137 # u s carkou
cz2[283] = 138 # e s hackem
cz2[271] = 139 # d s hackem
cz2[225] = 140 # a s carkou
cz2[233] = 141 # e s carkou
cz2[243] = 142 # o s carkou
cz2[344] = 143 # R s hackem
cz2[205] = 144 # I s carkou
cz2[352] = 145 # S s hackem
cz2[381] = 146 # Z s hackem
cz2[356] = 147 # T s hackem
cz2[268] = 148 # C s hackem
cz2[221] = 149 # Y s carkou
cz2[366] = 150 # U s krouzkem
cz2[327] = 151 # N s hackem
cz2[218] = 152 # U s carkou
cz2[282] = 153 # E s hackem
cz2[270] = 154 # D s hackem
cz2[193] = 155 # A s carkou
cz2[201] = 156 # E s carkou
cz2[211] = 157 # O s carkou
cz2[228] = 228 # prehlasovane a
cz2[235] = 235 # prehlasovane e
cz2[239] = 239 # prehlasovane i
cz2[246] = 246 # prehlasovane o
cz2[252] = 252 # prehlasovane u
cz2[196] = 196 # prehlasovane A
cz2[214] = 214 # prehlasovane O
cz2[220] = 220 # prehlasovane U
cz2[176] = 176 # stupen
cz2[177] = 177 # plus minus
cz2[171] = 171 # dvojsipka vlevo
cz2[166] = 166 # prerusene svislitko
cz2[223] = 223 # beta
# prirazeni GPIO pinu
sdata_pin = 7 # (pin 26 = GPIO7) = DATA
sclk_pin = 8 # (pin 24 = GPIO8) = HODINY
reset_pin = 25 # (pin 22 = GPIO25) = RESET
mapa={} # pamet, do ktere se uklada aktualni stav zobrazenych pixelu na displeji
txtmapa={} # pamet, do ktere se uklada aktualni stav textu na displeji
font2={} # pamet, ve ktere je ulozeny font, nacetny z externiho souboru
ikodata={} # promenna, pres kterou se budou definovat graficke ikony
#==============================================================
# hlavni program
#==============================================================
def main():
init() # zakladni HW nastaveni systemu - smery portu na expanderu a reset displeje
disclear(0) # kompletni smazani displeje
nacist_font2("/home/pi/font2.txt") # nacteni externiho fontu ze souboru
#==============================================================
# Zacatek ukazky vsech funkci
#==============================================================
#- - - - - - - - - psani textu na displej - - - - - - - - - - - - - - - - - - - -
init_text() # prepnuti do textoveho rezimu
velky_napis("Ukazka zobrazeni",0,0) # zobrazeni napisu v textovem rezimu na urcenych souradnicich
velky_napis("displeje",4,1)
velky_napis("v textovem",3,2)
velky_napis("rezimu",5,3)
time.sleep(2)
velky_napis("chr(1)...chr(32)", 0 , 1)
kod_znaku = 0
for r in range(2,4):
for s in range (16):
kod_znaku = kod_znaku + 1
velky_znak(kod_znaku , s , r) # zobrazeni znaku v textovem rezimu podle jeho (ASCII)kodu
time.sleep(3)
velky_napis("chr(33)..chr(64)" , 0 , 1)
for r in range(2,4):
for s in range (16):
kod_znaku = kod_znaku + 1
velky_znak(kod_znaku , s , r)
time.sleep(3)
clr_text() # smazani textove casti displeje
time.sleep(1)
#- - - - - - - - - Ikony - - - - - - - - - - - - - - - - - - - -
velky_napis("vlastni ikony" , 0 , 0)
# definice zrafické podoby 4 vlastnich ikon:
# prvni uzivatelsky definovana ikona (zamerovaci kriz)
ikodata[0] = 0b0011111111111100
ikodata[1] = 0b0111111111111110
ikodata[2] = 0b1110000110000111
ikodata[3] = 0b1100000110000011
ikodata[4] = 0b1100000110000011
ikodata[5] = 0b1100000000000011
ikodata[6] = 0b1100000000000011
ikodata[7] = 0b1111100110011111
ikodata[8] = 0b1111100110011111
ikodata[9] = 0b1100000000000011
ikodata[10] = 0b1100000000000111
ikodata[11] = 0b1100000110000011
ikodata[12] = 0b1100000110000011
ikodata[13] = 0b1110000110000111
ikodata[14] = 0b0111111111111110
ikodata[15] = 0b0011111111111100
defikon(0 , ikodata)
# druha uzivatelsky definovana ikona (ctverec s krizkem)
ikodata[0] = 0b1111111111111111
ikodata[1] = 0b1111111111111111
ikodata[2] = 0b1110000000000111
ikodata[3] = 0b1101000000001011
ikodata[4] = 0b1100100000010011
ikodata[5] = 0b1100010000100011
ikodata[6] = 0b1100001001000011
ikodata[7] = 0b1100000110000011
ikodata[8] = 0b1100000110000011
ikodata[9] = 0b1100001001000011
ikodata[10] = 0b1100010000100011
ikodata[11] = 0b1100100000010011
ikodata[12] = 0b1101000000001011
ikodata[13] = 0b1110000000000111
ikodata[14] = 0b1111111111111111
ikodata[15] = 0b1111111111111111
defikon(1 , ikodata)
# treti uzivatelsky definovana ikona (prazdny ctverec)
ikodata[0] = 0b1111111111111111
ikodata[1] = 0b1111111111111111
ikodata[2] = 0b1100000000000011
ikodata[3] = 0b1100000000000011
ikodata[4] = 0b1100000000000011
ikodata[5] = 0b1100000000000011
ikodata[6] = 0b1100000000000011
ikodata[7] = 0b1100000000000011
ikodata[8] = 0b1100000000000011
ikodata[9] = 0b1100000000000011
ikodata[10] = 0b1100000000000011
ikodata[11] = 0b1100000000000011
ikodata[12] = 0b1100000000000011
ikodata[13] = 0b1100000000000011
ikodata[14] = 0b1111111111111111
ikodata[15] = 0b1111111111111111
defikon(2 , ikodata)
# ctvrta uzivatelsky definovana ikona (kriz v krouzku)
ikodata[0] = 0b0000011111100000
ikodata[1] = 0b0000100110010000
ikodata[2] = 0b0011000110001100
ikodata[3] = 0b0010000110000100
ikodata[4] = 0b0100000110000010
ikodata[5] = 0b1000000110000001
ikodata[6] = 0b1000000110000001
ikodata[7] = 0b1111111111111111
ikodata[8] = 0b1111111111111111
ikodata[9] = 0b1000000110000001
ikodata[10] = 0b1000000110000001
ikodata[11] = 0b0100000110000010
ikodata[12] = 0b0010000110000100
ikodata[13] = 0b0011000110001100
ikodata[14] = 0b0000100110010000
ikodata[15] = 0b0000011111100000
defikon(3 , ikodata)
printiko(1 , 0 , 1) # ikona c.2 na zacatek druhe radky zhora
for iko in range (7): # zbytek te radky se zaplni nahodnymi ikonami
# kdyz se tiskne vic ikon za sebe, tak se nemusi u kazde nastavovat pozice
ikona = random.randint(0,3) * 2 # posledni parametr je dvojnasobek cisla ikony
posli_bajt2( 1 , 0 , ikona)
printiko(2 , 0 , 2) # ikona c.3 na zacatek treti radky zhora
for iko in range (7): # zbytek te radky se zaplni nahodnymi ikonami
# kdyz se tiskne vic ikon za sebe, tak se nemusi u kazde nastavovat pozice
ikona = random.randint(0,3) * 2 # posledni parametr je dvojnasobek cisla ikony
posli_bajt2( 1 , 0 , ikona)
printiko(3 , 0 , 3) # ikona c.4 na zacatek spodni radky
for iko in range (7): # cely zbytek te radky se zaplni ikonou c.4
# kdyz se tiskne vic ikon za sebe, tak se nemusi u kazde nastavovat pozice
posli_bajt2( 1 , 0 , 6) # (6 = ikona c.4)
time.sleep(2)
velky_napis(" zmena definice ", 0 , 0)
time.sleep(2)
velky_napis(" ctvrte ikony ", 0 , 0)
time.sleep(2)
# pri zmene definice ikony se OKAMZITE meni vzhled VSECH prave zobrazenych ikon
# ctvrta uzivatelsky definovana ikona se timto prenastavi na sachovnici
ikodata[0] = 0b1111000011110000
ikodata[1] = 0b1111000011110000
ikodata[2] = 0b1111000011110000
ikodata[3] = 0b1111000011110000
ikodata[4] = 0b0000111100001111
ikodata[5] = 0b0000111100001111
ikodata[6] = 0b0000111100001111
ikodata[7] = 0b0000111100001111
ikodata[8] = 0b1111000011110000
ikodata[9] = 0b1111000011110000
ikodata[10] = 0b1111000011110000
ikodata[11] = 0b1111000011110000
ikodata[12] = 0b0000111100001111
ikodata[13] = 0b0000111100001111
ikodata[14] = 0b0000111100001111
ikodata[15] = 0b0000111100001111
defikon(3 , ikodata)
time.sleep(3)
clr_text()
#- - - - - - - - -Cinské znaky - - - - - - - - - - - - - - - -
velky_napis(" Jako ikony " , 0 , 0)
velky_napis(" se zobrazuji " , 0 , 1)
velky_napis(" i cinske znaky " , 0 , 2)
time.sleep(3)
clr_text()
# tisk CINSTINY obrim fontem 16x16 bodu (v textovem rezimu)
# Tohle jsou jen nahodne vybrane znaky (cinstina mi nic nerika)
# Znak je vybran pomoci poslednich dvou cisel funkce "posli_bajt2()"
# prvni z tech dvou cisel musi byt vyssi, nez 127
ikopos(2,0) # nastaveni pozice prvniho znaku [0,0] az [7,3]
posli_bajt2( 1 , 200 , 150)
posli_bajt2( 1 , 218 , 10)
posli_bajt2( 1 , 128 , 1)
posli_bajt2( 1 , 211 , 200)
ikopos(4,2) # nastaveni pozice prvniho znaku [0,0] az [7,3]
posli_bajt2( 1 , 240 , 4)
posli_bajt2( 1 , 240 , 33)
posli_bajt2( 1 , 240 , 222)
# svisly ctyrznakovy napis
ikopos(0,0) # nastaveni pozice znaku
posli_bajt2( 1 , 128 , 18)
ikopos(0,1) # nastaveni pozice znaku
posli_bajt2( 1 , 154 , 251)
ikopos(0,2) # nastaveni pozice znaku
posli_bajt2( 1 , 197 , 37)
ikopos(0,3) # nastaveni pozice znaku
posli_bajt2( 1 , 141 , 90)
time.sleep(3)
clr_text()
#- - - - - - - - - text v grafickem rezimu - - - - - - - - - - - - - - - - - - -
#tisk napisu fontem 8x8 bodu (v grafickem rezimu)
init_grafika()
slovo("Displej je možné" , 0 , 0 , False) # normalni graficky napis na horni radku
slovo("provozovat" , 3 , 15 , False)
slovo("i v grafickém" , 1 , 30 , False)
slovo("režimu" , 5 , 45 , False)
time.sleep(2)
slovo("grafickém" , 5 , 30 , True) # inverzne prepsany text
time.sleep(3)
clr_grafika() # smazani graficke casti displeje
# ve stejnem rezimu je mozne tisknout jednotlive znaky podle jejich kodu
for kod in range(32,128):
sloupec = (kod-32) % 16
radka = int((kod-32)/16) * 11 # rozestupy mezi radkami jsou 11 bodu
if (radka / 22.0 == int(radka/22)): # kazda druha radka je inverzni
inverze = True
else:
inverze = False
znak(kod , sloupec, radka , inverze) # podprogram pro tisk znaku v grafickem rezimu
time.sleep(2)
clr_grafika()
for kod in range(128,256):
sloupec = (kod-128) % 16
radka = int((kod-128)/16) * 8
znak(kod , sloupec, radka , False)
time.sleep(2)
clr_grafika()
#- - - - - - - tisk bodu a car - - - - - - - - - - - - - - - - - -
slovo(" V tomto režimu " ,0, 2,False) # normalni napis 2 pixely od horniho okraje
slovo("je možné kreslit" ,0,11,False)
slovo(" body a čáry " ,0,20,False)
# oramovani displeje plnou carou
h_cara ( 0 , 0 , 127 , 1) # horizontalni cara na libovolne pozici
h_cara2( 63 , 0 , 7 , 0b11111111) # rychla hor. cara v 16-sloupcovem rastru s nastavenim masky
v_cara ( 0 , 0 , 63 , 0b11111111) # vertikalni cara v libovolne pozici s nastavenim masky
v_cara (127 , 0 , 63 , 0b11111111)
# vnitrni mensi obdelnik carkovanou carou
h_cara2( 31 , 1 , 6 , 0b11001100)
h_cara2( 56 , 1 , 6 , 0b11001100)
v_cara ( 16 , 31 , 56 , 0b11001100)
v_cara (111 , 31 , 56 , 0b11001100)
# nahodne nasypani bodu do maleho obdelniku v inverznim rezimu
for i in range(2000):
x= int(random.randint(17,110))
y= int(random.randint(32,55))
plot( x , y , 2) # tisk inverzniho bodu na souradnice [x,y]
#- - - - - - - - - - - - ruzne styly horizontalnich car - - - - - - - - - - - - - - - - -
clr_grafika()
h_cara2( 0 , 2 , 5 , 0b11111111) # rychla hor. cara v 16-sloupcovem rastru s nastavenim masky
h_cara2( 10 , 3 , 4 , 0b11001100) # rychla hor. cara v 16-sloupcovem rastru s nastavenim masky
h_cara2( 20 , 2 , 5 , 0b11110000) # rychla hor. cara v 16-sloupcovem rastru s nastavenim masky
h_cara2( 30 , 1 , 6 , 0b10101010) # rychla hor. cara v 16-sloupcovem rastru s nastavenim masky
h_cara2( 40 , 0 , 7 , 0b11110101) # rychla hor. cara v 16-sloupcovem rastru s nastavenim masky
h_cara2( 50 , 1 , 6 , 0b01110101) # rychla hor. cara v 16-sloupcovem rastru s nastavenim masky
time.sleep(3)
clr_grafika(0xff) # cely displej zaplnit bilou barvou
#- - - - - - - - - - kresleni - - - - - - - - - - - - - - - - - - - -
# vykresleni dvojite kruznice pomoci primeho tisku bodu na displej (pomale)
for kruh in range(0,6283,4):
x = int(((math.sin(kruh/1000.0) * 30.0)) + 32)
y = int(((math.cos(kruh/1000.0) * 30.0)) + 32)
plot(x,y,0)
x = int(((math.sin(kruh/1000.0) * 20.0)) + 32)
y = int(((math.cos(kruh/1000.0) * 20.0)) + 32)
plot(x,y,0)
# vykresleni peti kruznic s vyuzitim zapisu do pameti
# a nasledneho presypani cele pameti na displej (rychle)
for kruh in range(0,6283,4):
x = int(((math.sin(kruh/1000.0) * 30.0)) + 96)
y = int(((math.cos(kruh/1000.0) * 30.0)) + 32)
mem_plot(x,y,0)
x = int(((math.sin(kruh/1000.0) * 25.0)) + 96)
y = int(((math.cos(kruh/1000.0) * 25.0)) + 32)
mem_plot(x,y,0)
x = int(((math.sin(kruh/1000.0) * 20.0)) + 96)
y = int(((math.cos(kruh/1000.0) * 20.0)) + 32)
mem_plot(x,y,0)
x = int(((math.sin(kruh/1000.0) * 15.0)) + 96)
y = int(((math.cos(kruh/1000.0) * 15.0)) + 32)
mem_plot(x,y,0)
x = int(((math.sin(kruh/1000.0) * 10.0)) + 96)
y = int(((math.cos(kruh/1000.0) * 10.0)) + 32)
mem_plot(x,y,0)
mem_dump() # presypani dat z pameti na displej
time.sleep(2)
clr_grafika()
#- - - - - - - - - - prepinani textoveho a grafickeho rezimu - - - - - - - - - -
slovo(" Grafický " , 0 , 0 , False)
slovo("a textový režim" , 0 , 10 , False)
slovo("je možné použít" , 0 , 20 , False)
slovo(" zároveň " , 0 , 30 , False)
time.sleep(2)
clr_grafika()
init_text() # prepnuti displeje do textoveho rezimu
velky_napis("Velky napis" , 2 , 0)
velky_napis("v textovem" , 3 , 1)
velky_napis("rezimu" , 5 , 2)
printiko(1 , 0 , 2)
printiko(1 , 7 , 2)
time.sleep(2)
init_grafika() # prepnuti displeje do grafickeho rezimu
h_cara2( 53 , 0 , 7 , 0b10011001)
slovo("Grafická řádka" , 1 , 56 , False)
# pri kombinaci textoveho a grafickeho rezimu se spolecna oblast na displeji XORuje
# priklad: 4 body tlusta sikma cara pres cely displej
for x in range(128):
plot(x ,x/2 , 1)
plot(x,(x/2) + 1 , 1)
plot(x,(x/2) + 2 , 1)
plot(x,(x/2) + 3 , 1)
time.sleep(2)
slovo("Smazání grafiky" , 0 , 56 , True)
time.sleep(2)
clr_grafika() # grafiku je mozne smazat samostatne, takze puvodni text zustava
slovo(" Text zůstává " , 0 , 56 , True)
time.sleep(2)
slovo("Dokreslení čáry" , 0 , 56 , True)
for x in range(128):
plot(127-x ,x/2 , 1)
plot(127-x,(x/2) + 1 , 1)
plot(127-x,(x/2) + 2 , 1)
plot(127-x,(x/2) + 3 , 1)
time.sleep(2)
slovo(" Smazání textu " , 0 , 56 , True)
time.sleep(1)
clr_text() # textovy displej je mozne take smazat samostatne
init_grafika()
mem_dump() # grafika se ale v tom pripade musi obnovit z pameti
time.sleep(1)
slovo("Grafika zůstává" , 0 , 56 , True)
time.sleep(2)
clr_grafika()
#- - - - - - - - - nahrani obrazku - - - - - - - - - - - - - - - - - -
slovo(" zobrazení " ,0, 0,False) #
slovo(" souboru " ,0, 10,False) #
slovo(" s obrázkem " ,0, 20,False) #
time.sleep(2)
load_bmp12864("/home/pi/pokladnik.bmp") # nahrani bitmapy o velikosti 128x64 bodu na displej
time.sleep(4)
# zaplneni displeje svislymi carami (pattern = 0b10101010)
disclear(0b10101010) # po funkci disclear() zustava displej v textovem rezimu
init_grafika() # proto je treba ho pred dalsi grafickou funkci prepnout do grafickeho rezimu
slovo(" K O N E C " , 2 , 25 , True)
exit(0)
#==============================================================
# vsechny podprogramy jsou nize:
#==============================================================
#==============================================================
# zobrazeni jedne ze 4 nadefinovanych ikon o velikosti 16x16 bodu na pozici [x, y]
# x je v rozsahu 0 az 7
# y je v rozsahu 0 az 3
def printiko(cislo , x , y):
posun = x
if (y == 1) : posun = posun + 16
if (y == 2) : posun = posun + 8
if (y == 3) : posun = posun + 24
posli_bajt1( 0, 0b10000000 + posun) # Address Counter na pozadovanou pozici
posli_bajt2( 1 , 0 , cislo * 2)
#==============================================================
# zobrazeni jednoho znaku z fontu 8x8 bodu
# zn_x= pozice znaku v ose X (0 az 15) ,supery = 0 az 63 (mikroradka, na ktere je horni okraj znaku)
def znak(kod , zn_x , supery , inverze=False):
# kontrola svtupnich parametru a jejich pripadne prenastaveni na krajni meze
if (kod < 32) : kod = 32
if (kod > 255) : kod = 255
if (zn_x < 0) : zn_x = 0
if (zn_x > 15) : zn_x = 15
if (supery > 63) : supery = 63
if (supery < 0) : supery = 0
kod = kod - 32 # v souboru s fontem je jako prvni znak definovaná mezera s kodem 32
superx = zn_x * 8
# obraz znaku z fontu se bude postupne prenaset na displej bajt po bajtu v 8 krocich (zhora dolu)
for adr_font in range(kod*8,(kod*8)+8):
# vypocet horizontalni a vertikalni adresy v pameti displeje
horiz = int(superx / 16)
dis_adr_y = supery
if (dis_adr_y >= 32):
dis_adr_y = dis_adr_y - 32
horiz = horiz + 8
minibit = superx % 16 # poloha bitu, se kterym se bude pracovat, v dvojbajtu
posli_bajt2( 0, 0b10000000 + dis_adr_y , 0b10000000 + horiz ) # nastaveni adresy grafiky
puvodni_leva = mapa[horiz,dis_adr_y,0] # zjisteni aktualniho stavu dvojbajtu na displeji
puvodni_prava = mapa[horiz,dis_adr_y,1]
if(minibit < 8): # kdyz je minibit < 8, meni se jen levy bajt z dvojbajtu
if (inverze == False): # normalni text (prepise vsechno, co je pod textem)
levy_bajt = font2[adr_font]
if (inverze == True): # inverzni text (prepise vsechno, co je pod textem)
levy_bajt = ~font2[adr_font]
pravy_bajt = puvodni_prava # pravy bajt z dvojbajtu bude beze zmeny
else: # kdyz je minibit >= 8, meni se jen pravy bajt z dvojbajtu
if (inverze == False): # normalni text (prepise vsechno, co je pod textem)
pravy_bajt = font2[adr_font]
if (inverze == True): # inverzni text (prepise vsechno, co je pod textem)
pravy_bajt = ~font2[adr_font]
levy_bajt = puvodni_leva # levy bajt z dvojbajtu bude beze zmeny
posli_bajt2( 1, levy_bajt, pravy_bajt) # prepise dvojbajt na zadane adrese v displeji
mapa[horiz,dis_adr_y,0] = levy_bajt # stejne hodnoty si zapamatuje do promenne mapa[]
mapa[horiz,dis_adr_y,1] = pravy_bajt
supery = supery + 1 # posun aktualni mikroradky o jednu nize
#==============================================================
# nakresleni horizontalni cary bod po bodu
def h_cara(supery, od=0 , do=127, styl=1):
for x in range(od, do+1):
plot(x,supery,styl)
#==============================================================
# nakresleni vertikalni cary s vyuzitim bitove masky
def v_cara(superx, od=0 , do=63, pattern = 255):
poz_pat = 0 # pozice bitu v patternu
for y in range(od , do+1 ):
maska = (0b10000000 >> (poz_pat % 8)) # podle zadaneho patternu vybira jednotlive bity
bitpat= pattern & maska
if (bitpat == 0): # ktere na displeji bud zobrazi, nebo smaze
styl = 0
else:
styl = 1
plot(superx,y,styl)
poz_pat = poz_pat + 1
#==============================================================
# nakresleni horizontalni cary od kraje ke kraji po bajtech
def h_cara2(supery = 0, odbajtu = 0, dobajtu = 5, pattern = 0b11111111):
posun=odbajtu
if (supery >= 32):
supery = supery - 32
posun = posun + 8
posli_bajt2( 0, 0b10000000 + supery , 0b10000000 + posun )
for r in range(dobajtu - odbajtu + 1):
posli_bajt2( 1, pattern , pattern )
mapa[posun + r , supery,0] = pattern
mapa[posun + r , supery,1] = pattern
#==============================================================
#zobrazeni nekolika znaku za sebou fontem 8x8
# zn_x = pozice prvního znaku v textu je ve sloupci 0 az 15 ; supery = 0 az 63 (horni okraj znaku)
def slovo(text , zn_x , supery , inverze=False):
if (isinstance(text, unicode) == False): # pokud text neni v unicode, tak ho preved
text= unicode(text, "utf-8") # prevod textu z UTF-8 na unicode
# cely text prochazet znak po znaku a tisknout
for zn in range (len(text)):
if (zn_x < 16): # kontrola prekroceni sirky displeje
if (ord(text[zn:zn + 1]) > 127): # pokud jde o neASCII znak, provest prekodovani podle tabulky
try: # pokud neni specialni kod nadefinovany v tabulce, ...
znak(cz2[ord(text[zn:zn + 1])], zn_x, supery, inverze)
except: # ... skoncil by program chybou neexistujiciho indexu promenne cz2[].
znak(164, zn_xx, supery , inverze) # V tom pripade se nahradi nedefinovany znak znakem "kolecko s teckama"
else:
znak(ord(text[zn:zn + 1]), zn_x, supery , inverze) # ASCII znaky tisknout normalne
zn_x = zn_x + 1
#==============================================================
# zobrazeni / smazani / inverze 1 bodu na souradnicich superx (0 az 127) a supery (0 az 63)
def plot(superx , supery , styl=1):
# kontrola na spravny rozsah souradnic a jejich pripadne upraveni na krajni hodnoty
if (superx > 127): superx = 127
if (superx < 0 ): superx = 0
if (supery > 63 ): supery = 63
if (supery < 0 ): supery = 0
horiz = int(superx / 16)
if (supery >= 32):
supery = supery - 32
horiz = horiz + 8
minibit = superx % 16
posli_bajt2( 0, 0b10000000 + supery , 0b10000000 + horiz ) # nastaveni adresy grafiky
puvodni_leva = mapa[horiz,supery,0]
puvodni_prava = mapa[horiz,supery,1]
if (minibit < 8):
if (styl == 1): # nakreslit bod
levy_bajt = (0b10000000 >> minibit) | puvodni_leva
if (styl == 0): # smazat bod
levy_bajt = ~(0b10000000 >> minibit) & puvodni_leva
if (styl == 2): # smazat bod
levy_bajt = (0b10000000 >> minibit) ^ puvodni_leva
pravy_bajt = puvodni_prava
else:
if (styl == 1): # nakreslit bod
pravy_bajt = (0b10000000 >> (minibit-8)) | puvodni_prava
if (styl == 0): # smazat bod
pravy_bajt = ~(0b10000000 >> (minibit-8)) & puvodni_prava
if (styl == 2): # smazat bod
pravy_bajt = (0b10000000 >> (minibit-8)) ^ puvodni_prava
levy_bajt = puvodni_leva
posli_bajt2( 1, levy_bajt, pravy_bajt)
mapa[horiz,supery,0] = levy_bajt
mapa[horiz,supery,1] = pravy_bajt
#==============================================================
# zobrazeni / smazani / inverze 1 bodu na souradnicich superx (0 az 127) a supery (0 az 63)
def mem_plot(superx , supery , styl=1):
horiz = int(superx / 16)
if (supery >= 32):
supery = supery - 32
horiz = horiz + 8
minibit = superx % 16
puvodni_leva = mapa[horiz,supery,0]
puvodni_prava = mapa[horiz,supery,1]
if (minibit < 8):
if (styl == 1): # nakreslit bod
levy_bajt = (0b10000000 >> minibit) | puvodni_leva
if (styl == 0): # smazat bod
levy_bajt = ~(0b10000000 >> minibit) & puvodni_leva
if (styl == 2): # smazat bod
levy_bajt = (0b10000000 >> minibit) ^ puvodni_leva
pravy_bajt = puvodni_prava
else:
if (styl == 1): # nakreslit bod
pravy_bajt = (0b10000000 >> (minibit-8)) | puvodni_prava
if (styl == 0): # smazat bod
pravy_bajt = ~(0b10000000 >> (minibit-8)) & puvodni_prava
if (styl == 2): # smazat bod
pravy_bajt = (0b10000000 >> (minibit-8)) ^ puvodni_prava
levy_bajt = puvodni_leva
mapa[horiz,supery,0] = levy_bajt
mapa[horiz,supery,1] = pravy_bajt
#==============================================================
# nacteni fontu 8x8 bodu ze souboru do seznamu "font2[]"
def nacist_font2(jmenosouboru):
fontfile=file(jmenosouboru,"r")
adresafontu=0
for radka in fontfile:
rozlozeno = radka.split(",") # vysosani jednotlivych bajtu z jedne radky ...
for bajt in range(8): # 8 bajtu na jedne radce v souboru
font2[adresafontu] = int(rozlozeno[bajt][-4:],0) # ... a ulozeni kazdeho toho bajtu do seznamu
adresafontu = adresafontu + 1
fontfile.close()
#==============================================================
# podprogram pro zobrazeni textu obrim fontem (8x16 bodu)
# definice fontu je soucasti ROM v displeji - neumi tedy ceske znaky
# zn_x = pocatecni sloupec, na který se zacne text vypisovat [0 az 16]
# radka je v rozsahu [0 az 3]
def velky_napis(text , zn_x , radka):
if (len(text)+ zn_x > 16): # pokud je na radce text delsi, nez 16 znaku,
text=text[0:16 - zn_x] # ... tak se konec odsekne
txt_start(zn_x , radka) # startovni poloha textu se posle do displeje
for znak in range(len(text)):
posli_bajt1( 1, ord(text[znak:znak+1])) # znaky z textu se postupne posilaji do displeje
pomtext=txtmapa[radka][:zn_x+znak] + text[znak:znak+1] + txtmapa[radka][zn_x+znak+1:]
txtmapa[radka] = pomtext # pamet pro textovy rezim
#==============================================================
# zobrazeni jednoho znaku v textovem rezimu
def velky_znak(kod , zn_x, radka):
txt_start(zn_x , radka) # startovni poloha textu se posle do displeje
posli_bajt1( 1, kod) # kod znaku se posle do displeje
pomtext=txtmapa[radka][:zn_x] + chr(kod) + txtmapa[radka][zn_x+1:]
txtmapa[radka] = pomtext # pamet pro textovy rezim
#==============================================================
# nastaveni pozice tisku pro textovy rezim (pro znaky 8x16 bodu)
# sloupec (0 az 15) a radku (0 az 3)
def txt_start(sloupec , radka):
posun = sloupec
if (radka == 1) : posun = sloupec + 32
if (radka == 2) : posun = sloupec + 16
if (radka == 3) : posun = sloupec + 48
posli_bajt1( 0, 0b10000000 + int(posun / 2)) # Address Counter na pozadovanou pozici
# pri lichem sloupci se musi napis doplnit o znak, ktery je na displeji pred nove tisknutym napisem
if (sloupec / 2.0 != sloupec/2):
puvodni_predznak = txtmapa[radka][sloupec - 1:sloupec] # "predznak" se zjistuje z pomocne textove pameti
posli_bajt1( 1, ord(puvodni_predznak))
#==============================================================
# nacteni dvoubarevneho BMP obrazku 128x64 bodu do promenne mapa[]
# POZOR: Bez jakychkoli testu na korektni format BMP souboru!
def load_bmp12864(jmeno_obrazku):
soubor=open(jmeno_obrazku, "rb") # nacteni obrazku do promenne data[]
data = soubor.read()
soubor.close() # uzavreni souboru
# podrobna specifikace hlavicky BMP souboru je tady:
# http://www.root.cz/clanky/graficky-format-bmp-pouzivany-a-pritom-neoblibeny
# zacatek obrazovych dat urcuji 4 bajty v souboru na pozicich 10 az 13 (desitkove) od zacatku souboru
zacatekdat = ord(data[10]) + (ord(data[11]) * 256) + (ord(data[12]) * 65536) + (ord(data[13]) * 16777216)
bajt=zacatekdat
for mikroradka in range (63,-1,-1): # cteni promenne data[] bajt po bajtu a postupne ukladani do pameti (mapa[])
supery = mikroradka
if (mikroradka > 31):
supery = supery - 32
posun = 8
else:
posun = 0
posli_bajt2( 0, 0b10000000 + supery , 0b10000000 + posun ) # nastaveni adresy grafiky
for sloupec in range (8):
levy_bajt = (ord(data[bajt]))
pravy_bajt = (ord(data[bajt+1]))
posli_bajt2( 1, levy_bajt, pravy_bajt) #
mapa[sloupec+posun , supery,0] = levy_bajt
mapa[sloupec+posun , supery,1] = pravy_bajt
bajt = bajt + 2 # prejde na dalsi dvojbajt z grafickych dat
#==============================================================
# presypani cele graficke pameti (promenne mapa[]) na displej
def mem_dump():
for mikroradka in range(32):
posli_bajt2( 0, 0b10000000 + mikroradka , 0b10000000 ) # nastaveni adresy grafiky
for horizontal in range (16):
levy_bajt = mapa[horizontal , mikroradka , 0]
pravy_bajt = mapa[horizontal , mikroradka , 1]
posli_bajt2( 1, levy_bajt, pravy_bajt)
#==============================================================
# smazani graficke casi displeje
def clr_grafika(pattern = 0):
init_grafika()
posli_bajt1( 0, 0b00110110) # function set (extend instr.set)
posli_bajt1( 0, 0b00110100) # function set (grafika OFF) - aby nebylo videt postupne mazani displeje
posli_bajt1( 0, 0b00001000) # displ.=OFF , cursor=OFF , blik=OFF
for vertikal in range(32):
posli_bajt2( 0, 0b10000000 + vertikal, 0b10000000 ) # nastaveni adresy na displeji na zacatek mikroradky
for horizontal in range (16):
posli_bajt2( 1, pattern , pattern ) # po dvojbajtech zaplni cely displej stejnym kodem
# a tento kod se jeste zapise na jednotlive pozice do pomocne pameti
mapa[horizontal,vertikal,0]=pattern
mapa[horizontal,vertikal,1]=pattern
posli_bajt1( 0, 0b00110110) # function set (grafika ON) - smazany displej se zobrazi okamzite
#==============================================================
# smazani textove casti displeje
def clr_text():
posli_bajt1( 0, 0b00110000) # function set (8 bit)
posli_bajt1( 0, 0b00110000) # function set (basic instr. set)
posli_bajt1( 0, 0b00001100) # displ.=ON , cursor=OFF , blik=OFF
posli_bajt1( 0, 0b00000001) # clear
# vymazani pomocne textove pameti
txtmapa[0] = " "
txtmapa[1] = " "
txtmapa[2] = " "
txtmapa[3] = " "
#==============================================================
# smazani graficke a zaroven i textove casti displeje.
# POZOR: po navratu je displej nastaven v TEXTOVEM rezimu
def disclear(pattern=0):
clr_grafika(pattern)
clr_text()
#==============================================================
# nastavi displej do grafickeho rezimu
def init_grafika():
posli_bajt1( 0, 0b00110010) # function set (8 bit)
posli_bajt1( 0, 0b00110110) # function set (extend instr. set)
posli_bajt1( 0, 0b00110110) # function set (grafika ON)
posli_bajt1( 0, 0b00000010) # enable CGRAM po prenastaveni do BASIC instr.set
#==============================================================
# nastavi displej do textoveho rezimu
def init_text():
posli_bajt1( 0, 0b00110000) # function set (8 bit)
posli_bajt1( 0, 0b00110100) # function set (extend instr. set)
posli_bajt1( 0, 0b00110110) # function set (grafika OFF)
posli_bajt1( 0, 0b00000010) # enable CGRAM (po prenastaveni do BASIC instr.set)
posli_bajt1( 0, 0b00110000) # function set (basic instr. set)
posli_bajt1( 0, 0b00001100) # displ.=ON , cursor=OFF , blik=OFF
posli_bajt1( 0, 0b10000000) # Address Counter na levy horni roh
#==============================================================
# definice grafickeho tvaru 4 ikon o velikosti 16x16 bodu
# ikona = cislo ikony 0 az 3
# ikodata = pole 16 x dvojbajtova hodnota
def defikon(ikona,ikodata):
init_text()
posli_bajt1( 0, 64 + (ikona * 16) ) # nastaveni adresy grafiky
for dat in range(16):
levy_bajt = ikodata[dat] / 256
pravy_bajt = ikodata[dat] % 256
posli_bajt2( 1, levy_bajt , pravy_bajt)
#==============================================================
# rozblikani kurzoru za poslednim zadanym znakem v textovem rezimu
# je urceny pro cinske znaky, takze blika velky ctverec 16x16 bodu
# (pro evropske znaky (8x16 bodu) je to tedy nepouzitelne)
def blikkurzor(stav):
init_tetx()
if (stav == True):
posli_bajt1( 0, 0b00001111) # displ.=ON , cursor=ON , blik=ON
else:
posli_bajt1( 0, 0b00001100) # displ.=ON , cursor=OFF , blik=OFF
#==============================================================
#nastavi pozici na prislusny sloupec (0 az 7) a radku (0 az 3)
# pro velké znaky a ikony (16x16 bodu)
def ikopos(sloupec , radka):
posun = sloupec
if (radka == 1) : posun = sloupec + 16
if (radka == 2) : posun = sloupec + 8
if (radka == 3) : posun = sloupec + 24
posli_bajt1( 0, 0b10000000 + posun) # Address Counter na pozadovanou pozici
#==============================================================
# nastaveni datoveho pinu pri seriove komunikaci na "0" nebo "1"
def serd(bit):
if (bit == 1):
GPIO.output(sdata_pin, True)
else:
GPIO.output(sdata_pin, False)
#==============================================================
# kratky jednickovy impulz na hodinovem pinu pri seriove komunikaci
def strobe():
GPIO.output(sclk_pin, True)
time.sleep(0.0000001)
GPIO.output(sclk_pin, False)
time.sleep(0.0000001)
#==============================================================
# podprogram pro odeslani dvou bajtu po seriove komunikaci bez preruseni mezi jednotlivymi bajty
def posli_bajt2( rs, bajt1, bajt2):
serd(1) # zacatek komunikace se provadi "synchro" sekvenci 5 jednicek
for i in range (5):
strobe()
serd(0) # pak se odesle RW bit (pri zapisu je nastaven na "0")
strobe()
serd(rs) # pak se posle RS bit (prikazy = "0" ; data = "1")
strobe()
serd(0) # nasleduje nulovy bit
strobe()
for i in range(7,3,-1): # a pak horni ctyri bity z prvniho bajtu
bit = (bajt1 & (2**i)) >> i
serd(bit)
strobe()
serd(0) # dale je oddelovaci sekvence 4x "0"
for i in range (4):
strobe()
for i in range(3,-1,-1): # a pak nasleduje zbytek z prvniho bajtu (nizsi 4 bity)
bit = (bajt1 & (2**i)) >> i
serd(bit)
strobe()