src/modules/utils/player/Player.cpp

   1 /*
   2     This file is part of Smoothie (http://smoothieware.org/). The motion control part is heavily based on Grbl (https://github.com/simen/grbl).
   3     Smoothie is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
   4     Smoothie is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
   5     You should have received a copy of the GNU General Public License along with Smoothie. If not, see <http://www.gnu.org/licenses/>.
   6 */
   7
   8
   9 #include "libs/Kernel.h"
  10 #include "Player.h"
  11 #include "libs/nuts_bolts.h"
  12 #include "libs/utils.h"
  13 #include "libs/SerialMessage.h"
  14 #include "libs/StreamOutput.h"
  15 #include "modules/robot/Conveyor.h"
  16 #include "DirHandle.h"
  17 #include "PublicDataRequest.h"
  18 #include "PlayerPublicAccess.h"
  19
  20 void Player::on_module_loaded(){
  21     this->playing_file = false;
  22     this->booted = false;
  23     this->register_for_event(ON_CONSOLE_LINE_RECEIVED);
  24     this->register_for_event(ON_MAIN_LOOP);
  25     this->register_for_event(ON_SECOND_TICK);
  26     this->register_for_event(ON_GET_PUBLIC_DATA);
  27     this->register_for_event(ON_SET_PUBLIC_DATA);
  28     this->register_for_event(ON_GCODE_RECEIVED);
  29
  30     this->on_boot_gcode = this->kernel->config->value(on_boot_gcode_checksum)->by_default("/sd/on_boot.gcode -q")->as_string();
  31     this->on_boot_gcode_enable = this->kernel->config->value(on_boot_gcode_enable_checksum)->by_default(true)->as_bool();
  32     this->elapsed_secs= 0;
  33     this->reply_stream= NULL;
  34 }
  35
  36 void Player::on_second_tick(void*) {
  37      if (!kernel->pauser->paused()) this->elapsed_secs++;
  38 }
  39
  40 void Player::on_gcode_received(void *argument) {
  41     Gcode *gcode = static_cast<Gcode*>(argument);
  42     string args= get_arguments(gcode->command);
  43     if (gcode->has_m) {
  44         if (gcode->m == 21) { // Dummy code; makes Octoprint happy -- supposed to initialize SD card
  45             gcode->mark_as_taken();
  46             gcode->stream->printf("SD card ok\r\n");
  47
  48         }else if (gcode->m == 23) { // select file
  49             gcode->mark_as_taken();
  50             // Get filename
  51             this->filename= "/sd/" + this->absolute_from_relative(shift_parameter( args ));
  52             this->current_stream = &(StreamOutput::NullStream);
  53
  54             if(this->current_file_handler != NULL) {
  55                 this->playing_file = false;
  56                 fclose(this->current_file_handler);
  57             }
  58             this->current_file_handler = fopen( this->filename.c_str(), "r");
  59             // get size of file
  60             int result = fseek(this->current_file_handler, 0, SEEK_END);
  61             if (0 != result){
  62                     gcode->stream->printf("WARNING - Could not get file size\r\n");
  63                     file_size= -1;
  64             }else{
  65                     file_size= ftell(this->current_file_handler);
  66                     fseek(this->current_file_handler, 0, SEEK_SET);
  67             }
  68
  69             if(this->current_file_handler == NULL){
  70                 gcode->stream->printf("file.open failed: %s\r\n", this->filename.c_str());
  71             }else{
  72                 gcode->stream->printf("File opened:%s Size:%ld\r\n", this->filename.c_str(),file_size);
  73                 gcode->stream->printf("File selected\r\n");
  74             }
  75
  76             this->played_cnt= 0;
  77             this->elapsed_secs= 0;
  78
  79         }else if (gcode->m == 24) { // start print
  80             gcode->mark_as_taken();
  81             if (this->current_file_handler != NULL) {
  82                 this->playing_file = true;
  83                 this->reply_stream= gcode->stream;
  84             }
  85
  86         }else if (gcode->m == 25) { // pause print
  87             gcode->mark_as_taken();
  88             this->playing_file = false;
  89
  90         }else if (gcode->m == 26) { // Reset print. Slightly different than M26 in Marlin and the rest
  91             gcode->mark_as_taken();
  92             if(this->current_file_handler != NULL){
  93                 // abort the print
  94                 abort_command("", gcode->stream);
  95
  96                 // reload the last file opened
  97                 this->current_file_handler = fopen( this->filename.c_str(), "r");
  98
  99                 if(this->current_file_handler == NULL){
 100                     gcode->stream->printf("file.open failed: %s\r\n", this->filename.c_str());
 101                 }else{
 102                     // get size of file
 103                     int result = fseek(this->current_file_handler, 0, SEEK_END);
 104                     if (0 != result){
 105                             gcode->stream->printf("WARNING - Could not get file size\r\n");
 106                             file_size= -1;
 107                     }else{
 108                             file_size= ftell(this->current_file_handler);
 109                             fseek(this->current_file_handler, 0, SEEK_SET);
 110                     }
 111                 }
 112             }else{
 113                 gcode->stream->printf("No file loaded\r\n");
 114             }
 115
 116         }else if (gcode->m == 27) { // report print progress, in format used by Marlin
 117             gcode->mark_as_taken();
 118             progress_command("-b", gcode->stream);
 119
 120         }else if (gcode->m == 32) { // select file and start print
 121             gcode->mark_as_taken();
 122             // Get filename
 123             this->filename= "/sd/" + this->absolute_from_relative(shift_parameter( args ));
 124             this->current_stream = &(StreamOutput::NullStream);
 125
 126             if(this->current_file_handler != NULL) {
 127                 this->playing_file = false;
 128                 fclose(this->current_file_handler);
 129             }
 130
 131             this->current_file_handler = fopen( this->filename.c_str(), "r");
 132             if(this->current_file_handler == NULL){
 133                 gcode->stream->printf("file.open failed: %s\r\n", this->filename.c_str());
 134             }else{
 135                 this->playing_file = true;
 136             }
 137         }
 138     }
 139 }
 140
 141
 142 // When a new line is received, check if it is a command, and if it is, act upon it
 143 void Player::on_console_line_received( void* argument ){
 144     SerialMessage new_message = *static_cast<SerialMessage*>(argument);
 145     string possible_command = new_message.message;
 146
 147     //new_message.stream->printf("Received %s\r\n", possible_command.c_str());
 148
 149     // We don't compare to a string but to a checksum of that string, this saves some space in flash memory
 150     unsigned short check_sum = get_checksum( possible_command.substr(0,possible_command.find_first_of(" \r\n")) );  // todo: put this method somewhere more convenient
 151
 152     // Act depending on command
 153     if (check_sum == play_command_checksum)
 154         this->play_command(  get_arguments(possible_command), new_message.stream );
 155     else if (check_sum == progress_command_checksum)
 156         this->progress_command(get_arguments(possible_command),new_message.stream );
 157     else if (check_sum == abort_command_checksum)
 158         this->abort_command(get_arguments(possible_command),new_message.stream );
 159     else if (check_sum == cd_command_checksum)
 160         this->cd_command(  get_arguments(possible_command), new_message.stream );
 161 }
 162
 163 // Play a gcode file by considering each line as if it was received on the serial console
 164 void Player::play_command( string parameters, StreamOutput* stream ){
 165
 166     // Get filename
 167     this->filename          = this->absolute_from_relative(shift_parameter( parameters ));
 168     string options           = shift_parameter( parameters );
 169
 170     this->current_file_handler = fopen( this->filename.c_str(), "r");
 171     if(this->current_file_handler == NULL){
 172         stream->printf("File not found: %s\r\n", this->filename.c_str());
 173         return;
 174     }
 175
 176     stream->printf("Playing %s\r\n", this->filename.c_str());
 177
 178     this->playing_file = true;
 179
 180     // Do not output to any stream if we were passed the -q ( quiet ) option
 181     if( options.find_first_of("Qq") == string::npos ){
 182         this->current_stream = stream;
 183     }else{
 184         this->current_stream = &(StreamOutput::NullStream);
 185     }
 186
 187     // get size of file
 188     int result = fseek(this->current_file_handler, 0, SEEK_END);
 189     if (0 != result){
 190             stream->printf("WARNING - Could not get file size\r\n");
 191             file_size= -1;
 192     }else{
 193             file_size= ftell(this->current_file_handler);
 194             fseek(this->current_file_handler, 0, SEEK_SET);
 195             stream->printf("  File size %ld\r\n", file_size);
 196     }
 197     this->played_cnt= 0;
 198     this->elapsed_secs= 0;
 199 }
 200
 201 void Player::progress_command( string parameters, StreamOutput* stream ){
 202
 203     // get options
 204     string options           = shift_parameter( parameters );
 205
 206     if(!playing_file) {
 207         stream->printf("Not currently playing\r\n");
 208         return;
 209     }
 210
 211     if(file_size > 0) {
 212         int est= -1;
 213         if(this->elapsed_secs > 10) {
 214             int bytespersec= played_cnt / this->elapsed_secs;
 215             if(bytespersec > 0)
 216                 est= (file_size - played_cnt) / bytespersec;
 217         }
 218
 219         int pcnt= (file_size - (file_size - played_cnt)) * 100 / file_size;
 220         // If -b or -B is passed, report in the format used by Marlin and the others.
 221         if ( options.find_first_of("Bb") == string::npos ){
 222             stream->printf("%d %% complete, elapsed time: %d s", pcnt, this->elapsed_secs);
 223             if(est > 0){
 224                 stream->printf(", est time: %d s",  est);
 225             }
 226             stream->printf("\r\n");
 227         }else{
 228             stream->printf("SD printing byte %ld/%ld\r\n", played_cnt, file_size);
 229         }
 230
 231     }else{
 232         stream->printf("File size is unknown\r\n");
 233     }
 234 }
 235
 236 void Player::abort_command( string parameters, StreamOutput* stream ){
 237     if(!playing_file) {
 238         stream->printf("Not currently playing\r\n");
 239         return;
 240     }
 241     playing_file = false;
 242     played_cnt= 0;
 243     file_size= 0;
 244     fclose(current_file_handler);
 245     stream->printf("Aborted playing file\r\n");
 246 }
 247
 248 // Convert a path indication ( absolute or relative ) into a path ( absolute )
 249 string Player::absolute_from_relative( string path ){
 250     if( path[0] == '/' ){ return path; }
 251     if( path[0] == '.' ){ return this->current_path; }
 252     return this->current_path + path;
 253 }
 254
 255 // Change current absolute path to provided path
 256 void Player::cd_command( string parameters, StreamOutput* stream ){
 257     string folder = this->absolute_from_relative( parameters );
 258     if( folder[folder.length()-1] != '/' ){ folder += "/"; }
 259     DIR *d;
 260     d = opendir(folder.c_str());
 261     if(d == NULL) {
 262 //        stream->printf("Could not open directory %s \r\n", folder.c_str() );
 263     }else{
 264         this->current_path = folder;
 265         closedir(d);
 266     }
 267 }
 268
 269 void Player::on_main_loop(void* argument){
 270     if( !this->booted ) {
 271         if( this->on_boot_gcode_enable ){
 272             this->play_command(this->on_boot_gcode, this->kernel->serial);
 273         }else{
 274             //this->kernel->serial->printf("On boot gcode disabled! skipping...\n");
 275         }
 276         this->booted = true;
 277     }
 278
 279     if( this->playing_file ){
 280         string buffer;
 281         int c;
 282         buffer.reserve(20);
 283         // Print each line of the file
 284         while ((c = fgetc(this->current_file_handler)) != EOF){
 285             if (c == '\n'){
 286                 this->current_stream->printf("%s\n", buffer.c_str());
 287                 struct SerialMessage message;
 288                 message.message = buffer;
 289                 message.stream = this->current_stream;
 290                 // wait for the queue to have enough room that a serial message could still be received before sending
 291                 this->kernel->conveyor->wait_for_queue(2);
 292                 this->kernel->call_event(ON_CONSOLE_LINE_RECEIVED, &message);
 293                 played_cnt += buffer.size();
 294                 buffer.clear();
 295                 return;
 296             }else{
 297                 buffer += c;
 298             }
 299         }
 300
 301         this->playing_file = false;
 302         played_cnt= 0;
 303         file_size= 0;
 304         fclose(this->current_file_handler);
 305
 306         if(this->reply_stream != NULL) {
 307             // if we were printing from an M command from pronterface we need to send this back
 308             this->reply_stream->printf("Done printing file\r\n");
 309             this->reply_stream= NULL;
 310         }
 311     }
 312 }
 313
 314 void Player::on_get_public_data(void* argument) {
 315     PublicDataRequest* pdr = static_cast<PublicDataRequest*>(argument);
 316
 317     if(!pdr->starts_with(player_checksum)) return;
 318
 319     if(pdr->second_element_is(is_playing_checksum)) {
 320         static bool bool_data;
 321         bool_data= this->playing_file;
 322         pdr->set_data_ptr(&bool_data);
 323         pdr->set_taken();
 324
 325     }else if(pdr->second_element_is(get_progress_checksum)) {
 326         static struct pad_progress p;
 327         if(file_size > 0 && playing_file) {
 328             p.elapsed_secs= this->elapsed_secs;
 329             p.percent_complete= (this->file_size - (this->file_size - this->played_cnt)) * 100 / this->file_size;
 330             pdr->set_data_ptr(&p);
 331             pdr->set_taken();
 332         }
 333     }
 334 }
 335
 336 void Player::on_set_public_data(void* argument) {
 337     PublicDataRequest* pdr = static_cast<PublicDataRequest*>(argument);
 338
 339     if(!pdr->starts_with(player_checksum)) return;
 340
 341     if(pdr->second_element_is(abort_play_checksum)) {
 342         if(playing_file) {
 343             playing_file = false;
 344             played_cnt= 0;
 345             file_size= 0;
 346             fclose(current_file_handler);
 347             pdr->set_taken();
 348         }
 349     }
 350 }
 351
 352
 353
 354
 355
 356 /*
 357 void Player::on_main_loop(void* argument){
 358     if( !this->on_booted ){
 359         this->play_command(this->on_boot_file_name, new StreamOutput());
 360         this->on_booted = true;
 361     }
 362     if( this->playing_file ){
 363         string buffer;
 364         int c;
 365         // Print each line of the file
 366         while ((c = fgetc(this->current_file_handler)) != EOF){
 367             if (c == '\n'){
 368                 this->current_stream->printf("%s\n", buffer.c_str());
 369                 struct SerialMessage message;
 370                 message.message = buffer;
 371                 message.stream = this->current_stream;
 372                 // wait for the queue to have enough room that a serial message could still be received before sending
 373                 this->kernel->conveyor->wait_for_queue(2);
 374                 this->kernel->call_event(ON_CONSOLE_LINE_RECEIVED, &message);
 375                 buffer.clear();
 376                 return;
 377             }else{
 378                 buffer += c;
 379             }
 380         };
 381
 382         fclose(this->current_file_handler);
 383         this->playing_file = false;
 384     }
 385 }
 386 */
 387