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; }