/* FPレジスタ内容表示器 */
void printFPRegister(unsigned int* fpreg) {
// unsigned int rZ, rV, rN, rCarry; // condition register
int i=0,j=0;
// printf("R[Condition] ZVNC = %X/%X/%X/%X \n", rZ, rV, rN, rCarry);
for(i=0; i<FPREGSIZE; i++) {
if(i%4 == 0) {
printf("\tFP[%2d->%2d] : %12X ", i, i+3, fpreg[i]);
} else if( (i+1)%4 == 0 ) {
printf("%12X\n",fpreg[i]);
for(j=i-3;j<i+1;j++) {
if(j%4 == 0) {
printf("\t %12.3f ", printFloat(fpreg[j]));
} else if( (j+1)%4 == 0 ) {
printf("%12.3f\n",printFloat(fpreg[j]));
break;
} else {
printf("%12.3f ",printFloat(fpreg[j]));
}
}
} else {
printf("%12X ",fpreg[i]);
}
}
printf("\n");
}
size_t Print::print(double n, int digits, int digitsBefore)
{
if (digitsBefore> 0)
return printFloat(n, digits, digitsBefore);
else
return printFloat(n, digits);
}
// Prints gcode coordinate offset parameters
void report_gcode_parameters()
{
float coord_data[N_AXIS];
uint8_t coord_select, i;
for (coord_select = 0; coord_select <= SETTING_INDEX_NCOORD; coord_select++) {
if (!(settings_read_coord_data(coord_select,coord_data))) {
report_status_message(STATUS_SETTING_READ_FAIL);
return;
}
printPgmString(PSTR("[G"));
switch (coord_select) {
case 0: printPgmString(PSTR("54:")); break;
case 1: printPgmString(PSTR("55:")); break;
case 2: printPgmString(PSTR("56:")); break;
case 3: printPgmString(PSTR("57:")); break;
case 4: printPgmString(PSTR("58:")); break;
case 5: printPgmString(PSTR("59:")); break;
case 6: printPgmString(PSTR("28:")); break;
case 7: printPgmString(PSTR("30:")); break;
// case 8: printPgmString(PSTR("92:")); break; // G92.2, G92.3 not supported. Hence not stored.
}
for (i=0; i<N_AXIS; i++) {
printFloat(coord_data[i]*report_distance_conversion);
if (i < (N_AXIS-1)) { printPgmString(PSTR(",")); }
else { printPgmString(PSTR("]\r\n")); }
}
}
printPgmString(PSTR("[G92:")); // Print G92,G92.1 which are not persistent in memory
for (i=0; i<N_AXIS; i++) {
printFloat(gc.coord_offset[i]*report_distance_conversion);
if (i < (N_AXIS-1)) { printPgmString(PSTR(",")); }
else { printPgmString(PSTR("]\r\n")); }
}
}
void printFloat_RateValue(float n) {
if (bit_istrue(settings.flags,BITFLAG_REPORT_INCHES)) {
printFloat(n*INCH_PER_MM,N_DECIMAL_RATEVALUE_INCH);
} else {
printFloat(n,N_DECIMAL_RATEVALUE_MM);
}
}
void SerialManager::call(int _mode, int _move, int _lastMove, float _heading, float _lat, float _lon, float _wplat, float _wplon, float _waypointDistance, float _waypointDirection)
{
if(_mode == 1)
{
Serial1.println("");
Serial1.println("");
Serial1.println("--------------");
Serial1.print("move=");
serialMove(_move);
Serial1.println("--------------");
Serial1.print("GPS_lat=");
printFloat(_lat, 1000000000);
Serial1.print("GPS_lon=");
printFloat(_lon, 1000000000);
Serial1.println("--------------");
Serial1.print("WAY_currentWaypointLAT=");
printFloat(_wplat, 1000000000);
Serial1.print("WAY_currentWaypointLON=");
printFloat(_wplon, 1000000000);
Serial1.print("WAY_waypointDistance=");
printFloat(_waypointDistance, 1000000);
Serial1.print("WAY_waypointDirection=");
Serial1.println(_waypointDirection);
Serial1.println("--------------");
Serial1.print("COMP_heading=");
Serial1.println(_heading);
}
}
void dump(const char *name, float64x2 vec)
{
printf("%s: ", name);
printFloat(emscripten_float64x2_extractLane(vec, 0));
printf(" ");
printFloat(emscripten_float64x2_extractLane(vec, 1));
printf("\n");
}
// Prints real-time data. This function grabs a real-time snapshot of the stepper subprogram
// and the actual location of the CNC machine. Users may change the following function to their
// specific needs, but the desired real-time data report must be as short as possible. This is
// requires as it minimizes the computational overhead and allows grbl to keep running smoothly,
// especially during g-code programs with fast, short line segments and high frequency reports (5-20Hz).
void report_realtime_status()
{
// **Under construction** Bare-bones status report. Provides real-time machine position relative to
// the system power on location (0,0,0) and work coordinate position (G54 and G92 applied). Eventually
// to be added are distance to go on block, processed block id, and feed rate. Also a settings bitmask
// for a user to select the desired real-time data.
uint8_t i;
int32_t current_position[N_AXIS]; // Copy current state of the system position variable
memcpy(current_position,sys.position,sizeof(sys.position));
float print_position[N_AXIS];
// Report current machine state
switch (sys.state) {
case STATE_IDLE: printPgmString(PSTR("<Idle")); break;
case STATE_QUEUED: printPgmString(PSTR("<Queue")); break;
case STATE_CYCLE: printPgmString(PSTR("<Run")); break;
case STATE_HOLD: printPgmString(PSTR("<Hold")); break;
case STATE_HOMING: printPgmString(PSTR("<Home")); break;
case STATE_ALARM: printPgmString(PSTR("<Alarm")); break;
case STATE_CHECK_MODE: printPgmString(PSTR("<Check")); break;
}
// Report machine position
printPgmString(PSTR(",MPos:"));
for (i=0; i< N_AXIS; i++) {
print_position[i] = current_position[i]/settings.steps_per_mm[i];
if (bit_istrue(settings.flags,BITFLAG_REPORT_INCHES)) { print_position[i] *= INCH_PER_MM; }
printFloat(print_position[i]);
printPgmString(PSTR(","));
}
// Report work position
printPgmString(PSTR("WPos:"));
for (i=0; i< N_AXIS; i++) {
if (bit_istrue(settings.flags,BITFLAG_REPORT_INCHES)) {
print_position[i] -= (gc.coord_system[i]+gc.coord_offset[i])*INCH_PER_MM;
} else {
print_position[i] -= gc.coord_system[i]+gc.coord_offset[i];
}
printFloat(print_position[i]);
if (i < (N_AXIS-1)) { printPgmString(PSTR(",")); }
}
#ifdef USE_LINE_NUMBERS
// Report current line number
printPgmString(PSTR(",Ln:"));
int32_t ln=0;
plan_block_t * pb = plan_get_current_block();
if(pb != NULL) {
ln = pb->line_number;
}
printInteger(ln);
#endif
printPgmString(PSTR(">\r\n"));
}
// Print current gcode parser mode state
void report_gcode_modes()
{
switch (gc.motion_mode) {
case MOTION_MODE_SEEK : printPgmString(PSTR("[G0")); break;
case MOTION_MODE_LINEAR : printPgmString(PSTR("[G1")); break;
case MOTION_MODE_CW_ARC : printPgmString(PSTR("[G2")); break;
case MOTION_MODE_CCW_ARC : printPgmString(PSTR("[G3")); break;
case MOTION_MODE_CANCEL : printPgmString(PSTR("[G80")); break;
}
printPgmString(PSTR(" G"));
printInteger(gc.coord_select+54);
if (gc.plane_axis_0 == X_AXIS) {
if (gc.plane_axis_1 == Y_AXIS) { printPgmString(PSTR(" G17")); }
else { printPgmString(PSTR(" G18")); }
} else { printPgmString(PSTR(" G19")); }
if (gc.inches_mode) { printPgmString(PSTR(" G20")); }
else { printPgmString(PSTR(" G21")); }
if (gc.absolute_mode) { printPgmString(PSTR(" G90")); }
else { printPgmString(PSTR(" G91")); }
if (gc.inverse_feed_rate_mode) { printPgmString(PSTR(" G93")); }
else { printPgmString(PSTR(" G94")); }
switch (gc.program_flow) {
case PROGRAM_FLOW_RUNNING : printPgmString(PSTR(" M0")); break;
case PROGRAM_FLOW_PAUSED : printPgmString(PSTR(" M1")); break;
case PROGRAM_FLOW_COMPLETED : printPgmString(PSTR(" M2")); break;
}
switch (gc.spindle_direction) {
case SPINDLE_ENABLE_CW : printPgmString(PSTR(" M3")); break;
case SPINDLE_ENABLE_CCW : printPgmString(PSTR(" M4")); break;
case SPINDLE_DISABLE : printPgmString(PSTR(" M5")); break;
}
switch (gc.coolant_mode) {
case COOLANT_DISABLE : printPgmString(PSTR(" M9")); break;
case COOLANT_FLOOD_ENABLE : printPgmString(PSTR(" M8")); break;
#ifdef ENABLE_M7
case COOLANT_MIST_ENABLE : printPgmString(PSTR(" M7")); break;
#endif
}
printPgmString(PSTR(" T"));
printInteger(gc.tool);
printPgmString(PSTR(" F"));
if (gc.inches_mode) { printFloat(gc.feed_rate*INCH_PER_MM); }
else { printFloat(gc.feed_rate); }
printPgmString(PSTR("]\r\n"));
}
void printStock( print_t *settings, char* ticker, size_t length, float value, float open, float close){
printString(settings,"Ticker: ", 8);
printString(settings,ticker,length);
printChar(settings,'\n');
printString(settings,"Value: ", 8);
printFloat(settings,value);
printChar(settings,'\n');
printString(settings,"Open: ", 8);
printFloat(settings,open);
printChar(settings,'\n');
printString(settings,"Close: ", 8);
printFloat(settings,close);
printChar(settings,'\n');
printChar(settings,'\n');
printChar(settings,'\n');
}
int main(void) {
float voltage;
// -------- Inits --------- //
initUSART();
printString("\r\nDigital Voltmeter\r\n\r\n");
initADC();
setupADCSleepmode();
// ------ Event loop ------ //
while (1) {
voltage = oversample16x() * VOLTAGE_DIV_FACTOR * REF_VCC / 4096;
printFloat(voltage);
/* alternatively, just print it out:
* printWord(voltage*100);
* but then you have to remember the decimal place
*/
_delay_ms(500);
} /* End event loop */
return 0; /* This line is never reached */
}
// Render a value to text.
char*
aJsonClass::printValue(aJsonObject *item)
{
char *out = NULL;
if (!item)
return NULL;
switch (item->type)
{
case aJson_NULL:
out = strdup("null");
break;
case aJson_False:
out = strdup("false");
break;
case aJson_True:
out = strdup("true");
break;
case aJson_Int:
out = printInt(item);
break;
case aJson_Float:
out = printFloat(item);
break;
case aJson_String:
out = printString(item);
break;
case aJson_Array:
out = printArray(item);
break;
case aJson_Object:
out = printObject(item);
break;
}
return out;
}
//translate omega1,2,3,4 to pwm1,2,3,4 and actuate motors accordingly
unsigned int controlled_speed(void)
{
unsigned int t1;
unsigned int t2;
unsigned int t3;
unsigned int t4;
if (controller_param->FCS == FCS_MOTOR_TEST) {
setDutyCycle(test_speed[0], 1);
setDutyCycle(test_speed[1], 2);
setDutyCycle(test_speed[2], 3);
setDutyCycle(test_speed[3], 4);
} else {
//actuate the motors
if (motor_on) {
t1 = normalize_speed(ctrl_data->omega1square);
t2 = normalize_speed(ctrl_data->omega2square);
t3 = normalize_speed(ctrl_data->omega3square);
t4 = normalize_speed(ctrl_data->omega4square);
//setDutyCycle(ZERO_SPEED_THROTTLE+normalize_speed(ctrl_data->omega1square), 1);
//setDutyCycle(ZERO_SPEED_THROTTLE+normalize_speed(ctrl_data->omega2square), 2);
//setDutyCycle(ZERO_SPEED_THROTTLE+normalize_speed(ctrl_data->omega3square), 3);
//setDutyCycle(ZERO_SPEED_THROTTLE+normalize_speed(ctrl_data->omega4square), 4);
if (speed_report_count == SPEED_REPORT_RATE) {
printf("T1: %u, T2: %u, T3: %u, T4: %u.\n\r", t1, t2, t3, t4);
//print the motor speeds
printf("M1: ");
printFloat(ctrl_data->omega1square);
printf(", M2: ");
printFloat(ctrl_data->omega2square);
printf(", M3: ");
printFloat(ctrl_data->omega3square);
printf(", M4: ");
printFloat(ctrl_data->omega4square);
printf(".\n\r");
printf("e_roll: ");
printFloat(kinetic_errs->roll_error);
printf("e_pitch: ");
printFloat(kinetic_errs->pitch_error);
printf(", e_yaw: ");
printFloat(kinetic_errs->yaw_error);
printf(", e_alt: ");
printFloat(kinetic_errs->altitude_error);
printf(".\n\r");
printf(".\n\r");
speed_report_count = 0;
} else {
speed_report_count++;
}
} else {
// gives zero throttle to all
setDutyCycle(6, 0);
}
}
}
// Prints real-time data. This function grabs a real-time snapshot of the stepper subprogram
// and the actual location of the CNC machine. Users may change the following function to their
// specific needs, but the desired real-time data report must be as short as possible. This is
// requires as it minimizes the computational overhead and allows grbl to keep running smoothly,
// especially during g-code programs with fast, short line segments and high frequency reports (5-20Hz).
void report_realtime_status()
{
// **Under construction** Bare-bones status report. Provides real-time machine position relative to
// the system power on location (0,0,0) and work coordinate position (G54 and G92 applied). Eventually
// to be added are distance to go on block, processed block id, and feed rate. Also a settings bitmask
// for a user to select the desired real-time data.
uint8_t i;
int32_t current_position[3]; // Copy current state of the system position variable
float print_position[3];
memcpy(current_position,sys.position,sizeof(sys.position));
// Report current machine state
switch (sys.state) {
case STATE_IDLE: printPgmString((const char *)("<Idle")); break;
// case STATE_INIT: printPgmString((const char *)("[Init")); break; // Never observed
case STATE_QUEUED: printPgmString((const char *)("<Queue")); break;
case STATE_CYCLE: printPgmString((const char *)("<Run")); break;
case STATE_HOLD: printPgmString((const char *)("<Hold")); break;
case STATE_HOMING: printPgmString((const char *)("<Home")); break;
case STATE_ALARM: printPgmString((const char *)("<Alarm")); break;
case STATE_CHECK_MODE: printPgmString((const char *)("<Check")); break;
}
// Report machine position
printPgmString((const char *)(",MPos:"));
for (i=0; i<= 2; i++) {
print_position[i] = current_position[i]/settings.steps_per_mm[i];
if (bit_istrue(settings.flags,BITFLAG_REPORT_INCHES)) { print_position[i] *= INCH_PER_MM; }
printFloat(print_position[i]);
printPgmString((const char *)(","));
}
// Report work position
printPgmString((const char *)("WPos:"));
for (i=0; i<= 2; i++) {
if (bit_istrue(settings.flags,BITFLAG_REPORT_INCHES)) {
print_position[i] -= (gc.coord_system[i]+gc.coord_offset[i])*INCH_PER_MM;
} else {
print_position[i] -= gc.coord_system[i]+gc.coord_offset[i];
}
printFloat(print_position[i]);
if (i < 2) { printPgmString((const char *)(",")); }
}
printPgmString((const char *)(">\r\n"));
}
int main()
{
float n;
printf("Enter a floating point number: ");
scanf("%f", &n);
int x=printFloat(n);
printf("\n");
return 0;
}
int main(void) {
float voltage1;
float voltage2;
float res1;
float res2;
// -------- Inits --------- //
initUSART();
setupADCSleepmode();
printString("\r\nDigital Voltmeter\r\n\r\n");
// ------ Event loop ------ //
while (1) {
initADC(0);
voltage1 = oversample16x();
printString("Thermistor 1:\r\n");
printFloat(voltage1);
//printVoltage(voltage1);
res1 = printThermRes(voltage1);
printTemp(res1);
printString("\r\n");
_delay_ms(100);
initADC(1);
voltage2 = oversample16x();
printString("Thermistor 2:\r\n");
printFloat(voltage2);
//printVoltage(voltage2);
res2 = printThermRes(voltage2);
printTemp(res2);
printString("\r\n");
_delay_ms(2500);
} /* End event loop */
return (0); /* This line is never reached */
}
void settings_dump() {
printPgmString(PSTR("$0 = ")); printFloat(settings.steps_per_mm[X_AXIS]);
printPgmString(PSTR(" (steps/mm x)\r\n$1 = ")); printFloat(settings.steps_per_mm[Y_AXIS]);
printPgmString(PSTR(" (steps/mm y)\r\n$2 = ")); printFloat(settings.steps_per_mm[Z_AXIS]);
printPgmString(PSTR(" (steps/mm z)\r\n$3 = ")); printInteger(settings.pulse_microseconds);
printPgmString(PSTR(" (microseconds step pulse)\r\n$4 = ")); printFloat(settings.default_feed_rate);
printPgmString(PSTR(" (mm/min default feed rate)\r\n$5 = ")); printFloat(settings.default_seek_rate);
printPgmString(PSTR(" (mm/min default seek rate)\r\n$6 = ")); printFloat(settings.mm_per_arc_segment);
printPgmString(PSTR(" (mm/arc segment)\r\n$7 = ")); printInteger(settings.invert_mask);
printPgmString(PSTR(" (step port invert mask. binary = ")); printIntegerInBase(settings.invert_mask, 2);
printPgmString(PSTR(")\r\n$8 = ")); printFloat(settings.acceleration/(60*60)); // Convert from mm/min^2 for human readability
printPgmString(PSTR(" (acceleration in mm/sec^2)\r\n$9 = ")); printFloat(settings.junction_deviation);
printPgmString(PSTR(" (cornering junction deviation in mm)"));
printPgmString(PSTR("\r\n'$x=value' to set parameter or just '$' to dump current settings\r\n"));
}
void main() {
struct line u;
float sd;
u.p.x = 0; u.p.y = 0;
u.q.x = 1; u.q.y = 0;
sd = (u.q.x - u.p.x)*(u.q.x - u.p.x) + (u.q.y - u.p.y)*(u.q.y - u.p.y);
printFloat("[CHKPT3]: unit line length (1.0) = ", sd);
println();
}
// Prints current probe parameters. Upon a probe command, these parameters are updated upon a
// successful probe or upon a failed probe with the G38.3 without errors command (if supported).
// These values are retained until Grbl is power-cycled, whereby they will be re-zeroed.
void report_probe_parameters()
{
uint8_t i;
float print_position[N_AXIS];
// Report in terms of machine position.
printPgmString(PSTR("[Probe:"));
for (i=0; i< N_AXIS; i++) {
print_position[i] = sys.probe_position[i]/settings.steps_per_mm[i];
if (bit_istrue(settings.flags,BITFLAG_REPORT_INCHES)) { print_position[i] *= INCH_PER_MM; }
printFloat(print_position[i]);
if (i < (N_AXIS-1)) { printPgmString(PSTR(",")); }
}
printPgmString(PSTR("]\r\n"));
}
void main() {
struct point p[2];
float sd;
p[0].x = 2.0; p[0].y = 2.0;
p[1].x = 3.0; p[1].y = 2.0;
sd = (p[1].x - p[0].x)*(p[1].x - p[0].x) +
(p[1].y - p[0].y)*(p[1].y - p[0].y);
printFloat("[CHKPT3]: distance between points (1.0) = ", sd);
println();
}
size_t Print::printFloat(double number, uint8_t digitsAfterComma, uint8_t digitsBeforeComma) {
long intnum = (long)number; // extract integer part
// compute number of digits
if (number < 0.0) {
digitsBeforeComma--;
intnum= -intnum;
}
while (intnum >= 10) {
intnum /= 10;
digitsBeforeComma--;
};
size_t n = 0;
while (digitsBeforeComma > 1) {
digitsBeforeComma --;
n += print(' ');
}
return n+ printFloat(number,digitsAfterComma);
}
void settings_dump() {
printPgmString(PSTR("PortC")); printInteger(PORTC);
// printPgmString(PSTR("\r\nPortA")); printInteger(PORTA);
// printPgmString(PSTR("\r\nPortB")); printInteger(PORTB);
printPgmString(PSTR("\r\nddrC")); printInteger(DDRC);
// printPgmString(PSTR("\r\nddrA")); printInteger(DDRA);
// printPgmString(PSTR("\r\nddrB")); printInteger(DDRB);
printPgmString(PSTR("\r\n$0 = ")); printFloat(settings.steps_per_mm[X_AXIS]);
printPgmString(PSTR(" (steps/mm x)\r\n$1 = ")); printFloat(settings.steps_per_mm[Y_AXIS]);
printPgmString(PSTR(" (steps/mm y)\r\n$2 = ")); printFloat(settings.steps_per_mm[Z_AXIS]);
printPgmString(PSTR(" (steps/mm z)\r\n$3 = ")); printInteger(settings.pulse_microseconds);
printPgmString(PSTR(" (microseconds step pulse)\r\n$4 = ")); printFloat(settings.default_feed_rate);
printPgmString(PSTR(" (mm/min default feed rate)\r\n$5 = ")); printFloat(settings.default_seek_rate);
printPgmString(PSTR(" (mm/min default seek rate)\r\n$6 = ")); printFloat(settings.mm_per_arc_segment);
printPgmString(PSTR(" (mm/arc segment)\r\n$7 = ")); printInteger(settings.invert_mask);
printPgmString(PSTR(" (step port invert mask. binary = ")); printIntegerInBase(settings.invert_mask, 2);
printPgmString(PSTR(")\r\n$8 = ")); printFloat(settings.acceleration);
printPgmString(PSTR(" (acceleration in mm/sec^2)\r\n$9 = ")); printFloat(settings.max_jerk);
printPgmString(PSTR(" (max instant cornering speed change in delta mm/min)"));
printPgmString(PSTR("\r\n'$x=value' to set parameter or just '$' to dump current settings\r\n"));
}
// Render a value to text.
int
aJsonClass::printValue(aJsonObject *item, FILE* stream)
{
int result = 0;
if (item == NULL)
{
//nothing to do
return 0;
}
switch (item->type)
{
case aJson_NULL:
result = fprintf(stream, PSTR("null"));
break;
case aJson_False:
result = fprintf_P(stream, PSTR("false"));
break;
case aJson_True:
result = fprintf_P(stream, PSTR("true"));
break;
case aJson_Int:
result = printInt(item, stream);
break;
case aJson_Float:
result = printFloat(item, stream);
break;
case aJson_String:
result = printString(item, stream);
break;
case aJson_Array:
result = printArray(item, stream);
break;
case aJson_Object:
result = printObject(item, stream);
break;
}
//good time to flush the stream
fflush(stream);
return result;
}
size_t Print::print(double n, int digits)
{
return printFloat(n, digits);
}
void MarlinSerial::print(double n, int digits) {
printFloat(n, digits);
}
size_t HWSerial::print(double n, int digits)
{
return printFloat(n, digits);
}
void SerialOutput::println_float_P(PGM_P ptr,float value,uint8_t digits) {
print_P(ptr);
printFloat(value,digits);
println();
}
void Com::printF(FSTRINGPARAM(text),float value,uint8_t digits) {
printF(text);
printFloat(value,digits);
}
void Print::print(double n)
{
printFloat(n, 2);
}
size_t ICACHE_FLASH_ATTR Print::print(double n, int digits) {
return printFloat(n, digits);
}
void WaspXBee::print(double n)
{
printFloat(n, 10);
}
