로그인회원등록 내글장바구니주문조회현재접속자
 상품 검색








 게시판 검색





 
 
회원등록 비번분실


온라인 입금계좌
ㆍ기업은행
ㆍ219-043192-01-028
ㆍ이건영

      거래은행 바로가기
 
  AVR Applications
AVR 자료실
작성자 leeky        
작성일 2006/03/07
첨부#1 mmc_ledboard_icc_c.zip (0KB) (Down:151)
첨부#2 microsyl_MovingSign_asy2.jpg (0KB) (Down:29)
Link#1 ledsign.html (Down:19)
ㆍ추천: 0  ㆍ조회: 956   
  M128 MMC LED 전광판

이 프로젝트는 홈 네트웍크를 위한 LED 전광판의 구입으로 시작되었다.
이 홈 네트워크는 온도, 풍속, 습도 등의 정보를 표시합니다.
나는 LED 전광판을 Ebay에서 구입하였다. 그러나 그것을 받은 몇일 후,
메세지 프로그램을 직렬포트로 하는 것이 놀라웠다. 어떻게 만들었는지 알아보면,
작동원리는 LED를 구동하는 간단한 160비트 시프트 레지스터입니다.

구형 LED 전광판에서 CPU를 제거하였습니다.
그리고 시프트 레지스터(column driver)와 row driver를 전선으로 ATMega128로 연결하였습니다.
주 이유는 많은 ram이 있는 ATMega128을 쓰기로 내가 선택한 것입니다.  
모든 메세지의 저장에 3가지의 이유인 저가격, spi 인터페이스, 커다란 저장공간으로,  
MMC 메모리 카드를 쓰기로 결정하였습니다.

규격
- 3 색 전광판
- 5 화면전환 속도
- 메세지 업로드용 직렬포트

완성품 사진
 

소스코드와 회로도
-CPU 회로도 (PDF) 
  

LED 전광판에 표시할 메세지를 PC의 직렬포트로 보내면, ATMega128에서 수신하여
LED 전광판 내부의 MMC 카드에 저장한 다음, LED 전광판에 표시를 합니다.  

-LED 기판 회로도 (PDF)
 

LED 기판은 10핀 콘넥터를 통하여 CPU 기판에서 연결되어 5X7 도트 메트릭스 LED를
시프트레지스터를 이용하여 시프트 및 래치 그리고 표시 데이터를 LED에 출력합니다.  
필요에 의해 5X7 도트 매트릭스 LED는 74HC164와 ULN2803을 1조로
우측회로에 추가로 접속하는 방법으로 계속 확장할 수 있습니다.

그러나 LED의 숫자가 증가한 만큼 FET의 출력전류가 늘어나므로 FET는 그만큼 큰 것을 사용해야 합니다,
전류가 더 커진다면,  A측 드라이버를 P-CH FET로 바꾸고, 출력신호를 반전할 필요가 있습니다.
row driver의 출력은 N-CH FET를 8개 사용하여 소스전류 출력으로 LED의 A를 구동합니다.
column driver의 출력은 8회로 NPN TRANSISTOR ARRAY를 사용하여 LED의 k를 구동합니다.

다음은 Sylvain Bissonnette씨가 그의 사이트에 공개한 ICC AVR C 컴파일러로 만든 소스입니다.
Sylvain Bissonnette씨의 개인 사이트는 http://www.microsyl.com/ 입니다.

//**************************************
// Moving Sign Version 1.0 Dec 2003
// Sylvain Bissonnette
// 클럭 : 16Mhz
// 스택 : 32
//**************************************

//**************************************
//            I N C L U D E
//**************************************
#include <macros.h>
#include <stdlib.h>
#include <iom128v.h>
#include <STRING.H>

//**************************************
//            D E F I N E
//**************************************
#define VERSION     10
#define TRUE        0x01
#define FALSE       0x00

#define SERIALPORT  PORTA
#define SERIALDDR   DDRA
#define SERIALBIT   0x01
#define SERIALCLK   0x02

#define ROWPORT     PORTC
#define ROWDDR      DDRC

#define SPIDDR      DDRB
#define SPIPORT     PORTB
#define SPIPIN      PINB

#define SCLK        0x02
#define MOSI        0x04
#define MISO        0x08
#define CS          0x01
#define MMCPOWER    0x10

#define RED         0
#define GREEN       1
#define AMBER       2

