void SPIEEPROM_WriteInt(uint32_t addr, uint32_t *ival)
{
  SPIEEPROM_Write(addr,sizeof(uint32_t),(uint8_t*) ival);
}

uint32_t SPIEEPROM_ReadInt(uint32_t addr)
{
    uint32_t value;
    SPIEEPROM_Read(addr, sizeof(uint32_t), (uint8_t*)&value);
    return value;
}

void SPIEEPROM_WriteFloat(uint32_t addr, float *fval)  
{
  SPIEEPROM_Write(addr,sizeof(float),(uint8_t*) fval);
}

float SPIEEPROM_ReadFloat(uint32_t addr)
{
    float value;
    SPIEEPROM_Read(addr, sizeof(float), (uint8_t*)&value);
    return value;
}

uint32_t adr;
if(argument1 == NULL)
  UART_SendString(UART0,msg_misarg);
else
{
  adr = atoi(argument1);
  if(argument2 == NULL) //read operation
  {
      #ifdef SPI_INT
      uint32_t ival = SPIEEPROM_ReadInt(adr);
      UART_SendInt(UART0,ival);
      #endif
      #ifdef SPI_FLOAT
       float fval = SPIEEPROM_ReadFloat(adr);
        UART_SendFloat(UART0,fval,2);
      #endif
    }
    else  //write operation
    {                    
        #ifdef SPI_INT
         uint32_t ival = atoi(argument2);
        SPIEEPROM_WriteInt(adr, &ival);
         #endif
         #ifdef SPI_FLOAT
          float fval = atof(argument2);
          SPIEEPROM_WriteFloat(adr, &fval);
          #endif
                    
     }
}

void SPIEEPROM_Write(uint32_t address, uint32_t lenght, uint8_t *buffer)
{
    // Note!!!Every write operation demands a write enable!!!
    SPI2_CSlow();
    SPI_SendByte(USART2,SPIEEPROM_CMD_WREN);
    SPI2_CShigh();

    // start write
    SPI2_CSlow();
    // send write command
    SPI_SendByte(USART2,SPIEEPROM_CMD_WRITE);
    // send address
    SPI_SendByte(USART2,address>>8);
    SPI_SendByte(USART2,address&0x00FF);
    while(lenght--)
    {
      // send data to be written
      SPI_SendByte(USART2,*buffer++);
    }
    // stop write
    SPI2_CShigh();
}

void SPIEEPROM_Read(uint32_t address, uint32_t lenght, uint8_t *buffer)
{
    if(lenght>PAGE_SIZE)
        return;
    uint32_t data;
    // start read
    SPI2_CSlow();
    // send command
    SPI_SendByte(USART2,SPIEEPROM_CMD_READ);
    // send address
    SPI_SendByte(USART2,address>>8);
    SPI_SendByte(USART2,address&0x00FF);
    // read contents of memory address
    while(lenght--)
    {
        data = SPI_TransferByte(USART2,0x00);
        *buffer++ = data;
    }
    // stop read
    SPI2_CShigh();
}

//-------------------------------------------
unsigned char SPIWriteChar(unsigned char cmd)
{
unsigned char i;
unsigned char recv;
recv = 0;

for(i=0; i<8; i++)
{
if((cmd&0x80) != 0)
{
SPI_PORT_SET = MOSI;
}
else
{
SPI_PORT_CLR = MOSI;
}

SPI_PORT_SET = SCK;

recv<<=1;
if((SPI_PIN & MISO) != 0)
{
recv|=0x01;
}

SPI_PORT_CLR = SCK;

cmd<<=1;
}
return recv;
}
//-------------------------------------------

    else  //write operation
    {                    
        #ifdef SPI_INT
         uint32_t ival = atoi(argument2);
      UART_SendInt(UART0,ival);   // <------------------
        SPIEEPROM_WriteInt(adr, &ival);

void SPI_SendByte(USART_TypeDef  *usart,uint8_t sendbyte)
{
    /* Check that transmit buffer is empty */
    while (!(usart->STATUS & USART_STATUS_TXBL));

    usart->TXDATA = (uint32_t)sendbyte;

    /* Wait for transmitting to finished */
  while (!(usart->STATUS & USART_STATUS_TXC));
}


uint32_t SPI_TransferByte(USART_TypeDef *usart,uint32_t sendbyte)
{
   /* Check that transmit buffer is empty */
  while (!(usart->STATUS & USART_STATUS_TXBL));

  usart->TXDATA = (uint32_t)sendbyte;

  /* Wait for transmitting to finished */
  while (!(usart->STATUS & USART_STATUS_TXC));

  //return data;
    return majority32const(&usart->RXDATA);

}