hardware.c

linux上实现的多种型号的AVR模拟器

  case 3: set_pin(pin);  
  }
}

static void fpwm_compare_top_set_pin(int mode,int pin)
{
  switch(mode){
  case 2: set_pin(pin); break;
  case 3: clear_pin(pin);  
  }
}

static void set_icr1(void)
{
  int pin,capture=0;
  static int old_pin=0,count;

  if(ISFLAG(ACIC_FLAG)&&get_flag(ACIC_FLAG)) pin=get_flag(ACO_FLAG);
  else pin=get_pin(IC1_PIN);
  
  if(ISFLAG(ICNC1_FLAG)&&get_flag(ICNC1_FLAG))
    { /* Noise Canceler is enabled */
      if(old_pin!=pin) count=0;
      if(get_flag(ICES1_FLAG)) {if(!old_pin&&pin) count=1;}
      else {if(old_pin&&!pin) count=1;}
      if(old_pin==pin&&count) if(count++==4) {capture=1;count=0;}
    }
  else
    {
      if(get_flag(ICES1_FLAG)) {if(!old_pin&&pin) capture=1;}
      else {if(old_pin&&!pin) capture=1;}
    }
  
  if(capture)
    {
      set_port16(ICR1L,ICR1H,get_port16(TCNT1L,TCNT1H));
      set_flag(ICF1_FLAG);
    }
  old_pin=pin;
}

static void set_icr3(void)
{
  int pin,capture=0;
  static int old_pin=0,count;

  pin=get_pin(IC3_PIN);
  
  if(ISFLAG(ICNC3_FLAG)&&get_flag(ICNC3_FLAG))
    { /* Noise Canceler is enabled */
      if(old_pin!=pin) count=0;
      if(get_flag(ICES3_FLAG)) {if(!old_pin&&pin) count=1;}
      else {if(old_pin&&!pin) count=1;}
      if(old_pin==pin&&count) if(count++==4) {capture=1;count=0;}
    }
  else
    {
      if(get_flag(ICES3_FLAG)) {if(!old_pin&&pin) capture=1;}
      else {if(old_pin&&!pin) capture=1;}
    }
  
  if(capture)
    {
      set_port16(ICR3L,ICR3H,get_port16(TCNT3L,TCNT3H));
      set_flag(ICF3_FLAG);
    }
  old_pin=pin;
}

void analog_comparator(void)
{
  int mode=0,mux_mode=0,pin;
  static int aco_old=0,aco;

  if(!ISPORT(ACSR)) return;

  if(get_flag(ACD_FLAG)) return;

  if(ISFLAG(ACME_FLAG)&&get_flag(ACME_FLAG)&&!get_flag(ADEN_FLAG))
    {
      if(get_flag(MUX0_FLAG)) mux_mode|=1<<0;
      if(get_flag(MUX1_FLAG)) mux_mode|=1<<1;
      if(get_flag(MUX2_FLAG)) mux_mode|=1<<2;
      
      switch(mux_mode){
      case 0: pin=ADC0_PIN;break;
      case 1: pin=ADC1_PIN;break;
      case 2: pin=ADC2_PIN;break;
      case 3: pin=ADC3_PIN;break;
      case 4: pin=ADC4_PIN;break;
      case 5: pin=ADC5_PIN;break;
      case 6: pin=ADC6_PIN;break;
      case 7: pin=ADC7_PIN;break;
      }
      
      if(get_pin(AIN0_PIN)&&!get_pin(pin)) {aco=1;set_flag(ACO_FLAG);}
      else {clear_flag(ACO_FLAG);aco=0;}
    }
  else
    {
      if(get_pin(AIN0_PIN)&&!get_pin(AIN1_PIN)) {aco=1;set_flag(ACO_FLAG);}
      else {clear_flag(ACO_FLAG);aco=0;}
    }

  /* get mode */
  if(get_flag(ACIS0_FLAG)) mode|=1<<0;
  if(get_flag(ACIS1_FLAG)) mode|=1<<1;

  switch(mode){
  case 0: 
    if(aco_old!=aco) set_flag(ACI_FLAG);
    break;
  case 2:
    if(aco_old&&!aco) set_flag(ACI_FLAG);
    break;
  case 3:
    if(!aco_old&&aco) set_flag(ACI_FLAG);
    break;
  }
  aco_old=aco;
}