/*------------------------------------------
문자 발생기
이 테이블은 5x7 포맷의 표준 ASCII 문자를 정의한다.
--------------------------------------------------------*/
static const char FontLookup [][5] =
{
    { 0x00, 0x00, 0x00, 0x00, 0x00 },  // sp
    { 0x00, 0x00, 0x2f, 0x00, 0x00 },   // !
    { 0x00, 0x07, 0x00, 0x07, 0x00 },   // "
    { 0x14, 0x7f, 0x14, 0x7f, 0x14 },   // #
    { 0x24, 0x2a, 0x7f, 0x2a, 0x12 },   // $
    { 0xc4, 0xc8, 0x10, 0x26, 0x46 },   // %
    { 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, 0x00, 0x50, 0x30, 0x00 },   // ,
    { 0x10, 0x10, 0x10, 0x10, 0x10 },   // -
    { 0x00, 0x60, 0x60, 0x00, 0x00 },   // .
    { 0x20, 0x10, 0x08, 0x04, 0x02 },   // /
    { 0x3E, 0x51, 0x49, 0x45, 0x3E },   // 0
    { 0x00, 0x42, 0x7F, 0x40, 0x00 },   // 1
    { 0x42, 0x61, 0x51, 0x49, 0x46 },   // 2
    { 0x21, 0x41, 0x45, 0x4B, 0x31 },   // 3
    { 0x18, 0x14, 0x12, 0x7F, 0x10 },   // 4
    { 0x27, 0x45, 0x45, 0x45, 0x39 },   // 5
    { 0x3C, 0x4A, 0x49, 0x49, 0x30 },   // 6
    { 0x01, 0x71, 0x09, 0x05, 0x03 },   // 7
    { 0x36, 0x49, 0x49, 0x49, 0x36 },   // 8
    { 0x06, 0x49, 0x49, 0x29, 0x1E },   // 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 },   // ?
    { 0x32, 0x49, 0x59, 0x51, 0x3E },   // @
    { 0x7E, 0x11, 0x11, 0x11, 0x7E },   // A
    { 0x7F, 0x49, 0x49, 0x49, 0x36 },   // B
    { 0x3E, 0x41, 0x41, 0x41, 0x22 },   // C
    { 0x7F, 0x41, 0x41, 0x22, 0x1C },   // D
    { 0x7F, 0x49, 0x49, 0x49, 0x41 },   // E
    { 0x7F, 0x09, 0x09, 0x09, 0x01 },   // F
    { 0x3E, 0x41, 0x49, 0x49, 0x7A },   // G
    { 0x7F, 0x08, 0x08, 0x08, 0x7F },   // H
    { 0x00, 0x41, 0x7F, 0x41, 0x00 },   // I
    { 0x20, 0x40, 0x41, 0x3F, 0x01 },   // J
    { 0x7F, 0x08, 0x14, 0x22, 0x41 },   // K
    { 0x7F, 0x40, 0x40, 0x40, 0x40 },   // L
    { 0x7F, 0x02, 0x0C, 0x02, 0x7F },   // M
    { 0x7F, 0x04, 0x08, 0x10, 0x7F },   // N
    { 0x3E, 0x41, 0x41, 0x41, 0x3E },   // O
    { 0x7F, 0x09, 0x09, 0x09, 0x06 },   // P
    { 0x3E, 0x41, 0x51, 0x21, 0x5E },   // Q
    { 0x7F, 0x09, 0x19, 0x29, 0x46 },   // R
    { 0x46, 0x49, 0x49, 0x49, 0x31 },   // S
    { 0x01, 0x01, 0x7F, 0x01, 0x01 },   // T
    { 0x3F, 0x40, 0x40, 0x40, 0x3F },   // U
    { 0x1F, 0x20, 0x40, 0x20, 0x1F },   // V
    { 0x3F, 0x40, 0x38, 0x40, 0x3F },   // W
    { 0x63, 0x14, 0x08, 0x14, 0x63 },   // X
    { 0x07, 0x08, 0x70, 0x08, 0x07 },   // Y
    { 0x61, 0x51, 0x49, 0x45, 0x43 },   // Z
    { 0x00, 0x7F, 0x41, 0x41, 0x00 },   // [
    { 0x02, 0x04, 0x08, 0x10, 0x20 },   // back slash
    { 0x00, 0x41, 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, 0x48, 0x44, 0x44, 0x38 },   // b
    { 0x38, 0x44, 0x44, 0x44, 0x20 },   // c
    { 0x38, 0x44, 0x44, 0x48, 0x7F },   // d
    { 0x38, 0x54, 0x54, 0x54, 0x18 },   // e
    { 0x08, 0x7E, 0x09, 0x01, 0x02 },   // f
    { 0x0C, 0x52, 0x52, 0x52, 0x3E },   // 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, 0x18, 0x04, 0x78 },   // m
    { 0x7C, 0x08, 0x04, 0x04, 0x78 },   // n
    { 0x38, 0x44, 0x44, 0x44, 0x38 },   // o
    { 0x7C, 0x14, 0x14, 0x14, 0x08 },   // p
    { 0x08, 0x14, 0x14, 0x18, 0x7C },   // q
    { 0x7C, 0x08, 0x04, 0x04, 0x08 },   // r
    { 0x48, 0x54, 0x54, 0x54, 0x20 },   // s
    { 0x04, 0x3F, 0x44, 0x40, 0x20 },   // 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, 0x00 },   // {
    { 0x00, 0x00, 0x7f, 0x00, 0x00 },   // |
    { 0x00, 0x41, 0x36, 0x08, 0x00 },   // }
    { 0x04, 0x02, 0x04, 0x08, 0x04 },   // ~
    { 0x00, 0x00, 0x36, 0x00, 0x00 },   // ?/i>
    { 0x0e, 0x51, 0x31, 0x11, 0x08 },   // ?/i>
    { 0x3c, 0x41, 0x40, 0x21, 0x7c },   // ?
    { 0x38, 0x54, 0x56, 0x55, 0x18 },   // ?
    { 0x20, 0x56, 0x55, 0x56, 0x78 },   // ?
    { 0x20, 0x55, 0x54, 0x55, 0x78 },   // ?
    { 0x20, 0x55, 0x56, 0x54, 0x78 },   // ?
    { 0x08, 0x08, 0x2a, 0x1c, 0x08 },   // Right Arrow  (chr 134)
    { 0x0e, 0x51, 0x31, 0x11, 0x08 },   // ?
    { 0x38, 0x56, 0x55, 0x56, 0x18 },   // ?
    { 0x38, 0x55, 0x54, 0x55, 0x18 },   // ?
    { 0x38, 0x55, 0x56, 0x54, 0x18 },   // ?
    { 0x00, 0x45, 0x7c, 0x41, 0x00 },   // ?
    { 0x00, 0x46, 0x7d, 0x42, 0x00 },   // ?
    { 0x7f, 0x7f, 0x7f, 0x7f, 0x7f },   // free (chr 141)  
    { 0x7f, 0x7f, 0x7f, 0x7f, 0x7f },   // free (chr 142)      
    { 0x7f, 0x7f, 0x7f, 0x7f, 0x7f },   // free (chr 143)  
    { 0x7c, 0x54, 0x56, 0x55, 0x44 },   // ?
    { 0x7f, 0x7f, 0x7f, 0x7f, 0x7f },   // free (chr 145)        
    { 0x7f, 0x7f, 0x7f, 0x7f, 0x7f },   // free (chr 146)        
    { 0x38, 0x46, 0x45, 0x46, 0x38 },   // ?
    { 0x7f, 0x7f, 0x7f, 0x7f, 0x7f },   // free (chr 148)      
    { 0x38, 0x45, 0x46, 0x44, 0x38 },   // ?
    { 0x3c, 0x42, 0x41, 0x22, 0x7c },   // ?/i>
    { 0x3c, 0x41, 0x42, 0x20, 0x7c }    // ?  
};

