Example #1
0
int main()
{
    init_platform();

    xil_printf("%s\n\r", "Welcome to Brutus cracker system!");

    while (1) {
    	xil_printf("%s\n\r", "Enter hash: ");
		char recv = XUartLite_RecvByte(STDIN_BASEADDRESS); // read first char


		/* Read password hash */
		char buff[32];
		int idx_buff = 0;
		while (recv != '\r') {
			buff[idx_buff++] = recv;
			recv = XUartLite_RecvByte(STDIN_BASEADDRESS);
		}

		unsigned int i_buff[4] = {0};
		unsigned num = 0;

		for (int i = 0; i < 4; i++) {
			for (int j = 0; j < 8; j++) {
				num = ctox(buff[j + i*8]);
				i_buff[i] += (pow(16, 7-j) * num);
			}
			//xil_printf("%x\n\r", i_buff[i]);
		}

		//xil_printf("%u\n\r", i_buff[0]);


		putfsl(i_buff[0], 0);
		putfsl(i_buff[1], 0);
		putfsl(i_buff[2], 0);
		putfsl(i_buff[3], 0);
		xil_printf("Cracking...\n\r");

		unsigned int resp;
		char *str = &resp; // c-magic

		getfsl(resp, 0);
		unsigned i;
		xil_printf("password: "******"%c", *(str+i));
		}
		getfsl(resp, 0);
		for (i = 0; i < 4; i++) {
			xil_printf("%c", *(str+i));
		}
		xil_printf("\n\r");
    }
    cleanup_platform();

    return 0;
}
Example #2
0
char receive(){
	//
	// Helper function to handle receiving from UART and printing back to it for improved user experience
	char recieved = XUartLite_RecvByte(XPAR_RS232_DTE_BASEADDR);
	xil_printf("%c", recieved);
	return recieved;
}
Example #3
0
/*
 * runManualTest
 *
 * Provide a menu for user to test each interface manually 
 */
void runManualTest(void) {
	xil_printf("\r\n");
	while(1) {
		xil_printf("---- NetFPGA-SUME Manual Test Menu ----\r\n");
		xil_printf("i: Read DDR3 Info\r\n");
		xil_printf("s: Read DDR3 Test Status\r\n");
		xil_printf("p: Read Power Info\r\n");
		xil_printf("b: Back to Main Menu\r\n");
		xil_printf("Select: ");
		char cmd = XUartLite_RecvByte(XPAR_AXI_UARTLITE_0_BASEADDR);
		xil_printf("%c\r\n", cmd);
		switch (cmd) {
			case 'i':
				ddr3ReadInfo('B');
				break;
			case 's':
				ddr3RwStat();
				break;
			case 'p':
				pmReadInfo();
				break;
			case 'b':
				return;
			default:
				break;
		}
		xil_printf("\r\n");
	}
}
Example #4
0
inline u8 getkey(void)
{
	if(XUartLite_mIsReceiveEmpty(XLB_STDIO_BASEADDR)) {
		return '\0';
	} else {
		return XUartLite_RecvByte(XLB_STDIO_BASEADDR);
	}
}
Example #5
0
/* --- serGetChar1()  Get 1 char from the UART Lite, but do not block.
   --- Return number of chars received. */
char serGetChar1(unsigned char *str)
{

  /* Check if data is available */
    *str = XUartLite_RecvByte(UARTLITE_BASEADDRESS);
    return 1;

  return 0;
}
Example #6
0
/* --- serRecvStr1()  Receive n chars from the UART Lite.
   --- If n == 0, get only available chars (don't block) 
   --- n cannot be larger than 255 */
