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     // deduct tick time from secound counter
  75     flag_1s_count -= this->interval;
  76     // if a whole second has elapsed,
  77     if (flag_1s_count < 0)
  78     {
  79         // add a second to our counter
  80         flag_1s_count += SystemCoreClock >> 2;
  81         // and set a flag for idle event to pick up
  82         flag_1s_flag++;
  83     }
  84
  85     // if we're counting down a pause
  86     if (g4_ticks > 0)
  87     {
  88         // deduct tick time from timeout
  89         if (g4_ticks > interval)
  90             g4_ticks -= interval;
  91         else
  92             g4_ticks = 0;
  93     }
  94
  95     // Enter MRI mode if the ISP button is pressed
  96     // TODO : This should have it's own module
  97     if (ispbtn.get() == 0)
  98         __debugbreak();
  99
 100 }
 101
 102 bool SlowTicker::flag_1s(){
 103     // atomic flag check routine
 104     // first disable interrupts
 105     __disable_irq();
 106     // then check for a flag
 107     if (flag_1s_flag)
 108     {
 109         // if we have a flag, decrement the counter
 110         flag_1s_flag--;
 111         // re-enable interrupts
 112         __enable_irq();
 113         // and tell caller that we consumed a flag
 114         return true;
 115     }
 116     // if no flag, re-enable interrupts and return false
 117     __enable_irq();
 118     return false;
 119 }
 120
 121 void SlowTicker::on_idle(void*)
 122 {
 123     // if interrupt has set the 1 second flag
 124     if (flag_1s())
 125         // fire the on_second_tick event
 126         kernel->call_event(ON_SECOND_TICK);
 127
 128     // if G4 has finished, release our pause
 129     if (g4_pause && (g4_ticks == 0))
 130     {
 131         g4_pause = false;
 132         kernel->pauser->release();
 133     }
 134 }
 135
 136 // When a G4-type gcode is received, add it to the queue so we can execute it in time
 137 void SlowTicker::on_gcode_received(void* argument){
 138     Gcode* gcode = static_cast<Gcode*>(argument);
 139     // Add the gcode to the queue ourselves if we need it
 140     if( gcode->has_g && gcode->g == 4 ){
 141         if( this->kernel->conveyor->queue.size() == 0 ){
 142             this->kernel->call_event(ON_GCODE_EXECUTE, gcode );
 143         }else{
 144             Block* block = this->kernel->conveyor->queue.get_ref( this->kernel->conveyor->queue.size() - 1 );
 145             block->append_gcode(gcode);
 146         }
 147     }
 148 }
 149
 150 // When a G4-type gcode is executed, start the pause
 151 void SlowTicker::on_gcode_execute(void* argument){
 152     Gcode* gcode = static_cast<Gcode*>(argument);
 153
 154     if (gcode->has_g){
 155         if (gcode->g == 4){
 156             gcode->mark_as_taken();
 157             bool updated = false;
 158             if (gcode->has_letter('P')) {
 159                 updated = true;
 160                 g4_ticks += gcode->get_int('P') * ((SystemCoreClock >> 2) / 1000UL);
 161             }
 162             if (gcode->has_letter('S')) {
 163                 updated = true;
 164                 g4_ticks += gcode->get_int('S') * (SystemCoreClock >> 2);
 165             }
 166             if (updated){
 167                 // G4 Smm Pnn should pause for mm seconds + nn milliseconds
 168                 // at 120MHz core clock, the longest possible delay is (2^32 / (120MHz / 4)) = 143 seconds
 169                 if (!g4_pause){
 170                     g4_pause = true;
 171                     kernel->pauser->take();
 172                 }
 173             }
 174         }
 175     }
 176 }
 177
 178 extern "C" void TIMER2_IRQHandler (void){
 179     if((LPC_TIM2->IR >> 0) & 1){  // If interrupt register set for MR0
 180         LPC_TIM2->IR |= 1 << 0;   // Reset it
 181     }
 182     global_slow_ticker->tick();
 183 }
 184