//**************************************
//          P R O T O T Y P E
//**************************************
void main(void);
void GetNextPage(unsigned char First);
void uart1_rx_isr(void);
void Analyse(void);
void TxString(const char *ch);
void TxChar(char ch);
void ClrSCR(void);
void WriteString(int x,const unsigned char *ptr,unsigned char color);
void WriteChar(int ptr,unsigned char ch,unsigned char color);
int DoDisplay(void);
void SendOnBit(void);
void SendOffBit(void);
void Delay_1ms(int Del);

int MMCInit(void);
void MMCInfo(void);
int MMCReadSector(unsigned long lba, unsigned char * s);
int MMCWriteSector(unsigned long lba, unsigned char *s);
unsigned char MMCGet(void);
unsigned char MMCDataToken(void);
void MMCCommand(unsigned char command, unsigned int px, unsigned int py);

unsigned char SpiByte(unsigned char byte);

//******************************************************************
//*   Global Variable
//******************************************************************
char Red[512];
char Green[512];
char GreenT[512];
char RedT[512];
int MsgLen;
unsigned char Speed = 3;
unsigned char MaxPage = 0;

unsigned char NewData = FALSE;

char RxBuffer[100];

//**************************************
//            M A I N
//**************************************
void main(void)
{
WDR();
WDTCR = 0x0f; // Watch Dog enable
ROWDDR = 0xff;
SERIALDDR |= SERIALBIT + SERIALCLK;
UCSR1B = 0x00; //disable while setting baud rate
UCSR1A = 0x00;
UCSR1C = 0x06;
UBRR1L = 0x33; //set baud rate lo for 19200 at 16Mhz
UBRR1H = 0x00; //set baud rate hi
UCSR1B = 0x98;
SEI();
ClrSCR();
while (MMCInit() != 0);
cstrcpy(&RxBuffer[0],"<99MMC: ~GInit OK  ~AVer:1.0>\0");
Analyse();
MMCReadSector(0,&GreenT[0]);
MaxPage = GreenT[0];
GetNextPage(TRUE);
while(1)
       {
       if (DoDisplay()) GetNextPage(FALSE);
       if (NewData == TRUE)
         {
         Analyse();
         NewData = FALSE;
         }
       WDR();
       }
}
//**************************************
// void uart1_rx_isr(void)
//**************************************
#pragma interrupt_handler uart1_rx_isr:31
void uart1_rx_isr(void)
{
static char *Ptr = &RxBuffer[0];
unsigned char ch;
ch = UDR1;
if (Ptr > &RxBuffer[100]) Ptr = &RxBuffer[0];
if (ch == '<') Ptr = &RxBuffer[0];
*Ptr++ = ch;
if (ch == '>') NewData = TRUE;
}
//**************************************
// void Analyse(void)
//**************************************
void Analyse(void)
{
char *Ptr = &RxBuffer[0];
unsigned char Page;
int x = 0;
unsigned char Color = AMBER;
unsigned char Spd = 3;
unsigned char Row;
Row = ROWPORT;
ROWPORT = 0x00;
ClrSCR();
Ptr++;
Page = (((*Ptr)-0x30) * 10) + ((*(Ptr+1)-0x30));
Ptr++;
Ptr++;
if ((Page == 99) && (*Ptr == 'D'))
   {
   for (x=0;x<512;x++) GreenT[x] = 0x00;
   MMCWriteSector(0,&GreenT[0]);
   MaxPage = 0;
   TxString("Delete ALL\n\r\0");
   ROWPORT = Row;
   return;
   }
if ((Page > 99) || (Page < 0))
   {
   ROWPORT = Row;
   return;
   }
if (Page > (MaxPage+1))
   {
   ROWPORT = Row;
   return;
   }
while (*Ptr != '>')
     {
     if (*Ptr == '~')
       {
       Ptr++;
       if (*Ptr == 'R') Color = RED;
       if (*Ptr == 'G') Color = GREEN;
       if (*Ptr == 'A') Color = AMBER;
       if (*Ptr == '1') Spd = 1;
       if (*Ptr == '2') Spd = 2;
       if (*Ptr == '3') Spd = 3;
       if (*Ptr == '4') Spd = 4;
       if (*Ptr == '5') Spd = 5;
       Ptr++;
       }
     else WriteChar(x++,*Ptr++,Color);
     }
GreenT[510] = Spd;
RedT[510] = (x*6)>>8;
RedT[511] = (x*6);
MMCWriteSector((Page*2)+1, &RedT[0]);
MMCWriteSector((Page*2)+2, &GreenT[0]);
if ((Page > MaxPage) && (Page != 99))
   {
   for (x=0;x<512;x++) GreenT[x] = 0x00;
   GreenT[0] = Page;
   MMCWriteSector(0,&GreenT[0]);
   MaxPage = Page;
   }
ROWPORT = Row;
}
//**************************************
// void TxString(unsigned char *ch)
//**************************************
void TxString(const char *ch)
{
while(*ch != 0x00) TxChar(*ch++);
}
//**************************************
// void TxChar(unsigned char ch)
//**************************************
void TxChar(unsigned char ch)
{
while (!(UCSR1A & 0x20)) WDR(); // Wait for empty transmit buffer
UDR1 = ch;                     // Write char
}
//**************************************
// void GetNextPage(void)
//**************************************
void GetNextPage(unsigned char First)
{
static int Page = 0;
WDR();
if (First == TRUE) // Retrive the First time init message of status
   {
   MMCReadSector((99*2)+1, &Red[0]);
   MMCReadSector((99*2)+2, &Green[0]);
   Speed = Green[510];
   MsgLen = (Red[510]<<8) + Red[511];
   }
else
   {
   MMCReadSector((Page*2)+1, &Red[0]);
   MMCReadSector((Page*2)+2, &Green[0]);
   Speed = Green[510];
   if (Speed > 5) Speed = 1;
   MsgLen = (Red[510]<<8) + Red[511];
   Page++;
   if (Page > MaxPage) Page = 0;
   }
}
//**************************************
// void ClrSCR(void)
//**************************************
void ClrSCR(void)
{
int i;
for (i=0;i<510;i++)
   {
   WDR();
   RedT[i] = 0x00;
   GreenT[i] = 0x00;
   }
}
//**************************************
// void WriteString(unsigned char ptr,unsigned char color)
//**************************************
void WriteString(int x,const unsigned char *ptr,unsigned char color)
{
while(*ptr != 0x00) WriteChar(x++,*ptr++,color);
}
//**************************************
// void WriteChar(unsigned char x,unsigned char ch,unsigned char color)
//**************************************
void WriteChar(int x,unsigned char ch,unsigned char color)
{
unsigned char i;
x *= 6;
if (x > 509) return; // Max of 85 char per page 85*6 = 510
for (i=0;i<5;i++)
    {
   WDR();
    if (color == RED) RedT[x++] = FontLookup[ch - 32][i];
   if (color == GREEN) GreenT[x++] = FontLookup[ch - 32][i];
   if (color == AMBER)
      {
      RedT[x] = FontLookup[ch - 32][i];
      GreenT[x++] = FontLookup[ch - 32][i];
      }
    }
RedT[x] = 0x00;
GreenT[x++] = 0x00;
}
//**************************************
// void DoDisplay(void)
//**************************************
int DoDisplay(void)
{
unsigned char Row;
unsigned char Col;
unsigned char RowMask;
int i,j;
static int Pos = 80;
char GreenT[80];
char RedT[80];
char SHIFT[160];
WDR();
// Clear Buffer's
for (i=0;i<80;i++)
   {
   GreenT[i] = 0x00;
   RedT[i] = 0x00;
   }
// Do Scrolling Right to Left
if (Pos >= 0)
   {
   j = 0;
   for (i=Pos;i<80;i++)
         {
      GreenT[i] = Green[j];
      RedT[i] = Red[j];
      j++;
      }
   }
else
   {
   j = 0;
   for (i=abs(Pos);i<(80+abs(Pos));i++)
         {
      GreenT[j] = Green[i];
      RedT[j] = Red[i];
      j++;
      }
   }
Pos--;
if (Pos < 0-MsgLen)
   {
   Pos = 80;
   return 1;
   }
// Append Red & Green to the Real shifting buffer
j = 0;
for (i=0;i<80;i++)
   {
   if ((!(i % 8)) && (i != 0)) j +=8;
   SHIFT[j] = GreenT[i];
   SHIFT[j+8] = RedT[i];
   j++;
   }
// Do the Row/Column display
for (i=0;i<Speed;i++)
   {
   RowMask = 0x40;
   for (Row=0;Row<7;Row++)
      {
      WDR();
      for (Col=0;Col<160;Col++)
         {
         if ((SHIFT[Col] & RowMask) == RowMask) SendOnBit();
         else SendOffBit();
         }
      ROWPORT = RowMask;
      Delay_1ms(1);
      ROWPORT = 0x00;
      RowMask = RowMask >> 1;
      }
   }
return 0;
}
//**************************************
// void SendOnBit(void)
//**************************************
void SendOnBit(void)
{
SERIALPORT |= SERIALBIT;
SERIALPORT |= SERIALCLK;
SERIALPORT &= ~SERIALCLK;
}
//**************************************
// void SendOffBit(void)
//**************************************
void SendOffBit(void)
{
SERIALPORT &= ~SERIALBIT;
SERIALPORT |= SERIALCLK;
SERIALPORT &= ~SERIALCLK;
}
//**************************************
// void Delay_1ms(void)
//**************************************
void Delay_1ms(int Del)
{
int i;
while (Del--)
     {
     for (i=0;i<2000;i++) WDR();
     }
}
/*************************************************************
 * MMC Init function
 *
 * - flushes card receive buffer
 * - selects card
 * - sends the reset command
 * - sends the initialization command, waits for card ready
 *************************************************************/
