PIC16F88 128X8 PC ĐIỀU KHIỂN TRƯỢT VĂN BẢN VỚI CCS C

Chuẩn bị bởi: Eyüp KAPLAN - Lời cảm ơn đến những người cuối cùng Những giải thích sau đây là của riêng họ.

Hi ...

Với ma trận 128 × 8, tôi vừa hoàn thành cả chữ nổi và dự án Hiển thị Ma trận. Tôi muốn chia sẻ nó với bạn. Xây dựng doanh nghiệp của bạn.

Văn bản được dịch chuyển được lưu trong EEPROM và đọc từ nó trong khi cuộn. Vì lý do này, văn bản được dịch chuyển có thể được thay đổi bất cứ lúc nào và không mất dữ liệu. Chúng tôi sử dụng kết nối RS232 với sự trợ giúp của PC. Đối với điều này:

Nếu công tắc được kết nối với PIN_A5 tại thời điểm bật nguồn đầu tiên, PIC hiểu rằng bạn muốn nhập dữ liệu mới và hỏi xem có mục nhập mới hay không. Nếu nó không phải là một mục nhập mới, chúng tôi nhập ký tự "é". Nếu một mục mới được thực hiện thì chúng ta sẽ ghi dữ liệu để nhập.

Chương trình sẽ tự động chuyển thành chữ hoa. Vì tôi không có thời gian, tôi không thể tạo các phông chữ chữ nhỏ. Một số ký tự tiếng Thổ Nhĩ Kỳ bị thiếu. Chỉ "Ü" và "Tôi" hiện được xác định. Tôi sẽ giới thiệu tất cả các nhân vật ở các giai đoạn khác của dự án. Lakin đã quá mệt mỏi với tôi.

Sau khi nhập dữ liệu mới, chúng tôi chắc chắn nhập ký tự "é" làm ký tự cuối cùng k; Biết rằng dữ liệu PIC sắp kết thúc. Nếu không, nó sẽ tiếp tục đọc dữ liệu. Khi chúng tôi bật công tắc sau khi nhập dữ liệu xong, khi chúng tôi tiếp thêm sinh lực cho thiết bị, nó sẽ bắt đầu cuộn trên màn hình như thể chúng tôi đã nhập mà không hỏi bất cứ điều gì.

Tôi không nghĩ rằng sự run rẩy nhẹ trên màn hình sẽ được thực hành thực tế. Bởi vì mỗi lần máy tính được gắn vào mô phỏng Proteus, tùy thuộc vào thời gian, hình ảnh cũng bị đóng băng và nó làm rung động chúng ta như rung động.

Tôi đã sử dụng PIC16F88 trong dự án. Tôi đã sử dụng Ma trận Cathode chung. Nhưng ứng dụng LED có thể được thực hiện và Cathode chung có thể được kết nối. Tất nhiên, trong trường hợp này nó sẽ là cần thiết để lái xe các bóng bán dẫn và hàng và cột.

Các dự án như vậy chỉ dành cho mục đích di chuyển; Phần địa chỉ (các cột được quét) dễ dàng hơn nhiều với bộ dao động hoặc bộ kích hoạt bên ngoài được điều khiển trong một pic của PIC và chúng tôi có thể hiển thị nhiều hơn với số cột. Nhưng chúng tôi muốn tiếp cận trực tiếp hàng và cột mong muốn ở đây, vì vậy chúng tôi đã đạt đến rất nhiều (128) cột ngay bây giờ. Nhiều hơn bạn cần cho nhiều ứng dụng mặc dù.

Khi số lượng cột tăng lên, thời gian quét sẽ tăng lên và hình ảnh sẽ xuất hiện.
Rất nhiều cho tôi ... Số ký tự tối đa có thể được nhập không được vượt quá 255. Bởi vì bộ nhớ của PIC là nhiều. Tại mục nhập, nếu đạt 255, nó sẽ tự động bắt đầu cuộn.

Điều này ngăn cản nhập cảnh xa hơn. Cách tốt nhất để đăng nhập: PC với một chương trình như Delphi, VB, C và viết một giao diện để viết bài viết ở đây và sửa lỗi. Sau đó nó có thể được gửi trực tiếp từ cổng RS232 của máy tính hoặc được gửi với sự trợ giúp của điều khiển từ xa.

128X8 nổi viết mạch sơ đồ

Tôi đã cố gắng để thực hiện một dự án hiển thị ma trận nhằm đạt được các vật liệu tối thiểu và hiệu suất PIC tối đa càng nhiều càng tốt. Như tôi đã nói, nếu mục tiêu chỉ là thay đổi, thì logic khác nhau có thể được sử dụng. Một trong những tính năng quan trọng nhất của dự án là sự dịch chuyển điểm. Trượt trong nhân vật đòi hỏi phần mềm đơn giản hơn nhiều. Vấn đề là nhận được một chút phức tạp hơn khi nói đến điểm.

Nếu bạn phải cẩn thận, 128/6 = 21,33 ký tự. Mặc dù ký tự cuối cùng bị thiếu, 
phần này không được để trống và tất cả 128 cột được sử dụng. Đây là những chi tiết tốt, nhưng đây là những chi tiết làm cho chất lượng phần mềm. Nếu thay đổi chữ được thực hiện, 2 cột cuối cùng sẽ trống.

Khi phần mềm tiến triển, tốc độ di chuyển và thời gian chờ cũng được thực hiện để điều khiển PC, nhưng phần này chưa được thêm vào dự án này. Tôi đã cho nền tảng của dự án ở đây, để bạn sẽ có một ánh sáng trên những người muốn có một ý tưởng. Tôi đã gặp rất nhiều rắc rối khi tôi lần đầu tiên bắt đầu. Tôi chỉ mất 1-2 ngày để quyết định tích hợp và chỉ số nào để sử dụng và cách sử dụng chúng. Bây giờ, với dự án này, những người muốn làm loại công việc này sẽ thấy những gì họ cần là phần cứng và những gì họ có thể làm khi họ làm việc. Họ cũng sẽ phát triển mã nguồn riêng của họ.