void save_port(int portr,int ddr,int pinr,FILE *file)
{
  uint8_t pin_value;
  char str_c[10],value_hex[5];

  if(ISPORT(portr)) return;
  
  pin_value=get_port(portr)&get_port(ddr);
  set_port(pinr,pin_value);
  
  if(file==NULL) return;

  sprintf(str_c,"%d",clocks); 
  fill_zero(str_c,8);
  sprintf(value_hex,"%X",pin_value);
  fill_zero(value_hex,2);
  fprintf(file,"%s:0x%s\n",str_c,value_hex);
  fflush(file); 
  
}

void save_ports(void)
{
  int n;
  static FILE * files[6]={NULL};

  if(clocks==0)  /* init */
    {  
      for(n=0;n<6;n++)
	{
	  if(files[n]!=NULL) fclose(files[n]);      
	  files[n]=fopen(data_port_log[n].filename,"w");
	}
    }
  
  save_port(PORTA,DDRA,PINA,files[0]);
}

/*  void watchdog_timer(void) */
/*  { */
/*    static int wdtoe; */
/*    int wdtcr,flag; */

/*    if(index_ports[WDTCR]==-1) return; */
  
/*    wdtcr=io_port[index_ports[WDTCR]].address; */

/*    if(((int)((double)wtd_freq*clocks/frequency)%(2048*1024))!= */
/*       ((int)((double)wtd_freq*(clocks-1)/frequency)%(2048*1024))) */
/*      watchdog_prescaler++; */
  
  /*  printf("WatchDog: %d\n",watchdog_prescaler); */
/* if((io_pointer[wdtcr]&0x08)==0) return;*/ /* Watchdog isn't running */
  
  /*  if(io_port[index_ports[WDTCR]].write_mask!=0x0F&& */
/*       !(io_pointer[wdtcr]&0x10)&&flag==1) */
      /* watchdog is running */ 
/*      {if(clocks_wdt>watchdog_prescaler) watchdog_prescaler++;} */
/*    else */
      /* watchdog is stopped */ 
/*      wdtoe=0; */
    
  
/*    if(io_pointer[wdtcr]&0x10)*/  /* attempt to stop watchdog */
/*      { */
/*        if(wdtoe>4) */
/*  	{ */
/*  	*/  /* clear flag 'wdtoe' after 4 cycles */ 
/*  	  io_pointer[wdtcr]=io_pointer[wdtcr]&0xEF; */
/*  	  wdtoe=controllers[type_micro].size_gpr; */
/*  	  mem_file_changed[(wdtcr+wdtoe)/8]|=1<<(wdtcr+wdtoe)%8; */
/*  	  wdtoe=0; */
/*  	} */
/*        wdtoe++; */
/*      } */
  
/*    if(!watchdog_prescaler) return; */
/*    flag=0; */
/*  */  /* reset condition */ 
/*    switch(io_pointer[wdtcr]&0x7) */
/*      { */
/*      case 0: */
/*        if((watchdog_prescaler%(16*1024))==0) */
/*  	flag=1; */
/*        break; */
/*      case 1: */
/*        if((watchdog_prescaler%(32*1024))==0) */
/*  	flag=1; */
/*        break; */
/*      case 2: */
/*        if((watchdog_prescaler%(64*1024))==0) */
/*  	flag=1; */
/*        break; */
/*      case 3: */
/*        if((watchdog_prescaler%(128*1024))==0) */
/*  	flag=1; */
/*        break; */
/*      case 4: */
/*        if((watchdog_prescaler%(256*1024))==0) */
/*  	flag=1; */
/*        break; */
/*      case 5: */
/*        if((watchdog_prescaler%(512*1024))==0) */
/*  	flag=1; */
/*        break; */
/*      case 6: */
/*        if((watchdog_prescaler%(1024*1024))==0) */
/*  	flag=1; */
/*        break; */
/*      case 7: */
/*        if((watchdog_prescaler%(2048*1024))==0) */
/*  	watchdog_prescaler=0; */
/*  	flag=1; */
/*        break; */
/*      } */

/*    if(flag) */
/*      { */
/*        update_main(); */
/*        show_info(_("WatchDog Reset")); */
/*        pthread_kill(thread,SIGSTOP); */
/*        if(wacthdog_timeout==UNPROGRAMMED) */
/*  	{ */
/*  	  clocks+=(int)(((double)frequency*16*1024)/wtd_freq); */
/*  	  watchdog_prescaler+=16*1024+1; */
/*  	} */
/*        else */
/*  	{ */
/*  	  clocks+=(int)(((double)frequency*1024)/wtd_freq); */
/*  	  watchdog_prescaler+=1024; */
/*  	} */
/*        watchdog_prescaler=pc=0; */
/*      } */
/*  } */

