motor.cpp
1 /***************************************************************************
2  Copyright (C) 2002-2015 Kentaro Kitagawa
3  kitagawa@phys.s.u-tokyo.ac.jp
4 
5  This program is free software; you can redistribute it and/or
6  modify it under the terms of the GNU Library General Public
7  License as published by the Free Software Foundation; either
8  version 2 of the License, or (at your option) any later version.
9 
10  You should have received a copy of the GNU Library General
11  Public License and a list of authors along with this program;
12  see the files COPYING and AUTHORS.
13 ***************************************************************************/
14 //---------------------------------------------------------------------------
15 #include "ui_motorform.h"
16 #include "motor.h"
17 #include "interface.h"
18 #include "analyzer.h"
19 #include "xnodeconnector.h"
20 #include <QStatusBar>
21 
22 XMotorDriver::XMotorDriver(const char *name, bool runtime,
23  Transaction &tr_meas, const shared_ptr<XMeasure> &meas) :
24  XPrimaryDriverWithThread(name, runtime, ref(tr_meas), meas),
25  m_position(create<XScalarEntry>("Position", false,
26  dynamic_pointer_cast<XDriver>(shared_from_this()))),
27  m_target(create<XDoubleNode>("Target", true)),
28  m_stepMotor(create<XUIntNode>("StepMotor", true)),
29  m_stepEncoder(create<XUIntNode>("StepEncoder", true)),
30  m_currentStopping(create<XDoubleNode>("CurrentStopping", true)),
31  m_currentRunning(create<XDoubleNode>("CurrentRunning", true)),
32  m_speed(create<XDoubleNode>("Speed", true)),
33  m_timeAcc(create<XDoubleNode>("TimeAcc", true)),
34  m_timeDec(create<XDoubleNode>("TimeDec", true)),
35  m_active(create<XBoolNode>("Active", true)),
36  m_ready(create<XBoolNode>("Ready", true)),
37  m_slipping(create<XBoolNode>("Slipping", true)),
38  m_microStep(create<XBoolNode>("MicroStep", true)),
39  m_hasEncoder(create<XBoolNode>("HasEncoder", false)),
40  m_auxBits(create<XUIntNode>("AUXBits", false)),
41  m_clear(create<XTouchableNode>("Clear", true)),
42  m_store(create<XTouchableNode>("Store", true)),
43  m_round(create<XBoolNode>("Round", true)),
44  m_roundBy(create<XUIntNode>("RoundBy", true)),
45  m_forwardMotor(create<XTouchableNode>("ForwardMotor", true)),
46  m_reverseMotor(create<XTouchableNode>("ReverseMotor", true)),
47  m_stopMotor(create<XTouchableNode>("StopMotor", true)),
48  m_form(new FrmMotorDriver) {
49 
50  iterate_commit([=](Transaction &tr){
51  tr[ *active()] = false;
52  });
53 
54  meas->scalarEntries()->insert(tr_meas, m_position);
55 
56  m_form->statusBar()->hide();
57  m_form->setWindowTitle(i18n("Motor Driver - ") + getLabel() );
58 
59  m_position->setUIEnabled(false);
60  m_target->setUIEnabled(false);
61  m_stepMotor->setUIEnabled(false);
62  m_stepEncoder->setUIEnabled(false);
63  m_currentStopping->setUIEnabled(false);
64  m_currentRunning->setUIEnabled(false);
65  m_speed->setUIEnabled(false);
66  m_timeAcc->setUIEnabled(false);
67  m_timeDec->setUIEnabled(false);
68  m_active->setUIEnabled(false);
69  m_ready->setUIEnabled(false);
70  m_slipping->setUIEnabled(false);
71  m_microStep->setUIEnabled(false);
72  m_auxBits->setUIEnabled(false);
73  m_clear->setUIEnabled(false);
74  m_store->setUIEnabled(false);
75  m_round->setUIEnabled(false);
76  m_roundBy->setUIEnabled(false);
77  m_forwardMotor->setUIEnabled(false);
78  m_reverseMotor->setUIEnabled(false);
79  m_stopMotor->setUIEnabled(false);
80 // m_hasEncoder->setUIEnabled(true);
81 
82  m_conPosition = xqcon_create<XQLCDNumberConnector>(m_position->value(), m_form->m_lcdPosition);
83  m_form->m_dblTarget->setRange(-3600.0, 3600.0);
84  m_form->m_dblTarget->setSingleStep(1.0);
85  m_conTarget = xqcon_create<XQDoubleSpinBoxConnector>(m_target, m_form->m_dblTarget, m_form->m_slTarget);
86  m_conStepMotor = xqcon_create<XQLineEditConnector>(m_stepMotor, m_form->m_edStepMotor);
87  m_conStepEncoder = xqcon_create<XQLineEditConnector>(m_stepEncoder, m_form->m_edStepEncoder);
88  m_conCurrentStopping = xqcon_create<XQLineEditConnector>(m_currentStopping, m_form->m_edCurrStopping);
89  m_conCurrentRunning = xqcon_create<XQLineEditConnector>(m_currentRunning, m_form->m_edCurrRunning);
90  m_conSpeed = xqcon_create<XQLineEditConnector>(m_speed, m_form->m_edSpeed);
91  m_conTimeAcc = xqcon_create<XQLineEditConnector>(m_timeAcc, m_form->m_edTimeAcc);
92  m_conTimeDec = xqcon_create<XQLineEditConnector>(m_timeDec, m_form->m_edTimeDec);
93  m_conActive = xqcon_create<XQToggleButtonConnector>(m_active, m_form->m_ckbActive);
94  m_conMicroStep = xqcon_create<XQToggleButtonConnector>(m_microStep, m_form->m_ckbMicroStepping);
95  m_conSlipping = xqcon_create<XQLedConnector>(m_slipping, m_form->m_ledSlipping);
96  m_conReady = xqcon_create<XQLedConnector>(m_ready, m_form->m_ledReady);
97  m_conHasEncoder = xqcon_create<XQToggleButtonConnector>(m_hasEncoder, m_form->m_ckbHasEncoder);
98  m_conAUXBits = xqcon_create<XQLineEditConnector>(m_auxBits, m_form->m_edAUXBits);
99  m_conClear = xqcon_create<XQButtonConnector>(m_clear, m_form->m_btnClear);
100  m_conStore = xqcon_create<XQButtonConnector>(m_store, m_form->m_btnStore);
101  m_conRound = xqcon_create<XQToggleButtonConnector>(m_round, m_form->m_ckbRound);
102  m_conRoundBy = xqcon_create<XQLineEditConnector>(m_roundBy, m_form->m_edRoundBy);
103  m_conForwardMotor = xqcon_create<XQButtonConnector>(m_forwardMotor, m_form->m_btnFWD);
104  m_conReverseMotor = xqcon_create<XQButtonConnector>(m_reverseMotor, m_form->m_btnRVS);
105  m_conStopMotor = xqcon_create<XQButtonConnector>(m_stopMotor, m_form->m_btnSTOP);
106 }
107 
108 void
109 XMotorDriver::showForms() {
110 //! impliment form->show() here
111  m_form->showNormal();
112  m_form->raise();
113 }
114 
115 void
116 XMotorDriver::analyzeRaw(RawDataReader &reader, Transaction &tr) throw (XRecordError&) {
117  double pos;
118  bool slip, isready;
119  pos = reader.pop<double>();
120  slip = reader.pop<uint16_t>();
121  isready = reader.pop<uint16_t>();
122  m_position->value(tr, pos);
123  tr[ *m_slipping] = slip;
124  tr[ *m_ready] = isready;
125 }
126 void
127 XMotorDriver::visualize(const Snapshot &shot) {
128 }
129 
130 void
131 XMotorDriver::onTargetChanged(const Snapshot &shot, XValueNodeBase *) {
132  Snapshot shot_this( *this);
133  try {
134  setTarget(shot_this, shot[ *target()]);
135  }
136  catch (XKameError& e) {
137  e.print(getLabel() + " " + i18n("Error while changing target, "));
138  return;
139  }
140 }
141 void
142 XMotorDriver::onConditionsChanged(const Snapshot &shot, XValueNodeBase *) {
143  Snapshot shot_this( *this);
144  try {
145  changeConditions(shot_this);
146  setActive(shot_this[ *active()]);
147  }
148  catch (XKameError& e) {
149  e.print(getLabel() + " " + i18n("Error while changing conditions, "));
150  return;
151  }
152 }
153 void
154 XMotorDriver::onClearTouched(const Snapshot &shot, XTouchableNode *) {
155  Snapshot shot_this( *this);
156  try {
157  clearPosition();
158  }
159  catch (XKameError& e) {
160  e.print(getLabel() + " " + i18n("Error while clearing position, "));
161  return;
162  }
163  iterate_commit([=](Transaction &tr){
164  tr[ *target()] = 0.0;
165  tr.unmark(m_lsnTarget);
166  });
167 }
168 void
169 XMotorDriver::onStoreTouched(const Snapshot &shot, XTouchableNode *) {
170  Snapshot shot_this( *this);
171  try {
172  storeToROM();
173  }
174  catch (XKameError& e) {
175  e.print(getLabel() + " " + i18n("Error while storing to NV, "));
176  return;
177  }
178 }
179 void
180 XMotorDriver::onAUXChanged(const Snapshot &shot, XValueNodeBase *) {
181  try {
182  setAUXBits(shot[ *auxBits()]);
183  }
184  catch (XKameError& e) {
185  e.print(getLabel() + " " + i18n("Error, "));
186  return;
187  }
188 }
189 void
190 XMotorDriver::onForwardMotorTouched(const Snapshot &shot, XTouchableNode *) {
191  Snapshot shot_this( *this);
192  try {
193  setForward();
194  }
195  catch (XKameError& e) {
196  e.print(getLabel() + " " + i18n("Error, "));
197  return;
198  }
199 }
200 void
201 XMotorDriver::onReverseMotorTouched(const Snapshot &shot, XTouchableNode *) {
202  Snapshot shot_this( *this);
203  try {
204  setReverse();
205  }
206  catch (XKameError& e) {
207  e.print(getLabel() + " " + i18n("Error, "));
208  return;
209  }
210 }
211 void
212 XMotorDriver::onStopMotorTouched(const Snapshot &shot, XTouchableNode *) {
213  Snapshot shot_this( *this);
214  try {
215  stopRotation();
216  }
217  catch (XKameError& e) {
218  e.print(getLabel() + " " + i18n("Error, "));
219  return;
220  }
221  iterate_commit([=](Transaction &tr){
222  tr[ *target()] = (double)tr[ *(m_position->value())];
223  tr.unmark(m_lsnTarget);
224  });
225 }
226 void *
227 XMotorDriver::execute(const atomic<bool> &terminated) {
228  iterate_commit([=](Transaction &tr){
229  getConditions(tr);
230  });
231 
232  m_position->setUIEnabled(true);
233  m_target->setUIEnabled(true);
234  m_stepMotor->setUIEnabled(true);
235  m_stepEncoder->setUIEnabled(true);
236  m_currentStopping->setUIEnabled(true);
237  m_currentRunning->setUIEnabled(true);
238  m_speed->setUIEnabled(true);
239  m_timeAcc->setUIEnabled(true);
240  m_timeDec->setUIEnabled(true);
241  m_active->setUIEnabled(true);
242  m_ready->setUIEnabled(true);
243  m_slipping->setUIEnabled(true);
244  m_microStep->setUIEnabled(true);
245  m_clear->setUIEnabled(true);
246  m_store->setUIEnabled(true);
247  m_auxBits->setUIEnabled(true);
248  m_round->setUIEnabled(true);
249  m_roundBy->setUIEnabled(true);
250  m_forwardMotor->setUIEnabled(true);
251  m_reverseMotor->setUIEnabled(true);
252  m_stopMotor->setUIEnabled(true);
253 // m_hasEncoder->setUIEnabled(true);
254 
255  iterate_commit([=](Transaction &tr){
256  m_lsnTarget = tr[ *target()].onValueChanged().connectWeakly(shared_from_this(), &XMotorDriver::onTargetChanged);
257  m_lsnConditions = tr[ *stepMotor()].onValueChanged().connectWeakly(shared_from_this(), &XMotorDriver::onConditionsChanged);
258  tr[ *stepEncoder()].onValueChanged().connect(m_lsnConditions);
259  tr[ *currentStopping()].onValueChanged().connect(m_lsnConditions);
260  tr[ *currentRunning()].onValueChanged().connect(m_lsnConditions);
261  tr[ *speed()].onValueChanged().connect(m_lsnConditions);
262  tr[ *timeAcc()].onValueChanged().connect(m_lsnConditions);
263  tr[ *timeDec()].onValueChanged().connect(m_lsnConditions);
264  tr[ *active()].onValueChanged().connect(m_lsnConditions);
265  tr[ *microStep()].onValueChanged().connect(m_lsnConditions);
266  tr[ *round()].onValueChanged().connect(m_lsnConditions);
267  tr[ *roundBy()].onValueChanged().connect(m_lsnConditions);
268  m_lsnClear = tr[ *clear()].onTouch().connectWeakly(shared_from_this(), &XMotorDriver::onClearTouched);
269  m_lsnStore = tr[ *store()].onTouch().connectWeakly(shared_from_this(), &XMotorDriver::onStoreTouched);
270  m_lsnForwardMotor = tr[ *forwardMotor()].onTouch().connectWeakly(shared_from_this(), &XMotorDriver::onForwardMotorTouched);
271  m_lsnReverseMotor = tr[ *reverseMotor()].onTouch().connectWeakly(shared_from_this(), &XMotorDriver::onReverseMotorTouched);
272  m_lsnStopMotor = tr[ *stopMotor()].onTouch().connectWeakly(shared_from_this(), &XMotorDriver::onStopMotorTouched);
273  m_lsnAUX = tr[ *auxBits()].onValueChanged().connectWeakly(shared_from_this(), &XMotorDriver::onAUXChanged);
274  });
275 
276  while( !terminated) {
277  msecsleep(100);
278  XTime time_awared = XTime::now();
279  double pos = 0;
280  bool slip = false, isready = false;
281  // try/catch exception of communication errors
282  try {
283  Snapshot shot( *this);
284  getStatus(shot, &pos, &slip, &isready);
285  }
286  catch (XKameError &e) {
287  e.print(getLabel() + " " + i18n("Read Error, "));
288  continue;
289  }
290  auto writer = std::make_shared<RawData>();
291  writer->push(pos);
292  writer->push((uint16_t)slip);
293  writer->push((uint16_t)isready);
294  finishWritingRaw(writer, time_awared, XTime::now());
295  }
296 
297  m_position->setUIEnabled(false);
298  m_target->setUIEnabled(false);
299  m_stepMotor->setUIEnabled(false);
300  m_stepEncoder->setUIEnabled(false);
301  m_currentStopping->setUIEnabled(false);
302  m_currentRunning->setUIEnabled(false);
303  m_speed->setUIEnabled(false);
304  m_timeAcc->setUIEnabled(false);
305  m_timeDec->setUIEnabled(false);
306  m_active->setUIEnabled(false);
307  m_ready->setUIEnabled(false);
308  m_slipping->setUIEnabled(false);
309  m_microStep->setUIEnabled(false);
310  m_clear->setUIEnabled(false);
311  m_store->setUIEnabled(false);
312  m_auxBits->setUIEnabled(false);
313  m_round->setUIEnabled(false);
314  m_roundBy->setUIEnabled(false);
315  m_forwardMotor->setUIEnabled(false);
316  m_reverseMotor->setUIEnabled(false);
317  m_stopMotor->setUIEnabled(false);
318 // m_hasEncoder->setUIEnabled(true);
319 
320  m_lsnTarget.reset();
321  m_lsnConditions.reset();
322  m_lsnClear.reset();
323  m_lsnStore.reset();
324  m_lsnAUX.reset();
325  m_lsnForwardMotor.reset();
326  m_lsnReverseMotor.reset();
327  m_lsnStopMotor.reset();
328  return NULL;
329 }
Generated for KAME4 by  doxygen 1.8.3