// the ctbot class
void native_ctbot_clock_invoke(u08_t mref) {
// JAVA: void delayMilliseconds(int msec)
if(mref == NATIVE_METHOD_delayMilliseconds) {
nvm_int_t time = stack_pop_int();
while(time--)
_delay_ms(1);
}
// JAVA: void delayMicroseconds(int usec)
else if(mref == NATIVE_METHOD_delayMicroseconds) {
nvm_int_t time = stack_pop_int();
_delay_us(time);
}
// JAVA: int getSeconds()
else if(mref == NATIVE_METHOD_getSeconds) {
cli();
nvm_int_t res = pwm_timer_sec;
sei();
stack_push(res);
}
// JAVA: int getMiliseconds()
else if(mref == NATIVE_METHOD_getMilliseconds) {
cli();
nvm_int_t res = pwm_timer_ms;
sei();
stack_push(res);
}
}
// the Adc class
void native_avr_adc_invoke(u08_t mref) {
if(mref == NATIVE_METHOD_ADC_SETPRESCALER) {
ADCSRA = _BV(ADEN) | (stack_pop_int() & 7); // set prescaler value
} else if(mref == NATIVE_METHOD_ADC_SETREFERENCE) {
ADMUX = stack_pop_int() & 0xc0; // set reference value
} else if(mref == NATIVE_METHOD_ADC_GETVALUE) {
// ADLAR = 0
ADMUX = (ADMUX & 0xc0) | (stack_pop_int() & 0x0f);
// do conversion
ADCSRA |= _BV(ADSC); // Start conversion
while(!(ADCSRA & _BV(ADIF))); // wait for conversion complete
ADCSRA |= _BV(ADIF); // clear ADCIF
stack_push(ADCL + (ADCH << 8));
} else if(mref == NATIVE_METHOD_ADC_GETBYTE) {
// ADLAR = 1
ADMUX = (ADMUX & 0xc0) | _BV(ADLAR) | (stack_pop_int() & 0x0f);
// do conversion
ADCSRA |= _BV(ADSC); // Start conversion
while(!(ADCSRA & _BV(ADIF))); // wait for conversion complete
ADCSRA |= _BV(ADIF); // clear ADCIF
stack_push(ADCH);
} else
error(ERROR_NATIVE_UNKNOWN_METHOD);
}
// the timer class, based on STM32 32-bit timer 1
void native_stm32_timer_invoke(u08_t mref){
if(mref == NATIVE_METHOD_SETSPEED) {
/*OCR1A =*/ stack_pop_int(); // set reload value
} else if(mref == NATIVE_METHOD_GET) {
stack_push(ticks);
} else if(mref == NATIVE_METHOD_TWAIT) {
nvm_int_t wait = stack_pop_int();
ticks = 0;
while(ticks < wait); // reset watchdog here if enabled
} else if(mref == NATIVE_METHOD_SETPRESCALER) {
/*TCCR1B = */stack_pop_int();
} else
error(ERROR_NATIVE_UNKNOWN_METHOD);
}
// the ctbot class
void native_nibo_leds_invoke(u08_t mref) {
// JAVA: void setStatus(int state)
if(mref == NATIVE_METHOD_setStatus) {
nvm_int_t color = stack_pop_int();
nvm_int_t led = stack_pop_int();
if (color&0x01)
IO_LEDS_GREEN_PORT |= 0x04<<led;
else
IO_LEDS_GREEN_PORT &= ~(0x04<<led);
if (color&0x02)
IO_LEDS_RED_PORT |= 0x04<<led;
else
IO_LEDS_RED_PORT &= ~(0x04<<led);
}
// JAVA: int getStatus()
else if(mref == NATIVE_METHOD_getStatus) {
nvm_int_t led = stack_pop_int();
stack_push(led);
}
// JAVA: void setHeadlights(int state)
else if(mref == NATIVE_METHOD_setHeadlights) {
nvm_int_t light = stack_pop_int();
pwm_led_1 = light;
}
// JAVA: int getHeadlights()
else if(mref == NATIVE_METHOD_getHeadlights) {
nvm_int_t light = pwm_led_1;
stack_push(light);
}
// JAVA: void setDisplaylight(int state)
else if(mref == NATIVE_METHOD_setDisplaylight) {
nvm_int_t light = stack_pop_int();
pwm_led_2 = light;
}
// JAVA: int getDisplaylight()
else if(mref == NATIVE_METHOD_getDisplaylight) {
nvm_int_t light = pwm_led_2;
stack_push(light);
} else
error(ERROR_NATIVE_UNKNOWN_METHOD);
}
void native_nibo_motor_invoke(u08_t mref) {
// JAVA: void setParameters(int p, int i, int d)
if(mref == NATIVE_METHOD_setParameters) {
nvm_int_t d = stack_pop_int();
nvm_int_t i = stack_pop_int();
nvm_int_t p = stack_pop_int();
motco_setParameters(i, p, d);
}
// JAVA: void setPWM(int left, int right)
else if(mref == NATIVE_METHOD_setPWM) {
nvm_int_t right = stack_pop_int();
nvm_int_t left = stack_pop_int();
motco_setPWM(left, right);
}
// JAVA: void setSpeed(int left, int right)
else if(mref == NATIVE_METHOD_setSpeed) {
nvm_int_t right = stack_pop_int();
nvm_int_t left = stack_pop_int();
motco_setSpeed(left, right);
}
// JAVA: void stopt()
else if(mref == NATIVE_METHOD_stop) {
motco_stop();
}
// ERROR
else {
error(ERROR_NATIVE_UNKNOWN_METHOD);
}
}
void print_dijkstra_min_path(const Dijkstra_Result *result, const Graph *graph) {
int i, temp;
Stack *stack = get_Stack();
for (i = 0; i < graph->size; ++i) {
if (i != result->original)
stack_push_int(stack, i);
temp = result->min_path[i];
stack_push_int(stack, temp);
while (temp != result->original) {
temp = result->min_path[temp];
stack_push_int(stack, temp);
}
temp = stack_pop_int(stack);
while (temp != EMPTY) {
printf("%s ", graph->node[temp].name);
temp = stack_pop_int(stack);
}
printf("\n");
}
free(stack);
}
void print_floyd_result(const Graph *graph, const Floyd_Result *result) {
int i, j;
int temp;
Stack *stack = get_Stack();
for (i = 0; i < graph->size; ++i) {
for (j = 0; j < graph->size; ++j) {
printf("%d ", result->min_weight[i][j]);
}
printf("\n");
}
for (i = 0; i < graph->size; ++i) {
for (j = 0; j < graph->size; ++j) {
if (i == j)
continue;
printf("\n");
if (result->min_path[i][j] == NOT_FIND) {
printf("No path from %s to %s\n", graph->node[i].name, graph->node[j].name);
continue;
}
stack_push_int(stack, j);
temp = result->min_path[i][j];
while (temp != i) {
stack_push_int(stack, temp);
temp = result->min_path[i][temp];
}
stack_push_int(stack, i);
temp = stack_pop_int(stack);
while (temp != EMPTY) {
printf("%s ", graph->node[temp].name);
temp = stack_pop_int(stack);
}
printf("%d", result->min_weight[i][j]);
}
}
}
// the ctbot class
void native_ctbot_bot_invoke(u08_t mref) {
// JAVA: boolean getError()
if(mref == NATIVE_METHOD_getError) {
nvm_int_t val = get_input_bit(IO_SENS_ERROR)?1:0;
stack_push(val);
}
// JAVA: void setExtension1Enabled()
else if(mref == NATIVE_METHOD_setExtension1Enabled) {
if (stack_pop_int())
shift_reg_ena &= ~(uint8_t)ENA_ERW1;
else
shift_reg_ena |= ENA_ERW1;
shift_data(shift_reg_ena, SHIFT_REGISTER_ENA);
}
// JAVA: int getExtension1Enabled()
else if(mref == NATIVE_METHOD_getExtension1Enabled) {
nvm_int_t val = (shift_reg_ena & ENA_ERW1)?1:0;
stack_push(val);
}
// JAVA: int setExtension2Enabled()
else if(mref == NATIVE_METHOD_setExtension2Enabled) {
if (stack_pop_int())
shift_reg_ena &= ~(uint8_t)ENA_ERW2;
else
shift_reg_ena |= ENA_ERW2;
shift_data(shift_reg_ena, SHIFT_REGISTER_ENA);
}
// JAVA: int getExtension2Enabled()
else if(mref == NATIVE_METHOD_getExtension2Enabled) {
nvm_int_t val = (shift_reg_ena & ENA_ERW2)?1:0;
stack_push(val);
}
}
// the ctbot class
void native_ctbot_wheelencoder_invoke(u08_t mref) {
// JAVA: int getLeftInc()
if(mref == NATIVE_METHOD_getLeftInc) {
cli();
nvm_int_t val = (int16_t)wheelencoder_l;
wheelencoder_l = 0;
sei();
stack_push(val);
}
// JAVA: int getRightInc()
else if(mref == NATIVE_METHOD_getRightInc) {
cli();
nvm_int_t val = (int16_t)wheelencoder_r;
wheelencoder_r = 0;
sei();
stack_push(val);
}
// JAVA: void setEnabled(boolean enabled)
else if(mref == NATIVE_METHOD_setEnabled) {
if (stack_pop_int())
shift_reg_ena &= ~(uint8_t)ENA_RADLED;
else
shift_reg_ena |= ENA_RADLED;
shift_data(shift_reg_ena, SHIFT_REGISTER_ENA);
}
// JAVA: boolean getEnabled()
else if(mref == NATIVE_METHOD_getEnabled) {
stack_push((shift_reg_ena & ENA_RADLED)?1:0);
}
// JAVA: int getLeftSpeed()
else if(mref == NATIVE_METHOD_getLeftSpeed) {
cli();
nvm_int_t val = pid_left_speed;
sei();
stack_push(val);
}
// JAVA: int getRightSpeed()
else if(mref == NATIVE_METHOD_getRightSpeed) {
cli();
nvm_int_t val = pid_right_speed;
sei();
stack_push(val);
}
}
void native_nvmcomm_invoke(u08_t mref) {
if(mref == NATIVE_METHOD_SEND) {
uint8_t len = (uint8_t)stack_pop_int();
uint8_t *buf = (uint8_t *)stack_pop_addr();
uint8_t dest = (uint8_t)stack_pop_int();
DEBUGF_COMM("native send to "DBG8"\n", dest);
DEBUGF_COMM(""DBG8" bytes:", len);
for (uint8_t i=1; i<len+1; i++)
DEBUGF_COMM("["DBG8"] ", buf[i]);
DEBUGF_COMM("\n");
stack_push(nvmcomm_send(dest, NVMCOMM_CMD_APPMSG, buf+1, len)); // +1 to skip the first byte which indicates the type of the array
} else if(mref == NATIVE_METHOD_RECEIVE) {
nvm_int_t waitmsec=stack_pop_int();
DEBUGF_COMM("native nvmcomm.receive: waiting "DBG16" msec\n", waitmsec);
while (nvc3_appmsg_size==0 && waitmsec>0) {
delay(MILLISEC(1));
// Check if there's any packet coming in that we need to handle before processing the next VM instruction.
// Need to do this here because the VM's main loop is stopped.
// TODO: Reconsider this when we have a better design for receiving messages.
nvmcomm_poll();
waitmsec--;
}
if (nvc3_appmsg_size==0) {
// Nothing was received, return NULL;
stack_push(0);
DEBUGF_COMM("native nvmcomm.receive: timeout\n");
} else {
DEBUGF_COMM("native nvmcomm.receive: received "DBG8" bytes\n", nvc3_appmsg_size);
// TODO: copy the data to a Java array and return it.
heap_id_t array = array_new(nvc3_appmsg_size, T_BYTE);
for (uint8_t i=0; i<nvc3_appmsg_size; i++)
array_bastore(array, i, nvc3_appmsg_buf[i]);
stack_push(array | NVM_TYPE_HEAP);
nvc3_appmsg_size = 0; // Buffer available for next message
}
} else
error(ERROR_NATIVE_UNKNOWN_METHOD);
}
// the ctbot class
void native_nibobee_linedetector_invoke(u08_t mref) {
// JAVA: int getValue(int idx)
if (mref == NATIVE_METHOD_getValue) {
nvm_int_t val = stack_pop_int();
val = line_get(val);
stack_push(val);
}
// JAVA: void calibrateWhite()
else if (mref == NATIVE_METHOD_calibrateWhite) {
line_calibrateWhite();
line_writePersistent();
}
// JAVA: void calibrateBlack()
else if (mref == NATIVE_METHOD_calibrateBlack) {
line_calibrateBlack();
line_writePersistent();
}
// JAVA: void setEnableIR(boolean val)
else if (mref == NATIVE_METHOD_setEnableIR) {
/* nvm_int_t val = */ stack_pop_int();
}
// JAVA: boolean getEnableIR()
else if (mref == NATIVE_METHOD_getEnableIR) {
nvm_int_t val = 1;
stack_push(val);
}
// ERROR
else
error(ERROR_NATIVE_UNKNOWN_METHOD);
}
// the ctbot class
void native_nibobee_clock_invoke(u08_t mref) {
// JAVA: void delayMilliseconds(int msec)
if(mref == NATIVE_METHOD_delayMilliseconds) {
nvm_int_t time = stack_pop_int();
sei();
while(time--)
_delay_ms(1);
}
// JAVA: void delayMicroseconds(int usec)
else if(mref == NATIVE_METHOD_delayMicroseconds) {
nvm_int_t time = stack_pop_int();
sei();
_delay_us(time);
}
// JAVA: int getSeconds()
else if(mref == NATIVE_METHOD_getSeconds) {
cli();
nvm_int_t res = clock_sec;
sei();
stack_push(res);
}
// JAVA: int getMiliseconds()
else if(mref == NATIVE_METHOD_getMilliseconds) {
cli();
nvm_int_t res = clock_ms;
sei();
stack_push(res);
} else
error(ERROR_NATIVE_UNKNOWN_METHOD);
}
void native_nibo_distsensor_invoke(u08_t mref) {
// JAVA: void update()
if(mref == NATIVE_METHOD_update) {
copro_update_dist();
}
// JAVA: int getSensor(int id)
else if(mref == NATIVE_METHOD_getSensor) {
nvm_int_t id = stack_pop_int();
if ((id<0) || (id>4))
error(ERROR_NATIVE_ILLEGAL_ARGUMENT);
nvm_int_t val = copro_distance[id]/256;
stack_push(val);
}
// JAVA: void setEnabled(boolean enabled)
else if(mref == NATIVE_METHOD_setEnabled) {
if (stack_pop_int()) {
enabled=1;
copro_ir_startMeasure();
} else {
enabled=0;
copro_ir_stop();
}
}
// JAVA: boolean getEnabled()
else if(mref == NATIVE_METHOD_getEnabled) {
stack_push(enabled);
}
// ERROR
else {
error(ERROR_NATIVE_UNKNOWN_METHOD);
}
}
// the ctbot class
void native_nibo_irtransceiver_invoke(u08_t mref) {
// JAVA: int getCommand()
if(mref == NATIVE_METHOD_getCommand) {
copro_update_dist();
nvm_int_t val = copro_rc5_cmd;
copro_rc5_cmd = 0;
stack_push(val);
}
// JAVA: void sendCommand(int)
else if(mref == NATIVE_METHOD_sendCommand) {
nvm_int_t val = stack_pop_int();
copro_transmitRC5(val);
}
// ERROR
else {
error(ERROR_NATIVE_UNKNOWN_METHOD);
}
}
// the ctbot class
void native_ctbot_edgedetector_invoke(u08_t mref) {
// JAVA: void updateLeft()
if(mref == NATIVE_METHOD_updateLeft) {
value_l = adc_read(SENS_KANTE_L);
}
// JAVA: void updateRight()
else if(mref == NATIVE_METHOD_updateRight) {
value_r = adc_read(SENS_KANTE_R);
}
// JAVA: int getLeft()
else if(mref == NATIVE_METHOD_getLeft) {
nvm_int_t val = value_l;
stack_push(val);
}
// JAVA: int getRight()
else if(mref == NATIVE_METHOD_getRight) {
nvm_int_t val = value_r;
stack_push(val);
}
// JAVA: void setEnabled(boolean enabled)
else if(mref == NATIVE_METHOD_setEnabled) {
if (stack_pop_int())
shift_reg_ena &= ~(uint8_t)ENA_KANTLED;
else
shift_reg_ena |= ENA_KANTLED;
shift_data(shift_reg_ena, SHIFT_REGISTER_ENA);
}
// JAVA: boolean getEnabled()
else if(mref == NATIVE_METHOD_getEnabled) {
stack_push((shift_reg_ena & ENA_KANTLED)?1:0);
}
}
// the ctbot class
void native_ctbot_lightbarrier_invoke(u08_t mref) {
// JAVA: void getState()
if(mref == NATIVE_METHOD_getState) {
nvm_int_t val = get_input_bit(IO_SENS_SCHRANKE)?1:0;
stack_push(val);
}
// JAVA: void setEnabled()
else if(mref == NATIVE_METHOD_setEnabled) {
if (stack_pop_int())
shift_reg_ena &= ~(uint8_t)ENA_SCHRANKE;
else
shift_reg_ena |= ENA_SCHRANKE;
shift_data(shift_reg_ena, SHIFT_REGISTER_ENA);
}
// JAVA: boolean getEnabled()
else if(mref == NATIVE_METHOD_getEnabled) {
nvm_int_t val = (shift_reg_ena & ENA_SCHRANKE)?1:0;
stack_push(val);
}
}
void native_math_invoke(u08_t mref) {
if(mref == NATIVE_METHOD_absF) {
stack_push(nvm_float2stack(fabs(stack_pop_float())));
} else if(mref == NATIVE_METHOD_absI) {
stack_push(nvm_int2stack(abs(stack_pop_int())));
} else if(mref == NATIVE_METHOD_acos) {
stack_push(nvm_float2stack(acos(stack_pop_float())));
} else if(mref == NATIVE_METHOD_asin) {
stack_push(nvm_float2stack(asin(stack_pop_float())));
} else if(mref == NATIVE_METHOD_atan) {
stack_push(nvm_float2stack(atan(stack_pop_float())));
} else if(mref == NATIVE_METHOD_atan2) {
nvm_float_t a = stack_pop_float();
nvm_float_t b = stack_pop_float();
stack_push(nvm_float2stack(atan2(a,b)));
} else if(mref == NATIVE_METHOD_ceil) {
stack_push(nvm_float2stack(ceil(stack_pop_float())));
} else if(mref == NATIVE_METHOD_cos) {
stack_push(nvm_float2stack(cos(stack_pop_float())));
} else if(mref == NATIVE_METHOD_exp) {
stack_push(nvm_float2stack(exp(stack_pop_float())));
} else if(mref == NATIVE_METHOD_floor) {
stack_push(nvm_float2stack(floor(stack_pop_float())));
} else if(mref == NATIVE_METHOD_log) {
stack_push(nvm_float2stack(log(stack_pop_float())));
} else if(mref == NATIVE_METHOD_maxF) {
nvm_float_t a=stack_pop_float();
nvm_float_t b=stack_pop_float();
stack_push(nvm_float2stack(a>b?a:b));
} else if(mref == NATIVE_METHOD_maxI) {
nvm_int_t a=stack_pop_int();
nvm_int_t b=stack_pop_int();
stack_push(nvm_int2stack(a>b?a:b));
} else if(mref == NATIVE_METHOD_minI) {
nvm_int_t a=stack_pop_int();
nvm_int_t b=stack_pop_int();
stack_push(nvm_int2stack(a<b?a:b));
} else if(mref == NATIVE_METHOD_minF) {
nvm_float_t a=stack_pop_float();
nvm_float_t b=stack_pop_float();
stack_push(nvm_float2stack(a<b?a:b));
} else if(mref == NATIVE_METHOD_pow) {
nvm_float_t a = stack_pop_float();
nvm_float_t b = stack_pop_float();
stack_push(nvm_float2stack(pow(a,b)));
} else if(mref == NATIVE_METHOD_random) {
stack_push(nvm_float2stack((nvm_float_t)rand()/RAND_MAX));
} else if(mref == NATIVE_METHOD_rint) {
stack_push(nvm_float2stack((int)(stack_pop_float())));
} else if(mref == NATIVE_METHOD_round) {
stack_push(nvm_int2stack((int)(stack_pop_float())));
} else if(mref == NATIVE_METHOD_sin) {
stack_push(nvm_float2stack(sin(stack_pop_float())));
} else if(mref == NATIVE_METHOD_sqrt) {
stack_push(nvm_float2stack(sqrt(stack_pop_float())));
} else if(mref == NATIVE_METHOD_tan) {
stack_push(nvm_float2stack(tan(stack_pop_float())));
} else if(mref == NATIVE_METHOD_toDegrees) {
stack_push(nvm_float2stack(180/M_PI*stack_pop_float()));
} else if(mref == NATIVE_METHOD_toRadians) {
stack_push(nvm_float2stack(M_PI/180*stack_pop_float()));
} else
error(ERROR_NATIVE_UNKNOWN_METHOD);
}
// the ctbot class
void native_ctbot_motor_invoke(u08_t mref) {
// JAVA: void setLeft(int val)
if(mref == NATIVE_METHOD_setLeft) {
nvm_int_t val = stack_pop_int();
cli();
pwm_motor_l=val;
pid_mode &= ~PID_LEFT_ENABLED;
sei();
}
// JAVA: void setRight(int val)
else if(mref == NATIVE_METHOD_setRight) {
nvm_int_t val = stack_pop_int();
cli();
pwm_motor_r=val;
pid_mode &= ~PID_RIGHT_ENABLED;
sei();
}
else if(mref == NATIVE_METHOD_setLeftSpeed) {
nvm_int_t val = stack_pop_int();
cli();
pid_left_value=val;
pid_mode |= PID_LEFT_ENABLED;
sei();
}
// JAVA: void setRight(int val)
else if(mref == NATIVE_METHOD_setRightSpeed) {
nvm_int_t val = stack_pop_int();
cli();
pid_right_value=val;
pid_mode |= PID_RIGHT_ENABLED;
sei();
}
// JAVA: int getLeft()
else if(mref == NATIVE_METHOD_getLeft) {
nvm_int_t val = pwm_motor_l;
stack_push(val);
}
// JAVA: int getRight()
else if(mref == NATIVE_METHOD_getRight) {
nvm_int_t val = pwm_motor_r;
stack_push(val);
}
// JAVA: int getLeft()
else if(mref == NATIVE_METHOD_getLeftSpeed) {
nvm_int_t val = pwm_motor_l;
stack_push(val);
}
// JAVA: int getRight()
else if(mref == NATIVE_METHOD_getRightSpeed) {
nvm_int_t val = pwm_motor_r;
stack_push(val);
}
// JAVA: void stopt()
else if(mref == NATIVE_METHOD_stop) {
cli();
pwm_motor_r = 0;
pwm_motor_l = 0;
pid_mode &= ~(PID_RIGHT_ENABLED|PID_LEFT_ENABLED);
pid_reset();
sei();
}
}
