test.c

PS/2 keyboard atmega128

#include<iom128.h>
#include<ina90.h>
#include"DebugAtmega128.h"
#include"socket.h"
#include"scancode.h"

void init_sock(SOCKET s, uint16 port, uint8 flag, uint8 udp_mode, uint8 client_mode);
void mcu_init(void);
void uart_send(char data);
char scan_to_ascii(void);

#define MAX_BUF_SIZE   2048

uint8 rx_buf[2048];
uint8 *rx_ptr;

unsigned char MAC[6]     = {0X00, 0X01, 0X45, 0X67, 0X89, 0XAB};
unsigned char GateWay[4] = {210, 119, 156, 1};
unsigned char Subnet[4]  = {255, 255, 255, 0};
unsigned char IP[4]      = {210, 119, 156, 252};
unsigned char ConnIP[4]  = {210, 119, 156, 76};

unsigned char MAC_chk[6];  
unsigned char GateWay_chk[4];
unsigned char Subnet_chk[4];
unsigned char IP_chk[4];
unsigned int Rch_meet_cnt=0;
unsigned char connect_state=0;

unsigned char bitcount=0;
unsigned char edge=0;
unsigned char keyupdn=0;
static unsigned char key_data;
static unsigned char conv_data=0;
unsigned char *key_data_ptr;

void main(void)
{
//------虐焊靛 函荐 檬扁拳-----
  bitcount = 11;
  edge =0;
  key_data_ptr = &conv_data;
//----------------------------  
  SOCKET i;
  uint16 check_rx;
  
  AtMg128DebugInit();
  mcu_init();
  
  UCSR1A = 0X00;
  UCSR1B = 0X00;
  UCSR1B |= 0X80;
  UCSR1B |= 0X10;
  UCSR1B |= 0X08;
  
  UCSR1C =0X00;
  UCSR1C |=0X06;
  UBRR1H = 0;
  UBRR1L =25;
  
  __enable_interrupt();
  iinchip_init();
  
  setSHAR(MAC);
  setGAR(GateWay);
  setSUBR(Subnet);
  setSIPR(IP);
  
  getSHAR(MAC_chk);
  getGAR(GateWay_chk);
  getSUBR(Subnet_chk);
  getSIPR(IP_chk);
  
  setRCR(0X05);
  sysinit(0X55, 0X55);
  
  for(i=0; i< MAX_SOCK_NUM; i++)
  {
   init_sock(i, 7000+i, 0, 0, 0);
  }
  
  while(1)
  {
    for(i=0; i<MAX_SOCK_NUM; i++)
    {
     switch( getSn_SR(i))
     {
      case SOCK_ESTABLISHED:
            connect_state = 1;
            check_rx = getSn_RX_RSR(i);
            if(check_rx > 0)
             {
             if(check_rx > MAX_BUF_SIZE)
                check_rx = MAX_BUF_SIZE;
                  Rcv_meet_cnt++;
                  
                  recv(i,rx_buf, check_rx);
                  
                  rx_ptr=rx_buf;
                  
                  while(check_rx--)uart_send(*rx_ptr++);
                  }
                  break;
                  case SOCK_CLOSE_WAIT:
                    connect_state = 0;
                    
                    disconnect(i);
                    break;
                    case SOCK_CLOSED:
                      connect_state = 0;
                      init_sock(i, 7000+i,0,0,0);
                      break;
                     case SOCK_UDP:
                        check_rx = getSn_RX_RSR(i);
                        if(check_rx > 0)
                        {
                        
                        }
                        break;
                        
                       default:
                          break;
                      }
                   }
                }
             }  
              
              
   uint8 test_socket=0;
   void init_sock(SOCKET s, uint16 port, uint8 flag, uint8 udp_mode, uint8 client_mode)
   {
    if(udp_mode == 1)
    {
        test_socket = socket(s, Sn_MR_UDP, port, flag);
    }
    else
    {
        test_socket = socket(s, Sn_MR_TCP,port, flag);
        if(client_mode ==1)
        {
        
        }
        else
         {
          listen(s);
         }
    }
   }
 }
 
 void uart_send(char data)
 {
  while(!(UCSR1A &0X20));
  UDR1=data;
 }
 
 char scan_to_ascii(void)
 {
  unsigned char cnt=47, num=0;
  
  while(cnt--)
  {
    if(asc_dat[num][0]==key_data)
    {
    conv_data = asc_dat[num][1];
    return 1;
   }
   else
   {
      num++;
   }
 }
 return 0;
}

#pragma vector = USART1_RXC_vect
__interrupt void Usart1RxIsr()
{
    char txstring[] = " Ethernet No Ready....!";
    char *ptxt;
    ptxt=txstring;
    
    uint8 rx_temp=0;
    uint8 * rx_ptr;
    rx_temp = UDR1;
    rx_ptr = &rx_temp;
    if(connect_state==1)
    {
     send(0,rxptr, 1);
    }
    else
    {
     while(*ptxt)uart_send(*ptxt++);
    }
}

#pragma vector =  INT0_vect
__interrupt void INT0_interrupt(void)
{
  char string[] = "PS/2 Keyboard Connection... OK!!";
  char *pStr;
  pStr= string;
  
  if(!edge)
  {
    if(bitcount<11 && bitcount>2)
    {
        key_data= (key_data >>1);
        if(PIND & 2)key_data = key_data |0x80;
        }
        
        EICRA=0X03;
        edge=1;
       }
       else
       {
          EICRA = 0X02;
          edge = 0;
          if(--bitcount ==0)
          {
            switch(key_data)
            {
            case 0xaa:
              while(*pStr) uart_send(*pStr++);
              break;
            case 0xf0:
              keyupdn = 1;
              break;  
              
             default :
              if(keyupdn ==0)
              {
              if(scan_to_ascii())
                 {
                 uart_send(conv_data);
                 if(connect_state==1) send(0,key_data_ptr, 1);
                 }
              }
              else
              {
                    keyupdn = 0;
              }
              
            
          }
          bitcount = 11;
         
         
        }
      }
}