unsigned char serRecvStr1(unsigned char *str, unsigned char n)
{
  unsigned char i;

  i = 0;
  if (n > 0){
    /* If n > 0, block for n chars */
    while(i < n){
        (str[i++]) = XUartLite_RecvByte(UARTLITE_BASEADDRESS);
    }
    return n;
  } else if (XUartLite_IsReceiveEmpty(UARTLITE_BASEADDRESS)){
  	return 0;
  } else {
    /* if n == 0, get as many as available now (non-blocking) */
      (str[i++]) = XUartLite_RecvByte(UARTLITE_BASEADDRESS);
    return i;
  }
}
int main(void)
{
	uint32_t Index;
    uint32_t* gpio_ptr = (uint32_t *)XPAR_GPIO_0_BASEADDR;
    u32 uart_ptr = XPAR_UARTLITE_0_BASEADDR;
    command_t cmd;
    int cmd_args[4];
    char output_string[100];

	print("Type commands.\n\r");

	Index = 0;
	for(;;){
		char_temp = XUartLite_RecvByte(uart_ptr);  // this waits until there is a character available.
    	//*gpio_ptr = char_temp;  // write character to LED's.
		RecvBuffer[Index] = char_temp;
		if (Index==(TEST_BUFFER_SIZE-1)) Index = 0; else Index++;
		if (char_temp=='\r'){ // carriage return detected
			Index = 0;
			//process the command line.
			parse_command(RecvBuffer, &cmd, cmd_args);

			// for now, just print something to indicate that the command is parsed.
			if (cmd==reg_wr) {
				sprintf(output_string, "command = reg_wr, args = 0x%x 0x%x 0x%x 0x%x\n\r", cmd_args[0], cmd_args[1], cmd_args[2], cmd_args[3]);
			} else if (cmd==reg_rd) {
				sprintf(output_string, "command = reg_rd, args = 0x%x 0x%x 0x%x 0x%x\n\r", cmd_args[0], cmd_args[1], cmd_args[2], cmd_args[3]);
			} else if (cmd==spi_wr) {
				sprintf(output_string, "command = spi_wr, args = 0x%x 0x%x 0x%x 0x%x\n\r", cmd_args[0], cmd_args[1], cmd_args[2], cmd_args[3]);
			} else if (cmd==spi_rd) {
				sprintf(output_string, "command = spi_rd, args = 0x%x 0x%x 0x%x 0x%x\n\r", cmd_args[0], cmd_args[1], cmd_args[2], cmd_args[3]);
			} else if (cmd==led_wr) {
				sprintf(output_string, "command = led_wr, args = 0x%x 0x%x 0x%x 0x%x\n\r", cmd_args[0], cmd_args[1], cmd_args[2], cmd_args[3]);
				*gpio_ptr = cmd_args[0];
			} else {
				sprintf(output_string, "command = nop, args = 0x%x 0x%x 0x%x 0x%x\n\r", cmd_args[0], cmd_args[1], cmd_args[2], cmd_args[3]);
			}
			print(output_string);
		}
	}

	return XST_SUCCESS;
}
Example #8
0
////////////  напюанрвхйх опепшбюмхи  //////////////////////////////////////////
void handler_RS232(void *arg2) {
  if(!XUartLite_mIsReceiveEmpty(XPAR_UARTLITE_0_BASEADDR)) {
    sost_rs =  XUartLite_RecvByte(XPAR_UARTLITE_0_BASEADDR);
  }
}
Example #9
0
/* target_getchar():
 * Assume there is a character in the UART's input buffer and just
 * pull it out and return it.
 */