/*  void eeprom_access(void) */
/*  { */
/*    static int attempt,time=-1; */
/*    int eedr,eecr,eecr_mask; */
/*    Word eear; */
  
/*    eear.word=0; */
/*    eear.byte[0]=io_pointer[io_port[index_ports[EEARL]].address]; */
/*    if(index_ports[EEARH]!=-1) */
/*      { */
/*        eear.byte[1]=io_pointer[io_port[index_ports[EEARH]].address]; */
/*      } */
/*    eecr=io_port[index_ports[EECR]].address; */
/*    eecr_mask=io_port[index_ports[EECR]].write_mask; */
/*    eedr=io_port[index_ports[EEDR]].address; */

/*    if((io_pointer[eecr]&0x03)==1) */
/*    */  /* read EEPROM data */ 
/*      { */
/*        if((type_micro>1&&type_micro<6)||type_micro>7) */
/*  	clocks+=4; */
/*        else*/ /* operation of reading EEPROM halts CPU for two/four cycles */ 
/*  	clocks+=2;  */
/*        io_pointer[eecr]=io_pointer[eecr]&0xFE; */
/*        if(eear.word<controllers[type_micro].size_eeprom) */
/*  	io_pointer[eedr]=eeprom_pointer[eear.word]; */
/*        else */
/*  	{puts("EEPROM address more then its size.");} */
/*        eecr+=controllers[type_micro].size_gpr; */
/*        mem_file_changed[eecr/8]|=1<<eecr%8; */
/*        eedr+=controllers[type_micro].size_gpr; */
/*        mem_file_changed[eedr/8]|=1<<eedr%8; */
/*        return; */
/*      } */

/*    if((io_pointer[eecr]&0x2)==0) {time=-1;}; */

/*    if(eecr_mask==0x03&&(io_pointer[eecr]&0x03)==0x02&&time==-1) */
/*   */   /* write EEPROM, for AT90S1200 */ 
/*      { */
/*        clocks+=2;*/ /* operation of writing EEPROM halts CPU for two cycles */ 
/*        time=clocks; */
/*        return; */
/*      } */

/*    if((eecr_mask&0x07)==0x07) */
/*      { */
/*        if(io_pointer[eecr]&0x4) */
/*  */	/* attempt to do writing operation */ 
/*  	{ */
/*  	  attempt++; */
/*  	  if(attempt>3) */ /* clear flag 'EEMWE' after 4 cycles */  
/*  	    { */
/*  	      io_pointer[eecr]=io_pointer[eecr]&0xFB; */
/*  	      attempt=0; */
/*  	      eecr+=controllers[type_micro].size_gpr; */
/*  	      mem_file_changed[eecr/8]|=1<<eecr%8; */
/*  	      return; */
/*  	    } */
/*  	} */
/*        if((io_pointer[eecr]&0x7)==0x6&&time==-1) */
/*  */ 	/* write data to EEPROM*/ 
/*  	{ */
/*  	  clocks+=2;*/ /* operation of writing EEPROM halts CPU for two cycles */ 
/*  	  time=clocks; */
/*  	} */
/*        if(!(io_pointer[eecr]&0x7)) */
/*  	attempt=0; */
/*      } */

/*    if(time!=-1) */
/*      { */ /* waiting until the write access time is elapsed then do write */ 
/*        if(eeprom_wat<=1.0/frequency*(clocks-time)) */
/*  	{ */
/*  	  io_pointer[eecr]&=0xFD; */
/*  	  if(eear.word<controllers[type_micro].size_eeprom) */
/*  	    { */
/*  	      eeprom_pointer[eear.word]=io_pointer[eedr]; */
/*  	      update_eeprom_window(); */
/*  	    } */
/*  	  else */
/*  	    {puts("EEPROM address more then its size.");} */
/*  	  if(eecr_mask&0x08) */ /* generate interrupt */ 
/*  	    io_pointer[eecr]|=0x08; */
/*  	  eecr+=controllers[type_micro].size_gpr; */
/*  	  mem_file_changed[eecr/8]|=1<<eecr%8; */
/*  	  time=-1; */
/*  	} */
/*        return; */
/*      } */
/*  } */