PIC16F88 Nổi Font_Source.c

#include <16f88 .h="">
#device * = 16
#device adc = 8

#FUSES NOWDT // Không có bộ đếm thời gian cho chó xem
# FUSES INTRC_IO // RC Osc nội bộ, không có CLKOUT
#FUSES NOPUT // Không có bộ hẹn giờ bật nguồn
// # FUSES MCLR // Đã bật ghim chính trống
# FUSES BROWNOUT // Đặt lại khi phát hiện ra màu nâu
// # FUSES LVP // Lập trình điện áp thấp trên B3 (PIC16) hoặc B5 (PIC18)
#FUSES NOCPD // Không bảo vệ EE
#FUSES NOWRT // Bộ nhớ chương trình không được ghi bảo vệ
#FUSES NODEBUG // Không có chế độ Gỡ lỗi cho ICD
#FUSES NOPROTECT // Mã không được bảo vệ khỏi việc đọc
# FUSES FCMEN // Đã bật chế độ giám sát đồng hồ không an toàn
# FUSES IESO // Chuyển đổi bên ngoài nội bộ Đã bật chế độ
// # FUSES CCPB0

#use delay (clock = 8000000)
#use rs232 (baud = 9600, chẵn lẻ = N, rcv = PIN_B7, bit = 8)
#use fast_io (a)
#use fast_io (b)

#include 

chữ số char [6];
Char Yazi_Len;
Dài Yazi_Bin_Len;

char message1 [] = "GHI NHẬN MỚI?";

void Char_5x7_Matrix (char opt); // Hàm được BAO GỒM ở cuối chương trình

Char Set_Output_A (int8 d, s)
{
char s1;

   s1 = ((s << 5) & 0b11000000) | ((s & 0b00000001) << 4);
   Trở lại (d | s1);
}

Char Set_Message_Output_A (int8 s) // Đếm tính toán phơi nhiễm X nếu đầu vào
{
char s1;
   
   s1 = ((s << 1) & 0b11000000) | (s & 0b00011111);
   Return (s1);
}

Char Set_Data_Output_B (int8 Kay_Data)
{
Char D, S;

   D = Kay_data / 6; //idiv.quot;
   S = Kay_Data% 6; //idiv.re I;
   char_5x7_matrix (read_eepro I (D));
   
   Return (Digit [s]);
}

Char Set_Mesaj_Output_B (int8 Kay_Data)
{
Char D, S;

   D = Kay_data / 6; //idiv.quot;
   S = Kay_Data% 6; //idiv.re I;
   char_5x7_matrix (Mesaj1 [D]);
   
   Return (Digit [s]);
}

