main.c

mb90340的擦写FLASH区小小 程序

/*===== Readout Buffer x ======= */

unsigned char GetCan0Data (char  x, unsigned char *BufPtr)
{
  char Len, pos;
    
  *BufPtr++ = Len = DLCR0(x);
  for (pos=0; pos<=Len;pos++)
    *BufPtr++ = DTR0_BYTE(x, pos);
  return (Len); 
}

unsigned char GetCan1Data (char  x, unsigned char *BufPtr)
{
  char Len, pos;
    
  *BufPtr++ = Len = DLCR1(x);
  for (pos=0; pos<=Len;pos++)
    *BufPtr++ = DTR1_BYTE(x, pos);
  return (Len); 
}


#define TIMEOUT 50000    /* <<< timeout value, if CAN-data can not be send   */
#define buffer1 1        /* receive buffer                                   */
#define buffer6 6        /* send buffer                                      */


/*===========================================================================*/
/*====== MAIN ===============================================================*/
/*===========================================================================*/

void main(void)
{
  unsigned char ch, Can0DataBuffer[9];
  unsigned long timeout;                   /* timeout-counter                */
  unsigned int  i;
  unsigned long l;

  InitIrqLevels();
  __set_il(7);                /* allow all levels */
  __EI();                     /* globaly enable interrupts */
    
  PDR0 = 0;
  DDR0 = 0xff;                /* Set User-LED Port0 as output */
    
  LED1 = 1;
  for(l=DELAY_LED; l>0; l--)
    __asm("\tNOP");                 /* delay      */

  LED2 = 1; LED1 = 0;
  for(l=DELAY_LED; l>0; l--)
    __asm("\tNOP");                 /* delay      */

  LED3 = 1; LED2 = 0;
  for(l=DELAY_LED; l>0; l--)
    __asm("\tNOP");                 /* delay      */

  LED4 = 1; LED3 = 0;
  for(l=DELAY_LED; l>0; l--)
    __asm("\tNOP");                 /* delay      */

  LED5 = 1; LED4 = 0;
  for(l=DELAY_LED; l>0; l--)
    __asm("\tNOP");                 /* delay      */

  LED6 = 1; LED5 = 0;
  for(l=DELAY_LED; l>0; l--)
    __asm("\tNOP");                 /* delay      */

  LED7 = 1; LED6 = 0;
  for(l=DELAY_LED; l>0; l--)
    __asm("\tNOP");                 /* delay      */

  LED8 = 1; LED7 = 0;
  for(l=DELAY_LED; l>0; l--)
    __asm("\tNOP");                 /* delay      */

  LED8 = 0;
  
  /* initialize UART0 "UART A" */
  InitUart0();
  Puts0("\n\nWelcome to the Flash-Can-100P-340 Evaluation-Board\n");
  Puts0("================================================================\n");		
  Puts0("After Reset => check running light at LEDs \n");		
  Puts0("optional LC-Display will be initialised\n");		
  Puts0("UART'A' will be echoed\n");		
  Puts0("UART'B' will be echoed\n");		
  Puts0("UART'B' will be send to CAN ID #3\n");		
  Puts0("CAN ID #2 will be send to UART'B'\n");		
  Puts0("Key INT0, INT1, TIN1, IN0 and ADTG will result in UART'B' output\n");		
  Puts0("================================================================\n");

  /* initialize UART2 "UART B" */
  ADER5 = 0;    /* Use Port 5 as I/O-Port */
  InitUart2();
  Puts2("\n\nWelcome to the Flash-Can-100P-340 Evaluation-Board\n");
  Puts2("================================================================\n");		
  Puts2("After Reset => check running light at LEDs \n");		
  Puts2("optional LC-Display will be initialised\n");		
  Puts2("UART'A' will be echoed\n");		
  Puts2("UART'B' will be echoed\n");		
  Puts2("UART'B' will be send to CAN'A' ID #3\n");		
  Puts2("CAN 'A' ID #2 will be send to UART'B'\n");		
  Puts2("Key INT0, INT1, TIN1, IN0 and ADTG will result in UART output\n");		
  Puts2("================================================================\n");

  /* initialize the LC display */

  LCDinitdisp();			

  LCDgoto(LCD_1st_line);	
  LCDprint("FlashCan100P-340");
  LCDgoto(LCD_2nd_line);	
  LCDprint("Evaluation-Board");

  /* Key Button initialisation */
  ADER7 = 0;    /* Use Port 7 as I/O-Port */
  DDR7_D70 = 0; /* Button INT0 as input  */
  DDR7_D71 = 0; /* Button INT1 as input  */
  DDR1_D10 = 0; /* Button TIN1 as input  */
  DDR2_D24 = 0; /* Button IN0  as input  */
  DDR8_D80 = 0; /* Button ADTG as input  */
  
  /* initialize CAN 0 */ 
  CAN0_init(); 
  CAN0_buffer1();
  CAN0_buffer6(); 

  while (1)
  {
    /* UART0 (UART"A") receive/send (echo) */

    if (SSR0_RDRF)                    /* check Receive-buffer           */
    {
      Puts0("UART'A'  receive: ");
      ch = RDR0;	                  /* readout character              */
      Putch0(ch);    	              /* send character                 */
      if (ch==13)	
        Putch0(10);

      Puts0("  ==> Please connect to UART'B'\n");  
    }
    
    /* UART2 (UART"B") receive/send (echo) => CAN send */

    if (SSR2_RDRF)                    /* check Receive-buffer           */
    {
      Puts2("UART'B'  receive: ");
      ch = RDR2;	                  /* readout character              */
      Putch2(ch);    	              /* send character                 */
      if (ch==13)	
        Putch2(10);
        
      /* ===== CAN0-Write ======= */

      DLCR0(buffer6) = 1;    /* <<< byte count that want to be sent (range: 0..8) */

                                      /* DTR and ID must not be written byte-wise */
      DTR0_WORD(buffer6,0) = ch;      /* <<< 1st data-word to send                */

      TREQR0 = 1 << buffer6;                  /* transmition request: TREQ6 = 1   */
      timeout = 0;
      while (   TREQR0_TREQ6                  /* <<< wait until trx is completed  */
             && ! CSR0_HALT                   /* or busoff                        */
             && (++timeout < TIMEOUT) );      /* or timeout                       */

      if (timeout == TIMEOUT)                 /* if timeout...                    */
      {
        TCANR0 = 1 << buffer6;                /* ... then cancel Transmit         */
        Puts2("  timeout !\n");
      }
      else 
        if (CSR0_HALT)                        /* if busoff... */
        {
          Puts2("  BusOff !\n");
        }        
        else
          Puts2("  sent !\n");

      /* ===== CAN-Write (finished) ======= */        
    }    


    /* ===== CAN0-Read Buffer 1======= */

    if (RCR0_RC1)  /* <<< wait for receive complete indication of buffer 1 */
    {
      do
      {
        ROVRR0 = ~(1 << buffer1);              /* clear Overrun-flag Buffer 1 */
        GetCan0Data (buffer1, Can0DataBuffer); /* readout message-buffer      */
      }  
      while (ROVRR0_ROVR1);  /* check for overrun: 
                                It may happen that another CAN-message 
                                is received while data was stored             */

      RCR0 = ~(1 << buffer1); /* clear Receive IRQ: RCR1_RCx=0;               */

      for (i = 1; i <= Can0DataBuffer[0]; i++)
      {
        Puts0("CAN 'A'  receive: ");
        Putch0(Can0DataBuffer[i]);
        Puts0("\n");

        Puts2("CAN 'A'  receive: ");
        Putch2(Can0DataBuffer[i]);
        Puts2("\n");
      }    
    } //if (RCR0_RC1) 
  
    /* ===== CAN0-Read Buffer 1 (finished) ===== */


    if (CSR0_HALT)         /* === simple Bus-off Handler ===      */
    {                     /* if busoff...                        */
      CAN0_init();        /* ... initialize CAN                  */ 
      CAN0_buffer1();     /* ... initialize used message-buffers */
      CAN0_buffer6();     /* ... initialize used message-buffers */
    }

    /* Button check */
    
    if (PDR7_P70 == 0) /* Key INT0 */
    {
      Puts0("Key INT0 pressed\n");
      Puts2("Key INT0 pressed\n");
    }

    if (PDR7_P71 == 0) /* Key INT1 */
    {
      Puts0("Key INT1 pressed\n");
      Puts2("Key INT1 pressed\n");
    }

    if (PDR1_P10 == 0) /* Key TIN1 */
    {
      Puts0("Key TIN1 pressed\n");
      Puts2("Key TIN1 pressed\n");
    }

    if (PDR2_P24 == 0) /* Key IN0  */
    {
      Puts0("Key IN0  pressed\n");
      Puts2("Key IN0  pressed\n");
    }

    if (PDR8_P80 == 0) /* Key ADTG */
    {
      Puts0("Key ADTG pressed\n");
      Puts2("Key ADTG pressed\n");
    }

  } // while(1)
}