PIC Vietnam - pic 16f877a và hiển thị led matran

PIC Vietnam (http://www.picvietnam.com/forum/index.php)

- PIC - Thiết kế và Ứng dụng (http://www.picvietnam.com/forum/forumdisplay.php?f=23)

- - pic 16f877a và hiển thị led matran (http://www.picvietnam.com/forum/showthread.php?t=9261)

pic 16f877a và hiển thị led matran

chào các bác!!!!!!!!!11
mình đang làm đề tài quang báo hiển thị led matran vấn đề mình gặp phải chưa giải quyết được là khi từ máy tính đẩy một chuỗi dữ liệu xuống thì làm sao xử lý chuỗi đó hiển thị led matran(ở đây mình đã làm hiển thị được ký tự rồi nhưng xử lý chuỗi từ pc xuống vẫn chưa được)
vd :truyền chuỗi từ pc xuống pic là"*picvietnam.com#"
khi pic nhận dc ký tự # rồi thì sẽ xử lý chuỗi vậy làm sao mình lấy từng ký tự hiển thị led matran(mình nghĩ lấy từng ký tự tra mảng rồi hiển thị nhưng vẫn không biết tách từng ký tự trong 1 chuỗi như thế nào)
mong bác nào đã làm qua có thể chỉ mình cách viết được không...........cám ơn các bác

Từ máy tình truyền nối tiếp xuống xuống PIC mà, bạn chỉ lấy từng byte từ bộ đệm ra thôi. Không bít có đúng ý bạn muốn hỏi không?

nhưng cách lấy mình lấy như thế nào mình muốn hỏi là vậy
một chuỗi là vậy nhưng lấy 1 ký tự hiện thì mình vẫn chưa làm được
bạn biết cách lấy ko chỉ mỉnh dc không?

cái này bạn chỉ việc trong hàm ngắt nhận bạn đưa data vào 1 mảng.Sau đó bạn lấy từng byte trong mảng đem tham chiếu vào bảng mã Font =>Quét hiển thị lên led ma trận

Trong hàm ngắt bạn viết như sau:

Code:

#int_RDA

void ngat()

{

data=getc()

if(data='#')

{

index=0;

}

else

{

mangdata[index]=data;

index++;

}

}

vậy bạn stupid xử lý chuỗi pic hiển thị lên như thế nào để lấy từng ký tự ra rồi xuất lên led matrix

mong các bạn đóng góp ý kiến giúp mình làm đồ án tốt nghiệp
nếu làm xong thì mình sẽ post len toàn bộ cho bạn nào chưa làm hay muốn nghiên cứu về led matran
mong các bác pro nào đã từng làm chỉ giáo giúp mình.........thanks

..............**********Học thầy không tày học bạn*********...............
..............******ở nhà nhờ ba mẹ,ra đường nhờ bạn bè******..............

sao không ai giúp thế nhỉ?

Trích:

Nguyên văn bởi friend_1990 (Post 44915)

một gợi ý cho bạn:
vd bạn nhận được một chuỗi là :pic#
bạn lưu nó vào vùng luu_chuỗi[]
đọc luu_chuỗi[] so sánh nếu không phải là kí tự #
so sánh xem nó là kí tự gì rồi lấy font kí tự đó lưu vào vùng nhớ :hien_thị[]
lúc này chỉ cần lấy data từ vùng nhớ:hien_thị[] đưa ra matrix là xong.

mình đã nghĩ tới phương pháp đó nhưng viết mãi vẫn không lấy ký tự ra được
bạn có thể post 1 đoạn chương trình làm vd được không

mong bạn giúp mình nha!!!!!!!!!!!

...........********Những điều ta biết là 1 hạt cát*********..............
...........******những điều ta chưa biết là cả 1 sa mạc*****.............

Trích:

Nguyên văn bởi friend_1990 (Post 44954)

bạn gởi file mô phỏng lên đây.

mình gửi cả file mo phỏng và code lên mình chỉ mới hiển thị được ký tự mặc định thôi chứ chưa lấy dc ký tự bất ký bạn xem và chỉ giúp mình nha

cám ơn tdm nha!!!!!!!!!!!!!!!

nếu ai làm được thì post lên diễn đàn mọi người cùng tham khảo và cùng làm nha
cám ơn mọi người đã xem qua!!!!!!!!!!!!!!!!!!!!!!

sao ko thấy ai trả lời dùm hết vậy ta
a admin giúp dùm em đi!!!!!!!!!!!!!

Trích:

Nguyên văn bởi friend_1990 (Post 44978)

sao ko thấy ai trả lời dùm hết vậy ta
a admin giúp dùm em đi!!!!!!!!!!!!!

một đọan code cho bạn ,bạn tìm hiểu thêm rồi phát triển thêm nhé.
hi vọng nó có ích cho bạn.

Code:

//lay mang du lieu so sanh voi font luu font vao vung nho hien thi

//mo phong proteus 7.6 ps2 OK

#include <16f877a.h>

#fuses nowdt,noprotect,nolvp,hs,put

#use delay(clock=20000000)

#use fast_io(b)

#byte portb=0x06

#bit b0=portb.0

#bit b1=portb.1

#bit b2=portb.2

#bit b3=portb.3

#bit b4=portb.4

#bit b5=portb.5

void lay_font(char * textptr);

unsigned char a,bi,temp,chieu_dai=0;

unsigned char hien_thi[64];

char du_lieu[] = "tdm_16f877a#";//

const BYTE TEXT[51][5] ={0x00, 0x00, 0x00, 0x00, 0x00, // SPACE

                         0x00, 0x00, 0x5F, 0x00, 0x00, // !

                         0x00, 0x03, 0x00, 0x03, 0x00, // "

                         0x14, 0x3E, 0x14, 0x3E, 0x14, // #

                         0x24, 0x2A, 0x7F, 0x2A, 0x12, // $

                         0x43, 0x33, 0x08, 0x66, 0x61, // %

                         0x36, 0x49, 0x55, 0x22, 0x50, // &

                         0x00, 0x05, 0x03, 0x00, 0x00, // '

                         0x00, 0x1C, 0x22, 0x41, 0x00, // (

                         0x00, 0x41, 0x22, 0x1C, 0x00, // )

                         0x14, 0x08, 0x3E, 0x08, 0x14, // *

                         0x08, 0x08, 0x3E, 0x08, 0x08, // +

                         0x00, 0x50, 0x30, 0x00, 0x00, // ,

                         0x08, 0x08, 0x08, 0x08, 0x08, // -

                         0x00, 0x60, 0x60, 0x00, 0x00, // .

                         0x20, 0x10, 0x08, 0x04, 0x02, // /

                         0x3E, 0x51, 0x49, 0x45, 0x3E, // 0

                         0x04, 0x02, 0x7F, 0x00, 0x00, // 1

                         0x42, 0x61, 0x51, 0x49, 0x46, // 2

                         0x22, 0x41, 0x49, 0x49, 0x36, // 3

                         0x18, 0x14, 0x12, 0x7F, 0x10, // 4

                         0x27, 0x45, 0x45, 0x45, 0x39, // 5

                         0x3E, 0x49, 0x49, 0x49, 0x32, // 6

                         0x01, 0x01, 0x71, 0x09, 0x07, // 7

                         0x36, 0x49, 0x49, 0x49, 0x36, // 8

                         0x26, 0x49, 0x49, 0x49, 0x3E, // 9

                         0x00, 0x36, 0x36, 0x00, 0x00, // :

                         0x00, 0x56, 0x36, 0x00, 0x00, // ;

                         0x08, 0x14, 0x22, 0x41, 0x00, // <

                         0x14, 0x14, 0x14, 0x14, 0x14, // =

                         0x00, 0x41, 0x22, 0x14, 0x08, // >

                         0x02, 0x01, 0x51, 0x09, 0x06, // ?

                         0x3E, 0x41, 0x59, 0x55, 0x5E, // @

                         0x7E, 0x09, 0x09, 0x09, 0x7E, // A

                         0x7F, 0x49, 0x49, 0x49, 0x36, // B

                         0x3E, 0x41, 0x41, 0x41, 0x22, // C

                         0x7F, 0x41, 0x41, 0x41, 0x3E, // D

                         0x7F, 0x49, 0x49, 0x49, 0x41, // E

                         0x7F, 0x09, 0x09, 0x09, 0x01, // F

                         0x3E, 0x41, 0x41, 0x49, 0x3A, // G

                         0x7F, 0x08, 0x08, 0x08, 0x7F, // H

                         0x00, 0x41, 0x7F, 0x41, 0x00, // I

                         0x30, 0x40, 0x40, 0x40, 0x3F, // J

                         0x7F, 0x08, 0x14, 0x22, 0x41, // K

                         0x7F, 0x40, 0x40, 0x40, 0x40, // L

                         0x7F, 0x02, 0x0C, 0x02, 0x7F, // M

                         0x7F, 0x02, 0x04, 0x08, 0x7F, // N

                         0x3E, 0x41, 0x41, 0x41, 0x3E, // O

                         0x7F, 0x09, 0x09, 0x09, 0x06, // P

                         0x1E, 0x21, 0x21, 0x21, 0x5E, // Q

                         0x7F, 0x09, 0x09, 0x09, 0x76};// R



const BYTE TEXT2[44][5]={0x26, 0x49, 0x49, 0x49, 0x32, // S

                         0x01, 0x01, 0x7F, 0x01, 0x01, // T

                         0x3F, 0x40, 0x40, 0x40, 0x3F, // U

                         0x1F, 0x20, 0x40, 0x20, 0x1F, // V

                         0x7F, 0x20, 0x10, 0x20, 0x7F, // W

                         0x41, 0x22, 0x1C, 0x22, 0x41, // X

                         0x07, 0x08, 0x70, 0x08, 0x07, // Y

                         0x61, 0x51, 0x49, 0x45, 0x43, // Z

                         0x00, 0x7F, 0x41, 0x00, 0x00, // [

                         0x02, 0x04, 0x08, 0x10, 0x20, // \

                         0x00, 0x00, 0x41, 0x7F, 0x00, // ]

                         0x04, 0x02, 0x01, 0x02, 0x04, // ^

                         0x40, 0x40, 0x40, 0x40, 0x40, // _

                         0x00, 0x01, 0x02, 0x04, 0x00, // `

                         0x20, 0x54, 0x54, 0x54, 0x78, // a

                         0x7F, 0x44, 0x44, 0x44, 0x38, // b

                         0x38, 0x44, 0x44, 0x44, 0x44, // c

                         0x38, 0x44, 0x44, 0x44, 0x7F, // d

                         0x38, 0x54, 0x54, 0x54, 0x18, // e

                         0x04, 0x04, 0x7E, 0x05, 0x05, // f

                         0x08, 0x54, 0x54, 0x54, 0x3C, // g

                         0x7F, 0x08, 0x04, 0x04, 0x78, // h

                         0x00, 0x44, 0x7D, 0x40, 0x00, // i

                         0x20, 0x40, 0x44, 0x3D, 0x00, // j

                         0x7F, 0x10, 0x28, 0x44, 0x00, // k

                         0x00, 0x41, 0x7F, 0x40, 0x00, // l

                         0x7C, 0x04, 0x78, 0x04, 0x78, // m

                         0x7C, 0x08, 0x04, 0x04, 0x78, // n

                         0x38, 0x44, 0x44, 0x44, 0x38, // o

                         0x7C, 0x14, 0x14, 0x14, 0x08, // p

                         0x08, 0x14, 0x14, 0x14, 0x7C, // q

                         0x00, 0x7C, 0x08, 0x04, 0x04, // r

                         0x48, 0x54, 0x54, 0x54, 0x20, // s

                         0x04, 0x04, 0x3F, 0x44, 0x44, // t

                         0x3C, 0x40, 0x40, 0x20, 0x7C, // u

                         0x1C, 0x20, 0x40, 0x20, 0x1C, // v

                         0x3C, 0x40, 0x30, 0x40, 0x3C, // w

                         0x44, 0x28, 0x10, 0x28, 0x44, // x

                         0x0C, 0x50, 0x50, 0x50, 0x3C, // y

                         0x44, 0x64, 0x54, 0x4C, 0x44, // z

                         0x00, 0x08, 0x36, 0x41, 0x41, // {

                         0x00, 0x00, 0x7F, 0x00, 0x00, // |

                         0x41, 0x41, 0x36, 0x08, 0x00, // }

                         0x02, 0x01, 0x02, 0x04, 0x02};// ~

   



int8 i,x=0,y,z,m,t;

int8 n;

void dich(void);

void xuat(unsigned char bi);

void main()

{ 

   set_tris_b(0b00000000);

   set_tris_d(0b00000000);

 lay_font(du_lieu);      // Write character set to matrix

 while(1) 

{

for(t=0;t<=100;t++)

{

b1=1;

b0=1;

b2=1;

b0=0;

b2=0;

x=0;

for(m=0;m<=63;m++)

{

n=hien_thi[m];

n=~n;

xuat(n);

delay_us(1000);

dich();

}

}

}

}



void dich()

{

b1=0;

b0=1;

b0=0;

b2=1;

b2=0;

}

void xuat(unsigned char temp)

{

#bit flag_bit = temp.7

b4=0;

for(i=0;i<=7;i++)

{

if(flag_bit)

{b4=1;}

else

{b4=0;}

b3=1;

b3=0;

temp<<=1;

}

b5=1;

b5=0;

}

void lay_font(char * textptr)

{

   int i, j;//

   BYTE pixelData[5];                     // Stores character data

   

   for(i=0; textptr[i] != '\0'; ++i ) // Loop through the passed string

   { 

      if(textptr[i] == '#')

      break;

       if(textptr[i] < 'S') // Checks if the letter is in the first text array

         memcpy(pixelData, TEXT[textptr[i]-' '], 5);

      else if(textptr[i] <= '~') // Check if the letter is in the second array

         memcpy(pixelData, TEXT2[textptr[i]-'S'], 5);

      else

         memcpy(pixelData, TEXT[0], 5);   // Default to space

    for(j=0;j<=4;j++)

    {

     hien_thi[chieu_dai]=(pixelData[j]);

     chieu_dai++;

    }

     

       }

      }

cám ơn tdm nhiều lắm nha
giúp mình lần nữa nha đoạn code lấy font sao mình đọc khó hiểu quá bạn có thể giải thích từng dòng bằng tiếng việt được không
với lại mình lấy bài bạn mô phỏng sao chỉ hiển thị mà khong dịch được vậy tdm xem lại dùm mình chỗ đó nữa nha

thanks tdm nhiều nha mong bạn giúp mình
mail bạn là gì vậy có gì mình trao đổi qua đó cho tiện
của mình là namcddt0811b@gmail.com
mong nhận được sự trả lời sớm nhất bạn thanks