int interrupt(void)
{
  uint16_t sp;
  int address,n;
  
  if(!get_sreg_flag(FLAG_I)) return 0;
  
  address=-1;
 
  for(n=1;controllers[type_micro].interrupts[n]!=-1&&address==-1;n++)
    address=func_int[controllers[type_micro].interrupts[n]](n);

  if(address==-1) return 0;

  if(!type_micro)
    {
      stack_90s1200[2]=stack_90s1200[1];
      stack_90s1200[1]=stack_90s1200[0];
      stack_90s1200[0]=pc;
    }
  else
    {
      if(ISPORT(SPH)) sp=get_port16(SPL,SPH);
      else sp=get_port(SPL);
      if(sp<2) {fprintf(stderr,"Error: Stack Pointer not set\n"); return 0;}
 
      gpr_pointer[sp]=(uint8_t)(pc>>8);
      mem_file_changed[sp/8]|=1<<sp%8;
      sp--;
      gpr_pointer[sp]=(uint8_t)pc;
      mem_file_changed[sp/8]|=1<<sp%8;
      sp--;
      if(ISPORT(SPH)) set_port16(SPL,SPH,sp);
      else set_port(SPL,sp); 
    }
  pc=address;
  clocks+=2; 
  clear_sreg_flag(FLAG_I);
  num_call++;

  return 1;
}
  
/*  void load_ports() */
/*  { */
/*    static FILE * files[6]={NULL}; */
/*    static int read_clock[6],read_value[6]; */
/*    int n,shift; */

/*    if(clocks==0) */ /* init */ 
/*      { */
/*        for(n=0;n<6;n++) */
/*  	{ */
/*  	  if(ports[n].pins!=-1) */
/*  	    { */
/*  	      if(files[n]!=NULL) fclose(files[n]); */
/*  	      if((files[n]=fopen(data_port_sti[n].filename,"r"))!=NULL) */
/*  		read_clock[n]=0; */
/*  	      else */
/*  		read_clock[n]=-1; */
/*  	    } */
/*  	  else */
/*  	    read_clock[n]=-1; */
/*  	} */
/*      } */
  
/*    for(n=0;n<6;n++) */
/*      if(!read_clock[n]) */
/*        if((fscanf(files[n],"%d:%x",&read_clock[n],&read_value[n])==EOF)) */
/*  	read_clock[n]=-1; */
  
/*    for(n=0;n<6;n++) */
/*      if(clocks==read_clock[n]) */
/*        { */
/*  	io_pointer[ports[n].pins]=read_value[n]; */
/*  	shift=controllers[type_micro].size_gpr; */
/*  	mem_file_changed[(ports[n].pins+shift)/8]|=1<<(ports[n].pins+shift)%8; */
/*  	read_clock[n]=0; */
/*        } */
/*  } */

/*  void save_ports() */
/*  { */
/*    static FILE * files[6]={NULL}; */
/*    static int write_value[6]; */
/*    int n,shift; */
/*    char buf[80],buf1[10],buf2[4]; */
  

  
/*    for(n=0;n<6;n++) */
/*      if(ports[n].data!=-1) */
/*        { */
/*  	if(ports[n].direct!=-1) */
/*  	  { */
/*  	    io_pointer[ports[n].pins]=(io_pointer[ports[n].pins]& */
/*  				       ~io_pointer[ports[n].direct])| */
/*  	      (io_pointer[ports[n].data]&io_pointer[ports[n].direct]); */
/*  	    shift=controllers[type_micro].size_gpr; */
/*  	    mem_file_changed[(ports[n].pins+shift)/8]|= */
/*  	      1<<(ports[n].pins+shift)%8; */
/*  	  } */
	
/*  	if((ports[n].direct==-1&&io_pointer[ports[n].data]!=write_value[n])|| */
/*  	   (ports[n].direct!=-1&&io_pointer[ports[n].pins]!=write_value[n])) */
/*  	  { */
	    
/*  	    if(ports[n].direct!=-1) */
/*  	      write_value[n]=io_pointer[ports[n].pins]; */
/*  	    else */
/*  	      write_value[n]=io_pointer[ports[n].data]; */
	    
/*  	    if(files[n]!=NULL) */
/*  	      { */
/*  		sprintf(buf1,"%d",clocks); */
/*  		fill_zero(buf1,8); */
/*  		sprintf(buf2,"%X",write_value[n]); */
/*  		fill_zero(buf2,2); */
/*  		sprintf(buf,"%s:%s\n",buf1,buf2); */
/*  		fputs(buf,files[n]);  */
/*  		fflush(files[n]);  */
/*  	      } */
/*  	  } */
	
