void
SpiDeviceTest::testMultipleTransmissions()
{
test::Transmission transmissions[] = {
test::Transmission(4, RX_DATA(1,2,3,4), TX_DATA(4,3,2,1)),
test::Transmission(2, RX_DATA(5, 6), TX_DATA(100, 101)),
};
test::SpiDevice device;
device.start(transmissions, ARRAY_SIZE(transmissions), __LINE__, false);
TEST_ASSERT_FALSE(device.isSuccessful());
device.select();
TEST_ASSERT_EQUALS(device.write(1), 4);
TEST_ASSERT_EQUALS(device.write(2), 3);
TEST_ASSERT_EQUALS(device.write(3), 2);
TEST_ASSERT_EQUALS(device.write(4), 1);
device.deselect();
device.select();
TEST_ASSERT_EQUALS(device.write(5), 100);
TEST_ASSERT_EQUALS(device.write(6), 101);
device.deselect();
TEST_ASSERT_TRUE(device.isSuccessful());
}
// ----------------------------------------------------------------------------
void
Ad7280aTest::testSoftwareReset()
{
test::Transmission transmissionsInitialize[] = {
test::Transmission(4, RX_DATA(0x01,0xD2,0xB4,0x12), TX_DATA(0x00,0x00,0x00,0x00)),
test::Transmission(4, RX_DATA(0x01,0xC2,0xB6,0xE2), TX_DATA(0x00,0x00,0x00,0x00)),
};
device.start(transmissionsInitialize, ARRAY_SIZE(transmissionsInitialize), __LINE__);
Ad7280a::softwareReset();
device.finish();
}
// ----------------------------------------------------------------------------
void
Ad7280aTest::testAllChannelRead()
{
test::Transmission transmissionsInitialize[] = {
test::Transmission(4, RX_DATA(0x03,0x80,0x11,0xCA), TX_DATA(0x00,0x00,0x00,0x00)),
test::Transmission(4, RX_DATA(0x01,0xB5,0x14,0xEA), TX_DATA(0x00,0x00,0x00,0x00)),
test::Transmission(4, RX_DATA(0xF8,0x00,0x03,0x0A), TX_DATA(0x00,0x03,0x27,0x24)),
test::Transmission(4, RX_DATA(0xF8,0x00,0x03,0x0A), TX_DATA(0x00,0x86,0x47,0x34)),
test::Transmission(4, RX_DATA(0xF8,0x00,0x03,0x0A), TX_DATA(0x01,0x09,0x67,0x84)),
test::Transmission(4, RX_DATA(0xF8,0x00,0x03,0x0A), TX_DATA(0x01,0x8C,0x87,0x14)),
test::Transmission(4, RX_DATA(0xF8,0x00,0x03,0x0A), TX_DATA(0x02,0x0F,0xA5,0xEC)),
test::Transmission(4, RX_DATA(0xF8,0x00,0x03,0x0A), TX_DATA(0x02,0x92,0xC6,0x74)),
};
device.start(transmissionsInitialize, ARRAY_SIZE(transmissionsInitialize), __LINE__);
uint16_t values[6];
TEST_ASSERT_TRUE(Ad7280a::readAllChannels(values));
TEST_ASSERT_EQUALS(values[0], 100);
TEST_ASSERT_EQUALS(values[1], 200);
TEST_ASSERT_EQUALS(values[2], 300);
TEST_ASSERT_EQUALS(values[3], 400);
TEST_ASSERT_EQUALS(values[4], 500);
TEST_ASSERT_EQUALS(values[5], 600);
device.finish();
}
int serial_getchar(void)
{
unsigned int Status;
unsigned int Ch;
Ch=0;
//Ch = lib_support_getchar();
if (Ch == 0)
{
#if defined(SEMIHOSTED)
// Use the debugger if the ports are the same
if (HOST_COMPORT == OS_COMPORT)
Ch = (int)SWI_READC();
else
#endif
{
do
{
Status = GET_STATUS(OS_COMPORT);
}
while (!RX_DATA(Status)); // wait until ready
Ch = GET_CHAR(OS_COMPORT);
}
}
return ((int)Ch);
}
static int cyg_hal_plf_serial_isr(void *__ch_data, int* __ctrlc, CYG_ADDRWORD __vector, CYG_ADDRWORD __data)
{
int res = 0;
channel_data_t* chan = (channel_data_t*)__ch_data;
volatile cyg_uint32* pulBase = chan->pulBase;
char c;
cyg_uint32 status;
CYGARC_HAL_SAVE_GP();
cyg_drv_interrupt_acknowledge(chan->isr_vector);
*__ctrlc = 0;
status = pulBase[REL_Adr_uartfr / sizeof(cyg_uint32)];
if(RX_DATA(status))
{
c = (cyg_uint8)(pulBase[REL_Adr_uartdr / sizeof(cyg_uint32)] & 0xFF);
if( cyg_hal_is_break( &c , 1 ) )
*__ctrlc = 1;
res = CYG_ISR_HANDLED;
}
CYGARC_HAL_RESTORE_GP();
return res;
}
// ----------------------------------------------------------------------------
void
Ad7280aTest::testChainSetup()
{
test::Transmission transmissionsInitialize[] = {
test::Transmission(4, RX_DATA(0x01,0xD2,0xB4,0x12), TX_DATA(0x00,0x00,0x00,0x00)),
test::Transmission(4, RX_DATA(0x01,0xC2,0xB6,0xE2), TX_DATA(0x00,0x00,0x00,0x00)),
test::Transmission(4, RX_DATA(0x03,0x87,0x16,0xCA), TX_DATA(0x00,0x00,0x00,0x00)),
test::Transmission(4, RX_DATA(0xF8,0x00,0x03,0x0A), TX_DATA(0x11,0xC2,0x65,0xDC)),
};
device.start(transmissionsInitialize, ARRAY_SIZE(transmissionsInitialize), __LINE__);
TEST_ASSERT_TRUE(Ad7280a::chainSetup());
device.finish();
}
static int
cyg_hal_plf_serial_isr(void *__ch_data, int* __ctrlc,
CYG_ADDRWORD __vector, CYG_ADDRWORD __data)
{
int res = 0;
channel_data_t* chan = (channel_data_t*)__ch_data;
char c;
cyg_uint32 status;
CYGARC_HAL_SAVE_GP();
cyg_drv_interrupt_acknowledge(chan->isr_vector);
*__ctrlc = 0;
status = GET_STATUS(chan->base);
if ( RX_DATA(status) ) {
c = GET_CHAR(chan->base);
if( cyg_hal_is_break( &c , 1 ) )
*__ctrlc = 1;
res = CYG_ISR_HANDLED;
}
CYGARC_HAL_RESTORE_GP();
return res;
}
// ----------------------------------------------------------------------------
void
Ad7280aTest::testSelftest()
{
test::Transmission transmissionsInitialize[] = {
test::Transmission(4, RX_DATA(0x01,0xC2,0xB6,0xE2), TX_DATA(0x00,0x00,0x00,0x00)),
test::Transmission(4, RX_DATA(0x01,0xB9,0x11,0x92), TX_DATA(0x00,0x00,0x00,0x00)),
test::Transmission(4, RX_DATA(0x03,0x86,0x17,0xCA), TX_DATA(0x00,0x00,0x00,0x00)),
// Read the self-test conversion result (value = 980)
test::Transmission(4, RX_DATA(0xF8,0x00,0x03,0x0A), TX_DATA(0x00,0x1E,0xA5,0x90)),
};
device.start(transmissionsInitialize, ARRAY_SIZE(transmissionsInitialize), __LINE__);
TEST_ASSERT_TRUE(Ad7280a::performSelftest());
device.finish();
}
// ----------------------------------------------------------------------------
void
Ad7280aTest::testChannelRead()
{
test::Transmission transmissionsInitialize[] = {
test::Transmission(4, RX_DATA(0x01,0xA6,0x15,0x1A), TX_DATA(0x00,0x00,0x00,0x00)),
test::Transmission(4, RX_DATA(0x01,0xA1,0x02,0x0A), TX_DATA(0x00,0x00,0x00,0x00)),
test::Transmission(4, RX_DATA(0x03,0x80,0x61,0xBA), TX_DATA(0x00,0x00,0x00,0x00)),
test::Transmission(4, RX_DATA(0xF8,0x00,0x03,0x0A), TX_DATA(0x01,0x91,0x2D,0x88)),
};
device.start(transmissionsInitialize, ARRAY_SIZE(transmissionsInitialize), __LINE__);
uint16_t value;
TEST_ASSERT_TRUE(Ad7280a::readChannel(0, xpcc::ad7280a::CELL_VOLTAGE_4, &value));
TEST_ASSERT_EQUALS(value, 549);
device.finish();
}
// ----------------------------------------------------------------------------
void
Ad7280aTest::testBalancer()
{
test::Transmission transmissionsInitialize[] = {
test::Transmission(4, RX_DATA(0x02,0x81,0x83,0xC2), TX_DATA(0x00,0x00,0x00,0x00)),
};
device.start(transmissionsInitialize, ARRAY_SIZE(transmissionsInitialize), __LINE__);
Ad7280a::enableBalancer(0, xpcc::ad7280a::CB1 | xpcc::ad7280a::CB2);
device.finish();
}
static cyg_bool
cyg_hal_plf_serial_getc_nonblock(void* __ch_data, cyg_uint8* ch)
{
cyg_uint8* base = ((channel_data_t*)__ch_data)->base;
cyg_uint32 status ;
long timeout = 100; // A long time...
do {
status = GET_STATUS(base);
if (--timeout == 0) return false ;
} while (!RX_DATA(status)); // wait until ready
*ch = GET_CHAR(base);
return true;
}
static cyg_bool cyg_hal_plf_serial_getc_nonblock(void* __ch_data, cyg_uint8* ch)
{
volatile cyg_uint32* pulBase = ((channel_data_t*)__ch_data)->pulBase;
cyg_uint32 status ;
long timeout = 100; // A long time...
do
{
status = pulBase[REL_Adr_uartfr / sizeof(cyg_uint32)];
if (--timeout == 0)
return false ;
} while (!RX_DATA(status)); // wait until ready
*ch = (cyg_uint8)(pulBase[REL_Adr_uartdr / sizeof(cyg_uint32)] & 0xFF);
return true;
}
int serial_kbhit(void)
{
unsigned int Status;
#if defined(SEMIHOSTED)
// If the ports are the same, have to use the debugger and we
// can't tell if there is a character available
if (HOST_COMPORT == OS_COMPORT)
{
return (1);
}
#endif
//lib_flush_buffer();
Status = GET_STATUS(0xFFF80000);
if (!RX_DATA(Status))
return (0);
else
return (1);
}
void
SpiDeviceTest::testSingleTransmission()
{
test::Transmission transmissions[] = {
test::Transmission(4, RX_DATA(1,2,3,4), TX_DATA(4,3,2,1)),
};
test::SpiDevice device;
device.start(transmissions, ARRAY_SIZE(transmissions), __LINE__, false);
TEST_ASSERT_FALSE(device.isSuccessful());
device.select();
TEST_ASSERT_EQUALS(device.write(1), 4);
TEST_ASSERT_EQUALS(device.write(2), 3);
TEST_ASSERT_EQUALS(device.write(3), 2);
TEST_ASSERT_EQUALS(device.write(4), 1);
device.deselect();
TEST_ASSERT_TRUE(device.isSuccessful());
device.select();
device.deselect();
TEST_ASSERT_FALSE(device.isSuccessful());
// Restart transmission
device.start(transmissions, ARRAY_SIZE(transmissions), __LINE__, false);
device.select();
TEST_ASSERT_EQUALS(device.write(1), 4);
TEST_ASSERT_EQUALS(device.write(2), 3);
TEST_ASSERT_EQUALS(device.write(3), 2);
TEST_ASSERT_EQUALS(device.write(4), 1);
TEST_ASSERT_EQUALS(device.write(5), 0xff); // one byte to much
device.deselect();
TEST_ASSERT_FALSE(device.isSuccessful());
}
