static void NetworkIPAddr( IPN IPAddr, uint32_t IfIdx, uint32_t fAdd )
{
static uint32_t fAddGroups = 0;
IPN IPTmp;
if( fAdd )
platform_write("Network Added: ");
else
platform_write("Network Removed: ");
/* Print a message */
IPTmp = ntohl( IPAddr );
platform_write("If-%d:%d.%d.%d.%d \n", IfIdx,
(uint8_t)(IPTmp>>24)&0xFF, (uint8_t)(IPTmp>>16)&0xFF,
(uint8_t)(IPTmp>>8)&0xFF, (uint8_t)IPTmp&0xFF );
/* This is a good time to join any multicast group we require */
if( fAdd && !fAddGroups )
{
fAddGroups = 1;
/* IGMPJoinHostGroup( inet_addr("224.1.2.3"), IfIdx ); */
}
return;
}
FPGA_STATUS fpga_spi_loopback(uint8_t* data,uint32_t data_len)
{
FPGA_STATUS ret;
uint8_t i,rcvd[100];
uint8_t writecmd = CMDPKT_FPGA_WRITE,readcmd=CMDPKT_FPGA_READ;
//initialise SPI
ret = fpga_spiclaim(SPI_FPGA_OPFREQ);
if (ret) {
spi_release();
return FAIL;
}
//transmit data
spi_xfer(1,&writecmd,NULL,0);
spi_xfer(data_len,data,NULL,0);
spi_release();
delay (100);
platform_write("DATA sent successfully \n");
//receive the data
ret = fpga_spiclaim(SPI_FPGA_OPFREQ);
if (ret) {
spi_release();
return FAIL;
}
spi_cmd_read(&readcmd,1,rcvd,data_len);
//verify the data
for(i=0;i<data_len;i++)
{
if(rcvd[i]=!data[i])
platform_write("error occurred for byte %d expected :%d received %d",i,data[i],rcvd[i]);
else
platform_write("DATA verification successful \n");
}
spi_release();
return SUCCESS;
}
void ADCInterrupt(UArg arg)
{
platform_write("received interrupt");
timer_flag=1;
return;
}
/*************************************************************************
* main()
* Entry point for the application.
************************************************************************/
int main()
{
/* Start the BIOS 6 Scheduler - it will kick off our main thread ledPlayTask() */
platform_write("Start BIOS 6\n");
//Timer_start(timer1);
BIOS_start();
}
int main()
{
TestResults results = {};
AllTypes message = {};
pb_istream_t istream = pb_istream_from_buffer((uint8_t*)input_data, sizeof(input_data));
results.success = pb_decode(&istream, AllTypes_fields, &message);
results.success &= (message.end == 1099);
results.has_stack_usage = true;
results.stack_usage = platform_stack_usage();
uint8_t buf[16];
pb_ostream_t ostream = pb_ostream_from_buffer(buf, sizeof(buf));
pb_encode(&ostream, TestResults_fields, &results);
platform_write(buf, ostream.bytes_written);
return 0;
}
void
platform_debug_print(size_t nbytes, const char* buf)
{
platform_write({1}, nbytes, buf);
}
/******************************************************************************
* Function: print_platform_info
******************************************************************************/
static void print_platform_info(platform_info * p_info, test_config * args)
{
uint32_t i;
PLATFORM_DEVICE_info *p_device;
PLATFORM_EMAC_EXT_info emac_info;
PRINT_VARIABLE(%s, p_info->version);
PRINT_VARIABLE(%d, p_info->cpu.core_count);
PRINT_VARIABLE(%s, p_info->cpu.name);
PRINT_VARIABLE(%d, p_info->cpu.id);
PRINT_VARIABLE(%d, p_info->cpu.revision_id);
PRINT_VARIABLE(%d, p_info->cpu.silicon_revision_major);
PRINT_VARIABLE(%d, p_info->cpu.silicon_revision_minor);
PRINT_VARIABLE(%d, p_info->cpu.megamodule_revision_major);
PRINT_VARIABLE(%d, p_info->cpu.megamodule_revision_minor);
PRINT_VARIABLE(%d, p_info->cpu.endian);
PRINT_VARIABLE(%s, p_info->board_name);
PRINT_VARIABLE(%d, p_info->frequency);
PRINT_VARIABLE(%d, p_info->board_rev);
PRINT_VARIABLE(%d, p_info->led[PLATFORM_USER_LED_CLASS].count);
PRINT_VARIABLE(%d, p_info->led[PLATFORM_SYSTEM_LED_CLASS].count);
PRINT_VARIABLE(%d, p_info->emac.port_count);
for (i = 0; i < PLATFORM_MAX_EMAC_PORT_NUM; i++)
{
platform_get_emac_info (i, &emac_info);
if (emac_info.mode == PLATFORM_EMAC_PORT_MODE_PHY)
{
platform_write("EMAC port %d connected to the PHY.\n", emac_info.port_num);
platform_write("MAC Address = %02x:%02x:%02x:%02x:%02x:%02x\n",
emac_info.mac_address[0], emac_info.mac_address[1],
emac_info.mac_address[2], emac_info.mac_address[3],
emac_info.mac_address[4], emac_info.mac_address[5]);
}
}
if(args->test_nand) {
p_device = platform_device_open(PLATFORM_DEVID_NAND512R3A2D, 0);
if (p_device) {
platform_write("\nNAND Device: \n");
PRINT_VARIABLE(%d, p_device->device_id);
PRINT_VARIABLE(%d, p_device->manufacturer_id);
PRINT_VARIABLE(%d, p_device->width);
PRINT_VARIABLE(%d, p_device->block_count);
PRINT_VARIABLE(%d, p_device->page_count);
PRINT_VARIABLE(%d, p_device->page_size);
PRINT_VARIABLE(%d, p_device->spare_size);
PRINT_VARIABLE(%d, p_device->column);
PRINT_VARIABLE(%d, p_device->handle);
PRINT_VARIABLE(%d, p_device->flags);
PRINT_VARIABLE(%d, p_device->bboffset);
if (p_device->bblist) {
platform_write("Bad Block Table (only bad block numbers shown): \n");
for (i=0; i < p_device->block_count; i++) {
if (p_device->bblist[i] == 0x00) {
platform_write("%d \n", i);
}
}
}
platform_device_close(p_device->handle);
}
else {
/******************************************************************************
* Function: print_current_core_id
******************************************************************************/
static void print_current_core_id(void)
{
platform_write("Current core id is %d\n", platform_get_coreid());
}
float acquire_data()
{
//GPIO_3-CNVST, GPIO_13-CS
//Start the ADC communication
timer_flag=0;
//Timer_start(timer1);
platform_write("stated timer \n");
data_index=0;
int cnt=0;
long int tscl_val, tsch_val;
long int tscl_val1, tsch_val1;
float elapsed_time=0;
for(;;)
{
TSCL = 0;
TSCH = 0;
tscl_val = TSCL;
//tsch_val = TSCH;
/*if(timer_flag==1)
{
platform_write("processing sample %d \n",cnt);
timer_flag=0;
break;
}*/
//Pull CNVST low
//platform_write("eeee");
gpioClearOutput(GPIO_3);
//platform_write("BBBB");
//Wait for 50ns right now without any delay (10ns minimum)
//Set CNVST high again
gpioSetOutput(GPIO_3);
//platform_write("CCCCC");
platform_delaycycles(650); //Approximately 650 ns for 500 argument and 720ns for 600 argument
//Pull CS pin low
gpioClearOutput(GPIO_13);
//platform_write("DDDDD");
//gpioSetOutput(GPIO_7);
for(i=0; i<28; i++)
{
gpioClearOutput(GPIO_7);
if(i==0 || i==14)
{
if(i==0)
data_bufferA[data_index]=0;
else if(i==14)
data_bufferB[data_index]=0;
platform_delaycycles(100);
//platform_write("AAAA");
data_bit=gpioReadInput(GPIO_10);
//platform_write("FFFFF");
}
else
platform_delaycycles(60);
if(i<14)
data_bufferA[data_index]=(data_bufferA[data_index]<<1)+data_bit;
if(i<28 && i >=14)
data_bufferB[data_index]=(data_bufferB[data_index]<<1)+data_bit;
gpioSetOutput(GPIO_7);
interrupt_call_count=0;
if(i==27)
{
if(data_bufferB[data_index]>NEGATIVE_VALUE_MARGIN) //Means negative value
data_bufferB[data_index] = data_bufferB[data_index]-FULL_SCALE_VALUE; //Invert the value
}
if(i==13)
{
if(data_bufferA[data_index]>NEGATIVE_VALUE_MARGIN) //Means negative value
data_bufferA[data_index] = data_bufferB[data_index]-FULL_SCALE_VALUE; //Invert the value
}
}
//Release CS pin
gpioSetOutput(GPIO_13);
cnt++;
data_index=data_index+1;
data_index=data_index%PULSE_SAMPLE;
tscl_val1 = TSCL;
elapsed_time += ((float)(tscl_val1-tscl_val)/(float)DSP_clockcycles_persec);//_itoll(tsch_val, tscl_val);
if(elapsed_time >=2 )
break;
//platform_write("elapsed time for sample is %d ",elapsed_time);
// if(data_index==0)
// break;
}
platform_write("Total number of samples are %d,%f \n",cnt,elapsed_time);
return cnt;
}
int hpdspuaStart (void) {
uint32_t coreId;
QMSS_CFG_T qmss_cfg;
CPPI_CFG_T cppi_cfg;
/* determine the core number. */
coreId = CSL_chipReadReg (CSL_CHIP_DNUM);
led_no=coreId;
platform_write("num of cores %d starts twinkling its LED\n", number_of_cores);
platform_write("core = %d starts twinkling its LED\n", coreId);
//platform_uart_init();
//platform_uart_set_baudrate(115200);
// write_uart("AAAAAAAA");
gpioInit();
gpioSetDirection(GPIO_10 ,GPIO_IN); //DOUTA pin
gpioSetDirection(GPIO_3 ,GPIO_OUT); //CNVST pin
gpioSetDirection(GPIO_13 ,GPIO_OUT); //CS pin
gpioSetDirection(GPIO_7 ,GPIO_OUT); //SCLK
//ADDR = 0, VA1 and VB1 are sampled; ADDR =1, VA2 and VB2 are sampled
//Right now VA1 and VB1 are being sampled
gpioSetOutput(GPIO_7); //By default clock high
gpioSetOutput(GPIO_3); // by default conversion pin high
gpioSetOutput(GPIO_13); // BY Default CS pin high
gpioSetFallingEdgeInterrupt(GPIO_10);
gpioSetRisingEdgeInterrupt(GPIO_10);
gpioEnableGlobalInterrupt();
//Wait for 100us before starting first conversion
platform_delay(100);
int rc=0;
while(1) {
if(coreId==0)
{
if (platform_get_coreid() == 0)
{
qmss_cfg.master_core = 1;
}
else
{
qmss_cfg.master_core = 0;
}
qmss_cfg.max_num_desc = MAX_NUM_DESC;
qmss_cfg.desc_size = MAX_DESC_SIZE;
qmss_cfg.mem_region = Qmss_MemRegion_MEMORY_REGION0;
if (res_mgr_init_qmss (&qmss_cfg) != 0)
{
platform_write ("Failed to initialize the QMSS subsystem \n");
goto main_exit;
}
else
{
platform_write ("QMSS successfully initialized \n");
}
if (platform_get_coreid() == 0)
{
cppi_cfg.master_core = 1;
}
else
{
cppi_cfg.master_core = 0;
}
cppi_cfg.dma_num = Cppi_CpDma_PASS_CPDMA;
cppi_cfg.num_tx_queues = NUM_PA_TX_QUEUES;
cppi_cfg.num_rx_channels = NUM_PA_RX_CHANNELS;
if (res_mgr_init_cppi (&cppi_cfg) != 0)
{
platform_write ("Failed to initialize CPPI subsystem \n");
goto main_exit;
}
else
{
platform_write ("CPPI successfully initialized \n");
}
if (res_mgr_init_pass()!= 0) {
platform_write ("Failed to initialize the Packet Accelerator \n");
goto main_exit;
}
else
{
platform_write ("PA successfully initialized \n");
}
rc = NC_SystemOpen( NC_PRIORITY_HIGH, NC_OPMODE_INTERRUPT );
if( rc ) {
platform_write("NC_SystemOpen Failed (%d). Will die in an infinite loop so you need to reset...\n",rc);
for(;;);
}
platform_write("HUA version %s\n", BLM_VERSION);
hCfg = CfgNew();
if( !hCfg )
{
platform_write("Unable to create a configuration for the IP stack.\n");
goto main_exit;
}
strcpy (HostName, "tidemo-");
i = strlen(HostName);
j = strlen(gPlatformInfo.serial_nbr);
if (j > 0) {
if (j > 6) {
memcpy (&HostName[i], &gPlatformInfo.serial_nbr[j-6], 6);
HostName[i+7] = '\0';
}
else {
memcpy (&HostName[i], gPlatformInfo.serial_nbr, j);
HostName[i+j+1] = '\0';
}
}
if( strlen( DomainName ) >= CFG_DOMAIN_MAX ||
strlen( HostName ) >= CFG_HOSTNAME_MAX )
{
platform_write("Domain or Host Name too long\n");
goto main_exit;
}
platform_write("Setting hostname to %s \n", HostName);
platform_write("MAC Address: %02X-%02X-%02X-%02X-%02X-%02X \n",
gPlatformInfo.emac.efuse_mac_address[0], gPlatformInfo.emac.efuse_mac_address[1],
gPlatformInfo.emac.efuse_mac_address[2], gPlatformInfo.emac.efuse_mac_address[3],
gPlatformInfo.emac.efuse_mac_address[4], gPlatformInfo.emac.efuse_mac_address[5]);
CfgAddEntry( hCfg, CFGTAG_SYSINFO, CFGITEM_DHCP_HOSTNAME, 0,
strlen(HostName), (uint8_t *)HostName, 0 );
if (!platform_get_switch_state(1)) {
CI_IPNET NA;
CI_ROUTE RT;
IPN IPTmp;
bzero( &NA, sizeof(NA) );
NA.IPAddr = inet_addr(EVMStaticIP);
NA.IPMask = inet_addr(LocalIPMask);
strcpy( NA.Domain, DomainName );
CfgAddEntry( hCfg, CFGTAG_IPNET, 1, 1, sizeof(CI_IPNET), (uint8_t *)&NA, 0 );
bzero( &RT, sizeof(RT) );
RT.IPDestAddr = inet_addr(PCStaticIP);
RT.IPDestMask = inet_addr(LocalIPMask);
RT.IPGateAddr = inet_addr(GatewayIP);
CfgAddEntry( hCfg, CFGTAG_ROUTE, 0, 1, sizeof(CI_ROUTE), (uint8_t *)&RT, 0 );
platform_write("EVM in StaticIP mode at %s\n",EVMStaticIP);
platform_write("Set IP address of PC to %s\n", PCStaticIP);
}
rc = DBG_WARN;
CfgAddEntry( hCfg, CFGTAG_OS, CFGITEM_OS_DBGPRINTLEVEL,
CFG_ADDMODE_UNIQUE, sizeof(uint), (uint8_t *)&rc, 0 );
rc = 64000;
CfgAddEntry( hCfg, CFGTAG_IP, CFGITEM_IP_SOCKTCPTXBUF,
CFG_ADDMODE_UNIQUE, sizeof(uint), (uint8_t *)&rc, 0 );
rc = 64000;
CfgAddEntry( hCfg, CFGTAG_IP, CFGITEM_IP_SOCKTCPRXBUF,
CFG_ADDMODE_UNIQUE, sizeof(uint), (uint8_t *)&rc, 0 );
rc = 64000;
CfgAddEntry( hCfg, CFGTAG_IP, CFGITEM_IP_SOCKTCPRXLIMIT,
CFG_ADDMODE_UNIQUE, sizeof(uint), (uint8_t *)&rc, 0 );
rc = 8192;
CfgAddEntry( hCfg, CFGTAG_IP, CFGITEM_IP_SOCKUDPRXLIMIT,
CFG_ADDMODE_UNIQUE, sizeof(uint), (uint8_t *)&rc, 0 );
do
{
rc = NC_NetStart( hCfg, NetworkOpen, NetworkClose, NetworkIPAddr );
} while( rc > 0 );
platform_write("Done with this utility. Shutting things down\n");
CfgFree( hCfg );
main_exit:
platform_write("Exiting the system\n");
//NC_SystemClose();
TaskExit();
return(0);
}
else
{
while(1)
{
platform_write("done processing .exiting core %d \n", coreId);
platform_delay(300000);
break;
}
platform_delay(300000);
break;
}
}
platform_write("done processing .exiting core %d", coreId);
platform_delay(3000000);
return 0;
}
void nullsrv()
{
SOCKET stcpactive = INVALID_SOCKET;
struct sockaddr_in sin1;
struct timeval timeout; // Timeout struct for select
int size;
int cnt;
char *pBuf;
HANDLE hBuffer;
//gpioEnableGlobalInterrupt();
// Allocate the file environment for this task
fdOpenSession(TaskSelf());
TaskSleep(15000);
platform_write("Raw Eth Task Started ... \n");
// Create the main TCP listen socket
platform_write("creating main TCP listen socket\n");
int k=0;
int n=0;
IMG_STORE_REQST_TYP a;
int *data;
UInt32 time1,time2;
for(;;)
{
//time1=Clock_getTicks();
a.fps=acquire_data();
a.number=min((int)a.fps*sizeof(int),PULSE_SAMPLE*sizeof(int));
//time2=Clock_getTicks();
///platform_write("time taken for acquire data is %lu \n",(unsigned long)(time2-time1));
//time1=Clock_getTicks();
for(k=0;k<2;k++)
{
if(k==0)
data=&data_bufferA[0];
else
data=&data_bufferB[0];
//WWdis_data();
stcp = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if( stcp == INVALID_SOCKET )
{
int ret=fdError();
goto leave;
}
timeout.tv_sec = 30;
timeout.tv_usec = 0;
setsockopt( stcp, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof( timeout ) );
setsockopt( stcp, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof( timeout ) );
//timeout.tv_sec = 3;
//int opt = 1;
//setsockopt( stcp, SOL_SOCKET, SO_BLOCKING , &opt, sizeof( opt ) );
platform_write("created main TCP client socket\n");
// Set Port = 1001, leaving IP address = Any
bzero( &sin1, sizeof(struct sockaddr_in) );
sin1.sin_family = AF_INET;
sin1.sin_addr.s_addr =inet_addr(PCStaticIP);
sin1.sin_port = htons(7000);
sin1.sin_len = sizeof( sin1 );
platform_write("LLL %d \n",(sin1.sin_addr.s_addr));
//fcntl(stcp, F_SETFL, O_NONBLOCK);
//while(1)
if( connect(stcp, (struct sockaddr *) &sin1, sizeof(sin1)) < 0)
{
if (fdError() == EINPROGRESS)
{
fd_set wrsd;
struct timeval tv;
FD_ZERO(&wrsd);
FD_SET(stcp, &wrsd);
tv.tv_sec = 2;
tv.tv_usec = 0;
int ret = fdSelect((int)stcp, 0, &wrsd, 0, &tv );
if(ret>0)
{
int err, lenErr;
lenErr = sizeof(err);
ret = getsockopt(stcp, SOL_SOCKET, SO_ERROR, &err, &lenErr);
if(ret==0 && err==0)
{
platform_write("connection completed");
break;
}
else
{
platform_write("Attempting to connect again");
continue;
}
}
}
}
platform_write("completed connect \n");
a.hydrophone=k;
n=0;
n = send(stcp,&a,sizeof(a),0);
if (n < 0)
{
perror("ERROR writing to socket");
break;
}
platform_write("writing hydrophone %d,bytes %d\n",k,a.number);
n=0;
int c=0;
//platform_write("writing %s \n",data);
do
{
n = send(stcp,data,a.number-c,0);
//platform_write("writing %d bytes \n",n);
if (n < 0)
{
perror("ERROR writing to socket");
break;
}
c=c+n;
data=data+n;
}while(c<a.number);
if (n < 0)
break;
//free(orig);
int status;
HANDLE hbuffer;
n = recv(stcp, &status, sizeof(status),0);
if(status==0)
{
platform_write("Client request success\n");
}
else
{
platform_write("Client request error");
continue;
}
if( stcp != INVALID_SOCKET )
fdClose(stcp);
}
if( stcp != INVALID_SOCKET )
{
shutdown(stcp,0);
fdClose(stcp);
}
//time2=Clock_getTicks();
platform_write("time taken for data transfer is %lu \n",(unsigned long)(time2-time1));
//TaskSleep(5);fe
}
leave:
TaskSleep(5000);
// We only get here on an error - close the sockets
// if( stcp != INVALID_SOCKET )
// fdClose( stcp );
platform_write("NullSrv Fatal Error\n");
// NetworkClose((HANDLE)TaskSelf());
// This task is killed by the system - here, we block
//TaskBlock( TaskSelf() );
}
void EVM_init()
{
platform_init_flags sFlags;
platform_init_config sConfig;
int32_t pform_status;
platform_info sPlatformInfo;
/* Initialise the UART
* You can choose what to initialise on the platform by setting the following
* flags. Things like the DDR, PLL, etc should have been set by the boot loader.
*/
memset( (void *) &sFlags, 0, sizeof(platform_init_flags));
memset( (void *) &sConfig, 0, sizeof(platform_init_config));
sFlags.pll = 0; /* PLLs for clocking */
sFlags.ddr = 1; /* External memory */
sFlags.tcsl = 1; /* Time stamp counter */
sFlags.phy = 1; /* Ethernet */
sFlags.ecc = 0; /* Memory ECC */
sConfig.pllm = 0; /* Use libraries default clock divisor */
pform_status = platform_init(&sFlags, &sConfig);
/* If we initialised the platform okay */
if (pform_status != Platform_EOK) {
/* Initialisation of the platform failed... die */
platform_write("Platform failed to initialise. Error code %d \n", pform_status);
platform_write("We will die in an infinite loop... \n");
while (1) {
(void) platform_led(1, PLATFORM_LED_ON, PLATFORM_USER_LED_CLASS);
(void) platform_delay(50000);
(void) platform_led(1, PLATFORM_LED_OFF, PLATFORM_USER_LED_CLASS);
(void) platform_delay(50000);
}
}
memset( (void *) &sPlatformInfo, 0, sizeof(platform_info));
memset( (void *) &gPlatformInfo, 0, sizeof(platform_info));
platform_get_info(&sPlatformInfo);
//platform_get_info(&sPlatformInfo);
platform_get_info(&gPlatformInfo);
number_of_cores = gPlatformInfo.cpu.core_count;
//MultiProc_setLocalId((Uint16) platform_get_coreid());
platform_uart_init();
platform_uart_set_baudrate(115200);
platform_write_configure (PLATFORM_WRITE_ALL);
platform_write("Board Name %s \n",sPlatformInfo.board_name);
//write_uart("\r\n\r\nBooting Hello World image from NAND flash via IBL over I2C 0x51 ...");
//MultiProc_setLocalId((Uint16) platform_get_coreid());
//CSL_init();
//Uint16 eventId0;
//IRQ_clear(eventId0);
//eventId0 = TIMER_getEventId(timer0Handle);
//IRQ_enable(eventId0);
//IRQ_globalEnable();
return;
}