int MMCInit(void)
{
unsigned int i;
unsigned char Byte;
SPIDDR = SCLK + MOSI + CS + MMCPOWER;
SPIPORT = 0x00;
Delay_1ms(500);
SPIPORT |= MMCPOWER;
SPIPORT |= CS;
SPCR = (1<<SPE) | (1<<MSTR) | (1<<SPR1) | (1<<SPR0);    /* enable SPI as master, set clk divider */
Delay_1ms(250);
/* start off with 80 bits of high data with card deselected */
for(i=0;i<10;i++)
SpiByte(0xff);
SPIPORT &= ~CS;        /* select card */
/* now send CMD0 - go to idle state */
MMCCommand(0,0,0);
if (MMCGet() != 1)
   {
   SPIPORT |= CS;
   return -1;  // MMC Not detected
   }
/* send CMD1 until we get a 0 back, indicating card is done initializing */
i = 0xffff;
while ((SpiByte(0xff) != 0) && (--i))
     {
     MMCCommand(1,0,0);
     WDR();
     }
if (i == 0)
   {
   SPIPORT |= CS;
   return -2;  // Init Fail
   }
SPIPORT |= CS;
return 0;
}
/************************************************************
 * void MMCInfo(void)
 *
 * - gets and prints formatted CID and CSD info from card
 ************************************************************/
