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 SlowTicker* global_slow_ticker;
  20
  21 SlowTicker::SlowTicker(){
  22     max_frequency = 0;
  23     global_slow_ticker = this;
  24     LPC_SC->PCONP |= (1 << 22);     // Power Ticker ON
  25     LPC_TIM2->MR0 = 10000;        // Initial dummy value for Match Register
  26     LPC_TIM2->MCR = 3;              // Match on MR0, reset on MR0
  27     LPC_TIM2->TCR = 1;              // Enable interrupt
  28     NVIC_EnableIRQ(TIMER2_IRQn);    // Enable interrupt handler
  29
  30     ispbtn.from_string("2.10")->as_input()->pull_up();
  31
  32     flag_1s_flag = 0;
  33     flag_1s_count = SystemCoreClock;
  34
  35     g4_ticks = 0;
  36     g4_pause = false;
  37 }
  38
  39 void SlowTicker::on_module_loaded(){
  40     register_for_event(ON_IDLE);
  41     register_for_event(ON_GCODE_RECEIVED);
  42     register_for_event(ON_GCODE_EXECUTE);
  43 }
  44
  45 void SlowTicker::set_frequency( int frequency ){
  46     this->interval = (SystemCoreClock >> 2) / frequency;   // SystemCoreClock/4 = Timer increments in a second
  47     LPC_TIM2->MR0 = this->interval;
  48     LPC_TIM2->TCR = 3;  // Reset
  49     LPC_TIM2->TCR = 1;  // Reset
  50 }
  51
  52 void SlowTicker::tick(){
  53     _isr_context = true;
  54
  55     for (uint32_t i=0; i<this->hooks.size(); i++){
  56         Hook* hook = this->hooks.at(i);
  57         hook->countdown -= this->interval;
  58         if (hook->countdown < 0)
  59         {
  60             hook->countdown += hook->interval;
  61             hook->call();
  62         }
  63     }
  64
  65     flag_1s_count -= this->interval;
  66     if (flag_1s_count < 0)
  67     {
  68         flag_1s_count += SystemCoreClock >> 2;
  69         flag_1s_flag++;
  70     }
  71
  72     if (g4_ticks > 0)
  73     {
  74         if (g4_ticks > interval)
  75             g4_ticks -= interval;
  76         else
  77             g4_ticks = 0;
  78     }
  79
  80     LPC_GPIO1->FIOCLR = 1<<20;
  81
  82     if (ispbtn.get() == 0)
  83         __debugbreak();
  84
  85     _isr_context = false;
  86 }
  87
  88 bool SlowTicker::flag_1s(){
  89     __disable_irq();
  90     if (flag_1s_flag)
  91     {
  92         flag_1s_flag--;
  93         __enable_irq();
  94         return true;
  95     }
  96     __enable_irq();
  97     return false;
  98 }
  99
 100 void SlowTicker::on_idle(void*)
 101 {
 102     if (flag_1s())
 103         kernel->call_event(ON_SECOND_TICK);
 104
 105     // if G4 has finished, release our pause
 106     if (g4_pause && (g4_ticks == 0))
 107     {
 108         g4_pause = false;
 109         kernel->pauser->release();
 110     }
 111 }
 112
 113 void SlowTicker::on_gcode_received(void* argument){
 114     Gcode* gcode = static_cast<Gcode*>(argument);
 115     // Add the gcode to the queue ourselves if we need it
 116     if( gcode->has_g && gcode->g == 4 ){
 117         if( this->kernel->conveyor->queue.size() == 0 ){
 118             this->kernel->call_event(ON_GCODE_EXECUTE, gcode );
 119         }else{
 120             Block* block = this->kernel->conveyor->queue.get_ref( this->kernel->conveyor->queue.size() - 1 );
 121             block->append_gcode(gcode);
 122         }
 123     }
 124 }
 125
 126 void SlowTicker::on_gcode_execute(void* argument){
 127     Gcode* gcode = static_cast<Gcode*>(argument);
 128
 129     if (gcode->has_g)
 130     {
 131         if (gcode->g == 4)
 132         {
 133             bool updated = false;
 134             if (gcode->has_letter('P')) {
 135                 updated = true;
 136                 g4_ticks += gcode->get_int('P') * ((SystemCoreClock >> 2) / 1000UL);
 137             }
 138             if (gcode->has_letter('S')) {
 139                 updated = true;
 140                 g4_ticks += gcode->get_int('S') * (SystemCoreClock >> 2);
 141             }
 142             if (updated)
 143             {
 144                 // G4 Smm Pnn should pause for mm seconds + nn milliseconds
 145                 // at 120MHz core clock, the longest possible delay is (2^32 / (120MHz / 4)) = 143 seconds
 146                 if (!g4_pause)
 147                 {
 148                     g4_pause = true;
 149                     kernel->pauser->take();
 150                 }
 151             }
 152         }
 153     }
 154 }
 155
 156 extern "C" void TIMER2_IRQHandler (void){
 157     if((LPC_TIM2->IR >> 0) & 1){  // If interrupt register set for MR0
 158         LPC_TIM2->IR |= 1 << 0;   // Reset it
 159     }
 160     global_slow_ticker->tick();
 161 }
 162