static int cmd_pb2led(int argc, char *argv[])
{
if(argc > 1)
{
my_errno = TOO_MANY_ARGUMENTS;
return 1;
}
int rfd1 = svc_open("/btn/sw1",'r');
if(rfd1 < 0)
{
return 1;
}
int rfd2 = svc_open("/btn/sw2",'r');
if(rfd2 < 0)
{
return 1;
}
int wfd1 = svc_open("/led/orange",'w');
if(wfd1 < 0)
{
return 1;
}
int wfd2 = svc_open("/led/yellow",'w');
if(wfd2 < 0)
{
return 1;
}
while(1)
{
char buff[2];
svc_read(rfd1,&buff[0]);
svc_read(rfd2,&buff[1]);
if(buff[0] == '1' && buff[1] == '1')
{
svc_close(rfd1);
svc_close(rfd2);
svc_close(wfd1);
svc_close(wfd2);
return 0;
}
svc_write(wfd1,buff[0]);
svc_write(wfd2,buff[1]);
}
return 1;
}
void demoProc1(int argc,char *argv[])
{
int wfd = svc_open("/lcd",'w');
if(wfd > 0)
{
char buff;
while((buff = ugetc()) != CHAR_EOF)
{
svc_write(wfd,buff);
}
svc_close(wfd);
}
}
int main(){
int xxx;
peer_self = NULL;
printf("initiating...\n");
svc_init(tst_callback);
printf("joining peer...\n");
peer_self = svc_peer_join();
printf("running...\n");
printf("You should be able to hear yourslef in the speakers\n");
scanf("%d", &xxx);
svc_close();
return 0;
}
static int cmd_fclose(int argc, char *argv[])
{
if(argc > 2)
{
my_errno = TOO_MANY_ARGUMENTS;
return 1;
}
if(argc < 2 )
{
my_errno = TOO_FEW_ARGUMENTS;
return 1;
}
int fd = strtoint(argv[1]);
svc_close(fd);
return 0;
}
static int cmd_touch2led(int argc, char *argv[])
{
if(argc > 1)
{
my_errno = TOO_MANY_ARGUMENTS;
return 1;
}
int rfd[4];
int wfd[4];
rfd[0] = svc_open("/tsr/orange",'r');
rfd[1] = svc_open("/tsr/yellow",'r');
rfd[2] = svc_open("/tsr/blue",'r');
rfd[3] = svc_open("/tsr/green",'r');
wfd[0] = svc_open("/led/orange",'w');
wfd[1] = svc_open("/led/yellow",'w');
wfd[2] = svc_open("/led/blue",'w');
wfd[3] = svc_open("/led/green",'w');
while(1)
{
char buff[4];
svc_read(rfd[0],&buff[0]);
svc_read(rfd[1],&buff[1]);
svc_read(rfd[2],&buff[2]);
svc_read(rfd[3],&buff[3]);
if(buff[0] == '1' && buff[1] == '1' && buff[2] == '1' && buff[3] == '1')
{
svc_close(rfd[0]);svc_close(rfd[1]);
svc_close(rfd[2]);svc_close(rfd[3]);
svc_close(wfd[0]);svc_close(wfd[1]);
svc_close(wfd[2]);svc_close(wfd[3]);
return 0;
}
svc_write(wfd[0],buff[0]);
svc_write(wfd[1],buff[1]);
svc_write(wfd[2],buff[2]);
svc_write(wfd[3],buff[3]);
}
return 1;
}
static int cmd_ser2lcd(int argc, char *argv[])
{
if(argc > 1)
{
my_errno = TOO_MANY_ARGUMENTS;
return 1;
}
int wfd = svc_open("/lcd",'w');
if(wfd > 0)
{
char buff;
while((buff = ugetc()) != CHAR_EOF)
{
svc_write(wfd,buff);
}
svc_close(wfd);
return 0;
}
return 1;
}
void demoProc3(int argc,char *argv[])
{
char ledState = getLedState();
svc_pdbDemo(1);
int fd = svc_open("/tsr/orange",'r');
while(1)
{
char buff;
svc_read(fd,&buff);
if(buff == '1')
{
break;
}
if(ledState != getLedState())
{
ledState = getLedState();
svc_pdbDemo(1);
}
}
svc_close(fd);
}
static int cmd_therm2ser(int argc, char *argv[])
{
if(argc > 1)
{
my_errno = TOO_MANY_ARGUMENTS;
return 1;
}
int rfd = svc_open("/ttr",'r');
if(rfd > 0)
{
char buff;int val;
val = svc_read(rfd,&buff);
while(!sw1In())
{
char temp[8];
sprintf(temp,"%d\r\n",val);
uprintf(temp);
val = svc_read(rfd,&buff);
}
svc_close(rfd);
return 0;
}
return 1;
}
int main(int argc, char* argv[]) {
dstring* input;
int input_done;
int code;
ENetEvent event;
if (argc > 1) {
fprintf(stderr, "svcc doesn't accept any command line arguments, use stdin instead.\n");
return 1;
}
/* initialize enet */
if (enet_initialize()) {
fprintf(stderr, "Failed to initialize ENet\n");
return 1;
}
/* initialize client state */
init_client_state();
/* init SVC */
svc_init(send_callback);
/* main loop */
input = dnew();
client.main_done = 0;
signal(SIGINT, sigint);
while(!client.main_done) {
/* enet event handler */
if (client.state == SVCECLIENT_STATE_CONNECTED) {
/* handle connection state */
while (1) {
mutex_lock(&client.network_lock);
code = enet_host_service(client.host, &event, 0);
mutex_unlock(&client.network_lock);
if (code <= 0) break;
/* handle event */
switch(event.type) {
case ENET_EVENT_TYPE_DISCONNECT:
/* we got disconnected */
mutex_lock(&client.network_lock);
client.state = SVCECLIENT_STATE_DISCONNECTED;
free_server_info();
mutex_unlock(&client.network_lock);
msg_state();
break;
case ENET_EVENT_TYPE_RECEIVE:
/* some data just arrived */
if (event.channelID == 0) {
handle_server_msg(event.packet);
} else if (event.channelID == 1) {
handle_server_audio(event.packet);
} else {
fprintf(stderr, "Received message from server on invalid channel %i.\n", event.channelID);
}
mutex_lock(&client.network_lock);
enet_packet_destroy(event.packet);
mutex_unlock(&client.network_lock);
break;
case ENET_EVENT_TYPE_CONNECT:
/* no one will connect, ignore the bastard */
default:
break;
}
}
} else if (client.state == SVCECLIENT_STATE_CONNECTING) {
/* handle connecting state */
mutex_lock(&client.network_lock);
code = enet_host_service(client.host, &event, 0);
mutex_unlock(&client.network_lock);
if (code > 0) {
if (event.type == ENET_EVENT_TYPE_CONNECT) {
client.state = SVCECLIENT_STATE_CONNECTED;
client.server_info = dsdict_new();
msg_state();
} else {
mutex_lock(&client.network_lock);
client.state = SVCECLIENT_STATE_DISCONNECTED;
enet_peer_disconnect(client.client, 0);
client.client = NULL;
enet_host_destroy(client.host);
client.host = NULL;
msg_state();
mutex_unlock(&client.network_lock);
}
}
} else {
/* sleep for 8ms */
usleep(8000);
}
/* play with the input queue */
if (!client.main_done) {
input_done = 0;
while (!input_done) {
/* get next input command */
mutex_lock(&client.input_lock);
if (client.input_queue->size) {
dcpy(input, client.input_queue->front->string);
dlist_erase(client.input_queue, client.input_queue->front);
} else {
input_done = 1;
}
mutex_unlock(&client.input_lock);
/* quit input loop if queue is empty */
if (input_done) {
break;
}
/* handle commands */
input_done = client.main_done = handle_input_command(input);
}
}
/* check if input died for some reasons */
mutex_lock(&client.input_lock);
if (client.input_error) {
/* if so, leave main loop */
client.main_done = 1;
}
mutex_unlock(&client.input_lock);
fflush(stdout);
fflush(stderr);
/* sleep for 8ms */
usleep(8000);
}
fprintf(stdout, ":STATE exiting\n");
dfree(input);
svc_close();
quit_client_state();
enet_deinitialize();
return 0;
}
static int fnL42801894(struct OSImageScript *imgScript,
void **bootAddrBuf,
void **var6)
{
int fdesc = 0;
int imgNo;
int fileSize = 0;
void *loadAddr;
wlibc_uprintf("load kernel start\n");
for(imgNo = 0; imgNo < imgScript->segmentSectionCount; ++imgNo) {
if(imgNo != 1) {
loadAddr = imgScript->images[imgNo].baseAddr;
} else {
loadAddr = svc_alloc(65536);
}
if(loadAddr == 0) {
wlibc_uprintf("img file %s base addres is NULL\n", loadAddr);
return -1;
}
fdesc = svc_open(imgScript->images[imgNo].name, "rb");
if(fdesc == 0) {
wlibc_uprintf("open img file %s failed\n",
imgScript->images[imgNo].name);
goto fail;
}
fileSize = svc_filesize(fdesc);
if( fileSize > imgScript->images[imgNo].maxSize ) {
wlibc_uprintf(
"the img file %s length %d is larger than img max size %d\n",
imgScript->images[imgNo].name, fileSize,
imgScript->images[imgNo].maxSize);
goto fail;
}
svc_read(loadAddr, 1, fileSize, fdesc);
svc_close(fdesc);
imgScript->images[imgNo].fileLen = fileSize;
if(imgNo == 1) {
do_boot_linux(imgScript->images[1].baseAddr, loadAddr, fileSize);
svc_free(loadAddr);
}
loadAddr = 0;
fdesc = 0;
fileSize = 0;
}
loadAddr = imgScript->baseAddr;
if(loadAddr == 0) {
wlibc_uprintf("no script could be filed\n");
} else {
/* 0x42F00000 - c:\script.bin contents */
memcpy(loadAddr, (const void*)0x42F00000, imgScript->maxSize);
imgScript->param776 = imgScript->maxSize;
}
*bootAddrBuf = imgScript->images[0].baseAddr;
*var6 = imgScript->images[1].baseAddr;
wlibc_uprintf("load kernel successed\n");
return 0;
fail:
if(fdesc != 0) {
svc_close(fdesc);
}
wlibc_uprintf("load kernel failed\n");
return -1;
}
int
eclose(int fd) {
return svc_close(fd);
}