void MMCInfo(void)
{
int i;
MMCCommand(10,0,0);
if (MMCDataToken() != 0xfe) TxString("MMC: error during CID read\n\r\0");
else TxString("MMC: CID read\n\r\0");
// Skip 3 byte Manufacturer ID
SpiByte(0xff);
SpiByte(0xff);
SpiByte(0xff);
TxString("MMC: Product Name : ");
for (i=0;i<7;i++) TxChar(SpiByte(0xff));
TxString("\n\r\0");
for (i=0;i<9;i++) SpiByte(0xff); // Read 9 left byte
SPIPORT |= CS;
}
/************************************************************
 * int MMCReadSector(unsigned long lba, unsigned char * s)
 *
 * - reads a sector from the card (512 bytes)
 * - takes sector # as param
 ************************************************************/
int MMCReadSector(unsigned long lba, char *s)
{
unsigned int i;
MMCCommand(17,(lba>>7) & 0xffff, (lba<<9) & 0xffff);
if (MMCDataToken() != 0xfe)
   {
   SEI();
   return -1;
   }
for (i=0;i<512;i++)     /* read the sector */
   {
    *s++ = SpiByte(0xff);
   }
SpiByte(0xff);          /* checksum -> don't care about it for now */
SpiByte(0xff);       /* checksum -> don't care about it for now */
SPIPORT |= CS;
return 0;
}
/************************************************************
 * int MMCWriteSector(unsigned long lba, unsigned char * s)
 *
 * - reads a sector from the card (512 bytes)
 * - takes sector # as param
 ************************************************************/
