src/libs/SlowTicker.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 using namespace std;
   9 #include <vector>
  10 #include "libs/nuts_bolts.h"
  11 #include "libs/Module.h"
  12 #include "libs/Kernel.h"
  13 #include "SlowTicker.h"
  14 #include "libs/Hook.h"
  15 #include "modules/robot/Conveyor.h"
  16
  17 #include <mri.h>
  18
  19 // This module uses a Timer to periodically call hooks
  20 // Modules register with a function ( callback ) and a frequency, and we then call that function at the given frequency.
  21
  22 SlowTicker* global_slow_ticker;
  23
  24 SlowTicker::SlowTicker(){
  25     max_frequency = 0;
  26     global_slow_ticker = this;
  27
  28     // Configure the actual timer
  29     LPC_SC->PCONP |= (1 << 22);     // Power Ticker ON
  30     LPC_TIM2->MR0 = 10000;          // Initial dummy value for Match Register
  31     LPC_TIM2->MCR = 3;              // Match on MR0, reset on MR0
  32     LPC_TIM2->TCR = 1;              // Enable interrupt
  33     NVIC_EnableIRQ(TIMER2_IRQn);    // Enable interrupt handler
  34
  35     // ISP button
  36     ispbtn.from_string("2.10")->as_input()->pull_up();
  37
  38     // TODO: What is this ??
  39     flag_1s_flag = 0;
  40     flag_1s_count = SystemCoreClock;
  41
  42     g4_ticks = 0;
  43     g4_pause = false;
  44 }
  45
  46 void SlowTicker::on_module_loaded(){
  47     register_for_event(ON_IDLE);
  48     register_for_event(ON_GCODE_RECEIVED);
  49     register_for_event(ON_GCODE_EXECUTE);
  50 }
  51
  52 // Set the base frequency we use for all sub-frequencies
  53 void SlowTicker::set_frequency( int frequency ){
  54     this->interval = (SystemCoreClock >> 2) / frequency;   // SystemCoreClock/4 = Timer increments in a second
  55     LPC_TIM2->MR0 = this->interval;
  56     LPC_TIM2->TCR = 3;  // Reset
  57     LPC_TIM2->TCR = 1;  // Reset
  58 }
  59
  60 // The actual interrupt being called by the timer, this is where work is done
  61 void SlowTicker::tick(){
  62
  63     // Call all hooks that need to be called ( bresenham )
  64     for (uint32_t i=0; i<this->hooks.size(); i++){
  65         Hook* hook = this->hooks.at(i);
  66         hook->countdown -= this->interval;
  67         if (hook->countdown < 0)
  68         {
  69             hook->countdown += hook->interval;
  70             hook->call();
  71         }
  72     }
  73
  74     flag_1s_count -= this->interval;
  75     if (flag_1s_count < 0)
  76     {
  77         flag_1s_count += SystemCoreClock >> 2;
  78         flag_1s_flag++;
  79     }
  80
  81     if (g4_ticks > 0)
  82     {
  83         if (g4_ticks > interval)
  84             g4_ticks -= interval;
  85         else
  86             g4_ticks = 0;
  87     }
  88
  89     // Enter MRI mode if the ISP button is pressed
  90     // TODO : This should have it's own module
  91     if (ispbtn.get() == 0)
  92         __debugbreak();
  93
  94 }
  95
  96 bool SlowTicker::flag_1s(){
  97     __disable_irq();
  98     if (flag_1s_flag)
  99     {
 100         flag_1s_flag--;
 101         __enable_irq();
 102         return true;
 103     }
 104     __enable_irq();
 105     return false;
 106 }
 107
 108 void SlowTicker::on_idle(void*)
 109 {
 110     if (flag_1s())
 111         kernel->call_event(ON_SECOND_TICK);
 112
 113     // if G4 has finished, release our pause
 114     if (g4_pause && (g4_ticks == 0))
 115     {
 116         g4_pause = false;
 117         kernel->pauser->release();
 118     }
 119 }
 120
 121 // When a G4-type gcode is received, add it to the queue so we can execute it in time
 122 void SlowTicker::on_gcode_received(void* argument){
 123     Gcode* gcode = static_cast<Gcode*>(argument);
 124     // Add the gcode to the queue ourselves if we need it
 125     if( gcode->has_g && gcode->g == 4 ){
 126         if( this->kernel->conveyor->queue.size() == 0 ){
 127             this->kernel->call_event(ON_GCODE_EXECUTE, gcode );
 128         }else{
 129             Block* block = this->kernel->conveyor->queue.get_ref( this->kernel->conveyor->queue.size() - 1 );
 130             block->append_gcode(gcode);
 131         }
 132     }
 133 }
 134
 135 // When a G4-type gcode is executed, start the pause
 136 void SlowTicker::on_gcode_execute(void* argument){
 137     Gcode* gcode = static_cast<Gcode*>(argument);
 138
 139     if (gcode->has_g){
 140         if (gcode->g == 4){
 141             bool updated = false;
 142             if (gcode->has_letter('P')) {
 143                 updated = true;
 144                 g4_ticks += gcode->get_int('P') * ((SystemCoreClock >> 2) / 1000UL);
 145             }
 146             if (gcode->has_letter('S')) {
 147                 updated = true;
 148                 g4_ticks += gcode->get_int('S') * (SystemCoreClock >> 2);
 149             }
 150             if (updated){
 151                 // G4 Smm Pnn should pause for mm seconds + nn milliseconds
 152                 // at 120MHz core clock, the longest possible delay is (2^32 / (120MHz / 4)) = 143 seconds
 153                 if (!g4_pause){
 154                     g4_pause = true;
 155                     kernel->pauser->take();
 156                 }
 157             }
 158         }
 159     }
 160 }
 161
 162 extern "C" void TIMER2_IRQHandler (void){
 163     if((LPC_TIM2->IR >> 0) & 1){  // If interrupt register set for MR0
 164         LPC_TIM2->IR |= 1 << 0;   // Reset it
 165     }
 166     global_slow_ticker->tick();
 167 }
 168