void main()
{
//enum data_source ABC;
//ABC=PRBS7;
tChar temp;
lcd_init();
display("Initializing...");
enable_spi(0);
dac_set(0);
chip_init_CCFFE();
pll_init();
clearscr();
enable_serial();
display("Set Jumpers and ping");
temp = receive_serial();
clearscr();
display("Offset trim DUT1");
sel_source(OFFSET_CAL);
msDelay(1);
LF_SELECT = 0;
CHIP_RESET = 0;
// LF_SELECT=1;
while(1);
// {
// LF_SELECT=1;
// msDelay(10000);
// LF_SELECT=0;
// msDelay(10000);
// }
}
spi_context_p spi_init()
{
spi_context_p spi = (spi_context_p)malloc(sizeof(spi_context));
memset(spi, 0, sizeof(spi_context));
// only one spi bus exist in edison
char buffer[MAX_PATH_SIZE] = {0};
snprintf( buffer, MAX_PATH_SIZE, SPI_DEV_PATH "%u.%u", EDISON_DEFAULT_SPI_DEV, EDISON_DEFAULT_SPI_CS );
if ( (spi->fd=open( buffer, O_RDWR)) < 0 )
{
free(spi);
return 0;
}
pBus spi_bus = (pBus)malloc(sizeof(bus));
memset(spi_bus, 0, sizeof(bus));
if ( spi_bus == 0 )
{
free(spi);
return 0;
}
spi->spi_bus = spi_bus;
if ( spi51_bus_init(spi) != FUNC_RESULT_SUCCESS )
{
free_spi51_bus(spi_bus);
close(spi->fd);
free(spi);
return 0;
}
if ( enable_spi(spi) != FUNC_RESULT_SUCCESS )
{
free_spi51_bus(spi->spi_bus);
close(spi->fd);
free(spi);
return 0;
}
return spi;
}
void main()
{
int i=10,j,k,N=24;
tInt bias,scale;
tLong frequency;
tChar temp;
// __bit test_resultA;
FLG_CPL=0;
lcd_init();
display("Initializing...");
enable_spi(0);
dac_set(0);
chip_init_CCFFE();
pll_init();
clearscr();
enable_serial();
display("Set Jumpers and ping");
temp = receive_serial();
clearscr();
display(" CCFFE");
line2();
display("Throughput test");
msDelay(1000);
enable_serial();
load_test_data();
clearscr();
display("Setting up test");
line2();
display("With 7 bit PRBS");
scale = 2650/N;
for(i=N;i>0;i--)
{
for(j=0;j<20;j++)
{
chip_init_CCFFE();
sel_source(RING);
bias=scale*i;
dac_set(bias);
msDelay(1000);
for(k=j;k>=0;k--)
{
tick_RX_RC_CKIN();
msDelay(1);
}
frequency = fmeasure();
clearscr();
display("f(");
display_int(i);
display(",");
display_int(j);
display(")=");
display_freq(frequency);
write_test_data_CCFFE();
LF_SELECT = 0;
msDelay(1);
LF_SELECT = 1;
read_results_CCFFE();
test_result = cross_correlation();//source_data);
if(test_result)
{
FLG_CPL=1;
send_byte(fm_byte[0]);
send_byte(fm_byte[1]);
send_byte(fm_byte[2]);
send_int(i);
send_byte(',');
send_int(j);
}
}
}
clearscr();
display("Throughput test");
line2();
if(FLG_CPL)
display("SUCCESS");
else
display("Failed");
while(1);
}
static void
statemachine(enum state_event ev)
{
static enum {
st_off,
st_power,
st_ezport_running,
st_erasing,
st_programming,
st_app_running,
} state = st_off;
static size_t program_address;
static struct timeout_ctx t;
if (state == st_off && ev == ev_button) {
state = st_power;
signal_leds(RESULT_UNKNOWN);
enable_power();
timeout_add(&t, 10, timeout, NULL);
} else if (state == st_power && ev == ev_reset) {
state = st_ezport_running;
timeout_cancel(&t);
enable_spi();
check_status();
} else if (state == st_ezport_running && ev == ev_cmd_done) {
/* Is chip bricked? */
if (ezport_status.fs && ezport_status.bedis)
goto error;
state = st_erasing;
bulk_erase();
/* Datasheet 6.4.1.2 */
timeout_add(&t, 300, timeout, NULL);
} else if (state == st_erasing && ev == ev_cmd_done) {
/* if still running, check again */
if (ezport_status.wip) {
check_status();
return;
}
timeout_cancel(&t);
program_address = 0;
state = st_programming;
goto program;
} else if (state == st_programming && ev == ev_cmd_done) {
/* if still running, check again */
if (ezport_status.wip) {
check_status();
return;
}
timeout_cancel(&t);
/* repeat if not done */
if (program_address < (size_t)&_binary_payload_bin_size) {
program:
program_address = program_sector(program_address);
/* Datasheet 6.4.1.2 */
timeout_add(&t, 200, timeout, NULL);
return;
}
state = st_app_running;
reset_target();
timeout_add(&t, 1000, timeout, NULL);
} else if (state == st_app_running && ev == ev_led) {
/**
* We reset the target here, but because there is a
* cap on the reset line, we never see that reset
* "edge" (actually an exponential slope).
*
* Instead, we wait for the LED to blink.
*/
state = st_off;
timeout_cancel(&t);
signal_leds(RESULT_SUCCESS);
disable_power();
} else {
error:
/* invalid transition */
state = st_off;
timeout_cancel(&t);
signal_leds(RESULT_FAIL);
disable_power();
}
}
