void RedScreen::on_layer_changed(ScreenLayer& layer)
{
Lock lock(_layer_changed_lock);
if (_active_layer_change_event) {
return;
}
_active_layer_change_event = true;
AutoRef<LayerChangedEvent> change_event(new LayerChangedEvent(_id));
_owner.push_event(*change_event);
}
MBconn*
master_connect_backup(BackupItem *bitem)
{
char *ip;
int write_port;
MBconn *mbconn;
WThread *wt = g_runtime->wthread;
//int error = 0;
ip = bitem->ip;
write_port = bitem->write_port;
if (bitem->mbconn && bitem->mbconn->sock > 0) {
DINFO("=====================destroy mbconn\n");
//bitem->mbconn->destroy((Conn *)bitem->mbconn);
mb_conn_destroy_delay((Conn *)bitem->mbconn);
bitem->state = STATE_NOWRITE;
bitem->mbconn = NULL;
}
mbconn = (MBconn *)conn_client_create(ip, write_port, sizeof(MBconn));
if (mbconn == NULL) {
DERROR("can not create mbconn struct\n");
return NULL;
}
DINFO("mbconn->rbuf: %p\n", mbconn->rbuf);
mbconn->item = bitem;
mbconn->thread = wt;
mbconn->destroy = mb_conn_destroy_delay;
mbconn->base = wt->base;
bitem->state = STATE_NOWRITE;
mbconn->ready = mb_data_ready;
mbconn->wrote = mb_conn_wrote;
Conn *conn = (Conn *)mbconn;
char *buffer = conn_write_buffer(conn, 1024);
int count;
g_cf->heartbeat_port = 30000;
count = pack(buffer, 0, "$4ciiii", CMD_GETPORT, g_cf->write_port, g_cf->read_port, g_cf->sync_port, g_cf->heartbeat_port);
//DINFO("--------------------count:%d\n", count);
conn->wlen = count;
change_event((Conn *)mbconn, EV_WRITE|EV_PERSIST, 0, 1);
return mbconn;
}
// Called to shutdown the current program. If the program has
// shutdown hooks then these will be initiated, if not the
// program will be terminated. The abort parameter controls what
// happens if shutdown is already in progress. If it is true and
// the shutdown sequence is already in progress then this will be
// aborted and the program terminated.
//
void shutdown_program(boolean abort)
{
// Search for a thread waiting for a shutdown event.
int i;
for(i = 0; i < eventCnt; i++)
{
NXTEvent *event = events[i];
if (event->typ == SYSTEM_EVENT && event->filter == SHUTDOWN)
{
// if a process is waiting the shutdown process has not started, so start it
if (event->state == WAITING)
change_event(event, SHUTDOWN, 0);
else
// process already underway, should we abort?
if (abort)
break;
return;
}
}
// no thread waiting so just shut things down...
schedule_request(REQUEST_EXIT);
}
int
master_ready(Conn *conn, char *data, int datalen)
{
WThread *wt = g_runtime->wthread;
//int ret;
int lastlogver, lastlogline;
//int lastret;
commitlog_read(wt->clog, &lastlogver, &lastlogline);
DINFO("=======lastlogver: %d, lastlogline: %d\n", lastlogver, lastlogline);
//DNOTE("=======lastlogver: %d, lastlogline: %d\n", lastlogver, lastlogline);
//写本地commitlog
//commitlog_write(wt->clog, g_runtime->synclog->version, g_runtime->synclog->index_pos,
//data, datalen);
int newlogver, newlogline;
//commitlog_read(wt->clog, &newlogver, &newlogline);
newlogver = g_runtime->synclog->version;
newlogline = g_runtime->synclog->index_pos;
//DNOTE("=======newlogver: %d, newlogline: %d\n", newlogver, newlogline);
DINFO("=======newlogver: %d, newlogline: %d\n", newlogver, newlogline);
//DNOTE("in synclog version: %d, logline: %d\n", g_runtime->synclog->version, g_runtime->synclog->index_pos);
DINFO("in synclog version: %d, logline: %d\n", g_runtime->synclog->version, g_runtime->synclog->index_pos);
/*
int dlen = wt->clog->len + sizeof(char);
char *buffer = conn_write_buffer(conn, dlen);
ret = pack(buffer, 0, "$4cC", dlen, CMD_WRITE, wt->clog->len, wt->clog->data);
*/
BackupInfo *binfo = wt->backup_info;
BackupItem *bitem = binfo->item;
//保存客户端命令
pack(binfo->cltcmd, 0, "ii", newlogver, newlogline);
memcpy(binfo->cltcmd+sizeof(int)*2, data, datalen);
binfo->cmdlen = datalen + sizeof(int)*2;
//binfo->done = 0;
binfo->succ = 0;
DINFO("state: %d, succ: %d\n", wt->state, binfo->succ);
//系统不可用
if (wt->state == STATE_NOCONN) {
conn_send_buffer_reply(conn, MEMLINK_ERR_NOWRITE, NULL, 0);
return 0;
}
//while (binfo->timer_send == TRUE) {
//}
binfo->ctlconn = conn;
DINFO("need send comand to all backup\n");
while (bitem) {
if(bitem->state == STATE_ALLREADY) {
Conn *conn = (Conn *)bitem->mbconn;
//DNOTE("-------------------wlen: %d, wpos: %d\n", conn->wlen, conn->wpos);
DINFO("-------------------wlen: %d, wpos: %d\n", conn->wlen, conn->wpos);
char *buffer = conn_write_buffer(conn, 2048);
int count;
int ret;
DINFO("clog->len: %d\n", wt->clog->len);
//count = pack(buffer, 0, "$4ciiiC:4", CMD_WRITE, lastlogver, lastlogline, wt->clog->state, wt->clog->len , wt->clog->data);
count = pack(buffer, 0, "$4ciiiC:4", CMD_WRITE, lastlogver, lastlogline, wt->clog->state, binfo->cmdlen, binfo->cltcmd);
int lastver, lastline, lastret, logver, logline;
unpack(buffer+sizeof(int)+sizeof(char), 0, "iii", &lastver, &lastline, &lastret);
DINFO("lastver: %d, lastline: %d, lastret: %d\n", lastver, lastline,
lastret);
unpack(buffer+sizeof(int)*5+sizeof(char), 0, "ii", &logver, &logline);
DINFO("unpack logver: %d, logline: %d\n", logver, logline);
conn->wlen = count;
DINFO("change event to write\n");
//DNOTE("change event to write\n");
ret = change_event((Conn *)bitem->mbconn, EV_WRITE | EV_PERSIST, 0, 0);
/*
if (ret < 0) {
DERROR("change_event error: %d, %s:%d\n", ret, bitem->ip, bitem->write_port);
Conn *conn = (Conn *)bitem->mbconn;
conn->destroy((Conn *)bitem->mbconn);
binfo->succ_conns--;
}
*/
}
bitem = bitem->next;
}
DINFO("=======add timer check event\n");
struct timeval tm;
evtimer_set(&binfo->timer_check_evt, mb_data_timeout, conn);
evutil_timerclear(&tm);
tm.tv_sec = 1;
event_base_set(wt->base, &binfo->timer_check_evt);
event_add(&binfo->timer_check_evt, &tm);
return 0;
}
int
request_vote(uint64_t id, unsigned char idflag, uint64_t voteid, unsigned short port)
{
struct sockaddr_in s;
int fd;
int ret;
char err[ERRBUFLEN];
DINFO("*** VOTE REQUEST: id: %llu, idflag: %d, voteid: %llu, port: %d\n",
(unsigned long long)id, idflag, (unsigned long long)voteid, port);
fd = socket(AF_INET, SOCK_STREAM, 0);
if (fd == -1) {
strerror_r(errno, err, ERRBUFLEN);
DERROR("*** VOTE: create socket error: %s\n", err);
return -1;
}
if (set_nonblock(fd) == -1) {
close(fd);
return -1;
}
VoteConn *conn = (VoteConn *)zz_malloc(sizeof(VoteConn));
if (conn == NULL) {
DERROR("*** VOTE: conn malloc error.\n");
MEMLINK_EXIT;
}
memset(conn, 0, sizeof(VoteConn));
conn->rbuf = (char *)zz_malloc(CONN_MAX_READ_LEN);
if (conn->rbuf == NULL) {
DERROR("*** VOTE: rbuf malloc error.\n");
MEMLINK_EXIT;
}
/*
conn->wbuf = (char *)zz_malloc(CONN_MAX_READ_LEN);
if (conn->wbuf == NULL) {
DERROR("*** VOTE: wbuf malloc error.\n");
MEMLINK_EXIT;
}
*/
conn->wbuf = conn->rbuf;
conn->rsize = CONN_MAX_READ_LEN;
conn->wsize = CONN_MAX_READ_LEN;
conn->sock = fd;
conn->destroy = vote_destroy;
conn->wrote = conn_wrote;
conn->ready = vote_ready;
conn->timeout = vote_timeout;
conn->read = conn_event_read;
conn->write = conn_event_write;
conn->base = g_runtime->wthread->base;
conn->vote_status = VOTE_REQUEST;
//conn->thread = &conn->status;
strcpy(conn->client_ip, g_cf->vote_host);
conn->client_port = g_cf->vote_port;
conn->id = id;
conn->idflag = idflag;
conn->voteid = voteid;
conn->wport = port;
conn->wlen = cmd_vote_pack(conn->wbuf, id, idflag, voteid, port);
bzero(&s, sizeof(s));
s.sin_family = AF_INET;
//strcpy(g_cf->vote_host, VOTE_HOST);
//g_cf->vote_port = VOTE_PORT;
inet_pton(AF_INET, g_cf->vote_host, &s.sin_addr);
s.sin_port = htons(g_cf->vote_port);
int flag = 1;
setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &flag, sizeof(flag));
ret = connect(fd, (struct sockaddr *)&s, sizeof(s));
if (ret == -1) {
if (errno != EINPROGRESS && errno != EINTR) {
strerror_r(errno, err, ERRBUFLEN);
DERROR("*** VOTE: connect error: %s\n", err);
conn->destroy((Conn *)conn);
return -1;
}
}
if (change_event((Conn *)conn, EV_WRITE|EV_PERSIST, g_cf->timeout, 1) < 0) {
DERROR("*** VOTE: change_event error\n");
conn->destroy((Conn *)conn);
return -1;
}
return 0;
}
int
vote_ready(Conn *conn, char *buf, int datalen)
{
short retcode;
uint8_t cmd;
int count = sizeof(int);
char ip[INET_ADDRSTRLEN];
uint16_t port;
uint64_t voteid;
memcpy(&cmd, buf+count, sizeof(cmd));
count += sizeof(cmd);
if (g_cf->sync_mode == MODE_MASTER_SLAVE) {
conn_send_buffer_reply(conn, MEMLINK_ERR_SLAVE, NULL, 0);
return 0;
}
switch (cmd) {
case CMD_VOTE:
memcpy(&retcode, buf+count, sizeof(retcode));
count += sizeof(retcode);
switch (retcode) {
case CMD_VOTE_WAIT:
DINFO("*** VOTE WAITING\n");
int timeout = 10*g_cf->timeout;
if (timeout < 60) {
timeout = 60;
} else if (timeout > 300) {
timeout = 300;
}
//*((int *)conn->thread) = VOTE_WAITING;
conn->vote_status = VOTE_WAITING;
event_del(&conn->evt);
change_event(conn, EV_READ|EV_PERSIST, timeout, 1);
break;
case CMD_VOTE_MASTER:
DINFO("*** VOTE MASTER\n");
/*
if (conn->thread != g_runtime->wthread)
*((int *)conn->thread) = VOTE_OK;
*/
conn->vote_status = VOTE_OK;
count += unpack_voteid(buf+count, &voteid);
if (g_cf->role == ROLE_NONE) {
DINFO("*** master init\n");
master_init(voteid, buf+count, datalen-count);
g_cf->role = ROLE_MASTER;
g_runtime->voteid = voteid;
} else {
DINFO("*** switch to master\n");
if (switch_master(voteid, buf+count, datalen-count) < 0) {
DERROR("*** FATAL ERROR : switch to master error\n");
g_cf->role = ROLE_NONE;
g_runtime->voteid = 0;
} else {
g_cf->role = ROLE_MASTER;
g_runtime->voteid = voteid;
}
}
DINFO("*** voteid: %llu\n", (unsigned long long)g_runtime->voteid);
DINFO("*** VOTE: I am master\n");
while (count < datalen) {
count += unpack_votehost(buf+count, ip, &port);
DINFO("*** VOTE backup: %s(%d)\n", ip, port);
}
/*
Host **hostp = &g_runtime->hosts;
while (count < datalen) {
count += unpack_votehost(buf+count, ip, &port);
DINFO("*** VOTE backup: %s(%d)\n", ip, port);
if (*hostp == NULL) {
*hostp = (Host *)zz_malloc(sizeof(Host));
strcpy((*hostp)->ip, ip);
(*hostp)->port = port;
(*hostp)->next = NULL;
hostp = &(*hostp)->next;
} else {
strcpy((*hostp)->ip, ip);
(*hostp)->port = port;
hostp = &(*hostp)->next;
}
}
if (*hostp != NULL) {
release_hosts(*hostp);
*hostp = NULL;
}
*/
conn_send_buffer_reply(conn, MEMLINK_OK, NULL, 0);
break;
case CMD_VOTE_BACKUP:
DINFO("*** VOTE BACKUP\n");
/*
if (conn->thread != g_runtime->wthread)
*((int *)conn->thread) = VOTE_OK;
*/
conn->vote_status = VOTE_OK;
count += unpack_voteid(buf+count, &voteid);
unpack_votehost(buf+count, ip, &port);
if (g_cf->role == ROLE_NONE) {
DINFO("*** backup init\n");
backup_init(voteid, buf+count, datalen-count);
g_cf->role = ROLE_BACKUP;
g_runtime->voteid = voteid;
} else {
DINFO("*** switch to backup\n");
if (switch_backup(voteid, buf+count, datalen-count) < 0) {
DERROR("*** FATAL ERROR : switch to backup error\n");
g_cf->role = ROLE_NONE;
g_runtime->voteid = 0;
} else {
g_cf->role = ROLE_BACKUP;
g_runtime->voteid = voteid;
}
}
DINFO("*** VOTE: I am backup, master is %s(%d)\n", ip, port);
DINFO("*** voteid: %llu\n", (unsigned long long)g_runtime->voteid);
/*
Host *host;
if (g_runtime->hosts == NULL) {
host = (Host *)zz_malloc(sizeof(Host));
if (host == NULL) {
DERROR("*** VOTE: zz_malloc error\n");
MEMLINK_EXIT;
}
host->next = NULL;
strcpy(host->ip, ip);
host->port = port;
g_runtime->hosts = host;
} else {
host = g_runtime->hosts;
strcpy(host->ip, ip);
host->port = port;
release_hosts(host->next);
host->next = NULL;
}
*/
conn_send_buffer_reply(conn, MEMLINK_OK, NULL, 0);
break;
case CMD_VOTE_NONEED:
DINFO("*** VOTE NONEED\n");
if (g_cf->role == ROLE_NONE) {
//*((int *)conn->thread) = VOTE_CONTINUE;
conn->vote_status = VOTE_CONTINUE;
break;
}
//*((int *)conn->thread) = VOTE_OK;
conn->vote_status = VOTE_OK;
backup_create_heartbeat(g_runtime->wthread);
break;
case MEMLINK_ERR_VOTE_PARAM:
DERROR("*** VOTE PARAM ERROR\n");
//*((int *)conn->thread) = VOTE_ERR_PARAM;
conn->vote_status = VOTE_ERR_PARAM;
break;
default:
DERROR("*** VOTE UNKNOWN ERROR\n");
//if (conn->thread != g_runtime->wthread)
// *((int *)conn->thread) = VOTE_OK;
conn->vote_status = VOTE_OK;
break;
}
break;
case CMD_VOTE_UPDATE:
DINFO("*** VOTE UPDATING\n");
if (g_cf->role != ROLE_MASTER) {
conn_send_buffer_reply(conn, MEMLINK_ERR_NOT_MASTER, NULL, 0);
break;
}
//DINFO("*** VOTE MASTER\n");
/*
if (conn->thread != g_runtime->wthread)
*((int *)conn->thread) = VOTE_OK;
*/
//conn->vote_status = VOTE_OK;
count += unpack_voteid(buf+count, &voteid);
DINFO("*** voteid: %llu\n", (unsigned long long)voteid);
DINFO("*** VOTE: I am master\n");
g_cf->role = ROLE_MASTER;
g_runtime->voteid = voteid;
mb_binfo_update(voteid, buf+count, datalen-count);
while (count < datalen) {
count += unpack_votehost(buf+count, ip, &port);
DINFO("*** VOTE backup: %s(%d)\n", ip, port);
}
/*
Host **hostp = &g_runtime->hosts;
while (count < datalen) {
count += unpack_votehost(buf+count, ip, &port);
DINFO("*** backup: %s(%d)\n", ip, port);
if (*hostp == NULL) {
*hostp = (Host *)zz_malloc(sizeof(Host));
strcpy((*hostp)->ip, ip);
(*hostp)->port = port;
(*hostp)->next = NULL;
hostp = &(*hostp)->next;
} else {
strcpy((*hostp)->ip, ip);
(*hostp)->port = port;
hostp = &(*hostp)->next;
}
}
if (*hostp != NULL) {
release_hosts(*hostp);
*hostp = NULL;
}
*/
conn_send_buffer_reply(conn, MEMLINK_OK, NULL, 0);
break;
case CMD_VOTE_DETECT:
DINFO("*** VOTE DETECT\n");
if (g_cf->role == ROLE_MASTER) {
retcode = CMD_VOTE_MASTER;
} else if (g_cf->role == ROLE_BACKUP) {
retcode = CMD_VOTE_BACKUP;
} else {
retcode = MEMLINK_ERR_NO_ROLE;
}
conn_send_buffer_reply(conn, retcode, (char *)&g_runtime->voteid, sizeof(g_runtime->voteid));
break;
default:
break;
}
return 0;
}
/**
* NOTE: The technique is not the same as that used in TinyVM.
* The return value indicates the impact of the call on the VM
* system. EXEC_CONTINUE normal return the system should return to the return
* address provided by the VM. EXEC_RUN The call has modified the value of
* VM PC and this should be used to restart execution. EXEC_RETRY The call
* needs to be re-tried (typically for a GC failure), all global state
* should be left intact, the PC has been set appropriately.
*
*/
int dispatch_native(TWOBYTES signature, STACKWORD * paramBase)
{
STACKWORD p0 = paramBase[0];
switch (signature) {
case wait_4_5V:
return monitor_wait((Object *) word2ptr(p0), 0);
case wait_4J_5V:
return monitor_wait((Object *) word2ptr(p0), ((int)paramBase[1] > 0 ? 0x7fffffff : paramBase[2]));
case notify_4_5V:
return monitor_notify((Object *) word2ptr(p0), false);
case notifyAll_4_5V:
return monitor_notify((Object *) word2ptr(p0), true);
case start_4_5V:
// Create thread, allow for instruction restart
return init_thread((Thread *) word2ptr(p0));
case yield_4_5V:
schedule_request(REQUEST_SWITCH_THREAD);
break;
case sleep_4J_5V:
sleep_thread(((int)p0 > 0 ? 0x7fffffff : paramBase[1]));
schedule_request(REQUEST_SWITCH_THREAD);
break;
case getPriority_4_5I:
push_word(get_thread_priority((Thread *) word2ptr(p0)));
break;
case setPriority_4I_5V:
{
STACKWORD p = (STACKWORD) paramBase[1];
if (p > MAX_PRIORITY || p < MIN_PRIORITY)
return throw_new_exception(JAVA_LANG_ILLEGALARGUMENTEXCEPTION);
else
set_thread_priority((Thread *) word2ptr(p0), p);
}
break;
case currentThread_4_5Ljava_3lang_3Thread_2:
push_ref(ptr2ref(currentThread));
break;
case interrupt_4_5V:
interrupt_thread((Thread *) word2ptr(p0));
break;
case interrupted_4_5Z:
{
JBYTE i = currentThread->interruptState != INTERRUPT_CLEARED;
currentThread->interruptState = INTERRUPT_CLEARED;
push_word(i);
}
break;
case isInterrupted_4_5Z:
push_word(((Thread *) word2ptr(p0))->interruptState
!= INTERRUPT_CLEARED);
break;
case join_4_5V:
join_thread((Thread *) word2ptr(p0), 0);
break;
case join_4J_5V:
join_thread((Thread *) word2obj(p0), paramBase[2]);
break;
case halt_4I_5V:
schedule_request(REQUEST_EXIT);
break;
case shutdown_4_5V:
shutdown_program(false);
break;
case currentTimeMillis_4_5J:
push_word(0);
push_word(systick_get_ms());
break;
case readSensorValue_4I_5I:
push_word(sp_read(p0, SP_ANA));
break;
case setPowerTypeById_4II_5V:
sp_set_power(p0, paramBase[1]);
break;
case freeMemory_4_5J:
push_word(0);
push_word(getHeapFree());
break;
case totalMemory_4_5J:
push_word(0);
push_word(getHeapSize());
break;
case floatToRawIntBits_4F_5I: // Fall through
case intBitsToFloat_4I_5F:
push_word(p0);
break;
case doubleToRawLongBits_4D_5J: // Fall through
case longBitsToDouble_4J_5D:
push_word(p0);
push_word(paramBase[1]);
break;
case drawString_4Ljava_3lang_3String_2II_5V:
{
String *p = (String *)word2obj(p0);
Object *charArray;
if (!p) return throw_new_exception(JAVA_LANG_NULLPOINTEREXCEPTION);
charArray = (Object *) word2ptr(get_word_4_ns(fields_start(p)));
if (!charArray) return throw_new_exception(JAVA_LANG_NULLPOINTEREXCEPTION);
display_goto_xy(paramBase[1], paramBase[2]);
display_jstring(p);
}
break;
case drawInt_4III_5V:
display_goto_xy(paramBase[1], paramBase[2]);
display_int(p0, 0);
break;
case drawInt_4IIII_5V:
display_goto_xy(paramBase[2], paramBase[3]);
display_int(p0, paramBase[1]);
break;
case asyncRefresh_4_5V:
display_update();
break;
case clear_4_5V:
display_clear(0);
break;
case getDisplay_4_5_1B:
push_word(display_get_array());
break;
case setAutoRefreshPeriod_4I_5I:
push_word(display_set_auto_update_period(p0));
break;
case getRefreshCompleteTime_4_5I:
push_word(display_get_update_complete_time());
break;
case bitBlt_4_1BIIII_1BIIIIIII_5V:
{
Object *src = word2ptr(p0);
Object *dst = word2ptr(paramBase[5]);
display_bitblt((byte *)(src != NULL ?jbyte_array(src):NULL), paramBase[1], paramBase[2], paramBase[3], paramBase[4], (byte *)(dst!=NULL?jbyte_array(dst):NULL), paramBase[6], paramBase[7], paramBase[8], paramBase[9], paramBase[10], paramBase[11], paramBase[12]);
break;
}
case getSystemFont_4_5_1B:
push_word(display_get_font());
break;
case setContrast_4I_5V:
nxt_lcd_set_pot(p0);
break;
case getBatteryStatus_4_5I:
push_word(battery_voltage());
break;
case getButtons_4_5I:
push_word(buttons_get());
break;
case getTachoCountById_4I_5I:
push_word(nxt_motor_get_count(p0));
break;
case controlMotorById_4III_5V:
nxt_motor_set_speed(p0, paramBase[1], paramBase[2]);
break;
case resetTachoCountById_4I_5V:
nxt_motor_set_count(p0, 0);
break;
case i2cEnableById_4II_5V:
if (i2c_enable(p0, paramBase[1]) == 0)
return EXEC_RETRY;
else
break;
case i2cDisableById_4I_5V:
i2c_disable(p0);
break;
case i2cStatusById_4I_5I:
push_word(i2c_status(p0));
break;
case i2cStartById_4II_1BIII_5I:
{
Object *p = word2obj(paramBase[2]);
JBYTE *byteArray = p ? jbyte_array(p) + paramBase[3] : NULL;
push_word(i2c_start(p0,
paramBase[1],
(U8 *)byteArray,
paramBase[4],
paramBase[5]));
}
break;
case i2cCompleteById_4I_1BII_5I:
{
Object *p = word2ptr(paramBase[1]);
JBYTE *byteArray = p ? jbyte_array(p) + paramBase[2] : NULL;
push_word(i2c_complete(p0,
(U8 *)byteArray,
paramBase[3]));
}
break;
case playFreq_4III_5V:
sound_freq(p0,paramBase[1], paramBase[2]);
break;
case btGetBC4CmdMode_4_5I:
push_word(bt_get_mode());
break;
case btSetArmCmdMode_4I_5V:
if (p0 == 0) bt_set_arm7_cmd();
else bt_clear_arm7_cmd();
break;
case btSetResetLow_4_5V:
bt_set_reset_low();
break;
case btSetResetHigh_4_5V:
bt_set_reset_high();
break;
case btWrite_4_1BII_5I:
{
Object *p = word2ptr(p0);
byte *byteArray = (byte *) jbyte_array(p);
push_word(bt_write(byteArray, paramBase[1], paramBase[2]));
}
break;
case btRead_4_1BII_5I:
{
Object *p = word2ptr(p0);
byte *byteArray = (byte *) jbyte_array(p);
push_word(bt_read(byteArray, paramBase[1], paramBase[2]));
}
break;
case btPending_4_5I:
{
push_word(bt_event_check(0xffffffff));
}
break;
case btEnable_4_5V:
if (bt_enable() == 0)
return EXEC_RETRY;
else
break;
case btDisable_4_5V:
bt_disable();
break;
case usbRead_4_1BII_5I:
{
Object *p = word2ptr(p0);
byte *byteArray = (byte *) jbyte_array(p);
push_word(udp_read(byteArray,paramBase[1], paramBase[2]));
}
break;
case usbWrite_4_1BII_5I:
{
Object *p = word2ptr(p0);
byte *byteArray = (byte *) jbyte_array(p);
push_word(udp_write(byteArray,paramBase[1], paramBase[2]));
}
break;
case usbStatus_4_5I:
{
push_word(udp_event_check(0xffffffff));
}
break;
case usbEnable_4I_5V:
{
udp_enable(p0);
}
break;
case usbDisable_4_5V:
{
udp_disable();
}
break;
case usbReset_4_5V:
udp_reset();
break;
case usbSetSerialNo_4Ljava_3lang_3String_2_5V:
{
byte *p = word2ptr(p0);
int len;
Object *charArray = (Object *) word2ptr(get_word_4_ns(fields_start(p)));
len = get_array_length(charArray);
udp_set_serialno((U8 *)jchar_array(charArray), len);
}
break;
case usbSetName_4Ljava_3lang_3String_2_5V:
{
byte *p = word2ptr(p0);
int len;
Object *charArray = (Object *) word2ptr(get_word_4_ns(fields_start(p)));
len = get_array_length(charArray);
udp_set_name((U8 *)jchar_array(charArray), len);
}
break;
case flashWritePage_4_1BI_5I:
{
Object *p = word2ptr(p0);
unsigned long *intArray = (unsigned long *) jint_array(p);
push_word(flash_write_page(intArray,paramBase[1]));
}
break;
case flashReadPage_4_1BI_5I:
{
Object *p = word2ptr(p0);
unsigned long *intArray = (unsigned long *) jint_array(p);
push_word(flash_read_page(intArray,paramBase[1]));
}
break;
case flashExec_4II_5I:
push_word(run_program((byte *)(&FLASH_BASE[(p0*FLASH_PAGE_SIZE)]), paramBase[1]));
break;
case playSample_4IIIII_5V:
sound_play_sample(((unsigned char *) &FLASH_BASE[(p0*FLASH_PAGE_SIZE)]) + paramBase[1],paramBase[2],paramBase[3],paramBase[4]);
break;
case playQueuedSample_4_1BIIII_5I:
push_word(sound_add_sample((U8 *)jbyte_array(word2obj(p0)) + paramBase[1],paramBase[2],paramBase[3],paramBase[4]));
break;
case getTime_4_5I:
push_word(sound_get_time());
break;
case getDataAddress_4Ljava_3lang_3Object_2_5I:
if (is_array(word2obj(p0)))
push_word (ptr2word ((byte *) array_start(word2ptr(p0))));
else
push_word (ptr2word ((byte *) fields_start(word2ptr(p0))));
break;
case getObjectAddress_4Ljava_3lang_3Object_2_5I:
push_word(p0);
break;
case gc_4_5V:
// Restartable garbage collection
return garbage_collect();
case shutDown_4_5V:
shutdown(); // does not return
case boot_4_5V:
display_clear(1);
while (1) nxt_avr_firmware_update_mode(); // does not return
case arraycopy_4Ljava_3lang_3Object_2ILjava_3lang_3Object_2II_5V:
return arraycopy(word2ptr(p0), paramBase[1], word2ptr(paramBase[2]), paramBase[3], paramBase[4]);
case executeProgram_4I_5V:
// Exceute program, allow for instruction re-start
return execute_program(p0);
case setDebug_4_5V:
set_debug(word2ptr(p0));
break;
case eventOptions_4II_5I:
{
byte old = debugEventOptions[p0];
debugEventOptions[p0] = (byte)paramBase[1];
push_word(old);
}
break;
case suspendThread_4Ljava_3lang_3Object_2_5V:
suspend_thread(ref2ptr(p0));
break;
case resumeThread_4Ljava_3lang_3Object_2_5V:
resume_thread(ref2ptr(p0));
break;
case getProgramExecutionsCount_4_5I:
push_word(gProgramExecutions);
break;
case getFirmwareRevision_4_5I:
push_word((STACKWORD) getRevision());
break;
case getFirmwareRawVersion_4_5I:
push_word((STACKWORD) VERSION_NUMBER);
break;
case hsEnable_4II_5V:
{
if (hs_enable((int)p0, (int)paramBase[1]) == 0)
return EXEC_RETRY;
}
break;
case hsDisable_4_5V:
{
hs_disable();
}
break;
case hsWrite_4_1BII_5I:
{
Object *p = word2ptr(p0);
byte *byteArray = (byte *) jbyte_array(p);
push_word(hs_write(byteArray, paramBase[1], paramBase[2]));
}
break;
case hsRead_4_1BII_5I:
{
Object *p = word2ptr(p0);
byte *byteArray = (byte *) jbyte_array(p);
push_word(hs_read(byteArray, paramBase[1], paramBase[2]));
}
break;
case hsPending_4_5I:
{
push_word(hs_pending());
}
break;
case hsSend_4BB_1BII_1C_5I:
{
Object *p = word2ptr(paramBase[2]);
U8 *data = (U8 *)jbyte_array(p);
p = word2ptr(paramBase[5]);
U16 *crc = (U16 *)jchar_array(p);
push_word(hs_send((U8) p0, (U8)paramBase[1], data, paramBase[3], paramBase[4], crc));
}
break;
case hsRecv_4_1BI_1CI_5I:
{
Object *p = word2ptr(p0);
U8 *data = (U8 *)jbyte_array(p);
p = word2ptr(paramBase[2]);
U16 *crc = (U16 *)jchar_array(p);
push_word(hs_recv(data, paramBase[1], crc, paramBase[3]));
}
break;
case getUserPages_4_5I:
push_word(FLASH_MAX_PAGES - flash_start_page);
break;
case setVMOptions_4I_5V:
gVMOptions = p0;
break;
case getVMOptions_4_5I:
push_word(gVMOptions);
break;
case isAssignable_4II_5Z:
push_word(is_assignable(p0, paramBase[1]));
break;
case cloneObject_4Ljava_3lang_3Object_2_5Ljava_3lang_3Object_2:
{
Object *newObj = clone((Object *)ref2obj(p0));
if (newObj == NULL) return EXEC_RETRY;
push_word(obj2ref(newObj));
}
break;
case memPeek_4III_5I:
push_word(mem_peek(p0, paramBase[1], paramBase[2]));
break;
case memCopy_4Ljava_3lang_3Object_2IIII_5V:
mem_copy(word2ptr(p0), paramBase[1], paramBase[2], paramBase[3], paramBase[4]);
break;
case memGetReference_4II_5Ljava_3lang_3Object_2:
push_word(mem_get_reference(p0, paramBase[1]));
break;
case setSensorPin_4III_5V:
sp_set(p0, paramBase[1], paramBase[2]);
break;
case getSensorPin_4II_5I:
push_word(sp_get(p0, paramBase[1]));
break;
case setSensorPinMode_4III_5V:
sp_set_mode(p0, paramBase[1], paramBase[2]);
break;
case readSensorPin_4II_5I:
push_word(sp_read(p0, paramBase[1]));
break;
case nanoTime_4_5J:
{
U64 ns = systick_get_ns();
push_word(ns >> 32);
push_word(ns);
}
break;
case createStackTrace_4Ljava_3lang_3Thread_2Ljava_3lang_3Object_2_5_1I:
{
Object *trace = create_stack_trace((Thread *)ref2obj(p0), ref2obj(paramBase[1]));
if (trace == NULL) return EXEC_RETRY;
push_word(obj2ref(trace));
}
break;
case registerEvent_4_5I:
push_word(register_event((NXTEvent *) ref2obj(p0)));
break;
case unregisterEvent_4_5I:
push_word(unregister_event((NXTEvent *) ref2obj(p0)));
break;
case changeEvent_4II_5I:
push_word(change_event((NXTEvent *) ref2obj(p0), paramBase[1], paramBase[2]));
break;
case isInitialized_4I_5Z:
push_word(is_initialized_idx(p0));
break;
case allocate_4II_5Ljava_3lang_3Object_2:
{
Object *allocated;
if(paramBase[1]>0){
allocated=new_single_array(p0,paramBase[1]);
}else{
allocated=new_object_for_class(p0);
}
if(allocated == NULL) return EXEC_RETRY;
push_word(obj2ref(allocated));
}
break;
case memPut_4IIII_5V:
store_word_ns((byte *)(memory_base[p0] + paramBase[1]), paramBase[2],paramBase[3]);
break;
case notifyEvent_4ILjava_3lang_3Thread_2_5Z:
push_word(debug_event(paramBase[1], NULL, (Thread*) ref2obj(paramBase[2]), 0, 0, 0, 0));
break;
case setThreadRequest_4Ljava_3lang_3Thread_2Llejos_3nxt_3debug_3SteppingRequest_2_5V:
{
Thread *th = (Thread*) ref2obj(p0);
th->debugData = (REFERENCE) paramBase[1];
// currently we only get stepping requests
if(paramBase[1])
th->flags |= THREAD_STEPPING;
else
th->flags &= ~THREAD_STEPPING;
}
break;
case isStepping_4Ljava_3lang_3Thread_2_5Z:
{
Thread *th = (Thread*) ref2obj(p0);
push_word(is_stepping(th));
}
break;
case setBreakpointList_4_1Llejos_3nxt_3debug_3Breakpoint_2I_5V:
breakpoint_set_list((Breakpoint**) array_start(p0), paramBase[1]);
break;
case enableBreakpoint_4Llejos_3nxt_3debug_3Breakpoint_2Z_5V:
breakpoint_enable((Breakpoint*) word2ptr(p0), (boolean) paramBase[1]);
break;
case firmwareExceptionHandler_4Ljava_3lang_3Throwable_2II_5V:
firmware_exception_handler((Throwable *)p0, paramBase[1], paramBase[2]);
break;
case exitThread_4_5V:
currentThread->state = DEAD;
schedule_request(REQUEST_SWITCH_THREAD);
break;
case updateThreadFlags_4Ljava_3lang_3Thread_2II_5I:
((Thread *)p0)->flags |= paramBase[1];
((Thread *)p0)->flags &= ~paramBase[2];
//printf("m %x %d\n", p0, ((Thread *)p0)->flags);
push_word(((Thread *)p0)->flags);
break;
default:
return throw_new_exception(JAVA_LANG_NOSUCHMETHODERROR);
}
return EXEC_CONTINUE;
}