int 
target_getchar(void)
{
	return((int)XUartLite_RecvByte(UART_BASE));
}
Example #10
0
char receive() {
    char recieved = XUartLite_RecvByte(XPAR_RS232_DTE_BASEADDR);
    xil_printf("%c", recieved);
    return recieved;
}
Example #11
0
int main()
{
    int Status;

    init_platform();

	xil_printf("NetFPGA-SUME ddr3B Acceptance Test\r\n");

	/*
	 * Setup Iic Instance
	 */
	Status = IicInit(&IicInstance);
	if (Status != XST_SUCCESS) {
		xil_printf("I2C Initialization FAILED\n\r");
		return XST_FAILURE;
	}

	/*
	 * Setup the Interrupt System.
	 */
	Status = SetupInterruptSystem(&IicInstance);
	if (Status != XST_SUCCESS) {
		xil_printf("SetupInterruptSystem FAILED\n\r");
		return XST_FAILURE;
	}

	/*
	 * Enable Iic Bus
	 */
	Status = IicInitPost(&IicInstance);
	if (Status != XST_SUCCESS) {
		xil_printf("I2C Initialization FAILED\n\r");
		return XST_FAILURE;
	}

	Status = ddr3Test_Init();
	if (Status != XST_SUCCESS) {
		xil_printf("I2C Initialization FAILED\n\r");
		return XST_FAILURE;
	}

	while(1) {
		xil_printf("============ NetFPGA-SUME ============\n\r");
		xil_printf("a: Auto Test \r\n");
		xil_printf("m: Manual Test \r\n");
		xil_printf("Select: ");
		char cmd = XUartLite_RecvByte(XPAR_AXI_UARTLITE_0_BASEADDR);
		xil_printf("%c\r\n", cmd);
		switch (cmd) {
			case 'a':
				runAutoTest();
				break;
			case 'm':
				runManualTest();
				break;
			default:
				break;
		}
		xil_printf("\r\n");
	}

    return 0;
}
Example #12
0
char inbyte(void) {
	 return XUartLite_RecvByte(STDIN_BASEADDRESS);
}
Example #13
0
char WarpEEPROM_ControlByteWrite(unsigned int* baseaddr, char ByteSelect, char value2store)
{   
   Xuint8 choice;
   if(ByteSelect < 5)
   {
      print("\r\nReturning\r\n");
      return; // Remove in order to enable writing to control bytes.
      print("\r\nSETTING THE PROTECTION REGISTERS TO WRITE PROTECT OR EPROM MODE IS\r\n");
      print("\r\n                    ***IRREVERSIBLE***\r\n");
      print("\r\nDo you wish to continue? (y)\r\n");
      choice = XUartLite_RecvByte(STDIN_BASEADDRESS);
      if(choice != 'y')
         return ABORT;
      
      print("\r\nPlease Verify the Control Byte you are Writing\r\n");
      print("      0: Protection Control Byte Page 0\r\n");      
      print("      1: Protection Control Byte Page 1\r\n");      
      print("      2: Protection Control Byte Page 2\r\n");      
      print("      3: Protection Control Byte Page 3\r\n");      
      print("      4: Copy Protection Byte\r\n");      
      print("      5: User Byte #1\r\n");      
      print("      6: User Byte #2\r\n");
      choice = XUartLite_RecvByte(STDIN_BASEADDRESS);   
      if((choice - 48) != ByteSelect)
         return ABORT;
         
      print("\r\nPlease Verify the value you are writing is %x.  (k)\r\n", value2store);
      choice = XUartLite_RecvByte(STDIN_BASEADDRESS);
      if(choice != 'k')
         return ABORT;
      
      print("\r\nSETTING THE PROTECTION REGISTERS TO 'WRITE PROTECT' OR 'EPROM MODE' IS\r\n");
      print("\r\n                    ***IRREVERSIBLE***\r\n");
      print("\r\nDo you wish to continue? (y)\r\n");
      choice = XUartLite_RecvByte(STDIN_BASEADDRESS);
      if(choice != 'y')
         return ABORT;
   }
   
   // Obtain Current Control Register Values
   Xuint8 control_regs[8], mem_address;
   WarpEEPROM_ReadControlBytes(baseaddr, control_regs); 
   mem_address = 0x80;
   switch(ByteSelect)
   {   
      case(0)  : 
      {
         control_regs[0] = value2store; break;
      }
      case(1)  : 
      {
         control_regs[1] = value2store; break;
      
      }
      case(2)  : 
      {
         control_regs[2] = value2store; break;
      
      }
      case(3)  : 
      {
         control_regs[3] = value2store; break;
      
      }
      case(4)  : 
      {
         control_regs[4] = value2store; break;
      
      }
      case(5)  : 
      {
         control_regs[6] = value2store; break;
      
      }
      case(6)  : 
      {
         control_regs[7] = value2store; break;
      
      }
      default : return; break;
   } 

      ////////////////////////////////////////////////////////////////////////////////////
      // Write Scratchpad
      Xuint8 CRC_n, check, verify[14];
      WarpEEPROM_Initialize(baseaddr);
      WarpEEPROM_WriteByte(baseaddr, 0xCC);     
      
      WarpEEPROM_WriteByte(baseaddr, 0x0F);             verify[0] = 0x0F;
      
      WarpEEPROM_WriteByte(baseaddr, mem_address);      verify[1] = mem_address;
      WarpEEPROM_WriteByte(baseaddr, 0x0);              verify[2] = 0x0;
      
      WarpEEPROM_WriteByte(baseaddr, control_regs[0]);  verify[3] = control_regs[0];
      WarpEEPROM_WriteByte(baseaddr, control_regs[1]);  verify[4] = control_regs[1];
      WarpEEPROM_WriteByte(baseaddr, control_regs[2]);  verify[5] = control_regs[2];
      WarpEEPROM_WriteByte(baseaddr, control_regs[3]);  verify[6] = control_regs[3];
      WarpEEPROM_WriteByte(baseaddr, control_regs[4]);  verify[7] = control_regs[4];
      WarpEEPROM_WriteByte(baseaddr, control_regs[5]);  verify[8] = control_regs[5];
      WarpEEPROM_WriteByte(baseaddr, control_regs[6]);  verify[9] = control_regs[6];
      WarpEEPROM_WriteByte(baseaddr, control_regs[7]); verify[10] = control_regs[7];
      
      CRC_n = WarpEEPROM_ReadByte(baseaddr); 
      verify[11] = ~CRC_n;
      CRC_n = WarpEEPROM_ReadByte(baseaddr); 
      verify[12] = ~CRC_n;
      
      check = WarpEEPROM_VerifyScratchpad(verify, 0);
      if(check != 0)
         return FAILURE;   
      
      ////////////////////////////////////////////////////////////////////////////////////
      // Read Scratchpad
      WarpEEPROM_Initialize(baseaddr);
      WarpEEPROM_WriteByte(baseaddr, 0xCC);     
      
      WarpEEPROM_WriteByte(baseaddr, 0xAA); verify[0] = 0xAA;
      
       verify[1] = WarpEEPROM_ReadByte(baseaddr);
       verify[2] = WarpEEPROM_ReadByte(baseaddr);
       verify[3] = WarpEEPROM_ReadByte(baseaddr); 
       
       verify[4] = WarpEEPROM_ReadByte(baseaddr);
       verify[5] = WarpEEPROM_ReadByte(baseaddr);
       verify[6] = WarpEEPROM_ReadByte(baseaddr);
       verify[7] = WarpEEPROM_ReadByte(baseaddr);
       verify[8] = WarpEEPROM_ReadByte(baseaddr);
       verify[9] = WarpEEPROM_ReadByte(baseaddr);
      verify[10] = WarpEEPROM_ReadByte(baseaddr);
      verify[11] = WarpEEPROM_ReadByte(baseaddr);
      
      CRC_n = WarpEEPROM_ReadByte(baseaddr); verify[12] = ~CRC_n;
      CRC_n = WarpEEPROM_ReadByte(baseaddr); verify[13] = ~CRC_n;
      
      check = WarpEEPROM_VerifyScratchpad(verify, 1);
      if(check != 0)
         return FAILURE;
      
      ////////////////////////////////////////////////////////////////////////////////////
      // Copy Scratchpad
      WarpEEPROM_Initialize(baseaddr);
      WarpEEPROM_WriteByte(baseaddr, 0xCC);     
      
      WarpEEPROM_WriteByte(baseaddr, 0x55);
      WarpEEPROM_WriteByte(baseaddr, verify[1]);
      WarpEEPROM_WriteByte(baseaddr, verify[2]);
      WarpEEPROM_WriteByte(baseaddr, verify[3]);
      usleep(12500);
      
      check = WarpEEPROM_ReadByte(baseaddr);
      if(check == 0xAA)
      {
         return SUCCESS;
      }
      else 
         return FAILURE;
}
Example #14
0
int main(void) {

    u8  c;

    while(1) {

    	c=XUartLite_RecvByte(uartReadReg);

    	switch(c) {

    		//-------------------------------------------------
    		// Reply with the help menu
    		//-------------------------------------------------
    		case '?':
    			xil_printf("--------------------------\r\n");
    			xil_printf("	count Q = %x\r\n",Xil_In16(countQReg));
    			xil_printf("--------------------------\r\n");
    			xil_printf("?: help menu\r\n");
    			xil_printf("o: k\r\n");
    			xil_printf("c: COUNTER	count up LEDs (by 9)\r\n");
    			xil_printf("l: COUNTER	load counter\r\n");
    			xil_printf("r: COUNTER	reset counter\r\n");
    			xil_printf("f: flush terminal\r\n");
    			break;

    		//-------------------------------------------------
    		// Basic I/O loopback
    		//-------------------------------------------------
    		case 'o':
    			xil_printf("k \r\n");
    			break;

    		//-------------------------------------------------
    		// Tell the counter to count up
    		//-------------------------------------------------
    		case 'c':
    			Xil_Out8(countCtrlReg,count_COUNT);
    			Xil_Out8(countCtrlReg,count_HOLD);
    			break;

        	//-------------------------------------------------
        	// Tell the counter to load a value
        	//-------------------------------------------------
        	case 'l':
        		xil_printf("Enter a 0-9 value to store in the counter: ");
            	c=XUartLite_RecvByte(uartReadReg) - 0x30;
        		Xil_Out8(countQReg,c);					// put value into slv_reg1
        		Xil_Out8(countCtrlReg,count_LOAD);				// load command
    			xil_printf("%c\r\n",c+0x30);
        		break;

            //-------------------------------------------------
            // Reset the counter
            //-------------------------------------------------
            case 'r':
            	Xil_Out8(countCtrlReg,count_RESET);				// reset command
            	break;

            //-------------------------------------------------
            // Clear the terminal window
            //-------------------------------------------------
            case 'f':
            	for (c=0; c<40; c++) xil_printf("\r\n");
               	break;

          //-------------------------------------------------
          // Unknown character was
          //-------------------------------------------------
    		default:
    			xil_printf("unrecognized character: %c\r\n",c);
    			break;
    	} // end case
    } // end while 1
    return 0;
} // end main
Example #15
0
int main(void)
{
 while (1)
 {
	 unsigned char c, d, e;
	 c = 0x00;
	 d = 0x00;
	 e = 0x00;

	 while(c == 0x00){
		 c = XUartLite_RecvByte(0x84000000); //receive letter
	 }
	 XUartLite_SendByte(0x84000000, c);

	 while(d == 0x00){
		 d = XUartLite_RecvByte(0x84000000); //receive letter
	 }
	 XUartLite_SendByte(0x84000000, d);

	 while(e == 0x00){
		 e = XUartLite_RecvByte(0x84000000); //receive letter
	 }
	 XUartLite_SendByte(0x84000000, e);
	 XUartLite_SendByte(0x84000000, 0x20);	 //send space char

	 //led command
	 if((c == 0x6C) && (d == 0x65) && (e == 0x64)){
		 c = 0x00;
		 d = 0x00;
		 e = 0x00;

		 while(c == 0x00){
		 	 c = XUartLite_RecvByte(0x84000000) - 0x30; //receive letter
		 	 d = c - 0x27;
		 	 if((c >= 0x0) && (c <= 0x9)){
		 		 e = c;
		 	 }
		 	 else if((d >= 0xA) && (d <= 0xF)){
		 		 e = d;
		 	 }
		 	 else{
		 		 e = 0x0;
		 	 }
		 }
		 XUartLite_SendByte(0x84000000, c + 0x30);
		 e = e << 4;

		 c = 0x00;
		 d = 0x00;

		 while(c == 0x00){
			 c = XUartLite_RecvByte(0x84000000) - 0x30; //receive letter
			 d = c - 0x27;
			 if((c >= 0x0) && (c <= 0x9)){
				 e += c;
			 }
			 else if((d >= 0xA) && (d <= 0xF)){
				 e += d;
			 }
			 else{
				 e = e;
			 }
		 }
		 XUartLite_SendByte(0x84000000, c + 0x30);
		 Xil_Out8(0x83000000, e);

	 }

	 //switch command
	 if((c == 0x73) && (d == 0x77) && (e == 0x74)){
		 c = 0x00;
		 d = 0x00;
		 e = 0x00;

		 c = Xil_In8(0x83000004) & 0xF;
		 d = Xil_In8(0x83000004) & 0xF0;

		 d = d >> 4;

		 if(c <= 0x9){
			 c = c + 0x30;
		 }
		 else{
			 c = c + 0x57;
		 }

		 if(d <= 0x9){
			 d = d + 0x30;
		 }
		 else{
			 d = d + 0x57;
		 }

		 XUartLite_SendByte(0x84000000, d);
		 XUartLite_SendByte(0x84000000, c);

	 }

	 XUartLite_SendByte(0x84000000, 0xA);	 //send new line char
	 XUartLite_SendByte(0x84000000, 0xD);	 //send return char

 }
Example #16
0
int main(){
w3_node_init();

// Write some code here that gives a user instructions for controlling your transceiver.
// --- Enable/disable transmitter
// --- Enable/disable receiver
// --- Enable/disable/reset CFO Correction
// --- Enable/disable/reset timing correction
// --- Select output of DAC (to view signals at various stages in your design)
// --- Modify all filter coefficients (both for CFO and timing synchronization) for tuning


//Set up the UART
XUartLite_Initialize(&UartLite, XPAR_UARTLITE_0_DEVICE_ID);

//Set up the Radio - For details about these calls, see http://warp.rice.edu/svn/WARP/PlatformSupport/CustomPeripherals/pcores/radio_controller_v3_00_b/doc/html/api/index.html

// Configure TX enable, RX enable, and Rx HP filter for software control
radio_controller_setCtrlSource(RC_BASEADDR, RC_RFA, (RC_REG0_TXEN_CTRLSRC|RC_REG0_RXEN_CTRLSRC|RC_REG0_RXHP_CTRLSRC), RC_CTRLSRC_REG);

// Configure TX  low-pass filter response to have a corner frequency of 18 MHz:
radio_controller_setRadioParam(RC_BASEADDR, RC_RFA, RC_PARAMID_TXLPF_BW, 0x01);

//Enable software Tx Gain control:
radio_controller_setRadioParam(RC_BASEADDR, RC_RFA,RC_PARAMID_TXGAINS_SPI_CTRL_EN, 0x01);

//Enable software Rx Gain control:
radio_controller_setRadioParam(RC_BASEADDR, RC_RFA,RC_PARAMID_RXGAINS_SPI_CTRL_EN, 0x01);

//Initialize the baseband Tx gain to its max value (0 dB)
radio_controller_setRadioParam(RC_BASEADDR, RC_RFA,RC_PARAMID_TXGAIN_BB, 0x00);

//Initialize the RF Tx gain
radio_controller_setRadioParam(RC_BASEADDR, RC_RFA, RC_PARAMID_TXGAIN_RF, TxGain);

// Configure receive HPF cutoff of 30kHz (DC block)
radio_controller_setRadioParam(RC_BASEADDR, RC_RFA, RC_PARAMID_RXHPF_HIGH_CUTOFF_EN, 0x01);

//14MHz Low Pass Filter on RX (our max freq is 10MHz + 2.25MHz)
// 0: 7.5MHz<br>1: 9.5MHz<br>2: 14MHz<br>3: 18MHz
radio_controller_setRadioParam(RC_BASEADDR, RC_RFA, RC_PARAMID_RXLPF_BW, 0x03);

//Initialize the Rx RF Gain (1:0dB, 2:15dB , 3:30dB )
radio_controller_setRadioParam(RC_BASEADDR, RC_RFA,RC_PARAMID_RXGAIN_RF, RxCoarseGain);

//Initialize the Rx baseband Gain
radio_controller_setRadioParam(RC_BASEADDR, RC_RFA, RC_PARAMID_RXGAIN_BB, RxFineGain);

// Enable the receiver by default

// Set center frequency (i.e. choose the WiFi channel)
radio_controller_setCenterFrequency(RC_BASEADDR , RC_RFA, RC_24GHZ, wifiChannel);


//DECLERATION OF VARIABLES
int x = 0;											//Variable used for reading UART
Xuint32 dataIn;										//Variable used to temporarily store data read from memory using the XIO_In32() function
Xuint32 dataOut;									//Variable used to temporarily store data to write to memory using the XIO_Out32() function

XIo_Out32(Delay,43);								//Write the desired value for the PA delay

radio_controller_RxEnable(RC_BASEADDR, RC_RFB);		//Turn on Receiver RFB
radio_controller_TxEnable(RC_BASEADDR, RC_RFA);		//Turn on Transmitter RFA


dataIn = XIo_In32(Delay);							//Read in first delay for sanity check
xil_printf("first delay: %d  \n \r", dataIn);		//Print to terminal for user to look at

XIo_Out32(Controls,0x80000000);						//Turn On LTE signal

while(1){
	x = XUartLite_RecvByte(STDIN_BASEADDRESS);	//Input from UART
	
	////TURN TRAINING ON////
	if(x=='t'){									
		XIo_Out32(Controls,0x04000000); 		//Turn Off Signal, DPD, learning, and reset
		XIo_Out32(Controls,0xF0000000);			//Turn On LTE, DPD, and Training
		xil_printf("Training Activated \n \r");
	}
	
	////COMMANDS TO LOOK AT AND CHANGE DELAY////
	if(x=='d'){									//Read current delay
		dataIn = XIo_In32(Delay);
		xil_printf("Current Delay: %d  \n \r", dataIn);
		}
	if(x=='e'){															//Increase delay
		radio_controller_TxRxDisable(RC_BASEADDR, RC_RFA|RC_RFB);		//Turn off TX and RX RFB
		XIo_Out32(Controls,0x04000000);									//Turn Off LTE, DPD, Training, and Reset
		dataIn = XIo_In32(Delay);										//Read current delay
		dataOut = dataIn + 1;											//step by 1
		XIo_Out32(Delay,dataOut);										//Write to delay
		dataIn = XIo_In32(Delay);										//Read current delay
		xil_printf("New Delay: %d  \n \r", dataIn);
		radio_controller_RxEnable(RC_BASEADDR, RC_RFB);					//Turn on Receiver RFB
		radio_controller_TxEnable(RC_BASEADDR, RC_RFA);					//Turn on Transmitter RFA
		XIo_Out32(Controls,0xF0000000);									//Turn On LTE, DPD, and Training
		}
	if(x=='c'){															//Decrease delay
		radio_controller_TxRxDisable(RC_BASEADDR, RC_RFA|RC_RFB);		//Turn off TX and RX RFB
		XIo_Out32(Controls,0x04000000);									//Turn Off LTE, DPD, Training, and Reset
		dataIn = XIo_In32(Delay);										//Read current delay
		dataOut = dataIn - 1;											//step by 1
		XIo_Out32(Delay,dataOut);										//Write to delay
		dataIn = XIo_In32(Delay);										//Read current delay
		xil_printf("New Delay: %d  \n \r", dataIn);
		radio_controller_RxEnable(RC_BASEADDR, RC_RFB);					//Turn on Receiver RFB
		radio_controller_TxEnable(RC_BASEADDR, RC_RFA);					//Turn on Transmitter RFA
		XIo_Out32(Controls,0xF0000000);									//Turn On LTE, DPD, and Training
		}

	////REPORT ALL ALPHAS FROM TRAINING////
	if(x=='l'){
		int i = 0;
		for(i = 0;i<Alpha_depth;i=i+4 ){
			dataIn = XIo_In32(Alpha_memory+i);				//Read alpha
			xil_printf("%08x, address: %08x  \n \r", dataIn, Alpha_memory+i);
			}
		}

	////COMMANDS FOR CHANGING ALPHA MANUALLY///
	if(x=='a'){								//Switch to Manual Alpha
		XIo_Out32(Controls,0x04000000); 	//Turn Off Signal, DPD, learning, and reset
		XIo_Out32(Controls,0xC8000000);		//Turn On LTE, DPD, and manual alpha
		dataIn = XIo_In32(Alpha_user);		//Read current user defined alpha
		xil_printf("Current Alpha: %08x  \n \r", dataIn);
	}
	if(x=='q'){								//Increase Manual Alpha Real
		dataIn = XIo_In32(Alpha_user);		//Read current user defined alpha
		dataOut = dataIn + 0x01000000;		//step by 2^-6 = 0.015625
		XIo_Out32(Alpha_user,dataOut);		//Write to user defined alpha
		dataIn = XIo_In32(Alpha_user);		//Read current user defined alpha
		xil_printf("New Alpha: %08x  \n \r", dataIn);
	}
	if(x=='z'){								//Decrease Manual Alpha Real
		dataIn = XIo_In32(Alpha_user);		//Read current user defined alpha
		dataOut = dataIn - 0x01000000;		//step by -2^-6 = -0.015625
		XIo_Out32(Alpha_user,dataOut);		//Write to user defined alpha
		dataIn = XIo_In32(Alpha_user);		//Read current user defined alpha
		xil_printf("New Alpha: %08x  \n \r", dataIn);
	}
	if(x=='w'){								//Increase Manual Alpha Imag
		dataIn = XIo_In32(Alpha_user);		//Read current user defined alpha
		dataOut = dataIn + 0x00000100;		//step by 2^-6 = 0.015625
		XIo_Out32(Alpha_user,dataOut);		//Write to user defined alpha
		dataIn = XIo_In32(Alpha_user);		//Read current user defined alpha
		xil_printf("New Alpha: %08x  \n \r", dataIn);
	}
	if(x=='x'){								//Decrease Manual Alpha Imag
		dataIn = XIo_In32(Alpha_user);		//Read current user defined alpha
		dataOut = dataIn - 0x00000100;		//step by -2^-6 = -0.015625
		XIo_Out32(Alpha_user,dataOut);		//Write to user defined alpha
		dataIn = XIo_In32(Alpha_user);		//Read current user defined alpha
		xil_printf("New Alpha: %08x  \n \r", dataIn);
	}
}
}