int MMCWriteSector(unsigned long lba, char *s)
{
unsigned int i;
MMCCommand(24, (lba>>7)& 0xffff, (lba<<9)& 0xffff);
if (MMCGet() == 0xff) return -1;
SpiByte(0xfe);  // Send Start Byte
for (i=0;i<512;i++)       /* read the sector */
   {
    SpiByte(*s++);
   }
SpiByte(0xff);          /* checksum -> don't care about it for now */
SpiByte(0xff);       /* checksum -> don't care about it for now */
SpiByte(0xff);       /* Read "data response byte"                 */
i = 0xffff;
while ((SpiByte(0xff) == 0x00) && (--i)); /* wait for write finish */
if (i == 0) return -1; // Error
SPIPORT |= CS;
return 0;
}
/************************************************************
 * unsigned char MMCGet(void)
 *
 * - pings the card until it gets a non-0xff value
 * - returns one byte of read info
 ************************************************************/
unsigned char MMCGet(void)
{
unsigned int i = 0xffff;
unsigned char Byte = 0xff;
while((Byte == 0xff) && (--i)) Byte = SpiByte(0xff);
return Byte;
}
/************************************************************
 * int MMCDataToken(void)
 *
 * - pings the card until it gets data token
 * - returns one byte of read info (data token)
 ************************************************************/
unsigned char MMCDataToken(void)
{
unsigned int i = 0xffff;
unsigned char Byte = 0xff;
while((Byte != 0xfe) && (--i)) Byte = SpiByte(0xff);
return Byte;
}
/************************************************************
 * void MMCCommand(unsigned char command, unsigned int px, unsigned int py)
 *
 * - send one byte of 0xff, then issue command + params + (fake) crc
 * - eat up the one command of nothing after the CRC
 ************************************************************/
void MMCCommand(unsigned char command, unsigned int px, unsigned int py)
{
SPIPORT &= ~CS;
SpiByte(0xff);
SpiByte(command | 0x40);
SpiByte((unsigned char)((px >> 8)&0x0ff)); /* high byte of param y */
SpiByte((unsigned char)(px & 0x00ff));     /* low byte of param y */
SpiByte((unsigned char)((py >> 8)&0x0ff)); /* high byte of param x */
SpiByte((unsigned char)(py & 0x00ff));     /* low byte of param x */
SpiByte(0x95);            /* correct CRC for first command in SPI          */
                          /* after that CRC is ignored, so no problem with */
                          /* always sending 0x95                           */
SpiByte(0xff);
}
/*****************************************************
 * Main SPI routine
 *  - transmits a byte and receives a byte simultaneously
 *  - received byte is returned
 *  - if you only want to read a byte, put a dummy
 *    (say 0xff) in the transmit slot
 ****************************************************/
unsigned char SpiByte(unsigned char byte)
{
WDR();
SPDR = byte;               /* put byte to send in SPDR, which initiates xmit  */
while(!(SPSR & (1<<SPIF)));/* wait for completion */
return SPDR;               /* return with byte shifted in from slave */
}
 
AVRTOOLS™
   
윗글 AT90PWM3 교류모터 속도제어
아래글 Charon 2 이더넷 모듈의 소개
    N         제목    글쓴이 작성일 조회 추천