/*        } */
/*  } */


/*  void external_interrupts(void) */
/*  { */
/*    int gifr,mcucr,int_flag; */
/*    static int int_old[8]; */
 /* previous values of pins*/ 
  
/*    if(index_ports[GIFR]!=-1) gifr=io_port[index_ports[GIFR]].address; */
/*    else gifr=-1; */
/*    if(index_ports[MCUCR]!=-1) mcucr=io_port[index_ports[MCUCR]].address; */
/*    else mcucr=-1; */
  
/*    int_flag=0; */
    /* external interrupt 0 */ 
/*    if(index_pins[INT0_PIN]!=-1) */
/*      { */
/*        switch(io_pointer[mcucr]&0x03) */
	  /* check config EXT_INT0*/ 
/*  	{ */
/*  	case 0x00: */ /* low level */ 
/*  	  if(!(io_pointer[pin[index_pins[INT0_PIN]].pins_address]& */
/*  	       pin[index_pins[INT0_PIN]].mask)) */
/*  	    int_flag=1; */
/*  	  break; */
/*  	case 0x01: */ /* reserved */ 
/*  	  break; */
/*  	case 0x02: */ /* falling edge */ 
/*  	  if(int_old[0]&&!(io_pointer[pin[index_pins[INT0_PIN]].pins_address]& */
/*  			   pin[index_pins[INT0_PIN]].mask)) */
/*  	    int_flag=1; */
/*  	  break; */
/*  	case 0x03: */ /* rising edge */ 
/*  	  if(!int_old[0]&&(io_pointer[pin[index_pins[INT0_PIN]].pins_address]& */
/*  			   pin[index_pins[INT0_PIN]].mask)) */
/*  	    int_flag=1; */
/*  	  break; */
/*  	} */
/*        int_old[0]=io_pointer[pin[index_pins[INT0_PIN]].pins_address]& */
/*  	pin[index_pins[INT0_PIN]].mask; */
      
/*        if(int_flag) */
/*  	{ */
/*  	  if(index_ports[GIFR]!=-1) */
/*  	    { */
/*  	      gifr=io_port[index_ports[GIFR]].address; */
/*  	      io_pointer[gifr]|=0x40; */
/*  	      gifr+=controllers[type_micro].size_gpr; */
/*  	      mem_file_changed[gifr/8]|=1<<gifr%8; */
/*  	    } */
/*  	  else  */
/*  	    { */
/*  	      ex_ifr|=0x01; */
/*  	    } */
/*  	} */
/*      } */

/*    int_flag=0; */
    /* external interrupt 1 */ 
/*    if(index_pins[INT1_PIN]!=-1) */
/*      { */
/*        switch((io_pointer[mcucr]&0x0C)>>2) */ /* check config EXT_INT0*/ 
/*  	{ */
/*  	case 0x00: */ /* low level */ 
/*  	  if(!(io_pointer[pin[index_pins[INT1_PIN]].pins_address]& */
/*  	       pin[index_pins[INT1_PIN]].mask)) */
/*  	    int_flag=1; */
/*  	  break; */
/*  	case 0x01: */ /* reserved */ 
/*  	  break; */
/*  	case 0x02: */ /* falling edge */ 
/*  	  if(int_old[1]&&!(io_pointer[pin[index_pins[INT1_PIN]].pins_address]& */
/*  			   pin[index_pins[INT1_PIN]].mask)) */
/*  	    int_flag=1; */
/*  	  break; */
/*  	case 0x03: */
 /* rising edge */ 
/*  	  if(!int_old[1]&&(io_pointer[pin[index_pins[INT1_PIN]].pins_address]& */
/*  			   pin[index_pins[INT1_PIN]].mask)) */
/*  	    int_flag=1; */
/*  	  break; */
/*  	} */
/*        int_old[1]=io_pointer[pin[index_pins[INT1_PIN]].pins_address]& */
/*  	pin[index_pins[INT1_PIN]].mask; */
      
/*        if(int_flag) */
/*  	{ */
/*  	  if(index_ports[GIFR]!=-1) */
/*  	    { */
/*  	      gifr=io_port[index_ports[GIFR]].address; */
/*  	      io_pointer[gifr]|=0x80; */
/*  	      gifr+=controllers[type_micro].size_gpr; */
/*  	      mem_file_changed[gifr/8]|=1<<gifr%8; */
/*  	    } */
/*  	  else  */
/*  	    { */
/*  	      ex_ifr|=0x02; */
/*  	    } */