// 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(); } }