Thông báo

Collapse
No announcement yet.

Giải thích cho em đoạn code !

Collapse
X
 
  • Lọc
  • Giờ
  • Show
Clear All
new posts

  • Giải thích cho em đoạn code !

    Khi mình dùng codevisionavr để khai báo Uart thì nó tạo ra một số đoạn code sau mà em không hiểu rõ ý định . Bạn nào hiểu xin chỉ giùm :
    Code:
    // USART Receiver buffer
    #define RX_BUFFER_SIZE 8 
    char rx_buffer[RX_BUFFER_SIZE]; // Khai báo mảng nhận kiểu char có kích cỡ 1x8 byte
    
    #if RX_BUFFER_SIZE<256  // nếu mảng nhận nhỏ hơn 256 thì chỉ cần dùng biến 1byte
    unsigned char rx_wr_index,rx_rd_index,rx_counter;
    #else                                                                                  // nếu lớn hơn phải dùng biến 2byte
    unsigned int rx_wr_index,rx_rd_index,rx_counter;
    #endif
    
    // This flag is set on USART Receiver buffer overflow
    bit rx_buffer_overflow;                                                              
    
    // USART Receiver interrupt service routine           // chương trình ngắt nhận
    interrupt [USART_RXC] void usart_rx_isr(void)
    {
    char status,data;
    status=UCSRA;         // đưa thanh ghi kiểm tra cờ ngắt nhận vào biến status
    data=UDR;                 // đọc dữ liệu từ bộ đệm nhận 
    if ((status & (FRAMING_ERROR | PARITY_ERROR | DATA_OVERRUN))==0) // nếu ko lỗi
       {
       rx_buffer[rx_wr_index]=data;       // lưu dữ liệu vào mảng nhận
       if (++rx_wr_index == RX_BUFFER_SIZE) rx_wr_index=0; // đầy mảng thì đưa chỉ số mảng về 0
       if (++rx_counter == RX_BUFFER_SIZE)     // tương tự ? vậy tại sao dùng thêm rx_counter là gì ? 
          {
          rx_counter=0;
          rx_buffer_overflow=1; // đầy mảng thì set cờ tràn mảng lên 1
          };
       };
    }
    
    #ifndef _DEBUG_TERMINAL_IO_        // ??
    // Get a character from the USART Receiver buffer  
    #define _ALTERNATE_GETCHAR_  //?
    #pragma used+ //?
    char getchar(void) // hàm đọc dữ liệu từ mảng nhận
    {
    char data;
    while (rx_counter==0);     // nếu đúng thì cứ chờ ở đây ?? 
    data=rx_buffer[rx_rd_index];  // đọc từ mảng nhận và ghi vào biến data
    if (++rx_rd_index == RX_BUFFER_SIZE) rx_rd_index=0; // nếu dọc hết mảng thì đưa chỉ số về 0
    #asm("cli")     // cấm ngắt
    --rx_counter; // giảm biến chỉ số ??
    #asm("sei") // cho phép ngắt
    return data; // trả về dữ liệu đọc
    }
    #pragma used-
    #endif
    
    // USART Transmitter buffer
    #define TX_BUFFER_SIZE 8
    char tx_buffer[TX_BUFFER_SIZE];
    
    #if TX_BUFFER_SIZE<256
    unsigned char tx_wr_index,tx_rd_index,tx_counter;
    #else
    unsigned int tx_wr_index,tx_rd_index,tx_counter;
    #endif
    
    // USART Transmitter interrupt service routine
    interrupt [USART_TXC] void usart_tx_isr(void)
    {
    if (tx_counter)
       {
       --tx_counter;
       UDR=tx_buffer[tx_rd_index];
       if (++tx_rd_index == TX_BUFFER_SIZE) tx_rd_index=0;
       };
    }
    
    #ifndef _DEBUG_TERMINAL_IO_
    // Write a character to the USART Transmitter buffer
    #define _ALTERNATE_PUTCHAR_
    #pragma used+
    void putchar(char c)
    {
    while (tx_counter == TX_BUFFER_SIZE);
    #asm("cli")
    if (tx_counter || ((UCSRA & DATA_REGISTER_EMPTY)==0))
       {
       tx_buffer[tx_wr_index]=c;
       if (++tx_wr_index == TX_BUFFER_SIZE) tx_wr_index=0;
       ++tx_counter;
       }
    else
       UDR=c;
    #asm("sei")
    }
    #pragma used-
    #endif
    Một số lệnh mình chú thích theo ý hiểu. nhưng kô chắc đúng bạn nào hiểu rõ giải thích lại giùm.
    - với hàm ngắt sẽ tự động lưu dữ liệu vào mảng ở đây là mảng một chiều nhưng lại không thấy biến đếm chỉ số mảng tăng lên ? có phải nó được dùng gộp trong câu lệnh :
    Code:
    if (++rx_wr_index == RX_BUFFER_SIZE) rx_wr_index=0; // đầy mảng thì đưa chỉ số mảng về 0
    nếu vậy tại sao cần dùng thêm dòng lệnh nè :
    Code:
     if (++rx_counter == RX_BUFFER_SIZE)     // tương tự ? vậy tại sao dùng thêm rx_counter là gì ? 
          {
          rx_counter=0;
          rx_buffer_overflow=1; // đầy mảng thì set cờ tràn mảng lên 1
          };
    đoạn code nè có dư thừa không nhỉ ?

  • #2
    Nguyên văn bởi newbie_avr Xem bài viết
    Khi mình dùng codevisionavr để khai báo Uart thì nó tạo ra một số đoạn code sau mà em không hiểu rõ ý định . Bạn nào hiểu xin chỉ giùm :
    Code:
    // USART Receiver buffer
    #define RX_BUFFER_SIZE 8 
    char rx_buffer[RX_BUFFER_SIZE]; // Khai báo mảng nhận kiểu char có kích cỡ 1x8 byte
    
    #if RX_BUFFER_SIZE<256  // nếu mảng nhận nhỏ hơn 256 thì chỉ cần dùng biến 1byte
    unsigned char rx_wr_index,rx_rd_index,rx_counter;
    #else                                                                                  // nếu lớn hơn phải dùng biến 2byte
    unsigned int rx_wr_index,rx_rd_index,rx_counter;
    #endif
    
    // This flag is set on USART Receiver buffer overflow
    bit rx_buffer_overflow;                                                              
    
    // USART Receiver interrupt service routine           // chương trình ngắt nhận
    interrupt [USART_RXC] void usart_rx_isr(void)
    {
    char status,data;
    status=UCSRA;         // đưa thanh ghi kiểm tra cờ ngắt nhận vào biến status
    data=UDR;                 // đọc dữ liệu từ bộ đệm nhận 
    if ((status & (FRAMING_ERROR | PARITY_ERROR | DATA_OVERRUN))==0) // nếu ko lỗi
       {
       rx_buffer[rx_wr_index]=data;       // lưu dữ liệu vào mảng nhận
       if (++rx_wr_index == RX_BUFFER_SIZE) rx_wr_index=0; // đầy mảng thì đưa chỉ số mảng về 0
       if (++rx_counter == RX_BUFFER_SIZE)     // tương tự ? vậy tại sao dùng thêm rx_counter là gì ? 
          {
          rx_counter=0;
          rx_buffer_overflow=1; // đầy mảng thì set cờ tràn mảng lên 1
          };
       };
    }
    
    #ifndef _DEBUG_TERMINAL_IO_        // ??
    // Get a character from the USART Receiver buffer  
    #define _ALTERNATE_GETCHAR_  //?
    #pragma used+ //?
    char getchar(void) // hàm đọc dữ liệu từ mảng nhận
    {
    char data;
    while (rx_counter==0);     // nếu đúng thì cứ chờ ở đây ?? 
    data=rx_buffer[rx_rd_index];  // đọc từ mảng nhận và ghi vào biến data
    if (++rx_rd_index == RX_BUFFER_SIZE) rx_rd_index=0; // nếu dọc hết mảng thì đưa chỉ số về 0
    #asm("cli")     // cấm ngắt
    --rx_counter; // giảm biến chỉ số ??
    #asm("sei") // cho phép ngắt
    return data; // trả về dữ liệu đọc
    }
    #pragma used-
    #endif
    
    // USART Transmitter buffer
    #define TX_BUFFER_SIZE 8
    char tx_buffer[TX_BUFFER_SIZE];
    
    #if TX_BUFFER_SIZE<256
    unsigned char tx_wr_index,tx_rd_index,tx_counter;
    #else
    unsigned int tx_wr_index,tx_rd_index,tx_counter;
    #endif
    
    // USART Transmitter interrupt service routine
    interrupt [USART_TXC] void usart_tx_isr(void)
    {
    if (tx_counter)
       {
       --tx_counter;
       UDR=tx_buffer[tx_rd_index];
       if (++tx_rd_index == TX_BUFFER_SIZE) tx_rd_index=0;
       };
    }
    
    #ifndef _DEBUG_TERMINAL_IO_
    // Write a character to the USART Transmitter buffer
    #define _ALTERNATE_PUTCHAR_
    #pragma used+
    void putchar(char c)
    {
    while (tx_counter == TX_BUFFER_SIZE);
    #asm("cli")
    if (tx_counter || ((UCSRA & DATA_REGISTER_EMPTY)==0))
       {
       tx_buffer[tx_wr_index]=c;
       if (++tx_wr_index == TX_BUFFER_SIZE) tx_wr_index=0;
       ++tx_counter;
       }
    else
       UDR=c;
    #asm("sei")
    }
    #pragma used-
    #endif
    Một số lệnh mình chú thích theo ý hiểu. nhưng kô chắc đúng bạn nào hiểu rõ giải thích lại giùm.
    - với hàm ngắt sẽ tự động lưu dữ liệu vào mảng ở đây là mảng một chiều nhưng lại không thấy biến đếm chỉ số mảng tăng lên ? có phải nó được dùng gộp trong câu lệnh :
    Code:
    if (++rx_wr_index == RX_BUFFER_SIZE) rx_wr_index=0; // đầy mảng thì đưa chỉ số mảng về 0
    nếu vậy tại sao cần dùng thêm dòng lệnh nè :
    Code:
     if (++rx_counter == RX_BUFFER_SIZE)     // tương tự ? vậy tại sao dùng thêm rx_counter là gì ? 
          {
          rx_counter=0;
          rx_buffer_overflow=1; // đầy mảng thì set cờ tràn mảng lên 1
          };
    đoạn code nè có dư thừa không nhỉ ?
    - biến đếm chỉ số mảng nhận là rx_wr_index rồi đó bạn, lệnh ++rx_wr_index tương đương rx_wr_index = rx_wr_index + 1.
    - tuy nhiên dùng thêm biến rx_couter là không thừa vì : rx_couter vừa dùng đếm byte nhận được từ PC mỗi khi có ngắt nhận nhằm ngăn chặn tràn mảng dữ liệu nhận, nhưng biến này cũng dùng chung trong hàm get_char () để mỗi khi người lập trình gọi hàm get_char() trong chương trình chính để đọc dữ liệu nhận được lưu vào một biến mới thì rx_couter sẽ giảm một byte để giải phóng bộ nhớ cho mảng dữ liệu nhận được rx_buffer [ ], hàm get_char chỉ trả lại một phần tử trong mảng nhận thôi nên rx_couter sẽ giảm đi một đơn vị.
    hàm ngắt nhận là hàm tự động thực thi khi có ngắt ở phần cứng, còn hàm get_char() thì chỉ thực thi khi người dùng gọi mà thôi.

    Comment


    • #3
      mình cũng đoán vậy vì ở đây khi tạo bằng chương trình tự động thì nó vừa tăng chỉ số mà vừa kết hợp với hàm so sánh để kiểm tra :
      Code:
      if (++rx_wr_index == RX_BUFFER_SIZE) rx_wr_index=0;
      .

      - Nhưng mình không thấy cờ báo tràn (cái này là soft chứ không phải phần cứng được dùng làm gì ).
      Code:
      if (++rx_counter == RX_BUFFER_SIZE)     // tương tự ? vậy tại sao dùng thêm rx_counter là gì ? 
            {
            rx_counter=0;
            rx_buffer_overflow=1; // đầy mảng thì set cờ tràn mảng lên 1
      cái cờ này kô thấy dùng làm gì nhỉ ? chỉ đơn giản là set lên rồi để đó ah mà chắc sẽ làm gì là do trong main mình có cần kiểm tra gì đó không uh bạn ?
      Code:
       rx_buffer_overflow=1; // đầy mảng thì set cờ tràn mảng lên 1
      .
      rồi có một số đoạn mình không hiểu, mình nghĩ là để tiết kiệm bộ nhớ cho chương trình :
      Code:
      #define RX_BUFFER_SIZE 8
      .
      Code:
      #if RX_BUFFER_SIZE<256  // nếu mảng nhận nhỏ hơn 256 thì chỉ cần dùng biến 1byte
      unsigned char rx_wr_index,rx_rd_index,rx_counter;
      #else                                                                                  // nếu lớn hơn phải dùng biến 2byte
      unsigned int rx_wr_index,rx_rd_index,rx_counter;
      #endif
      . mặc định ban đầu chương trình thì mảng nhận ngắt sẽ có độ lớn dài là 8 phần tử
      Code:
      ]#define RX_BUFFER_SIZE 8
      . Nhưng giả sử khi xảy ra ngắt nhận mà vượt qua 8 phần tử (1x8 byte) thì nó sẽ tăng một số chỉ số sang biến dạng int
      Code:
      #else                                                                                  // nếu lớn hơn phải dùng biến 2byte
      unsigned int rx_wr_index,rx_rd_index,rx_counter;
      #endif
      nhưng mình thắc mắc ở chỗ đoạn lệnh này được đặt ngoài ngắt nhận nó đâu có kiểm tra chỉ số mảng để biết phải chọn loại char hay int khi xảy ra ngắt nhỉ ? hay là luc tràn rồi nó sẽ tự set mà mình không hiểu. ?

      Comment


      • #4
        Kệ nó loằng ngoằng vậy. Bạn không phải lo về những cái ấy đâu.
        GTH sản xuất mạch in PCB 1 mặt:
        -phủ xanh: 40.000 đ/dm2
        -không phủ xanh: 30.000 đ/dm2
        -Cung cấp mực cảm quang để làm mạch in
        email:

        Comment


        • #5
          uh thì cái code họ là tổng quát và tốt rồi nhưng thắc mắc thì mới post mừ.

          Comment


          • #6
            Nguyên văn bởi newbie_avr Xem bài viết
            Khi mình dùng codevisionavr để khai báo Uart thì nó tạo ra một số đoạn code sau mà em không hiểu rõ ý định . Bạn nào hiểu xin chỉ giùm :
            Code:
            // USART Receiver buffer
            
            
            Code:
            #define RX_BUFFER_SIZE 8
            char rx_buffer[RX_BUFFER_SIZE]; // Khai báo mảng nhận kiểu char có kích cỡ 1x8 byte #if RX_BUFFER_SIZE<256 // nếu mảng nhận nhỏ hơn 256 thì chỉ cần dùng biến 1byte unsigned char rx_wr_index,rx_rd_index,rx_counter; #else // nếu lớn hơn phải dùng biến 2byte unsigned int rx_wr_index,rx_rd_index,rx_counter; #endif // This flag is set on USART Receiver buffer overflow bit rx_buffer_overflow; // USART Receiver interrupt service routine // chương trình ngắt nhận interrupt [USART_RXC] void usart_rx_isr(void) { char status,data; status=UCSRA; // đưa thanh ghi kiểm tra cờ ngắt nhận vào biến status data=UDR; // đọc dữ liệu từ bộ đệm nhận if ((status & (FRAMING_ERROR | PARITY_ERROR | DATA_OVERRUN))==0) // nếu ko lỗi { rx_buffer[rx_wr_index]=data; // lưu dữ liệu vào mảng nhận if (++rx_wr_index == RX_BUFFER_SIZE) rx_wr_index=0; // đầy mảng thì đưa chỉ số mảng về 0 if (++rx_counter == RX_BUFFER_SIZE) // tương tự ? vậy tại sao dùng thêm rx_counter là gì ? { rx_counter=0; rx_buffer_overflow=1; // đầy mảng thì set cờ tràn mảng lên 1 }; }; } #ifndef _DEBUG_TERMINAL_IO_ // ?? // Get a character from the USART Receiver buffer #define _ALTERNATE_GETCHAR_ //? #pragma used+ //? char getchar(void) // hàm đọc dữ liệu từ mảng nhận { char data; while (rx_counter==0); // nếu đúng thì cứ chờ ở đây ?? data=rx_buffer[rx_rd_index]; // đọc từ mảng nhận và ghi vào biến data if (++rx_rd_index == RX_BUFFER_SIZE) rx_rd_index=0; // nếu dọc hết mảng thì đưa chỉ số về 0 #asm("cli") // cấm ngắt --rx_counter; // giảm biến chỉ số ?? #asm("sei") // cho phép ngắt return data; // trả về dữ liệu đọc } #pragma used- #endif // USART Transmitter buffer #define TX_BUFFER_SIZE 8 char tx_buffer[TX_BUFFER_SIZE]; #if TX_BUFFER_SIZE<256 unsigned char tx_wr_index,tx_rd_index,tx_counter; #else unsigned int tx_wr_index,tx_rd_index,tx_counter; #endif // USART Transmitter interrupt service routine interrupt [USART_TXC] void usart_tx_isr(void) { if (tx_counter) { --tx_counter; UDR=tx_buffer[tx_rd_index]; if (++tx_rd_index == TX_BUFFER_SIZE) tx_rd_index=0; }; } #ifndef _DEBUG_TERMINAL_IO_ // Write a character to the USART Transmitter buffer #define _ALTERNATE_PUTCHAR_ #pragma used+ void putchar(char c) { while (tx_counter == TX_BUFFER_SIZE); #asm("cli") if (tx_counter || ((UCSRA & DATA_REGISTER_EMPTY)==0)) { tx_buffer[tx_wr_index]=c; if (++tx_wr_index == TX_BUFFER_SIZE) tx_wr_index=0; ++tx_counter; } else UDR=c; #asm("sei") } #pragma used- #endif
            Một số lệnh mình chú thích theo ý hiểu. nhưng kô chắc đúng bạn nào hiểu rõ giải thích lại giùm.
            - với hàm ngắt sẽ tự động lưu dữ liệu vào mảng ở đây là mảng một chiều nhưng lại không thấy biến đếm chỉ số mảng tăng lên ? có phải nó được dùng gộp trong câu lệnh :
            Code:
            if (++rx_wr_index == RX_BUFFER_SIZE) rx_wr_index=0; // đầy mảng thì đưa chỉ số mảng về 0
            nếu vậy tại sao cần dùng thêm dòng lệnh nè :
            Code:
             if (++rx_counter == RX_BUFFER_SIZE)     // tương tự ? vậy tại sao dùng thêm rx_counter là gì ? 
                  {
                  rx_counter=0;
                  rx_buffer_overflow=1; // đầy mảng thì set cờ tràn mảng lên 1
                  };
            đoạn code nè có dư thừa không nhỉ ?
            bạn cũng có những thắc mắc khá hay đấy, chắc bạn mới sử dụng CV.
            Code:
            #define RX_BUFFER_SIZE 8
            đây là dòng định nghĩa dung lượng của bộ đệm nhận về(RX) số ở phía sau chính là kích thước tính theo byte của bộ đệm, ở đây là số 8 nên bộ đệm của bạn chỉ có 8byte. bạn có thể thiết lập thông số này khi khởi tạo hoặc chỉnh sửa trực tiếp ở đây cũng dc. và toàn bộ những xử lí về dung lượng hay các vấn đề lưu trữ đều căn cứ vào cái tên RX_BUFFER_SIZE. bạn nên chú ý điều này.
            Code:
            #if RX_BUFFER_SIZE<256  // nếu mảng nhận nhỏ hơn 256 thì chỉ cần dùng biến 1byte
            unsigned char rx_wr_index,rx_rd_index,rx_counter;
            #else                                                                                  // nếu lớn hơn phải dùng biến 2byte
            unsigned int rx_wr_index,rx_rd_index,rx_counter;
            #endif
            tiếp theo là các biến rx_wr_index, rx_rd_index và rx_counter.
            kiểu biến của các biến này sẽ được quyết định bằng dung lượng của bộ đệm mà bạn vừa định nghĩa ở trên, ở đây trình biên dịch sẽ làm việc này. nghĩa là kiểu biến của các biến phải đủ để có thể đếm được đến con số lớn nhất của bộ đệm, giả sử, bộ đệm của bạn nhỏ hơn 256 byte thì chỉ cần biến đếm kiểu char,, nếu lớn hơn thì sẽ cần kiểu int....

            biến rx_wr_index và rx_rd_index ở đây là các biến con trỏ cho dữ liệu của bộ đệm, nó khác biệt so với biến rx_counter (chứ ko phải dư thừa đâu). 2 biến này dùng để trỏ đến vị trí của data một cái là data vừa ghi và một cái là data vừa đọc. và giá trị của nó tăng chứ ko giảm. khi nào tăng đến bằng giá trị RZ_BUFFER_SIZE mà bạn đã định nghĩa thì nó sẽ trả về 0.
            còn biến rx_counter là biến đếm, nó đếm lượng data đã nhận và đang chứa trong bộ đệm, nó tăng khi nhận data và giảm khi có data được đọc ra bằng hàm getchar() (ko bit còn hàm nào nữa ko, bạn thử kiểm tra xem..).
            khi nó nhận về mà bạn ko đọc ra hoặc đọc ra ko kịp thì gây tràn bộ đệm khi đó nó sẽ xóa toàn bộ data bằng dòng lệnh
            Code:
                  {
                  rx_counter=0;
                  rx_buffer_overflow=1; // đầy mảng thì set cờ tràn mảng lên 1
                  };
            và set rx_buffer_overflow, việc kiểm tra này sẽ do bạn thực hiện và tự xóa nếu phát hiện có tràn.

            Comment


            • #7
              Túm lại:
              -muốn nhận dữ liệu thì cứ kiểm tra cái rx_counter.Nếu > 0 thì lấy giữ liệu từ getchar()
              -Muốn xuất dữ liệu thì dùng putchar(du_lieu_8bit)


              Add: 97 Quán Nam - Lê Chân - Hải Phòng.
              Tel: 031 518648 Phone: 0904 283 505

              Comment


              • #8
                Nguyên văn bởi hoangdai Xem bài viết
                Túm lại:
                -muốn nhận dữ liệu thì cứ kiểm tra cái rx_counter.Nếu > 0 thì lấy giữ liệu từ getchar()
                -Muốn xuất dữ liệu thì dùng putchar(du_lieu_8bit)
                không cần kiểm tra rx_counter vẫn nhận dược dữ liệu.chú ý là các bản giới hạn của code visual không hỗ trợ sử dụng ngắt RX và TX và (phải tự khai báo ) không kiểm tra được rx_counter bằng lệnh " if ( rx_counter >0);" nếu viết vậy nó sẽ báo lỗi

                Comment


                • #9
                  Code:
                  Muốn xuất dữ liệu thì dùng putchar(du_lieu_8bit)
                  - vậy mình hỏi thêm một sô ý :

                  +) nếu mình mốn truyền só 15 lên máy tính thì viết kiểu nào sẽ đúng :

                  putchar(15)
                  putchar(0x0F)
                  putchar(0b00001111)
                  +) nếu mình muốn truyền kí tự a lên máy tính thì sẽ dùng như thế nào :

                  putchar('a');
                  putchar(60);
                  putchar(0x41);
                  +) nếu muốn truyền kí tự 15 lên máy tính thì viết kiểu nào sẽ đúng :
                  putchar('15') ??
                  +) truyền chuỗi kí tự "hello" thì tách thứ tụ ah ?

                  --> dữ liệu trong mảng ngắt nhận sẽ ở định dạng nào ( hex, deci ,char, binar...) và nó phụ thuộc vào điều gì ạ !

                  Comment


                  • #10
                    Nguyên văn bởi newbie_avr Xem bài viết
                    Code:
                    Muốn xuất dữ liệu thì dùng putchar(du_lieu_8bit)
                    - vậy mình hỏi thêm một sô ý :

                    +) nếu mình mốn truyền só 15 lên máy tính thì viết kiểu nào sẽ đúng :

                    putchar(15)
                    putchar(0x0F)
                    putchar(0b00001111)
                    +) nếu mình muốn truyền kí tự a lên máy tính thì sẽ dùng như thế nào :

                    putchar('a');
                    putchar(60);
                    putchar(0x41);
                    +) nếu muốn truyền kí tự 15 lên máy tính thì viết kiểu nào sẽ đúng :
                    putchar('15') ??
                    +) truyền chuỗi kí tự "hello" thì tách thứ tụ ah ?

                    --> dữ liệu trong mảng ngắt nhận sẽ ở định dạng nào ( hex, deci ,char, binar...) và nó phụ thuộc vào điều gì ạ !
                    truyền cách nào cũng đúng.tất nhiên là mỗi lần truyền chỉ được một ký tự nếu nhiều hơn thì phải cắt ra mà truyền thôi

                    Comment


                    • #11
                      putchar('15') ??
                      +) truyền chuỗi kí tự "hello" thì tách thứ tụ ah ?
                      -> dữ liệu trong mảng ngắt nhận sẽ ở định dạng nào ( hex, deci ,char, binar...) và nó phụ thuộc vào điều gì ạ !
                      "ký tự" '15', thật ra là chuỗi "15" và chuỗi "hello" bạn có thể gởi bằng lệnh puts("15"); puts("hello");
                      hay tách ra từng chữ gởi đi đều được. Thực ra nếu coi kỹ stdio.h thì thấy hàm puts cũng dùng hàm putchar để gởi từng ký tự đi mà thôi.

                      Bạn có thể gởi một loạt nhiều ký tự. Nếu không dùng ngắt, avr dùng hàm putchar trong stdio.h và gởi từng chữ một. Hết chữ này đến chữ khác đến khi hết chuỗi (gặp ký tự null) thì chuyển qua dòng lệnh kế tiếp. Nếu dùng ngắt Txd, avr sẽ bỏ ngay chuỗi này buffer, bắt đầu phát rồi thực hiện lệnh kế tiếp. Cứ phát xong một ký tự sẽ kích hoạt một ngắt, isr lấy ký tự kế tiếp để chuyển đi, rồi lại làm việc khác đến khi hết buffer thì thôi. Dữ liệu trong mảng ngắt nhận tất nhiên cũng là kiểu unsigned char như khai báo
                      Đã bỏ nghề về quê chăn gà...

                      Comment

                      Về tác giả

                      Collapse

                      newbie_avr Tìm hiểu thêm về newbie_avr

                      Bài viết mới nhất

                      Collapse

                      Đang tải...
                      X