AVR 자료실 안내 avrtools™ 2008/09/02 (화) 311 0
97 AVR Basic Compiler (4K Free) avrtools™ 2008/12/03 (수) 244 0
96 코드비젼 V2.05.0 평가판 avrtools™ 2011/07/17 (일) 163 0
95 8x8 LED Audio Spectrum Display avrtools™ 2009/10/18 (일) 278 0
94 AVR 펌웨어로 만드는 USB 드라이버 avrtools™ 2009/10/07 (수) 480 0
93 AVR-CDC and V-USB avrtools™ 2009/10/06 (화) 249 0
92 AVR USB-HID-Bootloader의 제작 avrtools™ 2009/10/01 (목) 285 0
91 AT91SAM7S256 개발환경과 컴파일러 [2] avrtools™ 2008/11/03 (월) 2218 0
90 SAM7S256 USB 드라이버와 AT91-ISP avrtools™ 2008/11/01 (토) 1212 0
89 AT91SAM7S256 공부를 시작합니다. avrtools™ 2008/11/01 (토) 603 1
88 ICCAVR V7.16A AVR 컴파일러 45일판 avrtools™ 2009/03/09 (월) 157 0
87 CodeVisionAVR1248b 最新版下载 leeky 2008/11/08 (토) 331 0
86 AVR UART 소스 (ICC AVR V6) avrtools™ 2008/12/03 (수) 218 0
85 cvAVR Soft Uart Source avrtools™ 2008/12/03 (수) 175 0
84 cvAVR 직렬포트와 LCD 시험용 소스 avrtools™ 2008/12/03 (수) 178 0
83 Free SmallC for AVR avrtools™ 2008/12/03 (수) 217 0
82 AVR910-ISP용 AVR-OSP2 Ver5.43 avrtools™ 2008/12/03 (수) 196 0
81 Code Vision AVR 컴파일러 2K 데모버전 avrtools™ 2008/12/02 (화) 129 0
80 AVR delay loop generator avrtools™ 2008/12/02 (화) 181 0
79 ICC tiny C컴파일러 V6 데모버전 (30일 제한판) avrtools™ 2008/12/02 (화) 92 0
78 ICC AVR C 컴파일러 V6 (4K 제한판) avrtools™ 2008/12/02 (화) 117 0
77 DasmAVR (Windows용 AVR 역어셈블러) avrtools™ 2008/12/02 (화) 179 0
76 AVR PROG KIT avrtools™ 2008/12/02 (화) 201 0
75 AVR JTAG ICE KIT avrtools™ 2008/12/02 (화) 295 0
74 AVR 부동소수점, 지연시간 계산기 avrtools™ 2008/12/02 (화) 203 0
73 ATtiny45 USB to RS232 인터페이스 avrtools™ 2008/09/26 (금) 228 0
72 MEGA32 128x64 GLCD Scope 제작 avrtools™ 2008/09/22 (월) 336 0
71 PC송신방식 Tiny2313 50x7 LED 전광판 avrtools™ 2008/09/10 (수) 290 0
70 mega8 적외선 거리측정 레이더 leeky 2006/05/07 (일) 1401 0
69 ATmega16 RFID #3 소프트웨어 leeky 2006/12/27 (수) 910 0
68 ATmega16 RFID #2 하드웨어 leeky 2006/12/27 (수) 1158 0
67 ATmega16 RFID #1 태그 leeky 2006/12/27 (수) 888 0
66 ISO 14443A RFID 카드의 읽기/쓰기 방법 [1] leeky 2007/02/25 (일) 1522 1
65 ATmega8 PSK31 RF Modem의 제작 leeky 2006/03/07 (화) 1406 21
64 T89C51SND1C 64M USB MP3 플레이어 avrtools 2006/03/04 (토) 1022 8
63 AVR 13.56MHz RFID 읽기/쓰기 장치의 제작 [7] leeky 2007/02/19 (월) 1092 4
62 WhereAVR for APRS GPS/Telemetry avrtools 2006/05/05 (금) 429 2
61 ATmega8 UI-TNC 무선모뎀의 제작 avrtools 2006/03/07 (화) 424 0
60 AVR APRS(GPS) Packet 무선모뎀 avrtools 2006/03/07 (화) 422 0
59 AT90PWM3 교류모터 속도제어 leeky 2006/04/07 (금) 976 1
58 M128 MMC LED 전광판 leeky 2006/03/07 (화) 956 0
57 Charon 2 이더넷 모듈의 소개 avrtools 2006/04/04 (화) 509 0
56 S2313 LED 회전계 (TACHO METER) avrtools 2006/03/28 (화) 627 0
55 Mega8 + 128x128 LCD 스코프 avrtools 2006/03/28 (화) 1217 0
54 Mega8 + OV6630 Treva 모바일용 카메라의 화상처리 leeky 2006/03/19 (일) 825 0
53 YUKI Mega8 MP3 Player #3 avrtools 2006/03/11 (토) 871 0
52 AVR JTAG 에뮬레이터의 제작 avrtools 2006/03/07 (화) 881 0
51 USB AVR 프로그래머 AvrUsb500 avrtools 2006/03/07 (화) 760 1
50 Mega88 USB 버스 모니터 avrtools 2006/03/07 (화) 417 0
49 M16 MMC Flash Memory leeky 2006/03/07 (화) 487 1
48 M163 SD,MMC Interface leeky 2006/03/07 (화) 471 0
47 S2313 MMC to Serial leeky 2006/03/07 (화) 346 0
46 ATmega48 UDP/IP 적외선 리모콘 수신장치 avrtools 2006/03/07 (화) 448 0
45 HDD MP3 플레이어 leeky 2006/03/07 (화) 627 0
44 MP3 yampp-3/USB leeky 2006/03/07 (화) 319 0
43 MP3 Player yampp-3 leeky 2006/03/07 (화) 284 0
42 YUKI MP3 플레이어2의 제작 (ATmega8 + SD Card) avrtools 2006/03/07 (화) 417 0
41 AVR CD 플레이어 leeky 2006/03/07 (화) 567 0
40 S2313 초음파 거리계 (미터, TV 스크린, LED 표시) avrtools 2006/03/07 (화) 578 0
39 RF Spectrum Monitor avrtools 2006/03/07 (화) 423 0
38 Easy Ethernet AVR 웹서버 leeky 2006/03/07 (화) 484 0
37 90S4433 LCD표시 100Mhz 주파수 카운터 leeky 2006/03/07 (화) 278 0
36 ELM Audio Spectrum Monitor avrtools 2006/03/07 (화) 393 0
35 Mega8 Door Bell leeky 2006/03/07 (화) 306 0
34 AVR 휴대용 DVM leeky 2006/03/07 (화) 538 0
33 Minimum Mass Waveform Capture and Display leeky 2006/03/07 (화) 289 0
32 AT90S2313 디지털 용량계 avrtools 2006/03/07 (화) 397 0
31 SLO2016 Alphanumeric Intelligent Display leeky 2006/03/07 (화) 200 0
30 AT90S2313 흔드는 LED 전광판 (POV) leeky 2006/03/07 (화) 453 0
29 ATtiny2313 Scrolling LED Sign avrtools 2006/03/07 (화) 389 0
28 Tiny22,S1200 나이트 라이더 avrtools 2006/03/07 (화) 340 0
27 ATtiny26L의 AD 변환과 PWM 출력제어 leeky 2006/03/07 (화) 544 0
26 S2313을 사용한 DS1820 온도계 leeky 2006/03/07 (화) 293 0
25 ATmega8535 온도센서 leeky 2006/03/07 (화) 322 0
24 AVR2313 100MHz RF연결 주파수 측정메터 avrtools 2006/03/07 (화) 225 0
23 VHF 무선 데이터 송신기 leeky 2006/03/07 (화) 528 0
22 90S2313 1MHz 파형 포착기 leeky 2006/03/07 (화) 262 0
21 VHF 무선 데이터 수신기 avrtools 2006/03/07 (화) 421 0
20 AVR 5x7 Dotmatrix LED leeky 2006/03/07 (화) 264 0
19 Mega163 웹 LCD leeky 2006/03/07 (화) 418 0
18 AVR 이더넷 시험소프트 avrtools 2006/03/07 (화) 345 0
17 AVR 넷트웍 시계 (타임 프로토콜) avrtools 2006/03/07 (화) 406 0
16 RS-232 to 100 MHz RF desktop avrtools 2006/03/07 (화) 263 0
15 AVR 6디지트 50MHz 주파수 카운터 leeky 2006/03/07 (화) 241 0
14 AVR DS1820 온도센서 avrtools 2006/03/07 (화) 283 0
13 AVR 직접주파수 발생기 (AT90S2313 DDS) avrtools 2006/03/07 (화) 432 0
12 프로그래머블 PLL 제어 avrtools 2006/03/07 (화) 261 0
11 AVR AT90S2313 7Segment LED Display leeky 2006/03/07 (화) 240 0
10 TINY15L 무전원 4채널 온도계 avrtools 2006/03/07 (화) 368 0
9 8PIN AVR을 사용한 풀컬러 LED leeky 2006/03/07 (화) 398 0
8 DS1820 고분해능 온도계 avrtools 2006/03/07 (화) 369 0
7 S2313 디지털 전압계 avrtools 2006/03/07 (화) 492 0
6 S2313 적외선 USB 모듈 avrtools 2006/03/07 (화) 356 0
5 S2313 주파수 카운터 avrtools 2006/03/07 (화) 287 0
4 AVR90S2313과 Treva 카메라의 연결 leeky 2006/03/07 (화) 343 0
3 Mega8 PID 온도제어 leeky 2006/02/24 (금) 713 1
2 90S2333 3채널 다이오드 온도계 avrtools 2006/02/24 (금) 263 0
1 AT89S8252로 만드는 1~40MHz DDS leeky 2006/02/14 (화) 332 0
1

바구니 : 0
 보관함 : 0
오늘뷰 : 0
HOME   |   회사소개   |   제휴안내   |   회사위치   |   서비스이용 약관   |   개인정보 보호정책   |   사이트맵
17015 경기도 용인시 기흥구 동백중앙로16번길 16-25, 508호. 전화 : 031-282-3310
사업자 등록번호 : 697-47-00075 / 대표 : 이건영 / 업태 : 제조업 / 종목 : LED조명, LED전원, 제어장치.
개인정보 관리책임자 : 홈페이지 관리자 . Copyright ⓒ2016 아크레즈 (ACLEDS INC.)
HOME TOP PREVNEXT 0 0 0