USHORT Hal4D13_GetDataFromChipRam(void)
{
    USHORT i;
    IOWR(USB_0_BASE,D13_COMMAND_PORT,D13CMD_DEV_RD_RAM);
    i = IORD(USB_0_BASE,D13_DATA_PORT);
    return i;
}

USHORT Hal4D13_GetDevConfig(void)
{
  USHORT i; 
  IOWR(USB_0_BASE,D13_COMMAND_PORT,D13CMD_DEV_RD_CNFG);
  i = IORD(USB_0_BASE,D13_DATA_PORT);
  return i;
}

USHORT Hal4D13_GetDMACounter(void)
{
    USHORT i;
    IOWR(USB_0_BASE,D13_COMMAND_PORT,D13CMD_DMA_RD_COUNT);
    i = IORD(USB_0_BASE,D13_DATA_PORT);
    return i;
}

USHORT Hal4D13_ReadChipID(void)
{
    USHORT i;
    IOWR(USB_0_BASE, D13_COMMAND_PORT, D13CMD_DEV_RD_CHIPID);
    i=IORD(USB_0_BASE, D13_DATA_PORT);
    return i;
}

UCHAR Hal4D13_GetEndpointStatusWOInteruptClear(UCHAR bEPIndex)
{
    UCHAR c;
    IOWR(USB_0_BASE,D13_COMMAND_PORT, D13CMD_EP_RDSTS + bEPIndex);
    c = (UCHAR)(IORD(USB_0_BASE,D13_DATA_PORT) &0x0ff);
    return c;
}

UCHAR Hal4D13_GetErrorCode(UCHAR bEPIndex)
{
    UCHAR   c;
    IOWR(USB_0_BASE,D13_COMMAND_PORT, D13CMD_EP_RD_ERR+bEPIndex);
    c = (UCHAR)(IORD(USB_0_BASE,D13_DATA_PORT)&0x0ff);
    return c;
}

/**
 *
 * This function reads data from the internal registers of the Cypress
 * CY7C67200 USB controller.
 *
 * @param    Address is the address of the register.
 *
 * @return   The data read from the specified address
 *
 * @note     None
 *
 ******************************************************************************/
alt_u16 UsbRead(alt_u16 Address)
{
	//XIo_Out16(HPI_ADDR, Address);
	IOWR(CY7C67200_BASE,HPI_ADDR,Address);
	//usleep(20);
	return IORD(CY7C67200_BASE,HPI_DATA);
}

/* Tests basic sigmoid functionality */
int test_sigmoid(void){

	float M,time,result;

	alltypes_u input;

	M = 2.24;
	time = 3.8;
	result = 0;

	fprintf(stderr,"Starting sigmoid test....\n");

	fprintf(stderr,"Sigmoid block test register returns [%X].\n", IORD(EULERBLOCK_0_BASE,3));

	fprintf(stderr,"Floats have byte count of [%d].\n",(int)sizeof(float));

	input.fl = M;

	IOWR(EULERBLOCK_0_BASE,0,input.ui);

	/* Check it's corrent */
	input.ui = IORD(EULERBLOCK_0_BASE, 0);


	fprintf(stderr,"Inputs are M=[%4.2f], time=[%4.2f].\n",M,time);

	fprintf(stderr,"IORD returns [%4.8f].\n", input.fl);

	sigmoid(M, time, &result);

	fprintf(stderr,"Sigmoid returned [%4.8f].\n", result);

	return 0;
}

USHORT Hal4D13_ReadCurrentFrameNumber(void)
{
    USHORT i;
    IOWR(USB_0_BASE,D13_COMMAND_PORT, D13CMD_RD_FRMNUM);
    i= IORD(USB_0_BASE,D13_DATA_PORT);
    return i;
}

UCHAR Hal4D13_GetEndpointConfig(UCHAR bEPIndex)
{
    UCHAR   c;
    IOWR(USB_0_BASE,D13_COMMAND_PORT, D13CMD_EP_RD_CNFG+bEPIndex);
    c = (UCHAR)(IORD(USB_0_BASE,D13_DATA_PORT) & 0x0ff);
    return c;
}

/* Parses user input string and performs relevant method.
 */
