API tools faq
paste
Advertisement
RazZziel

Untitled

RazZziel
Apr 6th, 2015
216
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 13.19 KB | None | 0 0
raw download clone embed print report
  1. package com.imasdetres.gobike.model;
  2.  
  3. import com.gobike.middleware.BikePCB;
  4. import com.gobike.middleware.DockingStation.SlaveState;
  5. import com.gobike.middleware.DockingStation.UncondChargingTimer;
  6. import com.gobike.middleware.Event;
  7. import com.gobike.middleware.BikePCB.BikeState;
  8. import com.gobike.middleware.DockingStation;
  9. import com.gobike.middleware.ReturnCode;
  10. import com.imasdetres.gobike.actions.bike.SetBikeStateAction;
  11. import com.imasdetres.util.BufferedLog;
  12.  
  13. public class MetaState {
  14.  
  15. private static final String TAG = MetaState.class.getSimpleName();
  16.  
  17. enum MSBikeState {
  18. Unknown,
  19. Docked,
  20. Undocking,
  21. Running,
  22. Docking
  23. };
  24.  
  25. private MSBikeState _bikeState = MSBikeState.Unknown;
  26. private void setBikeState(MSBikeState bikeState) {
  27.  
  28. if (_bikeState != bikeState) {
  29.  
  30. BufferedLog.log().i(TAG, "Bike state: "+_bikeState+" --> "+bikeState);
  31.  
  32. if (bikeState == MSBikeState.Docked) {
  33. Middleware.getInstance().sendEvent(new Event(DockingStation.BIKE_DOCKED));
  34. //TODO: trigger(DateTimeUpdater)
  35. } else if (bikeState == MSBikeState.Undocking) {
  36. Middleware.getInstance().setUndockPollingThread();
  37. } else if (bikeState == MSBikeState.Running) {
  38. Middleware.getInstance().sendEvent(new Event(DockingStation.BIKE_UNDOCKED));
  39. } else if (bikeState == MSBikeState.Docking) {
  40. //TODO: Middleware.getInstance().setDockPollingThread();
  41. }
  42.  
  43. _bikeState = bikeState;
  44. }
  45. }
  46. public MSBikeState bikeState() {
  47. return _bikeState;
  48. }
  49.  
  50.  
  51.  
  52. enum MSChargeState {
  53. Unknown,
  54. NotCharging,
  55. Waiting,
  56. Charging,
  57. UnconditionalCharging,
  58. ChargingError
  59. }
  60.  
  61. private boolean isChargingState(MSChargeState state) {
  62. return (state == MSChargeState.Charging ||
  63. state == MSChargeState.UnconditionalCharging);
  64. }
  65.  
  66. private MSChargeState _chargeState = MSChargeState.Unknown;
  67. private void setChargeState(MSChargeState chargeState) {
  68.  
  69. if (_chargeState != chargeState) {
  70.  
  71. BufferedLog.log().i(TAG, "Charge state: "+_chargeState+" --> "+chargeState);
  72.  
  73. boolean wasCharging = isChargingState(_chargeState);
  74. boolean isCharging = isChargingState(chargeState);
  75. boolean wasUnconditionalCharging = (_chargeState == MSChargeState.UnconditionalCharging);
  76. boolean isUnconditionalCharging = (chargeState == MSChargeState.UnconditionalCharging);
  77.  
  78. if (!wasCharging && isCharging) {
  79. Middleware.getInstance().sendEvent(new Event(DockingStation.BIKE_STARTED_CHARGING));
  80. setCanUndock(false, CantUndockReason.BikeCharging);
  81. } else if (wasCharging && !isCharging) {
  82. Middleware.getInstance().sendEvent(new Event(DockingStation.BIKE_STOPPED_CHARGING));
  83. }
  84.  
  85. if (!wasUnconditionalCharging && isUnconditionalCharging) {
  86. Middleware.getInstance().sendEvent(new Event(DockingStation.SLAVEPCB_UNCONDITIONAL_CHARGING));
  87. } else if (wasUnconditionalCharging && !isUnconditionalCharging) {
  88. Middleware.getInstance().sendEvent(new Event(DockingStation.SLAVEPCB_UNCONDITIONAL_CHARGING_FINISHED));
  89. }
  90.  
  91. if (chargeState == MSChargeState.ChargingError) {
  92. Middleware.getInstance().sendEvent(new Event(DockingStation.ERROR_CHARGING));
  93. }
  94.  
  95. _chargeState = chargeState;
  96. }
  97. }
  98. public MSChargeState chargeState() {
  99. return _chargeState;
  100. }
  101.  
  102.  
  103.  
  104. enum MSLockState {
  105. Unknown,
  106. Unlocked,
  107. WaitingUser,
  108. Locked
  109. }
  110.  
  111. private MSLockState _lockState = MSLockState.Unknown;
  112. private void setLockState(MSLockState lockState) {
  113.  
  114. if (_lockState != lockState) {
  115.  
  116. BufferedLog.log().i(TAG, "Lock state: "+_lockState+" --> "+lockState);
  117.  
  118. if (lockState == MSLockState.Unlocked) {
  119. Middleware.getInstance().sendEvent(new Event(BikePCB.LOCK_DISABLED));
  120. } else if (lockState == MSLockState.WaitingUser) {
  121. Middleware.getInstance().sendEvent(new Event(BikePCB.LOCK_WAITING_USER));
  122. } else if (lockState == MSLockState.Locked) {
  123. Middleware.getInstance().sendEvent(new Event(BikePCB.LOCK_ENABLED));
  124. }
  125.  
  126. _lockState = lockState;
  127. }
  128. }
  129. public MSLockState lockState() {
  130. return _lockState;
  131. }
  132. public boolean isLocked() {
  133. return _lockState == MSLockState.Locked;
  134. }
  135.  
  136.  
  137.  
  138. private boolean _slaveUnavailable = false;
  139. private void setSlaveUnavailable(boolean slaveUnavailable) {
  140.  
  141. if (_slaveUnavailable != slaveUnavailable) {
  142.  
  143. BufferedLog.log().i(TAG, "Slave unavailable: "+_slaveUnavailable+" --> "+slaveUnavailable);
  144.  
  145. if (slaveUnavailable) {
  146. Middleware.getInstance().sendEvent(new Event(DockingStation.SLAVE_UNAVAILABLE));
  147. setCanUndock(false);
  148. }
  149.  
  150. _slaveUnavailable = slaveUnavailable;
  151. }
  152. }
  153. public boolean isSlaveUnavailable() {
  154. return _slaveUnavailable;
  155. }
  156.  
  157.  
  158.  
  159. private boolean _standing = false;
  160. private void setStanding(boolean standing) {
  161.  
  162. if (_standing != standing) {
  163.  
  164. BufferedLog.log().i(TAG, "Bike standing: "+_standing+" --> "+standing);
  165.  
  166. if (standing) {
  167. Middleware.getInstance().sendEvent(new Event(BikePCB.KICKSTAND_DEPLOYED));
  168. } else {
  169. Middleware.getInstance().sendEvent(new Event(BikePCB.KICKSTAND_RETRACTED));
  170. }
  171.  
  172. _standing = standing;
  173. }
  174. }
  175. public boolean isStanding() {
  176. return _standing;
  177. }
  178.  
  179.  
  180.  
  181. enum CantUndockReason {
  182. None,
  183. BikeNotPushedIn,
  184. BikeNotDocked,
  185. BikeCharging
  186. }
  187. private boolean _canUndock = false;
  188. private CantUndockReason _cantUndockReason = CantUndockReason.None;
  189. private void setCanUndock(boolean canUndock) {
  190. setCanUndock(canUndock, CantUndockReason.None);
  191. }
  192. private void setCanUndock(boolean canUndock, CantUndockReason reason) {
  193.  
  194. if (_canUndock != canUndock) {
  195.  
  196. BufferedLog.log().i(TAG, "Can undock: "+_canUndock+" --> "+canUndock + " (Reason: "+reason+")");
  197.  
  198. _canUndock = canUndock;
  199. }
  200.  
  201. _cantUndockReason = reason;
  202. }
  203. public boolean canUndock() {
  204. return _canUndock;
  205. }
  206.  
  207.  
  208.  
  209. /**
  210. * This is the main algorithm discussed in http://redmine.imasdetres.com/issues/5451
  211. * It's the central point in charge of updating the Middleware MetaState according to
  212. * the state reported by the electronics
  213. */
  214. public void update() {
  215. BikePCB.BikeState bikeStatus = Bike_PCB.getInstance().getState();
  216. DockingStation.SlaveState slaveStatus = SlaveController.getInstance().getState();
  217.  
  218. /*int bikeDigitalInputs = 0;
  219. try {
  220. bikeDigitalInputs = BikePCB.getDigitalInputStatus();
  221. } catch (NullPointerException e) {
  222. BufferedLog.log().e(TAG, "Coult not retrieve BikePCB digital input status");
  223. return;
  224. }*/
  225. int slaveDigitalInputs = SlaveController.getInstance().getDigitalInputs();
  226.  
  227. int syncTimer = SlaveController.getInstance().getSyncTimer();
  228.  
  229.  
  230. if (bikeStatus == BikeState.BIKE_SLAVE_UNAVAILABLE) {
  231.  
  232. setBikeState(MSBikeState.Docked);
  233. setChargeState(MSChargeState.NotCharging);
  234. setSlaveUnavailable(true);
  235.  
  236. } else if (bikeStatus == BikeState.BIKE_SLAVE_UNCOND_CHARGING) {
  237.  
  238. setBikeState(MSBikeState.Docked);
  239. setChargeState(MSChargeState.UnconditionalCharging);
  240. setSlaveUnavailable(true);
  241.  
  242. } else if (syncTimer != 0xFF) {
  243.  
  244. if (bikeStatus == BikeState.BIKE_ERROR_ASSOC) {
  245. if (bikeState() == MSBikeState.Undocking) {
  246. SetBikeStateAction setBikeStateAction = new SetBikeStateAction(BikeState.BIKE_RUNNING);
  247. if (setBikeStateAction.execute() != ReturnCode.RET_OK)
  248. BufferedLog.log().e(TAG, "Error setting BikePCB state to BIKE_RUNNING");
  249. setBikeState(MSBikeState.Running);
  250. } else if (bikeState() == MSBikeState.Docked) {
  251. setSlaveUnavailable(true);
  252. }
  253. } else {
  254. bikeDocking(bikeStatus, slaveStatus, slaveDigitalInputs, syncTimer);
  255. }
  256.  
  257. } else if (bikeStatus == BikeState.BIKE_12V_PROBE) {
  258.  
  259. if (bikeState() == MSBikeState.Undocking) {
  260. setBikeState(MSBikeState.Running);
  261. }
  262.  
  263. } else if (bikeStatus == BikeState.BIKE_ERROR_NOT_BIKE) {
  264.  
  265. setBikeState(MSBikeState.Running);
  266. Middleware.getInstance().sendEvent(new Event(DockingStation.ERROR_DOCK_FAILED));
  267.  
  268. } else if (bikeStatus == BikeState.BIKE_42V_PROBE) {
  269.  
  270. if (bikeState() == MSBikeState.Running) {
  271. setBikeState(MSBikeState.Docking);
  272. }
  273.  
  274. } else if (bikeStatus == BikeState.BIKE_DISASSOC || bikeStatus == BikeState.BIKE_UNDOCKING) {
  275.  
  276. setBikeState(MSBikeState.Undocking);
  277.  
  278. } else if (bikeState() == MSBikeState.Docked) {
  279.  
  280. setSlaveUnavailable(true);
  281.  
  282. } else if (bikeState() != MSBikeState.Running) {
  283.  
  284. setBikeState(MSBikeState.Running);
  285.  
  286. } else if (bikeStatus == BikeState.BIKE_RUNNING) {
  287.  
  288. setStanding(false);
  289. setBikeState(MSBikeState.Running);
  290. setLockState(MSLockState.Unlocked);
  291.  
  292. } else if (bikeStatus == BikeState.BIKE_STANDING) {
  293.  
  294. setStanding(true);
  295. setBikeState(MSBikeState.Running);
  296. setLockState(MSLockState.Unlocked);
  297.  
  298. } else if (bikeStatus == BikeState.BIKE_LOCKED || bikeStatus == BikeState.BIKE_LOCKED_WAKEUP) {
  299.  
  300. setLockState(MSLockState.Locked);
  301.  
  302. if (bikeStatus == BikeState.BIKE_LOCKED) {
  303. setStanding(true);
  304. } else if (bikeStatus == BikeState.BIKE_LOCKED_WAKEUP) {
  305. setStanding(false);
  306. }
  307.  
  308. } else if (bikeStatus == BikeState.BIKE_MAKE_LOCK_3) {
  309.  
  310. setLockState(MSLockState.WaitingUser);
  311.  
  312. } else if (bikeStatus == BikeState.BIKE_ERROR_LOCK_TAMPER || bikeStatus == BikeState.BIKE_ERROR_UNLOCK_3) {
  313.  
  314. if (_lockState == MSLockState.Locked) {
  315. Middleware.getInstance().sendEvent(new Event(BikePCB.LOCK_ERROR));
  316. } else {
  317. Middleware.getInstance().sendEvent(new Event(BikePCB.LOCK_CONSISTENCY_CERROR));
  318. }
  319.  
  320. } else if (bikeStatus == BikeState.BIKE_ERROR_LOCK_CURRENT) {
  321.  
  322. Middleware.getInstance().sendEvent(new Event(BikePCB.LOCK_ERROR));
  323.  
  324. }
  325. }
  326.  
  327. private void bikeDocking(BikePCB.BikeState bikeStatus, DockingStation.SlaveState slaveStatus, int slavePCBDigitalInputStatus, int syncTimer) {
  328.  
  329. if (syncTimer >= 0x05 && syncTimer <= 0x07) {
  330.  
  331. assertDocking();
  332.  
  333. if (bikeStatus == BikeState.BIKE_CHARGING) {
  334.  
  335. assertCharging(bikeStatus, slaveStatus);
  336.  
  337. } else if (slaveStatus == SlaveState.SLAVE_START_CHARGING ||
  338. slaveStatus == SlaveState.SLAVE_START_CHARGING_WAIT ||
  339. slaveStatus == SlaveState.SLAVE_UNCONDITIONAL_CHARGING_WAIT) {
  340.  
  341. setChargeState(MSChargeState.Waiting);
  342.  
  343. } else if (slaveStatus == SlaveState.SLAVE_BIKE_CHARGING) {
  344.  
  345. if (bikeStatus == BikeState.BIKE_DOCKING) {
  346. setChargeState(MSChargeState.ChargingError);
  347. } else {
  348. assertCharging(bikeStatus, slaveStatus);
  349. }
  350.  
  351. } else if (slaveStatus == SlaveState.SLAVE_ERROR_ASSOC_42V) {
  352.  
  353. Middleware.getInstance().sendEvent(new Event(DockingStation.ERROR_ASSOC_42V));
  354. setChargeState(MSChargeState.ChargingError);
  355.  
  356. } else if (slaveStatus == SlaveState.SLAVE_ERROR_CHARGING ||
  357. slaveStatus == SlaveState.SLAVE_ERROR_CHARGE_CURRENT) {
  358.  
  359. setChargeState(MSChargeState.ChargingError);
  360.  
  361. } else if (slaveStatus == SlaveState.SLAVE_ERROR_TEMP_SENSOR ||
  362. slaveStatus == SlaveState.SLAVE_ERROR_CHARGE_CURRENT ||
  363. slaveStatus == SlaveState.SLAVE_ERROR_LEFT_SOLENOID ||
  364. slaveStatus == SlaveState.SLAVE_ERROR_RIGHT_SOLENOID ||
  365. slaveStatus == SlaveState.SLAVE_ERROR_HEATER ||
  366. slaveStatus == SlaveState.SLAVE_ERROR_SOLENOID_SENSORS) { // other errors
  367.  
  368. setChargeState(MSChargeState.NotCharging);
  369. Middleware.getInstance().sendEvent(new Event(DockingStation.ERROR_DOCKING_POINT));
  370.  
  371. } else {
  372.  
  373. if (_chargeState != MSChargeState.NotCharging) {
  374. setChargeState(MSChargeState.NotCharging);
  375. }
  376.  
  377. if ((slavePCBDigitalInputStatus & 0x03) != 0x03) { // Bike is pushed in
  378. setCanUndock(false, CantUndockReason.BikeNotPushedIn);
  379. } else if (bikeStatus != BikeState.BIKE_DOCKING)
  380. setCanUndock(false, CantUndockReason.BikeNotDocked);
  381. } else {
  382. setCanUndock(true);
  383. }
  384. }
  385.  
  386. } else {
  387.  
  388. setBikeState(MSBikeState.Docked);
  389. setSlaveUnavailable(true);
  390. setCanUndock(false);
  391.  
  392. }
  393. }
  394.  
  395. private void assertCharging(BikePCB.BikeState bikeStatus, DockingStation.SlaveState slaveStatus) {
  396.  
  397. setChargeState(MSChargeState.Charging);
  398.  
  399. if (bikeStatus == BikeState.BIKE_DOCKING) {
  400. setChargeState(MSChargeState.ChargingError);
  401. }
  402.  
  403. if (slaveStatus == SlaveState.SLAVE_UNCONDITIONAL_CHARGING_START ||
  404. slaveStatus == SlaveState.SLAVE_UNCONDITIONAL_CHARGING_4H5 ||
  405. slaveStatus == SlaveState.SLAVE_UNCONDITIONAL_CHARGING_2H5 ||
  406. slaveStatus == SlaveState.SLAVE_UNCONDITIONAL_CHARGING_1H5 ||
  407. slaveStatus == SlaveState.SLAVE_UNCONDITIONAL_CHARGING_0H5 || // Uncond_Charging
  408. slaveStatus == SlaveState.SLAVE_TABLET_BOOTUP) {
  409. if (_chargeState != MSChargeState.UnconditionalCharging) {
  410. setChargeState(MSChargeState.UnconditionalCharging);
  411. }
  412. } else {
  413. if (_chargeState == MSChargeState.UnconditionalCharging) {
  414. setChargeState(MSChargeState.NotCharging);
  415. }
  416. }
  417. }
  418.  
  419. private void assertDocking() {
  420. if (_bikeState == MSBikeState.Docked) {
  421. setBikeState(MSBikeState.Docked);
  422. setCanUndock(true);
  423. }
  424. }
  425.  
  426. private void debugState(String msg) {
  427. BufferedLog.log().w(TAG,
  428. "[Line "+Thread.currentThread().getStackTrace()[4].getLineNumber()+"] "+
  429. "State not considered ("+msg+")");
  430. }
  431. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!