Void Clr_Matrix ()
{
Char s, j;
   
   Đối với (s = 0; s <8 ch="" d="" font="" g="" i="" n="" ng="" s="">
   {                    
      Đối với (j = 0; j <= 15; j ++) // Gửi bit dữ liệu
      { 
         OUTPUT_DIR A (set_output_ A (j, p));
         OUTPUT_BIN (0x00);
         delay_us (300);
      }
   }
}

Void Tara ()
{
char i, j, s, count = 0, Kay_Ep = 0;
   
kay_ep = 0; // Lưu trữ vị trí bắt đầu của Dữ liệu để cuộn
Đếm = 0;

While (true)
{
   Đếm = Kay_Ep;
   clr_matrix ();
   cho (i = 0; i <7 c="" cu="" font="" gian="" i="" khi="" n.="" qu="" t="" th="" tr="">Thay đổi chậm trễ! ...
   {
      count = Kay_Ep;
      Đối với (s = 0; s <8 ch="" d="" font="" g="" i="" n="" ng="" s="">
      {                    
         Đối với (j = 0; j <= 15; j ++) // Gửi bit dữ liệu
         {         
            OUTPUT_DIR A (set_output_ A (j, p));   
            OUTPUT_BIN (set_data_output_b (Đếm));
            delay_us (1); // Thời gian hiển thị dữ liệu
            OUTPUT_BIN (0x00); // vì lý do này, chúng tôi đặt lại dữ liệu khi hoàn tất. Để hiển thị dữ liệu thực tế sau khi chọn mới trước số 0.
            Đếm ++;            
            Nếu (Count == Yazi_Bin_Len) Count = 0; // Nếu Pixel của bạn là người cuối cùng quay lại đầu trang              
         }
      }
   }
   kay_ep ++;
   Nếu (Kay_Ep == Yazi_Bin_Len) Kay_Ep = 0;
}
}

Bỏ qua Message_Yaz (char X, * Mes)
{
char i, s, count = 0, Xs = 0, Xsm, Ss, * Msg;
      
   Msg = Mes;   
   Xs = X;   
   Xsm = (Xs + 10 * 6);
   Nếu (Xsm & gt; = 128) Xsm = 128;
   
   clr_matrix ();
   
   cho (i = 0; i <255 c="" cu="" font="" i="" khi="" l="" n.="" ng="" qu="" t="" th="" tr="">Thay đổi chậm trễ! ...
   {
      count = 0;
      cho (s = Xs; s 0) write_eeprom (255, Pos);
}

void main ()
{

   setup_adc_ports (NO_ANALOGS);
   setup_adc (ADC_OFF);
   setup_sp của (SPI_SS_DISABLED);
   setup_wdt (WDT_OFF);
   setup_timer_0 (RTCC_INTERNAL);
   setup_timer_1 (T1_DISABLED);
   setup_timer_2 (T2_DISABLED, 0,1);
   setup_comparat là (NC_NC_NC_NC);
   setup_vref (FALSE);

   set_tris_b (0b10000000);      
   set_tris_a (0b00100000); // PIN_A5 MCLR là đầu vào
   
   OUTPUT_DIR A (0x00);
   OUTPUT_BIN (0x00);
   
   If (Input (PIN_A5))
   {
      mesaj_yaz (21, Mesaj1);
   }
   
   Nếu (Đầu vào (PIN_A5)) // Nhập dữ liệu từ máy tính
   {
      write_eprom_yaz của ();
   }        
   
   yazi_l read_eepro Một = I (255);
   Yazi_Bin_Len = (int16) Yazi_Len * 6;   
   
   While (true)
   {
      Scan ();
   }
}

#include 

PIC16F88 Floating Type_K Character_Source.c

void Char_5x7_Matrix (lựa chọn char)
{
   chuyển đổi (opt)
   {                            
      trường hợp 'A': Chữ số [0] = 0x3F;  
                  Chữ số [1] = 0x48;
                  Chữ số [2] = 0x48;
                  Chữ số [3] = 0x48;
                  Chữ số [4] = 0x3F;   
                  Chữ số [5] = 0x00;   
                  break;
      trường hợp 'B': Chữ số [0] = 0x7f;  
                  Chữ số [1] = 0x49;
                  Chữ số [2] = 0x49;
                  Chữ số [3] = 0x49;
                  Chữ số [4] = 0x36;   
                  Chữ số [5] = 0x00;   
                  break;
      case 'C': Digit [0] = 0x3e;  
                  Chữ số [1] = 0x41;
                  Chữ số [2] = 0x41;
                  Chữ số [3] = 0x41;
                  Chữ số [4] = 0x22;   
                  Chữ số [5] = 0x00;   
                  break;
      trường hợp 'D': Chữ số [0] = 0x7f;  
                  Chữ số [1] = 0x41;
                  Chữ số [2] = 0x41;
                  Chữ số [3] = 0x41;
                  Chữ số [4] = 0x3A;   
                  Chữ số [5] = 0x00;   
                  break;
      trường hợp 'E': Chữ số [0] = 0x7f;  
                  Chữ số [1] = 0x49;
                  Chữ số [2] = 0x49;
                  Chữ số [3] = 0x49;
                  Chữ số [4] = 0x41;   
                  Chữ số [5] = 0x00;   
                  break;
      trường hợp 'F': Chữ số [0] = 0x7f;  
                  Chữ số [1] = 0x48;
                  Chữ số [2] = 0x48;
                  Chữ số [3] = 0x48;
                  Chữ số [4] = 0x40;   
                  Chữ số [5] = 0x00;   
                  break;
      case 'G': Digit [0] = 0x3E;  
                  Chữ số [1] = 0x41;
                  Chữ số [2] = 0x49;
                  Chữ số [3] = 0x49;
                  Chữ số [4] = 0x2;   
                  Chữ số [5] = 0x00;   
                  break;
      case 'H': Chữ số [0] = 0x7F;  
                  Chữ số [1] = 0x08;
                  Chữ số [2] = 0x08;
                  Chữ số [3] = 0x08;
                  Chữ số [4] = 0x7F;   
                  Chữ số [5] = 0x00;   
                  break;
      case 'I': Digit [0] = 0x41;  
                  Chữ số [1] = 0x7F;
                  Chữ số [2] = 0x41;
                  Chữ số [3] = 0x00;
                  Chữ số [4] = 0x00;  
                  Chữ số [5] = 0x00;   
                  break;
      case 'I': Digit [0] = 0x11;  
                  Chữ số [1] = 0x5f;
                  Chữ số [2] = 0x11;
                  Chữ số [3] = 0x00;
                  Chữ số [4] = 0x00;  
                  Chữ số [5] = 0x00;   
                  break;                  
      case 'J': Digit [0] = 0x02;  
                  Chữ số [1] = 0x01;
                  Chữ số [2] = 0x41;
                  Chữ số [3] = 0x7E;
                  Chữ số [4] = 0x40;
                  Chữ số [5] = 0x00;   
                  break;
      chữ 'K': Chữ số [0] = 0x7f;  
                  Chữ số [1] = 0x08;
                  Chữ số [2] = 0x14;
                  Chữ số [3] = 0x22;
                  Chữ số [4] = 0x41;  
                  Chữ số [5] = 0x00;   
                  break;
      trường hợp 'L': Chữ số [0] = 0x7f;  
                  Chữ số [1] = 0x01;
                  Chữ số [2] = 0x01;
                  Chữ số [3] = 0x01;
                  Chữ số [4] = 0x01;   
                  Chữ số [5] = 0x00;   
                  break;
      case 'M': Chữ số [0] = 0x7f;  
                  Chữ số [1] = 0x20;
                  Chữ số [2] = 0x18;
                  Chữ số [3] = 0x20;
                  Chữ số [4] = 0x7F;   
                  Chữ số [5] = 0x00;   
                  break;
      case 'N': Digit [0] = 0x7F;  
                  Chữ số [1] = 0x10;
                  Chữ số [2] = 0x08;
                  Chữ số [3] = 0x04;
                  Chữ số [4] = 0x7F;  
                  Chữ số [5] = 0x00;   
                  break;  
      case 'O': Digit [0] = 0x3E;  
                  Chữ số [1] = 0x41;
                  Chữ số [2] = 0x41;
                  Chữ số [3] = 0x41;
                  Chữ số [4] = 0x3A;   
                  Chữ số [5] = 0x00;   
                  break;
      case 'P': Digit [0] = 0x7f;  
                  Chữ số [1] = 0x48;
                  Chữ số [2] = 0x48;
                  Chữ số [3] = 0x48;
                  Chữ số [4] = 0x30;   
                  Chữ số [5] = 0x00;   
                  break;
      case 'Q': Digit [0] = 0x3e;  
                  Chữ số [1] = 0x41;
                  Chữ số [2] = 0x45;
                  Chữ số [3] = 0x42;
                  Chữ số [4] = 0x3d;   
                  Chữ số [5] = 0x00;   
                  break;
      trường hợp 'R': Chữ số [0] = 0x7f;  
                  Chữ số [1] = 0x48;
                  Chữ số [2] = 0x4c;
                  Chữ số [3] = 0x4 A;
                  Chữ số [4] = 0x31;   
                  Chữ số [5] = 0x00;   
                  break;
      case 'S': Digit [0] = 0x32;  
                  Chữ số [1] = 0x49;
                  Chữ số [2] = 0x49;
                  Chữ số [3] = 0x49;
                  Chữ số [4] = 0x26;   
                  Chữ số [5] = 0x00;   
                  break;
      case 'T': Chữ số [0] = 0x40;  
                  Chữ số [1] = 0x40;
                  Chữ số [2] = 0x7F;
                  Chữ số [3] = 0x40;
                  Chữ số [4] = 0x40;   
                  Chữ số [5] = 0x00;   
                  break;
      chữ 'U': Chữ số [0] = 0x7E;  
                  Chữ số [1] = 0x01;
                  Chữ số [2] = 0x01;
                  Chữ số [3] = 0x01;
                  Chữ số [4] = 0x7E;   
                  Chữ số [5] = 0x00;   
                  break;
      case 'Ü': Digit [0] = 0x1E;  
                  Chữ số [1] = 0x41;
                  Chữ số [2] = 0x01;
                  Chữ số [3] = 0x41;
                  Chữ số [4] = 0x1A;   
                  Chữ số [5] = 0x00;   
                  break;                  
      case 'V': Chữ số [0] = 0x7C;  
                  Chữ số [1] = 0x02;
                  Chữ số [2] = 0x01;
                  Chữ số [3] = 0x02;
                  Chữ số [4] = 0x7c;   
                  Chữ số [5] = 0x00;   
                  break;
      case 'W': Digit [0] = 0x7E;  
                  Chữ số [1] = 0x01;
                  Chữ số [2] = 0x0A;
                  Chữ số [3] = 0x01;
                  Chữ số [4] = 0x7E;   
                  Chữ số [5] = 0x00;   
                  break;
      case 'X': Chữ số [0] = 0x63;  
                  Chữ số [1] = 0x14;
                  Chữ số [2] = 0x08;
                  Chữ số [3] = 0x14;
                  Chữ số [4] = 0x63;   
                  Chữ số [5] = 0x00;   
                  break;
      case 'Y': Digit [0] = 0x70;  
                  Chữ số [1] = 0x08;
                  Chữ số [2] = 0x07;
                  Chữ số [3] = 0x08;
                  Chữ số [4] = 0x70;   
                  Chữ số [5] = 0x00;   
                  break;
      case 'Z': Digit [0] = 0x43;  
                  Chữ số [1] = 0x45;
                  Chữ số [2] = 0x49;
                  Chữ số [3] = 0x51;
                  Chữ số [4] = 0x61;
                  Chữ số [5] = 0x00;   
                  break;                  
      case '': Digit [0] = 0x00;  
                  Chữ số [1] = 0x00;
                  Chữ số [2] = 0x00;
                  Chữ số [3] = 0x00;
                  Chữ số [4] = 0x00;
                  Chữ số [5] = 0x00;   
                  break;
                  
      case '0': Chữ số [0] = 0x3E;  
                  Chữ số [1] = 0x45;
                  Chữ số [2] = 0x49;
                  Chữ số [3] = 0x51;
                  Chữ số [4] = 0x3A;
                  Chữ số [5] = 0x00;   
                  break;
                  
      case '1': Digit [0] = 0x21;  
                  Chữ số [1] = 0x7F;
                  Chữ số [2] = 0x01;
                  Chữ số [3] = 0x00;
                  Chữ số [4] = 0x00;
                  Chữ số [5] = 0x00;   
                  break;
                  
      trường hợp '2': Chữ số [0] = 0x21;  
                  Chữ số [1] = 0x43;
                  Chữ số [2] = 0x45;
                  Chữ số [3] = 0x49;
                  Chữ số [4] = 0x31;
                  Chữ số [5] = 0x00;   
                  break;
                  
      case '3': Digit [0] = 0x42;  
                  Chữ số [1] = 0x41;
                  Chữ số [2] = 0x51;
                  Chữ số [3] = 0x69;
                  Chữ số [4] = 0x46;
                  Chữ số [5] = 0x00;   
                  break;
                  
      case '4': Digit [0] = 0x0c;  
                  Chữ số [1] = 0x14;
                  Chữ số [2] = 0x24;
                  Chữ số [3] = 0x7F;
                  Chữ số [4] = 0x04;
                  Chữ số [5] = 0x00;   
                  break;
                  
      case '5': Chữ số [0] = 0x72;  
                  Chữ số [1] = 0x51;
                  Chữ số [2] = 0x51;
                  Chữ số [3] = 0x51;
                  Chữ số [4] = 0x4 A;
                  Chữ số [5] = 0x00;   
                  break;
                  
      case '6': Digit [0] = 0x1e;  
                  Chữ số [1] = 0x29;
                  Chữ số [2] = 0x49;
                  Chữ số [3] = 0x49;
                  Chữ số [4] = 0x06;
                  Chữ số [5] = 0x00;   
                  break;
                  
      trường hợp '7': Chữ số [0] = 0x40;  
                  Chữ số [1] = 0x47;
                  Chữ số [2] = 0x48;
                  Chữ số [3] = 0x50;
                  Chữ số [4] = 0x60;
                  Chữ số [5] = 0x00;   
                  break;
                  
      case '8': Chữ số [0] = 0x36;  
                  Chữ số [1] = 0x49;
                  Chữ số [2] = 0x49;
                  Chữ số [3] = 0x49;
                  Chữ số [4] = 0x36;
                  Chữ số [5] = 0x00;   
                  break;
                  
      trường hợp '9': Chữ số [0] = 0x30;  
                  Chữ số [1] = 0x49;
                  Chữ số [2] = 0x49;
                  Chữ số [3] = 0x4 A;
                  Chữ số [4] = 0x3C;
                  Chữ số [5] = 0x00;   
                  break;
                 
      case '?': Chữ số [0] = 0x20;  
                  Chữ số [1] = 0x40;
                  Chữ số [2] = 0x45;
                  Chữ số [3] = 0x48;
                  Chữ số [4] = 0x30;
                  Chữ số [5] = 0x00;
                  break; 
      case '$': Chữ số [0] = 0x32;  
                  Chữ số [1] = 0x49;
                  Chữ số [2] = 0x7F;
                  Chữ số [3] = 0x49;
                  Chữ số [4] = 0x26;   
                  Chữ số [5] = 0x00;
                  break;
      case '%': Chữ số [0] = 0x62;  
                  Chữ số [1] = 0x64;
                  Chữ số [2] = 0x08;
                  Chữ số [3] = 0x13;
                  Chữ số [4] = 0x23;   
                  Chữ số [5] = 0x00;
                  break;
      case '#': Chữ số [0] = 0x14;  
                  Chữ số [1] = 0x7F;
                  Chữ số [2] = 0x14;
                  Chữ số [3] = 0x7F;
                  Chữ số [4] = 0x14;   
                  Chữ số [5] = 0x00;
                  break;
      case '&': Digit [0] = 0x36;  
                  Chữ số [1] = 0x49;
                  Chữ số [2] = 0x39;
                  Chữ số [3] = 0x16;
                  Chữ số [4] = 0x05;   
                  Chữ số [5] = 0x00;
                  break;
      case '.': Digit [0] = 0x00;
                  Chữ số [1] = 0x03;
                  Chữ số [2] = 0x03;
                  Chữ số [3] = 0x00;
                  Chữ số [4] = 0x00;
                  Chữ số [5] = 0x00;
                  break;                  
      case ',': Digit [0] = 0x00;  
                  Chữ số [1] = 0x01;
                  Chữ số [2] = 0x01;
                  Chữ số [3] = 0x06;
                  Chữ số [4] = 0x00;
                  Chữ số [5] = 0x00;
                  break;
      case ';': Digit [0] = 0x00;
                  Chữ số [1] = 0x01;
                  Chữ số [2] = 0x01;
                  Chữ số [3] = 0x36;
                  Chữ số [4] = 0x30;
                  Chữ số [5] = 0x00;
                  break; 
      case '"': Chữ số [0] = 0x00;
                  Chữ số [1] = 0x60;
                  Chữ số [2] = 0x00;
                  Chữ số [3] = 0x60;
                  Chữ số [4] = 0x00;
                  Chữ số [5] = 0x00;
                  break;
      case '`': Chữ số [0] = 0x00;
                  Chữ số [1] = 0x60;
                  Chữ số [2] = 0x10;
                  Chữ số [3] = 0x00;
                  Chữ số [4] = 0x00;
                  Chữ số [5] = 0x00;
                  break;                  
      case '!': Chữ số [0] = 0x00;
                  Chữ số [1] = 0x00;
                  Chữ số [2] = 0x7d;
                  Chữ số [3] = 0x00;
                  Chữ số [4] = 0x00;
                  Chữ số [5] = 0x00;
                  break;                          
      case '-': Digit [0] = 0x00;
                  Chữ số [1] = 0x08;
                  Chữ số [2] = 0x08;
                  Chữ số [3] = 0x08;
                  Chữ số [4] = 0x00;
                  Chữ số [5] = 0x00;
                  break;
      case '+': Digit [0] = 0x08;
                  Chữ số [1] = 0x08;
                  Chữ số [2] = 0x3A;
                  Chữ số [3] = 0x08;
                  Chữ số [4] = 0x08;
                  Chữ số [5] = 0x00;
                  break;
      case '=': Chữ số [0] = 0x00;
                  Chữ số [1] = 0x14;
                  Chữ số [2] = 0x14;
                  Chữ số [3] = 0x14;
                  Chữ số [4] = 0x00;
                  Chữ số [5] = 0x00;
                  break;
      case '(': Digit [0] = 0x00;
                  Chữ số [1] = 0x1c;
                  Chữ số [2] = 0x22;
                  Chữ số [3] = 0x41;
                  Chữ số [4] = 0x00;
                  Chữ số [5] = 0x00;
                  break;                  
      case ')': Chữ số [0] = 0x00;
                  Chữ số [1] = 0x41;
                  Chữ số [2] = 0x22;
                  Chữ số [3] = 0x1c;
                  Chữ số [4] = 0x00;
                  Chữ số [5] = 0x00;
                  break;
      case '[': Digit [0] = 0x00;
                  Chữ số [1] = 0x7F;
                  Chữ số [2] = 0x41;
                  Chữ số [3] = 0x41;
                  Chữ số [4] = 0x00;
                  Chữ số [5] = 0x00;
                  break;                  
      case ']': Chữ số [0] = 0x00;
                  Chữ số [1] = 0x41;
                  Chữ số [2] = 0x41;
                  Chữ số [3] = 0x7F;
                  Chữ số [4] = 0x00;
                  Chữ số [5] = 0x00;
                  break;                  
      case '*': Chữ số [0] = 0x2A;
                  Chữ số [1] = 0x1c;
                  Chữ số [2] = 0x08;
                  Chữ số [3] = 0x1c;
                  Chữ số [4] = 0x2;
                  Chữ số [5] = 0x00;
                  break;
      case '/': Digit [0] = 0x02;
                  Chữ số [1] = 0x04;
                  Chữ số [2] = 0x08;
                  Chữ số [3] = 0x10;
                  Chữ số [4] = 0x20;
                  Chữ số [5] = 0x00;
                  break;                  
      case '_': Chữ số [0] = 0x01;  
                  Chữ số [1] = 0x01;
                  Chữ số [2] = 0x01;
                  Chữ số [3] = 0x01;
                  Chữ số [4] = 0x01;
                  Chữ số [5] = 0x00;
                  break;
      case '<': Digit [0] = 0x08;  
                  Chữ số [1] = 0x14;
                  Chữ số [2] = 0x22;
                  Chữ số [3] = 0x41;
                  Chữ số [4] = 0x00;
                  Chữ số [5] = 0x00;
                  break;
      case '>': Chữ số [0] = 0x00;  
                  Chữ số [1] = 0x41;
                  Chữ số [2] = 0x22;
                  Chữ số [3] = 0x14;
                  Chữ số [4] = 0x08;
                  Chữ số [5] = 0x00;
                  break;                  
      case 'é': Chữ số [0] = 0x0E;  
                  Chữ số [1] = 0x15;
                  Chữ số [2] = 0x35;
                  Chữ số [3] = 0x55;
                  Chữ số [4] = 0x0D;
                  Chữ số [5] = 0x00;
                  break;                  
      trường hợp 0x27: Chữ số [0] = 0x00; // '  
                  Chữ số [1] = 0x00;
                  Chữ số [2] = 0x10;
                  Chữ số [3] = 0x60;
                  Chữ số [4] = 0x00;
                  Chữ số [5] = 0x00;
                  break;                  
                  
      }                         
}

LOGIC CƠ BẢN CỦA MẠCH VIẾT NỔI

Logic của các mạch cuộn hoàn toàn dựa trên ảo giác của mắt. Theo logic của mạch được sử dụng cho các cột trượt, tất cả các cột không thể thay đổi cùng một lúc; hoặc nếu các dòng tương ứng với chỉ một cột được quét nhanh và thời gian đủ nhanh để được coi là bắt mắt, thì tất cả các đường và các khối đá sẽ giống nhau (như trường hợp của nhiều mạch đầu ra cho các mạch đó) Anda có ấn tượng về việc được tiếp thêm sinh lực.

Dựa trên kết luận này, sau đó, trước hết,

Chương trình trên cần phải được mã hóa bằng một chương trình tương tự. Bạn phải làm điều này từng cái một cho mỗi ký tự bạn muốn hiển thị trên màn hình. Tất nhiên, có thể nhận các phông chữ sẵn sàng từ một nơi nào đó. Nhưng một trong những khía cạnh thú vị nhất của công việc là tạo phông chữ của riêng bạn. Tôi đã thêm chương trình này vào tệp zip. Trong bài viết này, tôi sẽ không đề cập đến phần mạch điện tử của doanh nghiệp của bạn. Mọi người đều có thể thiết kế mạch phù hợp với anh ta. Đã có nhiều mẫu sẵn sàng.

Bây giờ chúng tôi đã tạo ra các phông chữ, đó là thời gian để hiển thị chúng trên màn hình. Thông thường 2 phương pháp được ưa thích cho việc này.

- Việc di chuyển nhân vật ký tự được thực hiện. 
- Hoặc mỗi thanh trượt được dịch chuyển. Trong trường hợp này, chúng ta cần phải cuộn 5 cho 1 ký tự.

Đây là sự lựa chọn của bạn. Ký tự chuyển đổi ký tự là một ứng dụng đơn giản hơn nhiều. Tính toán cũng dễ dàng hơn. Nhưng việc làm phẳng đường ống dẫn nước là khó khăn hơn một chút, và cần tính toán cẩn thận hơn. Dưới đây là ví dụ về một số phông chữ được mã hóa trong phông chữ:

'A': Chữ số [0] = 0x3F;
Chữ số [1] = 0x48;
Chữ số [2] = 0x48;
Chữ số [3] = 0x48;
Chữ số [4] = 0x3F;
Chữ số [5] = 0x00;

'B': Chữ số [0] = 0x7f;
Chữ số [1] = 0x49;
Chữ số [2] = 0x49;
Chữ số [3] = 0x49;
Chữ số [4] = 0x36;
Chữ số [5] = 0x00;

'1': Chữ số [0] = 0x21;
Chữ số [1] = 0x7F;
Chữ số [2] = 0x01;
Chữ số [3] = 0x00;
Chữ số [4] = 0x00;
Chữ số [5] = 0x00;

'2': Chữ số [0] = 0x21;
Chữ số [1] = 0x43;
Chữ số [2] = 0x45;
Chữ số [3] = 0x49;
Chữ số [4] = 0x31;
Chữ số [5] = 0x00;

As ...

Lưu ý rằng ở đây một số từ 0..5 được xác định và cột cuối cùng là 0x00. Cột cuối cùng này, 0x00, được thêm vào để tạo khoảng trắng giữa các ký tự. Tôi đã lập trình ở trên như một chuỗi riêng biệt cho mỗi chữ cái trong chương trình của tôi. Ngoài ra, các ký tự này có thể được xác định trong một dòng chung và mỗi ký tự có thể đạt được bằng phương pháp tính toán. Mặc dù tôi thích phương pháp này nói chung, theo tôi, tôi đã chọn để xác định một bởi chính nó bởi vì một số hạn chế được mang đến cho tôi.Một điểm cần lưu ý là mã của mọi người sẽ khác nhau

int harf_deg [264] = {0x3F, 0x48,0x48,0x48,0x3F, 0, // A
0x7F, 0x49,0x49,0x49,0x36,0, // B
0x3e, 0x41,0x41,0x41,0x22,0, // C
0x7f, 0x41,0x41,0x41,0x3e, 0, // D
0x7F, 0x49,0x49,0x49,0x41,0, // E
0x7F, 0x48,0x48,0x48,0x40,0, // F
0x3E, 0x41,0x49,0x49,0x2E, 0, // G
0x7F, 0x08, 0x08, 0x08, 0x7F, 0, // H
0x41, 0x7F, 0x41,0x00,0x00,0, // I
0x11,0x5F, 0x11,0x00,0x00,0, // I
0x02, 0x01, 0x41, 0x7e, 0x40,0, // J
0x7F, 0x08,0x14,0x22,0x41,0, // K
0x7F, 0x01,0x01,0x01,0x01,0, // L
0x7F, 0x20,0x18,0x20,0x7F, 0, // M
0x7F, 0x10,0x08,0x04,0x7F, 0, // N
0x3E, 0x41,0x41,0x41,0x3E, 0, // O
0x7F, 0x48,0x48,0x48,0x30,0, // P
0x3e, 0x41,0x45,0x42,0x3d, 0, // Q
0x7f, 0x48,0x4C, 0x4a, 0x31,0, // R
0x32,0x49,0x49,0x49,0x26,0, // S
0x40,0x40,0x7F, 0x40,0x40,0, // T
0x7E, 0x01, 0x01, 0x01, 0x7E, 0, // U
0x1E, 0x41,0x01,0x41,0x1E, 0, //
0x7C, 0x02, 0x01, 0x02, 0x7C, 0, // V
0x7E, 0x01, 0x0E, 0x01, 0x7E, 0, // W
0x63,0x14,0x08,0x14,0x63,0, // X
0x70,0x08,0x07,0x08,0x70,0, // Y
0x43,0x45,0x49,0x51,0x61,0, // Z
0x00,0x00,0x00,0x00,0x00,0, // Dấu cách
0x3E, 0x45,0x49,0x51,0x3E, 0, // 0
0x21,0x7F, 0x01,0x00,0x00,0, // 1
0x21,0x43,0x45,0x49,0x31,0, // 2
0x42,0x41,0x51,0x69,0x46,0, // 3
0x0c, 0x14,0x24,0x7f, 0x04,0, // 4
0x72,0x51,0x51,0x51,0x4e, 0, // 5
0x1e, 0x29,0x49,0x49,0x06,0, // 6
0x40,0x47,0x48,0x50,0x60,0, // 7
0x36,0x49,0x49,0x49,0x36,0, // 8
0x30,0x49,0x49,0x4 A, 0x3C, 0}; // 9

Ví dụ, trong ma trận mảng đơn ở trên, số tiền của ký tự "A" 0x3F, 0x48,0x48,0x48,0x3F, 0 . Đặt các mã này vào bộ mã hóa phông chữ 5 × 7 và chúng tôi có được hình ảnh sau đây. Chương trình này cho chúng ta kết quả và đưa ra kết quả theo thứ tự. Chúng ta cần nó theo sữa. Hãy chú ý đến điều đó.

Bằng cách này được đưa ra khi các mã của phần mềm được hoàn thành chúng để hiển thị trên màn hình ... Use'll LED Matrix Display 8 × 8 như đã sẵn sàng-Matrix Display 's được thực hiện sử dụng trong trường hợp này chúng tôi hoặc 5 × 7 chữ chứ không phải là 5 × 8, 6 × 8, 7 × 8 hoặc 8 Chúng tôi có thể tạo kiểu phông chữ mà chúng tôi muốn, chẳng hạn như × 8 hoặc để trống, không sử dụng một trong các dòng sử dụng loại phông chữ 5 × 7 đi vào loại quỹ nhỏ. Nếu chúng ta đang làm một màn hình 2 dòng, chúng ta cần phải để lại không gian cho nó, vì vậy nó sẽ được xử lý như một khoảng thời gian trên dòng chúng ta để trống.

Nếu chúng ta sẽ thực hiện một màn hình bằng cách sử dụng đèn LED của chúng tôi thì chúng tôi không thể thực hiện dòng thứ 8 này. 
Đó là tất cả tùy thuộc vào bạn. Bây giờ đầu tiên, nếu bạn sẽ trượt từ trái sang phải; Đây là những gì là đúng. Nếu không, sẽ có lỗi trong việc đọc.

- Chúng tôi đọc từ chuỗi ký tự mà chúng tôi đã tạo chuỗi ký tự sắp được chuyển. Nếu chúng tôi đã thực hiện mô tả tập thể, chúng tôi đã đọc tối đa 5 lần đầu tiên sau khi đọc mô tả đầu tiên. Nếu chúng tôi đã thực hiện nó một cách riêng biệt cho mỗi nhân vật như tôi đã làm, chúng tôi có thể đọc chúng tuần tự từ 0 đến 5, tương ứng.

- Chúng tôi đọc thông tin về điều đó. Ví dụ, giá trị này cho chữ cái "A"; 0: 0x3F, 1: 0x48, 2: 0x48, 3: 0x48, 4: 0x3F, 5: 0x00

- Đầu tiên giá trị h3F trong byte thứ 0 được truyền tới đầu ra (hiển thị 7 bit trong dòng) sẽ chuyển dữ liệu trong chu trình điện tử. Trong chương trình của tôi, tôi đã chọn nó là PORT_B cho 16F88 và trong trường hợp này một trong các đầu ra vẫn còn nhàn rỗi. Tôi đã sử dụng nó như một đầu vào RS232 cho một mục đích khác. Khi chân bị hạn chế, bạn phải có được hiệu suất tối đa từ mọi góc độ. Những người làm như vậy bằng cách sử dụng quá nhiều chân trong sự phong phú là những người thoát ra để đơn giản nhất của sự vật. Trong tương lai, chúng ta sẽ phải làm quen với việc đạt được hiệu suất tối đa để không bận tâm với các mạch phức tạp hơn nhiều.

- Bây giờ byte đầu tiên của ký tự đầu tiên được gửi trong cột cuối cùng của màn hình Matrik của bạn đã được gửi đi. Nhưng điều này chưa được hiển thị. Để hiển thị, cần chọn cột cho mạch điện tử và MCU qua; phản ánh ánh sáng và xem cột chúng tôi chọn. Điều này xảy ra theo hai cách. LED Matrix được kết nối như Cathode chung hoặc Anode chung. Trong trường hợp này, 
chúng ta sẽ phải tạo ra đầu ra tương ứng "0" hoặc "1".

- Bây giờ chúng ta đã viết cột đầu tiên của ký tự đầu tiên, chúng ta cần di chuyển nó sang bên trái. Nếu chúng ta hiển thị nhân vật, nó sẽ rất đơn giản để hiển thị chữ cái đầu tiên trước tiên. Vì vậy, để hiển thị chữ "A" 6 sẽ trở lại và chúng tôi sẽ quét chữ "A" từ đây. Sau 2 trường hợp thời gian qua một số cột nhân vật hoàn toàn là 6 ký tự cho đến khi (0..5 = 6 ký tự) rời khỏi tương lai và lần này một lần nữa từ ký tự đầu tiên (12 sữa trái tại đúng vị trí) kể từ khi dữ liệu sẽ quét, gõ cột tương ứng. Trong trường hợp này, 2 ký tự sẽ xuất hiện trên màn hình.

- Để đơn giản hóa quá trình quét này, chúng tôi luôn có thể làm tất cả các cách từ đầu đến cuối, bất kể có bao nhiêu thuyền. Nếu có 128 cột, tất cả các cột giữa 1..128 sẽ được sắp xếp. Khi thông tin cột tương ứng được tải lên, hình ảnh sẽ xuất hiện trên màn hình. Trong trường hợp này sẽ có một số chậm lại, và cũng bằng cách truy cập trực tiếp vào cột mong muốn, nó sẽ không thể sử dụng nó như một màn hình bình thường không di chuyển. Để ngăn chặn điều này, chúng tôi sẽ tính toán điều này bằng cách thực hiện một số phép tính và chúng tôi sẽ chỉ chọn cột đó để quét. Điều gì xảy ra cuối cùng: chúng tôi chỉ đạt được tốc độ bằng cách chọn cột mà chúng tôi quan tâm. Bên cạnh việc cuộn, chúng ta có thể sử dụng màn hình như một màn hình bình thường và viết ký tự mà chúng ta muốn cho vị trí mong muốn. Để đạt được điều này, phần điện tử phải được chọn theo tính năng này.

- Một số người thực hiện quét với đầu ra dao động cố định, hoặc chương trình sử dụng bụng như một bộ dao động và quét từng xung. Họ cũng làm việc và làm việc, nhưng bạn đang di chuyển và các chương trình của bạn ngăn bạn phát triển các dự án khác hoặc các dự án khác trong tay bạn. Bạn cũng không thể sử dụng nó như một màn hình bình thường. Bạn chỉ có thể cuộn. Rất khó để viết văn bản cố định. Điều này là hoàn toàn tùy thuộc vào bạn.

- Đó là cách bạn đến cột đầu tiên. Chúng ta biết cột nào chúng ta đang ở với một biến mà chúng ta đã theo dõi. Các phiếu về cơ bản sẽ bắt đầu ở đây bởi vì nó là cột đầu tiên. Vì vậy, các chương của bài viết sẽ được ẩn. Đây hoàn toàn là phong cách lập trình của bạn. Nó không phải là câu hỏi mà bạn sẽ sử dụng logic nào. Cho dù bạn muốn quét từng ký tự một lần nữa, nhưng không hiển thị nó vì bạn đang ở vị trí (-) trên màn hình, nếu bạn muốn theo dõi ký tự bạn đang trực tiếp, sau đó bắt đầu in trên màn hình. Trong trường hợp này, vì chúng ta sẽ làm cho nhân vật vô hình lần đầu tiên, chúng ta có thể định nghĩa nó bằng một biến mà chúng ta định nghĩa là "1". Sau đó, trong khi đọc các ký tự trong văn bản, chúng ta bắt đầu đọc từ ký tự thứ hai, chứ không phải ký tự đầu tiên.

- Sau đó, chúng tôi tiếp tục đọc các byte tương ứng của các ký tự và ký tự tương ứng, và in chúng trên màn hình.

- Nếu kích thước màn hình của bạn không đủ dài, chúng tôi sẽ viết nhiều ký tự ngay từ đầu cho đến khi toàn văn được hiển thị, nhưng ký tự mới sẽ luôn xuất hiện từ đầu. Sau khi viết ký tự cuối cùng, chúng ta phải bắt đầu một chu kỳ từ ký tự đầu tiên một lần nữa trên màn hình. Có thể phát triển nhiều lý do cho điều này. Và chúng tôi đã vào số lượng ký tự bằng cách sử dụng değişkne chúng ta đã biết sau khi huyền thoại một lần nữa 1. nhân vật và sau đó tuần tự những người khác, chúng tôi cung cấp theo cách tương tự như hình, hoặc một bộ mới của việc xác định nhân vật của bạn như xa như nó sẽ đưa màn hình khi chúng tôi di chuyển mỗi nhân vật chúng tôi nhập khẩu tự biến phù hợp với màn hình mới. Kết quả là, chúng tôi chỉ thành công trong việc sàng lọc chuỗi video mới này khi quét. Sau đó, ở cuối phiếu, chúng tôi thêm nhân vật tiếp theo vào cuối và cho lượt.

- Tôi muốn nhắc nhở bản thân về điều gì đó cần được chăm sóc ở đây. Nếu bạn bắt đầu với ký tự đầu tiên bạn nhìn thấy là không chính xác trong nửa như vô lý khi bạn đến hoặc chuyển hoạt động để ngay lập tức di chuyển màn hình cột 1 trái trong trường hợp này là không chính xác chia hết cho số cột để hiển thị các ký tự trên màn hình. Để tránh điều này, tính toán 6 cột cho mỗi ký tự ngay từ đầu, tìm hiểu tại thời điểm nào nhân vật cuối cùng của màn hình có thể được hiển thị và viết chương trình tương ứng.

- Di chuyển cột cột phức tạp hơn một chút. Trong trường hợp này, chúng ta cũng cần phải biết chúng ta đang ở trong cột nào. Đối với điều này, chúng ta cần phải xác định một biến thêm và lặp lại trong ba. Bây giờ bạn có thể phát triển phần này theo hệ thống trên.

Tải, 128 × 8 MATRIX Hiển thị và Yazı.pdf nổi, yazı.dsn PIC16F88 nổi, PIC16F88 nổi Yazı.hex, 5x7_matris_karakter_kodlayici.ex đến, MARQUEE CIRCUIT BASIC mantığı.pdf, PIC16F88 yazı_karakter_source.c nổi, yazı_source.c nổi PIC16F88 PIC16F88 128X8 PC điều khiển văn bản nổi với CCS C

Tệp tải xuống danh sách LINK (ở định dạng TXT) link-3751.zip mật khẩu-pass: 320volt.com