void processCommand(char * userInput, int userInputLength)
{
       
    int userParams [50];
    int nParams = 0;
    int error = 0;
    if(userInputLength > 0)
    {
        nParams = getUserParams(userInput, userParams);
        
        if(strncmp(userInput, "help",4) == 0)
            printHelp();

        else if(strncmp(userInput, "wc ", 3) == 0)
            if(nParams == 2)
            {
                IOWR(CONTROL_BASE, userParams[0], userParams[1]);
                printf("%s\n", userInput);
            }
            else
            {
                error = 1;
            }


        else if(strncmp(userInput, "rc ", 3) == 0)
            if(nParams == 1)
            {
                userParams[4] = IORD(CONTROL_BASE, userParams[0]);
                printf("%s: %d  %x\n", userInput, userParams[4], userParams[4]);
            }
            else
                error = 1;

        else if(strncmp(userInput, "restart", 7) == 0)
            restart();
        else if(strncmp(userInput, "pause", 5) == 0)
            pause();

        else if(strncmp(userInput, "set adc", 7) == 0)
        {
            if(nParams == 4)
            {
                setADCParams(userParams[0], userParams[1], userParams[2], userParams[3]);   
            }  
            else
               error = 1;
         
        }
  
        else
        {
            error = 1;
        }
        // Invalid Command
        if(error == 1) printf("%s: Unknown Command. Type 'help' for list of commands.\n", userInput);    
                                       
    }
}

ULONG Hal4D13_GetIntEnable(void)
{
    ULONG i;
    IOWR(USB_0_BASE,D13_COMMAND_PORT,D13CMD_DEV_RD_INTEN);
    i = IORD(USB_0_BASE,D13_DATA_PORT);
    i += (((ULONG)IORD(USB_0_BASE,D13_DATA_PORT)) << 16);
    return i;
}

void init_timer()
{
	ticks = 0;
	
	/* ajastimen keskeytys päälle */
	IOWR(TIMER, TIMER_CONTROL, 1);
	write_irq_mask(1u << TIMER_IRQ);
}

static void pulse_ISR(void* context, alt_u32 id)
{
   if (IORD(PIO_PULSE_BASE, 0) == 0)
   {
           IOWR(PIO_RESPONSE_BASE, 0, 1);
           flag++;
   }
   //IOWR(PIO_RESPONSE_BASE, 0, 1);
   if (IORD(PIO_PULSE_BASE, 0) == 1)
   {
           IOWR(PIO_RESPONSE_BASE, 0, 0);
           flag++;
   }
   // clear interrupt
   //IOWR(PIO_PULSE_BASE, 0, 0);
   IOWR(PIO_PULSE_BASE, 3, 0x0);
}

// Send dummy clock pulse
void SD_Ncc()
{
    IOWR(AVSDC_0_BASE, 0, AV_SDC_SEND_DUMMY);
    /*for (int i = 0; i < 8; i++)
    {
        SD_ClockPulse();
    }*/
}

int main(void) {

	if (init_system() != 0) return(-1);
	
	indexed_file_count = build_file_index(files);
	printf("Indexed files: %d\n", indexed_file_count);
	
	IOWR(BUTTON_PIO_BASE, 2, 0xf);
	IOWR(BUTTON_PIO_BASE, 3, 0x0);
	alt_irq_register( BUTTON_PIO_IRQ, (void*)0, button_ISR );
	
	IOWR(LED_PIO_BASE, 0, 0x00);
	
	player_state = PLAYER_STATE_DEFAULT;	
	
	int length;
	data_file file;
	
	while(1){
		if ((cur_file_index_update == 1) || (player_state_update == 1)) {

			if (cur_file_index_update)
				file = files[cur_file_index];

			switch (player_state){

				case PLAYER_STATE_PLAYING:
					LCD_File_Buffering(file.Name);
					length = 1 + ceil(file.FileSize/(BPB_BytsPerSec*BPB_SecPerClus));
					build_cluster_chain(cluster_chain, length, &file);

					LCD_Display(file.Name, player_mode);
					play(&file, buffer, cluster_chain, player_mode);
					player_state = PLAYER_STATE_USER_INPUT;

				case PLAYER_STATE_USER_INPUT:
					LCD_Display(file.Name, player_mode);
			}

			player_state_update = 0;
			cur_file_index_update = 0;
		}
	}
	
	return(0);
}

void phy_write(unsigned int reg, unsigned int value)
{ 
  /* set PHY register address into EPAR REG. 0CH */
  dm9000a_iow(0x0C, reg | 0x40); /* PHY register address setting,
			    and DM9000_PHY offset = 0x40 */

  /* fill PHY WRITE data into EPDR REG. 0EH & REG. 0DH */
  dm9000a_iow(0x0E, ((value >> 8) & 0xFF));   /* PHY data high_byte */
  dm9000a_iow(0x0D, value & 0xFF);            /* PHY data low_byte */

  /* issue PHY + WRITE command = 0xa into EPCR REG. 0BH */
  dm9000a_iow(0x0B, 0x8);                     /* clear PHY command first */
  IOWR(DM9000A_INST_BASE, IO_data, 0x0A);  /* issue PHY + WRITE command */
  usleep(STD_DELAY);
  IOWR(DM9000A_INST_BASE, IO_data, 0x08);  /* clear PHY command again */
  usleep(50);  /* wait 1~30 us (>20 us) for PHY + WRITE completion */
}

static void timer_ISR(void* context, alt_u32 id)
{
   // acknowledge the interrupt by clearing the TO bit in the status register
   IOWR(TIMER_0_BASE, 0, 0x0);

   // set the flag with a non zero value
   count_flag = 0xf;
}

int main()
{
  int i;
  
  unsigned long sw_time_1, sw_time_2;
  
  //enable the temperature sensor
  temp_sensor_init();

  //enable uCProbe communication
  ProbeCom_Init();
  ProbeRS232_Init(0);
  ProbeRS232_RxIntEn();

  // turn off the LEDS
  IOWR(LED_PIO_BASE,0,0xFF);

  printf("BeMicro SDK Lab1: \n");
  printf("-----------------\n\n");

  // Create the input data waveform
  printf("Creating buffer source data\n\n");
  for(i = 0; i < DATA_BUFFER_SIZE; i++)
  {
    source_databuffer[i] = input_data[i%INPUT_LENGTH];
  }

  // record the value of the high resolution time-stamp timer at the entry and exit points of the software filter
  if(alt_timestamp_start() < 0)
  {
    printf("Please add the high resolution timer to the timestamp timer setting in the syslib properties page.\n");
    return 0;
  }

  printf("Software filter is operating (please be patient)\n");
  sw_time_1 = alt_timestamp();
  FIR_SW(source_databuffer,
         DATA_BUFFER_SIZE,
         sw_destination_databuffer,
         T,
         coefficients[0],
         coefficients[1],
         coefficients[2],
         coefficients[3],
         coefficients[4],
         coefficients[5],
         coefficients[6],
         coefficients[7],
         DIVIDER_ORDER);
  sw_time_2 = alt_timestamp();
  printf("Software filter is done\n\n");

  sw_proc_time = ((double)(sw_time_2-sw_time_1))/((double)alt_timestamp_freq());
  printf("Software processing time was: %f seconds\n\n", sw_proc_time);
  printf("Processing time will also be reported by uC-Probe:\n");
  
  return 1;
}

void VPG_Config(VPG_MODE Mode, COLOR_TYPE Color) {
#ifndef TX_DISABLED

    //===== check whether vpg function is active
    if (!HDMITX_HPD())
        return;
#ifndef RX_DISABLED
    if (HDMIRX_IsVideoOn())
        return;
#endif //RX_DISABLED    


    OS_PRINTF("===> Pattern Generator Mode: %d (%s)\n", gVpgMode, gszVicText[gVpgMode]);

    //===== updagte vpg mode & color
    IOWR(HDMI_TX_MODE_CHANGE_BASE, 0, 0);
    // change color mode of VPG
    if (gVpgColor == COLOR_RGB444)
        IOWR(HDMI_TX_VPG_COLOR_BASE, 0, VPG_RGB444);  // RGB444
    else if (gVpgColor == COLOR_YUV422)
        IOWR(HDMI_TX_VPG_COLOR_BASE, 0, VPG_YUV422);  // YUV422
    else if (gVpgColor == COLOR_YUV444)
        IOWR(HDMI_TX_VPG_COLOR_BASE, 0, VPG_YUV444);  // YUV444

    IOWR(HDMI_TX_DISP_MODE_BASE, 0, gVpgMode);
    IOWR(HDMI_TX_MODE_CHANGE_BASE, 0, 1);
    IOWR(HDMI_TX_MODE_CHANGE_BASE, 0, 0);
    //
    //HDMITX_EnableVideoOutput();

#endif //#ifndef TX_DISABLED      
}