From f69f42f0f89518d928affde4c6f157b864b4e94c Mon Sep 17 00:00:00 2001 From: Nick-HZ Date: Thu, 16 Oct 2014 11:19:38 +0800 Subject: [PATCH] V1.0 --- SiLabs/EMAX_BLHeli.a51 | 6848 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 6848 insertions(+) create mode 100644 SiLabs/EMAX_BLHeli.a51 diff --git a/SiLabs/EMAX_BLHeli.a51 b/SiLabs/EMAX_BLHeli.a51 new file mode 100644 index 00000000..ade1090d --- /dev/null +++ b/SiLabs/EMAX_BLHeli.a51 @@ -0,0 +1,6848 @@ +$NOMOD51 +;**** **** **** **** **** +; +; BLHeli program for controlling brushless motors in helicopters +; +; Copyright 2011, 2012 Steffen Skaug +; This program is distributed under the terms of the GNU General Public License +; +; This file is part of BLHeli. +; +; BLHeli 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. +; +; BLHeli 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. +; +; You should have received a copy of the GNU General Public License +; along with BLHeli. If not, see . +; +;**** **** **** **** **** +; +; The software was initially designed for use with Eflite mCP X, but is now adapted to a copters/planes in general +; +; The software was inspired by and started from from Bernard Konze's BLMC: http://home.versanet.de/~bkonze/blc_6a/blc_6a.htm +; And also Simon Kirby's TGY: https://github.com/sim-/tgy +; +; This file is best viewed with tab width set to 5 +; +; The input signal can be positive 1kHz, 2kHz, 4kHz or 8kHz PWM (taken from the "resistor tap" on mCPx) +; And the input signal can be PPM (1-2ms) at rates up to several hundred Hz. +; The code adapts itself to the various input modes/frequencies +; The code ESC can also be programmed to accept inverted input signal. +; +; The first lines of the software must be modified according to the chosen environment: +; Uncomment the selected ESC and main/tail/multi mode +; BESC EQU "ESC"_"mode" +; +;**** **** **** **** **** +; Revision history: +; - Rev1.0: Initial revision based upon BLHeli for AVR controllers +; - Rev2.0: Changed "Eeprom" initialization, layout and defaults +; Various changes and improvements to comparator reading. Now using timer1 for time from pwm on/off +; Beeps are made louder +; Added programmable low voltage limit +; Added programmable damped tail mode (only for 1S ESCs) +; Added programmable motor rotation direction +; - Rev2.1: (minor changes by 4712) +; Added Disable TX Programming by PC Setup Application +; therfore changed EEPROM_LAYOUT_REVISION = 8 +; Added Vdd Monitor as reset source when writing to "EEProm" +; Changed for use of batch file to assemble, link and make hex files +; - Rev2.2: (minor changes by 4712) +; Added Disable Throttle Re-Arming every motor start by PC Setup Application +; - Rev2.3: (minor changes by 4712) +; Added bugfixed (2x CLR C before j(n)c operations)thx Steffen! +; - Rev2.4: Revisions 2.1 to 2.3 integrated +; - Rev3.0: Added PPM (1050us-1866us) as accepted input signal +; Added startup rpm as a programming parameter +; Added startup acceleration as a programming parameter +; Added option for using voltage measurements to compensate motor power +; Added governor target by setup as a governor mode option +; Governor is kept active regardless of rpm +; Smooth governor spoolup/down in arm and setup modes +; Increased governor P and I gain programming ranges +; Increased and changed low voltage limit programming range +; Disabled tx programming entry for all but the first arming sequence after power on +; Made it possible to skip parameters in tx programming by setting throttle midstick +; Made it default not to rearm for every restart +; - Rev3.1: Fixed bug that prevented chosen parameter to be set in tx programming +; - Rev3.2: ...also updated the EEPROM revision parameter +; - Rev3.3: Fixed negative number bug in voltage compensation +; Fixed bug in startup power calculation for non-default power +; Prevented possibility for voltage compensation fighting low voltage limiting +; Applied overall spoolup control to ensure soft spoolup in any mode +; Added a delay of 3 seconds from initiation of main motor stop until new startup is allowed +; Reduced beep power to reduce power consumption for very strong motors/ESCs +; - Rev3.4: Fixed bug that prevented full power in governor arm and setup modes +; Increased NFETON_DELAY for XP_7A and XP_12A to allow for more powerful fets +; Increased initial spoolup power, and linked to startup power +; - Rev4.0: Fixed bug that made tail tx program beeps very weak +; Added thermal protection feature +; Governor P and I gain ranges are extended up to 8.0x gain +; Startup sequence is aborted upon zero throttle +; Avoided voltage compensation function induced latency for tail when voltage compensation is not enabled +; Improved input signal frequency detection robustness +; - Rev4.1: Increased thermal protection temperature limits +; - Rev5.0: Added multi(copter) operating mode. TAIL define changed to MODE with three modes: MAIN, TAIL and MULTI +; Added programmable commutation timing +; Added a damped light mode that has less damping, but that can be used with all escs +; Added programmable damping force +; Added thermal protection for startup too +; Added wait beeps when waiting more than 30 sec for throttle above zero (after having been armed) +; Modified tail idling to provide option for very low speeds +; Changed PPM range to 1150-1830us +; Arming sequence is dropped for PPM input, unless it is governor arm mode +; Loss of input signal will immediately stop the motor for PPM input +; Bug corrected in Turnigy Plush 6A voltage measurement setup +; FET switching delays are set for original fets. Stronger/doubled/tripled etc fets may require faster pfet off switching +; Miscellaneous other changes +; - Rev6.0: Reverted comparator reading routine to rev5.0 equivalent, in order to avoid tail motor stops +; Added governor range programmability +; Implemented startup retry sequence with varying startup power for multi mode +; In damped light mode, damping is now applied to the active nfet phase for fully damped capable ESCs +; - Rev6.1: Added input signal qualification criteria for PPM, to avoid triggering on noise spikes (fix for plush hardware) +; Changed main and multi mode stop criteria. Will now be in run mode, even if RC pulse input is zero +; Fixed bug in commutation that caused rough running in damped light mode +; Miscellaneous other changes +; - Rev7.0 Added direct startup mode programmability +; Added throttle calibration. Min>=1000us and Max<=2000us. Difference must be >520us, otherwise max is shifted so that difference=520us +; Added programmable throttle change rate +; Added programmable beep strength, beacon strength and beacon delay +; Reduced power step to full power significantly +; Miscellaneous other changes +; - Rev8.0 Added a 2 second delay after power up, to wait for receiver initialization +; Added a programming option for disabling low voltage limit, and made it default for MULTI +; Added programable demag compensation, using the concept of SimonK +; Improved robustness against noisy input signal +; Refined direct startup +; Removed voltage compensation +; Miscellaneous other changes +; - Rev9.0 Increased programming range for startup power, and made it's default ESC dependent +; Made default startup method ESC dependent +; Even more smooth and gentle spoolup for MAIN, to suit larger helis +; Improved transition from stepped startup to run +; Refined direct startup +; - Rev9.1 Fixed bug that changed FW revision after throttle calibration or TX programming +; - Rev9.2 Altered timing of throttle calibration in order to work with MultiWii calibration firmware +; Reduced main spoolup time to around 5 seconds +; Changed default beacon delay to 3 minutes +; - Rev9.3 Fixed bug in Plush 60/80A temperature reading, that caused failure in operation above 4S +; Corrected temperature limit for HiModel cool 22/33/41A, RCTimer 6A, Skywalker 20/40A, Turnigy AE45A, Plush 40/60/80A. Limit was previously set too high +; - Rev9.4 Improved timing for increased maximum rpm limit +; - Rev10.0 Added closed loop mode for multi +; Added high/low BEC voltage option (for the ESCs where HW supports it) +; Added method of resetting all programmed parameter values to defaults by TX programming +; Added Turnigy K-force 40A and Turnigy K-force 120A HV ESCs +; Enabled fully damped mode for several ESCs +; Extended startup power range downwards to enable very smooth start for large heli main motors +; Extended damping force with a highest setting +; Corrected temperature limits for F310 chips (Plush 40A and AE 45A) +; Implemented temperature reading average in order to avoid problems with ADC noise on Skywalkers +; Increased switching delays for XP 7A fast, in order to avoid cross conduction of N and P fets +; Miscellaneous other changes +; - Rev10.1 Relaxed RC signal jitter requirement during frequency measurement +; Corrected bug that prevented using governor low +; Enabled vdd monitor always, in order to reduce likelihood of accidental overwriting of adjustments +; Fixed bug that caused stop for PPM input above 2048us, and moved upper accepted limit to 2160us +; - Rev10.2 Corrected temperature limit for AE20-30/XP7-25, where limit was too high +; Corrected temperature limit for 120HV, where limit was too low +; Fixed bug that caused AE20/25/30A not to run in reverse +; +; +;**** **** **** **** **** +; Up to 8K Bytes of In-System Self-Programmable Flash +; 768 Bytes Internal SRAM +; +;**** **** **** **** **** +; Master clock is internal 24MHz oscillator +; Timer 0 (167/500ns counts) always counts up and is used for +; - PWM generation +; Timer 1 (167/500ns counts) always counts up and is not used +; - Time from pwm on/off event +; Timer 2 (500ns counts) always counts up and is used for +; - RC pulse timeout/skip counts and commutation times +; Timer 3 (500ns counts) always counts up and is used for +; - Commutation timeouts +; PCA0 (500ns counts) always counts up and is used for +; - RC pulse measurement +; +;**** **** **** **** **** +; Interrupt handling +; The F330/2 does not disable interrupts when entering an interrupt routine. +; Also some interrupt flags need to be cleared by software +; The code disables interrupts in interrupt routines, in order to avoid nested interrupts +; - Interrupts are disabled during beeps, to avoid audible interference from interrupts +; - RC pulse interrupts are periodically disabled in order to reduce interference with pwm interrupts. +; +;**** **** **** **** **** +; Motor control: +; - Brushless motor control with 6 states for each electrical 360 degrees +; - An advance timing of 0deg has zero cross 30deg after one commutation and 30deg before the next +; - Timing advance in this implementation is set to 15deg nominally +; - "Damped" commutation schemes are available, where more than one pfet is on when pwm is off. This will absorb energy from bemf and make step settling more damped. +; Motor sequence starting from zero crossing: +; - Timer wait: Wt_Comm 15deg ; Time to wait from zero cross to actual commutation +; - Timer wait: Wt_Advance 15deg ; Time to wait for timing advance. Nominal commutation point is after this +; - Timer wait: Wt_Zc_Scan 7.5deg ; Time to wait before looking for zero cross +; - Scan for zero cross 22.5deg , Nominal, with some motor variations +; +; Motor startup in stepper mode: +; Initial motor rotations are done with the motor controlled as a stepper motor. +; In this stepper motor mode comparator information is not used. +; Settle phase is the first, where there are a few commutations with increasing step length, in order to settle the motor in a predefined position. +; Stepper phase comes next, where there is a step length decrease sequence. +; Direct startup is the last phase, for synchronization before normal bemf commutation run begins. +; Motor startup in direct mode: +; Direct startup is the only phase, before normal bemf commutation run begins. +; +;**** **** **** **** **** +; List of enumerated supported ESCs and modes (main, tail or multi) +XP_3A_Main EQU 1 +XP_3A_Tail EQU 2 +XP_3A_Multi EQU 3 +XP_7A_Main EQU 4 +XP_7A_Tail EQU 5 +XP_7A_Multi EQU 6 +XP_7A_Fast_Main EQU 7 +XP_7A_Fast_Tail EQU 8 +XP_7A_Fast_Multi EQU 9 +XP_12A_Main EQU 10 +XP_12A_Tail EQU 11 +XP_12A_Multi EQU 12 +XP_18A_Main EQU 13 +XP_18A_Tail EQU 14 +XP_18A_Multi EQU 15 +XP_25A_Main EQU 16 +XP_25A_Tail EQU 17 +XP_25A_Multi EQU 18 +DP_3A_Main EQU 19 +DP_3A_Tail EQU 20 +DP_3A_Multi EQU 21 +Supermicro_3p5A_Main EQU 22 +Supermicro_3p5A_Tail EQU 23 +Supermicro_3p5A_Multi EQU 24 +Turnigy_Plush_6A_Main EQU 25 +Turnigy_Plush_6A_Tail EQU 26 +Turnigy_Plush_6A_Multi EQU 27 +Turnigy_Plush_10A_Main EQU 28 +Turnigy_Plush_10A_Tail EQU 29 +Turnigy_Plush_10A_Multi EQU 30 +Turnigy_Plush_12A_Main EQU 31 +Turnigy_Plush_12A_Tail EQU 32 +Turnigy_Plush_12A_Multi EQU 33 +Turnigy_Plush_18A_Main EQU 34 +Turnigy_Plush_18A_Tail EQU 35 +Turnigy_Plush_18A_Multi EQU 36 +Turnigy_Plush_25A_Main EQU 37 +Turnigy_Plush_25A_Tail EQU 38 +Turnigy_Plush_25A_Multi EQU 39 +Turnigy_Plush_30A_Main EQU 40 +Turnigy_Plush_30A_Tail EQU 41 +Turnigy_Plush_30A_Multi EQU 42 +Turnigy_Plush_40A_Main EQU 43 +Turnigy_Plush_40A_Tail EQU 44 +Turnigy_Plush_40A_Multi EQU 45 +Turnigy_Plush_60A_Main EQU 46 +Turnigy_Plush_60A_Tail EQU 47 +Turnigy_Plush_60A_Multi EQU 48 +Turnigy_Plush_80A_Main EQU 49 +Turnigy_Plush_80A_Tail EQU 50 +Turnigy_Plush_80A_Multi EQU 51 +Turnigy_AE_20A_Main EQU 52 +Turnigy_AE_20A_Tail EQU 53 +Turnigy_AE_20A_Multi EQU 54 +Turnigy_AE_25A_Main EQU 55 +Turnigy_AE_25A_Tail EQU 56 +Turnigy_AE_25A_Multi EQU 57 +Turnigy_AE_30A_Main EQU 58 +Turnigy_AE_30A_Tail EQU 59 +Turnigy_AE_30A_Multi EQU 60 +Turnigy_AE_45A_Main EQU 61 +Turnigy_AE_45A_Tail EQU 62 +Turnigy_AE_45A_Multi EQU 63 +Turnigy_KForce_40A_Main EQU 64 +Turnigy_KForce_40A_Tail EQU 65 +Turnigy_KForce_40A_Multi EQU 66 +Turnigy_KForce_120A_HV_Main EQU 67 +Turnigy_KForce_120A_HV_Tail EQU 68 +Turnigy_KForce_120A_HV_Multi EQU 69 +Skywalker_20A_Main EQU 70 +Skywalker_20A_Tail EQU 71 +Skywalker_20A_Multi EQU 72 +Skywalker_40A_Main EQU 73 +Skywalker_40A_Tail EQU 74 +Skywalker_40A_Multi EQU 75 +HiModel_Cool_22A_Main EQU 76 +HiModel_Cool_22A_Tail EQU 77 +HiModel_Cool_22A_Multi EQU 78 +HiModel_Cool_33A_Main EQU 79 +HiModel_Cool_33A_Tail EQU 80 +HiModel_Cool_33A_Multi EQU 81 +HiModel_Cool_41A_Main EQU 82 +HiModel_Cool_41A_Tail EQU 83 +HiModel_Cool_41A_Multi EQU 84 +RCTimer_6A_Main EQU 85 +RCTimer_6A_Tail EQU 86 +RCTimer_6A_Multi EQU 87 +Align_RCE_BL15X_Main EQU 88 +Align_RCE_BL15X_Tail EQU 89 +Align_RCE_BL15X_Multi EQU 90 +Align_RCE_BL35X_Main EQU 91 +Align_RCE_BL35X_Tail EQU 92 +Align_RCE_BL35X_Multi EQU 93 +Align_RCE_BL35P_Main EQU 94 +Align_RCE_BL35P_Tail EQU 95 +Align_RCE_BL35P_Multi EQU 96 +H_King_10A_Main EQU 97 +H_King_10A_Tail EQU 98 +H_King_10A_Multi EQU 99 + +;**** **** **** **** **** +; Select the ESC and mode to use (or unselect all for use with external batch compile file) +;BESC EQU XP_3A_Main +;BESC EQU XP_3A_Tail +;BESC EQU XP_3A_Multi +;BESC EQU XP_7A_Main +;BESC EQU XP_7A_Tail +;BESC EQU XP_7A_Multi +;BESC EQU XP_7A_Fast_Main +;BESC EQU XP_7A_Fast_Tail +;BESC EQU XP_7A_Fast_Multi +;BESC EQU XP_12A_Main +;BESC EQU XP_12A_Tail +;BESC EQU XP_12A_Multi +;BESC EQU XP_18A_Main +;BESC EQU XP_18A_Tail +BESC EQU XP_18A_Multi +;BESC EQU XP_25A_Main +;BESC EQU XP_25A_Tail +;BESC EQU XP_25A_Multi +;BESC EQU DP_3A_Main +;BESC EQU DP_3A_Tail +;BESC EQU DP_3A_Multi +;BESC EQU Supermicro_3p5A_Main +;BESC EQU Supermicro_3p5A_Tail +;BESC EQU Supermicro_3p5A_Multi +;BESC EQU Turnigy_Plush_6A_Main +;BESC EQU Turnigy_Plush_6A_Tail +;BESC EQU Turnigy_Plush_6A_Multi +;BESC EQU Turnigy_Plush_10A_Main +;BESC EQU Turnigy_Plush_10A_Tail +;BESC EQU Turnigy_Plush_10A_Multi +;BESC EQU Turnigy_Plush_12A_Main +;BESC EQU Turnigy_Plush_12A_Tail +;BESC EQU Turnigy_Plush_12A_Multi +;BESC EQU Turnigy_Plush_18A_Main +;BESC EQU Turnigy_Plush_18A_Tail +;BESC EQU Turnigy_Plush_18A_Multi +;BESC EQU Turnigy_Plush_25A_Main +;BESC EQU Turnigy_Plush_25A_Tail +;BESC EQU Turnigy_Plush_25A_Multi +;BESC EQU Turnigy_Plush_30A_Main +;BESC EQU Turnigy_Plush_30A_Tail +;BESC EQU Turnigy_Plush_30A_Multi +;BESC EQU Turnigy_Plush_40A_Main +;BESC EQU Turnigy_Plush_40A_Tail +;BESC EQU Turnigy_Plush_40A_Multi +;BESC EQU Turnigy_Plush_60A_Main +;BESC EQU Turnigy_Plush_60A_Tail +;BESC EQU Turnigy_Plush_60A_Multi +;BESC EQU Turnigy_Plush_80A_Main +;BESC EQU Turnigy_Plush_80A_Tail +;BESC EQU Turnigy_Plush_80A_Multi +;BESC EQU Turnigy_AE_20A_Main +;BESC EQU Turnigy_AE_20A_Tail +;BESC EQU Turnigy_AE_20A_Multi +;BESC EQU Turnigy_AE_25A_Main +;BESC EQU Turnigy_AE_25A_Tail +;BESC EQU Turnigy_AE_25A_Multi +;BESC EQU Turnigy_AE_30A_Main +;BESC EQU Turnigy_AE_30A_Tail +;BESC EQU Turnigy_AE_30A_Multi +;BESC EQU Turnigy_AE_45A_Main +;BESC EQU Turnigy_AE_45A_Tail +;BESC EQU Turnigy_AE_45A_Multi +;BESC EQU Turnigy_KForce_40A_Main +;BESC EQU Turnigy_KForce_40A_Tail +;BESC EQU Turnigy_KForce_40A_Multi +;BESC EQU Turnigy_KForce_120A_HV_Main +;BESC EQU Turnigy_KForce_120A_HV_Tail +;BESC EQU Turnigy_KForce_120A_HV_Multi +;BESC EQU Skywalker_20A_Main +;BESC EQU Skywalker_20A_Tail +;BESC EQU Skywalker_20A_Multi +;BESC EQU Skywalker_40A_Main +;BESC EQU Skywalker_40A_Tail +;BESC EQU Skywalker_40A_Multi +;BESC EQU HiModel_Cool_22A_Main +;BESC EQU HiModel_Cool_22A_Tail +;BESC EQU HiModel_Cool_22A_Multi +;BESC EQU HiModel_Cool_33A_Main +;BESC EQU HiModel_Cool_33A_Tail +;BESC EQU HiModel_Cool_33A_Multi +;BESC EQU HiModel_Cool_41A_Main +;BESC EQU HiModel_Cool_41A_Tail +;BESC EQU HiModel_Cool_41A_Multi +;BESC EQU RCTimer_6A_Main +;BESC EQU RCTimer_6A_Tail +;BESC EQU RCTimer_6A_Multi +;BESC EQU Align_RCE_BL15X_Main +;BESC EQU Align_RCE_BL15X_Tail +;BESC EQU Align_RCE_BL15X_Multi +;BESC EQU Align_RCE_BL35X_Main +;BESC EQU Align_RCE_BL35X_Tail +;BESC EQU Align_RCE_BL35X_Multi +;BESC EQU Align_RCE_BL35P_Main +;BESC EQU Align_RCE_BL35P_Tail +;BESC EQU Align_RCE_BL35P_Multi +;BESC EQU H_King_10A_Main +;BESC EQU H_King_10A_Tail +;BESC EQU H_King_10A_Multi + + +;**** **** **** **** **** +; ESC selection statements +IF BESC == XP_3A_Main +MODE EQU 0 ; Choose mode. Set to 0 for main motor +$include (XP_3A.inc) ; Select XP 3A pinout +ENDIF + +IF BESC == XP_3A_Tail +MODE EQU 1 ; Choose mode. Set to 1 for tail motor +$include (XP_3A.inc) ; Select XP 3A pinout +ENDIF + +IF BESC == XP_3A_Multi +MODE EQU 2 ; Choose mode. Set to 2 for multirotor +$include (XP_3A.inc) ; Select XP 3A pinout +ENDIF + +IF BESC == XP_7A_Main +MODE EQU 0 ; Choose mode. Set to 0 for main motor +$include (XP_7A.inc) ; Select XP 7A pinout +ENDIF + +IF BESC == XP_7A_Tail +MODE EQU 1 ; Choose mode. Set to 1 for tail motor +$include (XP_7A.inc) ; Select XP 7A pinout +ENDIF + +IF BESC == XP_7A_Multi +MODE EQU 2 ; Choose mode. Set to 2 for multirotor +$include (XP_7A.inc) ; Select XP 7A pinout +ENDIF + +IF BESC == XP_7A_Fast_Main +MODE EQU 0 ; Choose mode. Set to 0 for main motor +$include (XP_7A_Fast.inc) ; Select XP 7A Fast pinout +ENDIF + +IF BESC == XP_7A_Fast_Tail +MODE EQU 1 ; Choose mode. Set to 1 for tail motor +$include (XP_7A_Fast.inc) ; Select XP 7A Fast pinout +ENDIF + +IF BESC == XP_7A_Fast_Multi +MODE EQU 2 ; Choose mode. Set to 2 for multirotor +$include (XP_7A_Fast.inc) ; Select XP 7A Fast pinout +ENDIF + +IF BESC == XP_12A_Main +MODE EQU 0 ; Choose mode. Set to 0 for main motor +$include (XP_12A.inc) ; Select XP 12A pinout +ENDIF + +IF BESC == XP_12A_Tail +MODE EQU 1 ; Choose mode. Set to 1 for tail motor +$include (XP_12A.inc) ; Select XP 12A pinout +ENDIF + +IF BESC == XP_12A_Multi +MODE EQU 2 ; Choose mode. Set to 2 for multirotor +$include (XP_12A.inc) ; Select XP 12A pinout +ENDIF + +IF BESC == XP_18A_Main +MODE EQU 0 ; Choose mode. Set to 0 for main motor +$include (XP_18A.inc) ; Select XP 18A pinout +ENDIF + +IF BESC == XP_18A_Tail +MODE EQU 1 ; Choose mode. Set to 1 for tail motor +$include (XP_18A.inc) ; Select XP 18A pinout +ENDIF + +IF BESC == XP_18A_Multi +MODE EQU 2 ; Choose mode. Set to 2 for multirotor +$include (XP_18A.inc) ; Select XP 18A pinout +ENDIF + +IF BESC == XP_25A_Main +MODE EQU 0 ; Choose mode. Set to 0 for main motor +$include (XP_25A.inc) ; Select XP 25A pinout +ENDIF + +IF BESC == XP_25A_Tail +MODE EQU 1 ; Choose mode. Set to 1 for tail motor +$include (XP_25A.inc) ; Select XP 25A pinout +ENDIF + +IF BESC == XP_25A_Multi +MODE EQU 2 ; Choose mode. Set to 2 for multirotor +$include (XP_25A.inc) ; Select XP 25A pinout +ENDIF + +IF BESC == DP_3A_Main +MODE EQU 0 ; Choose mode. Set to 0 for main motor +$include (DP_3A.inc) ; Select DP 3A pinout +ENDIF + +IF BESC == DP_3A_Tail +MODE EQU 1 ; Choose mode. Set to 1 for tail motor +$include (DP_3A.inc) ; Select DP 3A pinout +ENDIF + +IF BESC == DP_3A_Multi +MODE EQU 2 ; Choose mode. Set to 2 for multirotor +$include (DP_3A.inc) ; Select DP 3A pinout +ENDIF + +IF BESC == Supermicro_3p5A_Main +MODE EQU 0 ; Choose mode. Set to 0 for main motor +$include (Supermicro_3p5A.inc) ; Select Supermicro 3.5A pinout +ENDIF + +IF BESC == Supermicro_3p5A_Tail +MODE EQU 1 ; Choose mode. Set to 1 for tail motor +$include (Supermicro_3p5A.inc) ; Select Supermicro 3.5A pinout +ENDIF + +IF BESC == Supermicro_3p5A_Multi +MODE EQU 2 ; Choose mode. Set to 2 for multirotor +$include (Supermicro_3p5A.inc) ; Select Supermicro 3.5A pinout +ENDIF + +IF BESC == Turnigy_Plush_6A_Main +MODE EQU 0 ; Choose mode. Set to 0 for main motor +$include (Turnigy_Plush_6A.inc) ; Select Turnigy Plush 6A pinout +ENDIF + +IF BESC == Turnigy_Plush_6A_Tail +MODE EQU 1 ; Choose mode. Set to 1 for tail motor +$include (Turnigy_Plush_6A.inc) ; Select Turnigy Plush 6A pinout +ENDIF + +IF BESC == Turnigy_Plush_6A_Multi +MODE EQU 2 ; Choose mode. Set to 2 for multirotor +$include (Turnigy_Plush_6A.inc) ; Select Turnigy Plush 6A pinout +ENDIF + +IF BESC == Turnigy_Plush_10A_Main +MODE EQU 0 ; Choose mode. Set to 0 for main motor +$include (Turnigy_Plush_10A.inc) ; Select Turnigy Plush 10A pinout +ENDIF + +IF BESC == Turnigy_Plush_10A_Tail +MODE EQU 1 ; Choose mode. Set to 1 for tail motor +$include (Turnigy_Plush_10A.inc) ; Select Turnigy Plush 10A pinout +ENDIF + +IF BESC == Turnigy_Plush_10A_Multi +MODE EQU 2 ; Choose mode. Set to 2 for multirotor +$include (Turnigy_Plush_10A.inc) ; Select Turnigy Plush 10A pinout +ENDIF + +IF BESC == Turnigy_Plush_12A_Main +MODE EQU 0 ; Choose mode. Set to 0 for main motor +$include (Turnigy_Plush_12A.inc) ; Select Turnigy Plush 12A pinout +ENDIF + +IF BESC == Turnigy_Plush_12A_Tail +MODE EQU 1 ; Choose mode. Set to 1 for tail motor +$include (Turnigy_Plush_12A.inc) ; Select Turnigy Plush 12A pinout +ENDIF + +IF BESC == Turnigy_Plush_12A_Multi +MODE EQU 2 ; Choose mode. Set to 2 for multirotor +$include (Turnigy_Plush_12A.inc) ; Select Turnigy Plush 12A pinout +ENDIF + +IF BESC == Turnigy_Plush_18A_Main +MODE EQU 0 ; Choose mode. Set to 0 for main motor +$include (Turnigy_Plush_18A.inc) ; Select Turnigy Plush 18A pinout +ENDIF + +IF BESC == Turnigy_Plush_18A_Tail +MODE EQU 1 ; Choose mode. Set to 1 for tail motor +$include (Turnigy_Plush_18A.inc) ; Select Turnigy Plush 18A pinout +ENDIF + +IF BESC == Turnigy_Plush_18A_Multi +MODE EQU 2 ; Choose mode. Set to 2 for multirotor +$include (Turnigy_Plush_18A.inc) ; Select Turnigy Plush 18A pinout +ENDIF + +IF BESC == Turnigy_Plush_25A_Main +MODE EQU 0 ; Choose mode. Set to 0 for main motor +$include (Turnigy_Plush_25A.inc) ; Select Turnigy Plush 25A pinout +ENDIF + +IF BESC == Turnigy_Plush_25A_Tail +MODE EQU 1 ; Choose mode. Set to 1 for tail motor +$include (Turnigy_Plush_25A.inc) ; Select Turnigy Plush 25A pinout +ENDIF + +IF BESC == Turnigy_Plush_25A_Multi +MODE EQU 2 ; Choose mode. Set to 2 for multirotor +$include (Turnigy_Plush_25A.inc) ; Select Turnigy Plush 25A pinout +ENDIF + +IF BESC == Turnigy_Plush_30A_Main +MODE EQU 0 ; Choose mode. Set to 0 for main motor +$include (Turnigy_Plush_30A.inc) ; Select Turnigy Plush 30A pinout +ENDIF + +IF BESC == Turnigy_Plush_30A_Tail +MODE EQU 1 ; Choose mode. Set to 1 for tail motor +$include (Turnigy_Plush_30A.inc) ; Select Turnigy Plush 30A pinout +ENDIF + +IF BESC == Turnigy_Plush_30A_Multi +MODE EQU 2 ; Choose mode. Set to 2 for multirotor +$include (Turnigy_Plush_30A.inc) ; Select Turnigy Plush 30A pinout +ENDIF + +IF BESC == Turnigy_Plush_40A_Main +MODE EQU 0 ; Choose mode. Set to 0 for main motor +$include (Turnigy_Plush_40A.inc) ; Select Turnigy Plush 40A pinout +ENDIF + +IF BESC == Turnigy_Plush_40A_Tail +MODE EQU 1 ; Choose mode. Set to 1 for tail motor +$include (Turnigy_Plush_40A.inc) ; Select Turnigy Plush 40A pinout +ENDIF + +IF BESC == Turnigy_Plush_40A_Multi +MODE EQU 2 ; Choose mode. Set to 2 for multirotor +$include (Turnigy_Plush_40A.inc) ; Select Turnigy Plush 40A pinout +ENDIF + +IF BESC == Turnigy_Plush_60A_Main +MODE EQU 0 ; Choose mode. Set to 0 for main motor +$include (Turnigy_Plush_60A.inc) ; Select Turnigy Plush 60A pinout +ENDIF + +IF BESC == Turnigy_Plush_60A_Tail +MODE EQU 1 ; Choose mode. Set to 1 for tail motor +$include (Turnigy_Plush_60A.inc) ; Select Turnigy Plush 60A pinout +ENDIF + +IF BESC == Turnigy_Plush_60A_Multi +MODE EQU 2 ; Choose mode. Set to 2 for multirotor +$include (Turnigy_Plush_60A.inc) ; Select Turnigy Plush 60A pinout +ENDIF + +IF BESC == Turnigy_Plush_80A_Main +MODE EQU 0 ; Choose mode. Set to 0 for main motor +$include (Turnigy_Plush_80A.inc) ; Select Turnigy Plush 80A pinout +ENDIF + +IF BESC == Turnigy_Plush_80A_Tail +MODE EQU 1 ; Choose mode. Set to 1 for tail motor +$include (Turnigy_Plush_80A.inc) ; Select Turnigy Plush 80A pinout +ENDIF + +IF BESC == Turnigy_Plush_80A_Multi +MODE EQU 2 ; Choose mode. Set to 2 for multirotor +$include (Turnigy_Plush_80A.inc) ; Select Turnigy Plush 80A pinout +ENDIF + +IF BESC == Turnigy_AE_20A_Main +MODE EQU 0 ; Choose mode. Set to 0 for main motor +$include (Turnigy_AE_20A.inc) ; Select Turnigy AE-20A pinout +ENDIF + +IF BESC == Turnigy_AE_20A_Tail +MODE EQU 1 ; Choose mode. Set to 1 for tail motor +$include (Turnigy_AE_20A.inc) ; Select Turnigy AE-20A pinout +ENDIF + +IF BESC == Turnigy_AE_20A_Multi +MODE EQU 2 ; Choose mode. Set to 2 for multirotor +$include (Turnigy_AE_20A.inc) ; Select Turnigy AE-20A pinout +ENDIF + +IF BESC == Turnigy_AE_25A_Main +MODE EQU 0 ; Choose mode. Set to 0 for main motor +$include (Turnigy_AE_25A.inc) ; Select Turnigy AE-25A pinout +ENDIF + +IF BESC == Turnigy_AE_25A_Tail +MODE EQU 1 ; Choose mode. Set to 1 for tail motor +$include (Turnigy_AE_25A.inc) ; Select Turnigy AE-25A pinout +ENDIF + +IF BESC == Turnigy_AE_25A_Multi +MODE EQU 2 ; Choose mode. Set to 2 for multirotor +$include (Turnigy_AE_25A.inc) ; Select Turnigy AE-25A pinout +ENDIF + +IF BESC == Turnigy_AE_30A_Main +MODE EQU 0 ; Choose mode. Set to 0 for main motor +$include (Turnigy_AE_30A.inc) ; Select Turnigy AE-30A pinout +ENDIF + +IF BESC == Turnigy_AE_30A_Tail +MODE EQU 1 ; Choose mode. Set to 1 for tail motor +$include (Turnigy_AE_30A.inc) ; Select Turnigy AE-30A pinout +ENDIF + +IF BESC == Turnigy_AE_30A_Multi +MODE EQU 2 ; Choose mode. Set to 2 for multirotor +$include (Turnigy_AE_30A.inc) ; Select Turnigy AE-30A pinout +ENDIF + +IF BESC == Turnigy_AE_45A_Main +MODE EQU 0 ; Choose mode. Set to 0 for main motor +$include (Turnigy_AE_45A.inc) ; Select Turnigy AE-45A pinout +ENDIF + +IF BESC == Turnigy_AE_45A_Tail +MODE EQU 1 ; Choose mode. Set to 1 for tail motor +$include (Turnigy_AE_45A.inc) ; Select Turnigy AE-45A pinout +ENDIF + +IF BESC == Turnigy_AE_45A_Multi +MODE EQU 2 ; Choose mode. Set to 2 for multirotor +$include (Turnigy_AE_45A.inc) ; Select Turnigy AE-45A pinout +ENDIF + +IF BESC == Turnigy_KForce_40A_Main +MODE EQU 0 ; Choose mode. Set to 0 for main motor +$include (Turnigy_KForce_40A.inc) ; Select Turnigy KForce 40A pinout +ENDIF + +IF BESC == Turnigy_KForce_40A_Tail +MODE EQU 1 ; Choose mode. Set to 1 for tail motor +$include (Turnigy_KForce_40A.inc) ; Select Turnigy KForce 40A pinout +ENDIF + +IF BESC == Turnigy_KForce_40A_Multi +MODE EQU 2 ; Choose mode. Set to 2 for multirotor +$include (Turnigy_KForce_40A.inc) ; Select Turnigy KForce 40A pinout +ENDIF + +IF BESC == Turnigy_KForce_120A_HV_Main +MODE EQU 0 ; Choose mode. Set to 0 for main motor +$include (Turnigy_KForce_120A_HV.inc) ; Select Turnigy KForce 120A HV pinout +ENDIF + +IF BESC == Turnigy_KForce_120A_HV_Tail +MODE EQU 1 ; Choose mode. Set to 1 for tail motor +$include (Turnigy_KForce_120A_HV.inc) ; Select Turnigy KForce 120A HV pinout +ENDIF + +IF BESC == Turnigy_KForce_120A_HV_Multi +MODE EQU 2 ; Choose mode. Set to 2 for multirotor +$include (Turnigy_KForce_120A_HV.inc) ; Select Turnigy KForce 120A HV pinout +ENDIF + +IF BESC == Skywalker_20A_Main +MODE EQU 0 ; Choose mode. Set to 0 for main motor +$include (Skywalker_20A.inc) ; Select Skywalker 20A pinout +ENDIF + +IF BESC == Skywalker_20A_Tail +MODE EQU 1 ; Choose mode. Set to 1 for tail motor +$include (Skywalker_20A.inc) ; Select Skywalker 20A pinout +ENDIF + +IF BESC == Skywalker_20A_Multi +MODE EQU 2 ; Choose mode. Set to 2 for multirotor +$include (Skywalker_20A.inc) ; Select Skywalker 20A pinout +ENDIF + +IF BESC == Skywalker_40A_Main +MODE EQU 0 ; Choose mode. Set to 0 for main motor +$include (Skywalker_40A.inc) ; Select Skywalker 40A pinout +ENDIF + +IF BESC == Skywalker_40A_Tail +MODE EQU 1 ; Choose mode. Set to 1 for tail motor +$include (Skywalker_40A.inc) ; Select Skywalker 40A pinout +ENDIF + +IF BESC == Skywalker_40A_Multi +MODE EQU 2 ; Choose mode. Set to 2 for multirotor +$include (Skywalker_40A.inc) ; Select Skywalker 40A pinout +ENDIF + +IF BESC == HiModel_Cool_22A_Main +MODE EQU 0 ; Choose mode. Set to 0 for main motor +$include (HiModel_Cool_22A.inc) ; Select HiModel Cool 22A pinout +ENDIF + +IF BESC == HiModel_Cool_22A_Tail +MODE EQU 1 ; Choose mode. Set to 1 for tail motor +$include (HiModel_Cool_22A.inc) ; Select HiModel Cool 22A pinout +ENDIF + +IF BESC == HiModel_Cool_22A_Multi +MODE EQU 2 ; Choose mode. Set to 2 for multirotor +$include (HiModel_Cool_22A.inc) ; Select HiModel Cool 22A pinout +ENDIF + +IF BESC == HiModel_Cool_33A_Main +MODE EQU 0 ; Choose mode. Set to 0 for main motor +$include (HiModel_Cool_33A.inc) ; Select HiModel Cool 33A pinout +ENDIF + +IF BESC == HiModel_Cool_33A_Tail +MODE EQU 1 ; Choose mode. Set to 1 for tail motor +$include (HiModel_Cool_33A.inc) ; Select HiModel Cool 33A pinout +ENDIF + +IF BESC == HiModel_Cool_33A_Multi +MODE EQU 2 ; Choose mode. Set to 2 for multirotor +$include (HiModel_Cool_33A.inc) ; Select HiModel Cool 33A pinout +ENDIF + +IF BESC == HiModel_Cool_41A_Main +MODE EQU 0 ; Choose mode. Set to 0 for main motor +$include (HiModel_Cool_41A.inc) ; Select HiModel Cool 41A pinout +ENDIF + +IF BESC == HiModel_Cool_41A_Tail +MODE EQU 1 ; Choose mode. Set to 1 for tail motor +$include (HiModel_Cool_41A.inc) ; Select HiModel Cool 41A pinout +ENDIF + +IF BESC == HiModel_Cool_41A_Multi +MODE EQU 2 ; Choose mode. Set to 2 for multirotor +$include (HiModel_Cool_41A.inc) ; Select HiModel Cool 41A pinout +ENDIF + +IF BESC == RCTimer_6A_Main +MODE EQU 0 ; Choose mode. Set to 0 for main motor +$include (RCTimer_6A.inc) ; Select RC Timer 6A pinout +ENDIF + +IF BESC == RCTimer_6A_Tail +MODE EQU 1 ; Choose mode. Set to 1 for tail motor +$include (RCTimer_6A.inc) ; Select RC Timer 6A pinout +ENDIF + +IF BESC == RCTimer_6A_Multi +MODE EQU 2 ; Choose mode. Set to 2 for multirotor +$include (RCTimer_6A.inc) ; Select RC Timer 6A pinout +ENDIF + +IF BESC == Align_RCE_BL15X_Main +MODE EQU 0 ; Choose mode. Set to 0 for main motor +$include (Align_RCE_BL15X.inc) ; Select Align RCE-BL15X pinout +ENDIF + +IF BESC == Align_RCE_BL15X_Tail +MODE EQU 1 ; Choose mode. Set to 1 for tail motor +$include (Align_RCE_BL15X.inc) ; Select Align RCE-BL15X pinout +ENDIF + +IF BESC == Align_RCE_BL15X_Multi +MODE EQU 2 ; Choose mode. Set to 2 for multirotor +$include (Align_RCE_BL15X.inc) ; Select Align RCE-BL15X pinout +ENDIF + +IF BESC == Align_RCE_BL35X_Main +MODE EQU 0 ; Choose mode. Set to 0 for main motor +$include (Align_RCE_BL35X.inc) ; Select Align RCE-BL35X pinout +ENDIF + +IF BESC == Align_RCE_BL35X_Tail +MODE EQU 1 ; Choose mode. Set to 1 for tail motor +$include (Align_RCE_BL35X.inc) ; Select Align RCE-BL35X pinout +ENDIF + +IF BESC == Align_RCE_BL35X_Multi +MODE EQU 2 ; Choose mode. Set to 2 for multirotor +$include (Align_RCE_BL35X.inc) ; Select Align RCE-BL35X pinout +ENDIF + +IF BESC == Align_RCE_BL35P_Main +MODE EQU 0 ; Choose mode. Set to 0 for main motor +$include (Align_RCE_BL35P.inc) ; Select Align RCE-BL35P pinout +ENDIF + +IF BESC == Align_RCE_BL35P_Tail +MODE EQU 1 ; Choose mode. Set to 1 for tail motor +$include (Align_RCE_BL35P.inc) ; Select Align RCE-BL35P pinout +ENDIF + +IF BESC == Align_RCE_BL35P_Multi +MODE EQU 2 ; Choose mode. Set to 2 for multirotor +$include (Align_RCE_BL35P.inc) ; Select Align RCE-BL35P pinout +ENDIF + +IF BESC == H_King_10A_Main +MODE EQU 0 ; Choose mode. Set to 0 for main motor +$include (H_King_10A.inc) ; Select H-King 10A pinout +ENDIF + +IF BESC == H_King_10A_Tail +MODE EQU 1 ; Choose mode. Set to 1 for tail motor +$include (H_King_10A.inc) ; Select H-King 10A pinout +ENDIF + +IF BESC == H_King_10A_Multi +MODE EQU 2 ; Choose mode. Set to 2 for multirotor +$include (H_King_10A.inc) ; Select H-King 10A pinout +ENDIF + +;**** **** **** **** **** +; TX programming defaults +; +; Parameter dependencies: +; - Governor P gain, I gain and Range is only used if one of the three governor modes is selected +; - Governor setup target is only used if Setup governor mode is selected (or closed loop mode is on for multi) +; - Startup rpm and startup accel is only used if stepped startup method is selected +; - Damping force is only used if DampedLight or Damped is selected +; +; Main +DEFAULT_PGM_MAIN_P_GAIN EQU 9 ; 1=0.13 2=0.17 3=0.25 4=0.38 5=0.50 6=0.75 7=1.00 8=1.5 9=2.0 10=3.0 11=4.0 12=6.0 13=8.0 +DEFAULT_PGM_MAIN_I_GAIN EQU 9 ; 1=0.13 2=0.17 3=0.25 4=0.38 5=0.50 6=0.75 7=1.00 8=1.5 9=2.0 10=3.0 11=4.0 12=6.0 13=8.0 +DEFAULT_PGM_MAIN_GOVERNOR_MODE EQU 1 ; 1=Tx 2=Arm 3=Setup 4=Off +DEFAULT_PGM_MAIN_GOVERNOR_RANGE EQU 1 ; 1=High 2=Low +DEFAULT_PGM_MAIN_LOW_VOLTAGE_LIM EQU 4 ; 1=Off 2=3.0V/c 3=3.1V/c 4=3.2V/c 5=3.3V/c 6=3.4V/c +DEFAULT_PGM_MAIN_STARTUP_RPM EQU 3 ; 1=0.67 2=0.8 3=1.00 4=1.25 5=1.5 +DEFAULT_PGM_MAIN_STARTUP_ACCEL EQU 1 ; 1=0.4 2=0.7 3=1.0 4=1.5 5=2.3 +DEFAULT_PGM_MAIN_COMM_TIMING EQU 3 ; 1=Low 2=MediumLow 3=Medium 4=MediumHigh 5=High +DEFAULT_PGM_MAIN_THROTTLE_RATE EQU 13 ; 1=2 2=3 3=4 4=6 5=8 6=12 7=16 8=24 9=32 10=48 11=64 12=128 13=255 +DEFAULT_PGM_MAIN_DAMPING_FORCE EQU 1 ; 1=VeryLow 2=Low 3=MediumLow 4=MediumHigh 5=High 6=Highest +DEFAULT_PGM_MAIN_PWM_FREQ EQU 2 ; 1=High 2=Low 3=DampedLight +DEFAULT_PGM_MAIN_DEMAG_COMP EQU 1 ; 1=Disabled 2=15/0 3=15/7.5 4=7.5/7.5 5=7.5/15 (degrees blind advance / power off) +DEFAULT_PGM_MAIN_DIRECTION_REV EQU 1 ; 1=Normal 2=Reversed +DEFAULT_PGM_MAIN_RCP_PWM_POL EQU 1 ; 1=Positive 2=Negative +DEFAULT_PGM_MAIN_GOV_SETUP_TARGET EQU 180 ; Target for governor in setup mode. Corresponds to 70% throttle +DEFAULT_PGM_MAIN_REARM_START EQU 0 ; 1=Enabled 0=Disabled +DEFAULT_PGM_MAIN_BEEP_STRENGTH EQU 80 ; Beep strength +DEFAULT_PGM_MAIN_BEACON_STRENGTH EQU 100 ; Beacon strength +DEFAULT_PGM_MAIN_BEACON_DELAY EQU 2 ; 1=30s 2=1m 3=2m 4=3m 5=Infinite +; Tail +DEFAULT_PGM_TAIL_GAIN EQU 3 ; 1=0.75 2=0.88 3=1.00 4=1.12 5=1.25 +DEFAULT_PGM_TAIL_IDLE_SPEED EQU 4 ; 1=Low 2=MediumLow 3=Medium 4=MediumHigh 5=High +DEFAULT_PGM_TAIL_STARTUP_RPM EQU 3 ; 1=0.67 2=0.8 3=1.00 4=1.25 5=1.5 +DEFAULT_PGM_TAIL_STARTUP_ACCEL EQU 5 ; 1=0.4 2=0.7 3=1.0 4=1.5 5=2.3 +DEFAULT_PGM_TAIL_COMM_TIMING EQU 3 ; 1=Low 2=MediumLow 3=Medium 4=MediumHigh 5=High +DEFAULT_PGM_TAIL_THROTTLE_RATE EQU 13 ; 1=2 2=3 3=4 4=6 5=8 6=12 7=16 8=24 9=32 10=48 11=64 12=128 13=255 +DEFAULT_PGM_TAIL_DAMPING_FORCE EQU 5 ; 1=VeryLow 2=Low 3=MediumLow 4=MediumHigh 5=High 6=Highest +IF DAMPED_MODE_ENABLE == 1 +DEFAULT_PGM_TAIL_PWM_FREQ EQU 1 ; 1=High 2=Low 3=DampedLight 4=Damped +ELSE +DEFAULT_PGM_TAIL_PWM_FREQ EQU 1 ; 1=High 2=Low 3=DampedLight +ENDIF +DEFAULT_PGM_TAIL_DEMAG_COMP EQU 1 ; 1=Disabled 2=15/0 3=15/7.5 4=7.5/7.5 5=7.5/15 (degrees blind advance / power off) +DEFAULT_PGM_TAIL_DIRECTION_REV EQU 1 ; 1=Normal 2=Reversed +DEFAULT_PGM_TAIL_RCP_PWM_POL EQU 1 ; 1=Positive 2=Negative +DEFAULT_PGM_TAIL_BEEP_STRENGTH EQU 250 ; Beep strength +DEFAULT_PGM_TAIL_BEACON_STRENGTH EQU 250 ; Beacon strength +DEFAULT_PGM_TAIL_BEACON_DELAY EQU 4 ; 1=30s 2=1m 3=2m 4=3m 5=Infinite +; Multi +DEFAULT_PGM_MULTI_FIRST_KEYWORD EQU 66h ;增加首个关键字 2013.8.27 +DEFAULT_PGM_MULTI_P_GAIN EQU 9 ; 1=0.13 2=0.17 3=0.25 4=0.38 5=0.50 6=0.75 7=1.00 8=1.5 9=2.0 10=3.0 11=4.0 12=6.0 13=8.0 +DEFAULT_PGM_MULTI_I_GAIN EQU 9 ; 1=0.13 2=0.17 3=0.25 4=0.38 5=0.50 6=0.75 7=1.00 8=1.5 9=2.0 10=3.0 11=4.0 12=6.0 13=8.0 +DEFAULT_PGM_MULTI_GOVERNOR_MODE EQU 1 ; 1=Off 2=LoRange 3=MidRange 4=HiRange +DEFAULT_PGM_MULTI_GAIN EQU 3 ; 1=0.75 2=0.88 3=1.00 4=1.12 5=1.25 +DEFAULT_PGM_MULTI_LOW_VOLTAGE_LIM EQU 2 +;DEFAULT_PGM_MULTI_LOW_VOLTAGE_LIM EQU 1 ; 1=Off 2=3.0V/c 3=3.1V/c 4=3.2V/c 5=3.3V/c 6=3.4V/c +DEFAULT_PGM_MULTI_LOW_VOLTAGE_CTL EQU 1 ;增加低压保护控制方式默认值 1=功率逐渐降到31% 2=关闭输出 +DEFAULT_PGM_MULTI_STARTUP_RPM EQU 1 ; 1=0.67 2=0.8 3=1.00 4=1.25 5=1.5 +DEFAULT_PGM_MULTI_STARTUP_ACCEL EQU 5 ; 1=0.4 2=0.7 3=1.0 4=1.5 5=2.3 +DEFAULT_PGM_MULTI_COMM_TIMING EQU 3 ; 1=Low 2=MediumLow 3=Medium 4=MediumHigh 5=High +DEFAULT_PGM_MULTI_THROTTLE_RATE EQU 13 ; 1=2 2=3 3=4 4=6 5=8 6=12 7=16 8=24 9=32 10=48 11=64 12=128 13=255 +DEFAULT_PGM_MULTI_DAMPING_FORCE EQU 1 ; 1=VeryLow 2=Low 3=MediumLow 4=MediumHigh 5=High 6=Highest +IF DAMPED_MODE_ENABLE == 1 +DEFAULT_PGM_MULTI_PWM_FREQ EQU 1 ; 1=Low 2=High +ELSE +DEFAULT_PGM_MULTI_PWM_FREQ EQU 1 ; 1=Low 2=High +ENDIF +DEFAULT_PGM_MULTI_DEMAG_COMP EQU 2 ; 1=Disabled 2=15/0 3=15/7.5 4=7.5/7.5 5=7.5/15 (degrees blind advance / power off) +DEFAULT_PGM_MULTI_DIRECTION_REV EQU 1 ; 1=Normal 2=Reversed +DEFAULT_PGM_MULTI_RCP_PWM_POL EQU 1 ; 1=Positive 2=Negative +;DEFAULT_PGM_MULTI_BEEP_STRENGTH EQU 40 ; Beep strength +;DEFAULT_PGM_MULTI_BEACON_STRENGTH EQU 80 ; Beacon strength 等待摇杆操作声强 +;DEFAULT_PGM_MULTI_BEACON_DELAY EQU 4 ; 1=30s 2=1m 3=2m 4=3m 5=Infinite +DEFAULT_PGM_MULTI_BEEP_STRENGTH EQU 80 ; Beep strength 上电到一次信号拉到最低声强 +DEFAULT_PGM_MULTI_BEACON_STRENGTH EQU 100 ; Beacon strength 等待摇杆操作声强 +DEFAULT_PGM_MULTI_BEACON_DELAY EQU 2 ; 1=30s 2=1m 3=2m 4=3m 5=Infinite 等待摇杆操作时间 +; Common +DEFAULT_PGM_ENABLE_TX_PROGRAM EQU 1 ; 1=Enabled 0=Disabled +DEFAULT_PGM_PPM_MIN_THROTTLE EQU 37 ; 4*37+1000=1148 +DEFAULT_PGM_PPM_MAX_THROTTLE EQU 208 ; 4*208+1000=1832 +DEFAULT_PGM_BEC_VOLTAGE_HIGH EQU 0 ; 0=Low 1= High + +;**** **** **** **** **** +; Constant definitions for main +IF MODE == 0 + +GOV_SPOOLRATE EQU 1 ; Number of steps for governor requested pwm per 32ms + +RCP_TIMEOUT_PPM EQU 10 ; Number of timer2H overflows (about 32ms) before considering rc pulse lost +RCP_TIMEOUT EQU 64 ; Number of timer2L overflows (about 128us) before considering rc pulse lost +RCP_SKIP_RATE EQU 32 ; Number of timer2L overflows (about 128us) before reenabling rc pulse detection +RCP_MIN EQU 0 ; This is minimum RC pulse length +RCP_MAX EQU 254 ; This is maximum RC pulse length +RCP_VALIDATE EQU 2 ; Require minimum this pulse length to validate RC pulse +RCP_STOP EQU 1 ; Stop motor at or below this pulse length +RCP_STOP_LIMIT EQU 3 ; Stop motor if this many timer2H overflows (~32ms) are below stop limit + +PWM_SETTLE EQU 50 ; PWM used when in start settling phase (also max power during direct start) +PWM_STEPPER EQU 80 ; PWM used when in start stepper phase + +COMM_TIME_RED EQU 8 ; Fixed reduction (in us) for commutation wait (to account for fixed delays) +COMM_TIME_MIN EQU 1 ; Minimum time (in us) for commutation wait + +TEMP_CHECK_RATE EQU 8 ; Number of adc conversions for each check of temperature (the other conversions are used for voltage) + +ENDIF +; Constant definitions for tail +IF MODE == 1 + +GOV_SPOOLRATE EQU 1 ; Number of steps for governor requested pwm per 32ms +RCP_TIMEOUT_PPM EQU 10 ; Number of timer2H overflows (about 32ms) before considering rc pulse lost +RCP_TIMEOUT EQU 24 ; Number of timer2L overflows (about 128us) before considering rc pulse lost +RCP_SKIP_RATE EQU 6 ; Number of timer2L overflows (about 128us) before reenabling rc pulse detection +RCP_MIN EQU 0 ; This is minimum RC pulse length +RCP_MAX EQU 255 ; This is maximum RC pulse length +RCP_VALIDATE EQU 2 ; Require minimum this pulse length to validate RC pulse +RCP_STOP EQU 1 ; Stop motor at or below this pulse length +RCP_STOP_LIMIT EQU 130 ; Stop motor if this many timer2H overflows (~32ms) are below stop limit + +PWM_SETTLE EQU 50 ; PWM used when in start settling phase (also max power during direct start) +PWM_STEPPER EQU 120 ; PWM used when in start stepper phase + +COMM_TIME_RED EQU 8 ; Fixed reduction (in us) for commutation wait (to account for fixed delays) +COMM_TIME_MIN EQU 1 ; Minimum time (in us) for commutation wait + +TEMP_CHECK_RATE EQU 8 ; Number of adc conversions for each check of temperature (the other conversions are used for voltage) + +ENDIF +; Constant definitions for multi +IF MODE == 2 + +GOV_SPOOLRATE EQU 1 ; Number of steps for governor requested pwm per 32ms + +RCP_TIMEOUT_PPM EQU 64 ; Number of timer2H overflows (about 32ms) before considering rc pulse lost +RCP_TIMEOUT EQU 40 ; Number of timer2L overflows (about 128us) before considering rc pulse lost +RCP_SKIP_RATE EQU 6 ; Number of timer2L overflows (about 128us) before reenabling rc pulse detection +RCP_MIN EQU 0 ; This is minimum RC pulse length +RCP_MAX EQU 255 ; This is maximum RC pulse length +RCP_VALIDATE EQU 2 ; Require minimum this pulse length to validate RC pulse +RCP_STOP EQU 1 ; Stop motor at or below this pulse length +;//////RCP_STOP_LIMIT EQU 20 ; Stop motor if this many timer2H overflows (~32ms) are below stop limit + +PWM_SETTLE EQU 50 ; PWM used when in start settling phase (also max power during direct start) +PWM_STEPPER EQU 120 ; PWM used when in start stepper phase + +COMM_TIME_RED EQU 8 ; Fixed reduction (in us) for commutation wait (to account for fixed delays) +COMM_TIME_MIN EQU 1 ; Minimum time (in us) for commutation wait + +TEMP_CHECK_RATE EQU 8 ; Number of adc conversions for each check of temperature (the other conversions are used for voltage) + +ENDIF + +;**** **** **** **** **** +; Temporary register definitions +Temp1 EQU R0 +Temp2 EQU R1 +Temp3 EQU R2 +Temp4 EQU R3 +Temp5 EQU R4 +Temp6 EQU R5 +Temp7 EQU R6 +Temp8 EQU R7 + +;**** **** **** **** **** +; Register definitions +DSEG AT 20h ; Variables segment + +Bit_Access: DS 1 ; Variable at bit accessible address (for non interrupt routines) +Bit_Access_Int: DS 1 ; Variable at bit accessible address (for interrupts) + +Requested_Pwm: DS 1 ; Requested pwm (from RC pulse value) +Governor_Req_Pwm: DS 1 ; Governor requested pwm (sets governor target) +Current_Pwm: DS 1 ; Current pwm +Current_Pwm_Limited: DS 1 ; Current pwm that is limited (applied to the motor output) +Rcp_Prev_Edge_L: DS 1 ; RC pulse previous edge timer3 timestamp (lo byte) +Rcp_Prev_Edge_H: DS 1 ; RC pulse previous edge timer3 timestamp (hi byte) +Rcp_Timeout_Cnt: DS 1 ; RC pulse timeout counter (decrementing) +Rcp_Skip_Cnt: DS 1 ; RC pulse skip counter (decrementing) +Rcp_Edge_Cnt: DS 1 ; RC pulse edge counter +Rcp_Stop_Limit: DS 1 ;增加刹车速度 + +Flags0: DS 1 ; State flags. Reset upon init_start +T3_PENDING EQU 0 ; Timer3 pending flag +RCP_MEAS_PWM_FREQ EQU 1 ; Measure RC pulse pwm frequency +PWM_ON EQU 2 ; Set in on part of pwm cycle +DEMAG_DETECTED EQU 3 ; Set when excessive demag time is detected +DEMAG_CUT_POWER EQU 4 ; Set when demag compensation cuts power +; EQU 5 +PROGRAM_FUNC_FLAG EQU 6 +SUCCESS_BEEP_FLAG EQU 7 + +Flags1: DS 1 ; State flags. Reset upon init_start +MOTOR_SPINNING EQU 0 ; Set when in motor is spinning +SETTLE_PHASE EQU 1 ; Set when in motor start settling phase +STEPPER_PHASE EQU 2 ; Set when in motor start stepper motor phase +DIRECT_STARTUP_PHASE EQU 3 ; Set when in direct startup phase +INITIAL_RUN_PHASE EQU 4 ; Set when in initial run phase, before synchronized run is achieved +; EQU 5 +; EQU 6 +LOW_LIMIT_STOP EQU 7 + +Flags2: DS 1 ; State flags. NOT reset upon init_start +RCP_UPDATED EQU 0 ; New RC pulse length value available +RCP_EDGE_NO EQU 1 ; RC pulse edge no. 0=rising, 1=falling +PGM_PWMOFF_DAMPED EQU 2 ; Programmed pwm off damped mode. Set when fully damped or damped light mode is selected +PGM_PWMOFF_DAMPED_FULL EQU 3 ; Programmed pwm off fully damped mode. Set when all pfets shall be on in pwm_off period +PGM_PWMOFF_DAMPED_LIGHT EQU 4 ; Programmed pwm off damped light mode. Set when only 2 pfets shall be on in pwm_off period +PGM_PWM_HIGH_FREQ EQU 5 ; Progremmed pwm high frequency +CURR_PWMOFF_DAMPED EQU 6 ; Currently running pwm off cycle is damped +CURR_PWMOFF_COMP_ABLE EQU 7 ; Currently running pwm off cycle is usable for comparator + +Flags3: DS 1 ; State flags. NOT reset upon init_start +RCP_PWM_FREQ_1KHZ EQU 0 ; RC pulse pwm frequency is 1kHz +RCP_PWM_FREQ_2KHZ EQU 1 ; RC pulse pwm frequency is 2kHz +RCP_PWM_FREQ_4KHZ EQU 2 ; RC pulse pwm frequency is 4kHz +RCP_PWM_FREQ_8KHZ EQU 3 ; RC pulse pwm frequency is 8kHz +PGM_DIR_REV EQU 4 ; Programmed direction. 0=normal, 1=reversed +PGM_RCP_PWM_POL EQU 5 ; Programmed RC pulse pwm polarity. 0=positive, 1=negative +FULL_THROTTLE_RANGE EQU 6 ; When set full throttle range is used (1000-2000us) and stored calibration values are ignored +ERRO_DATA EQU 7 ;增加编程卡数据错误标志 2013.8.27 +;**** **** **** **** **** +; RAM definitions +DSEG AT 30h ; Ram data segment, direct addressing + +Initial_Arm: DS 1 ; Variable that is set during the first arm sequence after power on +;Pca_First_Int: DS 1 +Power_On_Wait_Cnt_L: DS 1 ; Power on wait counter (lo byte) +Power_On_Wait_Cnt_H: DS 1 ; Power on wait counter (hi byte) +Pgm_Pulse_Cnt: DS 1 +;Stepper_Step_Beg_L: DS 1 ; Stepper phase step time at the beginning (lo byte) +;Stepper_Step_Beg_H: DS 1 ; Stepper phase step time at the beginning (hi byte) +;Stepper_Step_End_L: DS 1 ; Stepper phase step time at the end (lo byte) +;Stepper_Step_End_H: DS 1 ; Stepper phase step time at the end (hi byte) +Startup_Rot_Cnt: DS 1 ; Startup phase rotations counter +Direct_Startup_Ok_Cnt: DS 1 ; Direct startup phase ok comparator waits counter (incrementing) + +Prev_Comm_L: DS 1 ; Previous commutation timer3 timestamp (lo byte) +Prev_Comm_H: DS 1 ; Previous commutation timer3 timestamp (hi byte) +Comm_Period4x_L: DS 1 ; Timer3 counts between the last 4 commutations (lo byte) +Comm_Period4x_H: DS 1 ; Timer3 counts between the last 4 commutations (hi byte) +Comm_Phase: DS 1 ; Current commutation phase +Comp_Wait_Reads: DS 1 ; Comparator wait comparator reads + +Gov_Target_L: DS 1 ; Governor target (lo byte) +Gov_Target_H: DS 1 ; Governor target (hi byte) +Gov_Integral_L: DS 1 ; Governor integral error (lo byte) +Gov_Integral_H: DS 1 ; Governor integral error (hi byte) +Gov_Integral_X: DS 1 ; Governor integral error (ex byte) +Gov_Proportional_L: DS 1 ; Governor proportional error (lo byte) +Gov_Proportional_H: DS 1 ; Governor proportional error (hi byte) +Gov_Prop_Pwm: DS 1 ; Governor calculated new pwm based upon proportional error +Gov_Arm_Target: DS 1 ; Governor arm target value +Gov_Active: DS 1 ; Governor active (enabled when speed is above minimum) + +Wt_Advance_L: DS 1 ; Timer3 counts for commutation advance timing (lo byte) +Wt_Advance_H: DS 1 ; Timer3 counts for commutation advance timing (hi byte) +Wt_Zc_Scan_L: DS 1 ; Timer3 counts from commutation to zero cross scan (lo byte) +Wt_Zc_Scan_H: DS 1 ; Timer3 counts from commutation to zero cross scan (hi byte) +Wt_Comm_L: DS 1 ; Timer3 counts from zero cross to commutation (lo byte) +Wt_Comm_H: DS 1 ; Timer3 counts from zero cross to commutation (hi byte) +;Wt_Stepper_Step_L: DS 1 ; Timer3 counts for stepper step (lo byte) +;Wt_Stepper_Step_H: DS 1 ; Timer3 counts for stepper step (hi byte) + +Rcp_PrePrev_Edge_L: DS 1 ; RC pulse pre previous edge pca timestamp (lo byte) +Rcp_PrePrev_Edge_H: DS 1 ; RC pulse pre previous edge pca timestamp (hi byte) +Rcp_Edge_L: DS 1 ; RC pulse edge pca timestamp (lo byte) +Rcp_Edge_H: DS 1 ; RC pulse edge pca timestamp (hi byte) +Rcp_Prev_Period_L: DS 1 ; RC pulse previous period (lo byte) +Rcp_Prev_Period_H: DS 1 ; RC pulse previous period (hi byte) +Rcp_Period_Diff_Accepted: DS 1 ; RC pulse period difference acceptable +New_Rcp: DS 1 ; New RC pulse value in pca counts +Prev_Rcp_Pwm_Freq: DS 1 ; Previous RC pulse pwm frequency (used during pwm frequency measurement) +Curr_Rcp_Pwm_Freq: DS 1 ; Current RC pulse pwm frequency (used during pwm frequency measurement) +Rcp_Stop_Cnt: DS 1 ; Counter for RC pulses below stop value + +Pwm_Limit: DS 1 ; Maximum allowed pwm +Pwm_Limit_Spoolup: DS 1 ; Maximum allowed pwm during spoolup of main +Pwm_Spoolup_Beg: DS 1 ; Pwm to begin main spoolup with +Pwm_Motor_Idle: DS 1 ; Motor idle speed pwm +Pwm_On_Cnt: DS 1 ; Pwm on event counter (used to increase pwm off time for low pwm) +Pwm_Off_Cnt: DS 1 ; Pwm off event counter (used to run some pwm cycles without damping) + +Spoolup_Limit_Cnt: DS 1 ; Interrupt count for spoolup limit +Spoolup_Limit_Skip: DS 1 ; Interrupt skips for spoolup limit increment (0=no skips, 1=skip one etc) + +Damping_Period: DS 1 ; Damping on/off period +Damping_On: DS 1 ; Damping on part of damping period + +;Lipo_Adc_Reference_L: DS 1 ; Voltage reference adc value (lo byte) +;Lipo_Adc_Reference_H: DS 1 ; Voltage reference adc value (hi byte) +Lipo_Adc_Limit_L: DS 1 ; Low voltage limit adc value (lo byte) +Lipo_Adc_Limit_H: DS 1 ; Low voltage limit adc value (hi byte) +Adc_Conversion_Cnt: DS 1 ; Adc conversion counter +Lipo_Cell_Count: DS 1 ;增加电池节数累计变量 2013.5.29 +Limit_Count: DS 1 ;增加逐渐递减计数变量 2013.7.5 + +Current_Average_Temp: DS 1 ; Current average temperature (lo byte ADC reading, assuming hi byte is 1) + +Ppm_Throttle_Gain: DS 1 ; Gain to be applied to RCP value for PPM input +Beep_Strength: DS 1 ; Strength of beeps + +Tx_Pgm_Func_No: DS 1 ; Function number when doing programming by tx +Tx_Pgm_Paraval_No: DS 1 ; Parameter value number when doing programming by tx +Tx_Pgm_Beep_No: DS 1 ; Beep number when doing programming by tx +Commu_Data_Buffer: DS 1 ;编程卡接收，发送数据暂存 2013.8.27 +Commu_Sum: DS 1 ;增加编程卡校验和 2013.8.27 +Min_Throttle: DS 1 + +; Indirect addressing data segment +ISEG AT 080h +Pgm_Fir_Key: DS 1 ;增加首个关键字 2013.8.27 +Pgm_Gov_P_Gain: DS 1 ; Programmed governor P gain +Pgm_Gov_I_Gain: DS 1 ; Programmed governor I gain +Pgm_Gov_Mode: DS 1 ; Programmed governor mode + +Pgm_Low_Voltage_Lim: DS 1 ; Programmed low voltage limit +Pgm_Low_Voltage_Ctl: DS 1 ;增加低压保护控制方式编程项 2013.7.5 +Pgm_Motor_Gain: DS 1 ; Programmed motor gain +Pgm_Motor_Idle: DS 1 ; Programmed motor idle speed +Pgm_Startup_Pwr: DS 1 ; Programmed startup power +Pgm_Pwm_Freq: DS 1 ; Programmed pwm frequency +Pgm_Direction_Rev: DS 1 ; Programmed rotation direction +Pgm_Input_Pol: DS 1 ; Programmed input pwm polarity +Initialized_L_Dummy: DS 1 ; Place holder +Initialized_H_Dummy: DS 1 ; Place holder +Pgm_Enable_TX_Program: DS 1 ; Programmed enable/disable value for TX programming +Pgm_Main_Rearm_Start: DS 1 ; Programmed enable/disable re-arming main every start +Pgm_Gov_Setup_Target: DS 1 ; Programmed main governor setup target +Pgm_Startup_Rpm: DS 1 ; Programmed startup rpm +Pgm_Startup_Accel: DS 1 ; Programmed startup acceleration +Pgm_Volt_Comp_Dummy: DS 1 ; Place holder +Pgm_Comm_Timing: DS 1 ; Programmed commutation timing +Pgm_Damping_Force: DS 1 ; Programmed damping force +Pgm_Gov_Range: DS 1 ; Programmed governor range +;Pgm_Startup_Method: DS 1 ; Programmed startup method +Pgm_Ppm_Min_Throttle: DS 1 ; Programmed throttle minimum +Pgm_Ppm_Max_Throttle: DS 1 ; Programmed throttle maximum +Pgm_Beep_Strength: DS 1 ; Programmed beep strength +Pgm_Beacon_Strength: DS 1 ; Programmed beacon strength +Pgm_Beacon_Delay: DS 1 ; Programmed beacon delay +Pgm_Throttle_Rate: DS 1 ; Programmed throttle rate +Pgm_Demag_Comp: DS 1 ; Programmed demag compensation +Pgm_BEC_Voltage_High: DS 1 ; Programmed BEC voltage + +Pgm_Gov_P_Gain_Decoded: DS 1 ; Programmed governor decoded P gain +Pgm_Gov_I_Gain_Decoded: DS 1 ; Programmed governor decoded I gain +Pgm_Throttle_Rate_Decoded: DS 1 ; Programmed throttle rate decoded +Pgm_Startup_Pwr_Decoded: DS 1 ; Programmed startup power decoded +Pgm_Demag_Comp_Wait_Decoded: DS 1 ; Programmed demag compensation wait decoded +Pgm_Demag_Comp_Power_Decoded: DS 1 ; Programmed demag compensation power cut decoded + + +; Indirect addressing data segment +ISEG AT 0D0h +Tag_Temporary_Storage: DS 48 ; Temporary storage for tags when updating "Eeprom" + + +;**** **** **** **** **** +CSEG AT 1A00h ; "Eeprom" segment +EEPROM_FW_MAIN_REVISION EQU 10 ; Main revision of the firmware +EEPROM_FW_SUB_REVISION EQU 2 ; Sub revision of the firmware +EEPROM_LAYOUT_REVISION EQU 16 ; Revision of the EEPROM layout + +Eep_FW_Main_Revision: DB EEPROM_FW_MAIN_REVISION ; EEPROM firmware main revision number +Eep_FW_Sub_Revision: DB EEPROM_FW_SUB_REVISION ; EEPROM firmware sub revision number +Eep_Layout_Revision: DB EEPROM_LAYOUT_REVISION ; EEPROM layout revision number + +IF MODE == 0 +Eep_Pgm_Gov_P_Gain: DB DEFAULT_PGM_MAIN_P_GAIN ; EEPROM copy of programmed governor P gain +Eep_Pgm_Gov_I_Gain: DB DEFAULT_PGM_MAIN_I_GAIN ; EEPROM copy of programmed governor I gain +Eep_Pgm_Gov_Mode: DB DEFAULT_PGM_MAIN_GOVERNOR_MODE ; EEPROM copy of programmed governor mode + +Eep_Pgm_Low_Voltage_Lim: DB DEFAULT_PGM_MAIN_LOW_VOLTAGE_LIM ; EEPROM copy of programmed low voltage limit +_Eep_Pgm_Motor_Gain: DB 0FFh +_Eep_Pgm_Motor_Idle: DB 0FFh +Eep_Pgm_Startup_Pwr: DB DEFAULT_PGM_MAIN_STARTUP_PWR ; EEPROM copy of programmed startup power +Eep_Pgm_Pwm_Freq: DB DEFAULT_PGM_MAIN_PWM_FREQ ; EEPROM copy of programmed pwm frequency +Eep_Pgm_Direction_Rev: DB DEFAULT_PGM_MAIN_DIRECTION_REV ; EEPROM copy of programmed rotation direction +Eep_Pgm_Input_Pol: DB DEFAULT_PGM_MAIN_RCP_PWM_POL ; EEPROM copy of programmed input polarity +Eep_Initialized_L: DB 0A5h ; EEPROM initialized signature low byte +Eep_Initialized_H: DB 05Ah ; EEPROM initialized signature high byte +Eep_Enable_TX_Program: DB DEFAULT_PGM_ENABLE_TX_PROGRAM ; EEPROM TX programming enable +Eep_Main_Rearm_Start: DB DEFAULT_PGM_MAIN_REARM_START ; EEPROM re-arming main enable +Eep_Pgm_Gov_Setup_Target: DB DEFAULT_PGM_MAIN_GOV_SETUP_TARGET ; EEPROM main governor setup target +Eep_Pgm_Startup_Rpm: DB DEFAULT_PGM_MAIN_STARTUP_RPM ; EEPROM copy of programmed startup rpm +Eep_Pgm_Startup_Accel: DB DEFAULT_PGM_MAIN_STARTUP_ACCEL ; EEPROM copy of programmed startup acceleration +_Eep_Pgm_Volt_Comp: DB 0FFh +Eep_Pgm_Comm_Timing: DB DEFAULT_PGM_MAIN_COMM_TIMING ; EEPROM copy of programmed commutation timing +Eep_Pgm_Damping_Force: DB DEFAULT_PGM_MAIN_DAMPING_FORCE ; EEPROM copy of programmed damping force +Eep_Pgm_Gov_Range: DB DEFAULT_PGM_MAIN_GOVERNOR_RANGE ; EEPROM copy of programmed governor range +Eep_Pgm_Startup_Method: DB DEFAULT_PGM_MAIN_STARTUP_METHOD ; EEPROM copy of programmed startup method +Eep_Pgm_Ppm_Min_Throttle: DB DEFAULT_PGM_PPM_MIN_THROTTLE ; EEPROM copy of programmed minimum throttle (final value is 4x+1000=1148) +Eep_Pgm_Ppm_Max_Throttle: DB DEFAULT_PGM_PPM_MAX_THROTTLE ; EEPROM copy of programmed minimum throttle (final value is 4x+1000=1832) +Eep_Pgm_Beep_Strength: DB DEFAULT_PGM_MAIN_BEEP_STRENGTH ; EEPROM copy of programmed beep strength +Eep_Pgm_Beacon_Strength: DB DEFAULT_PGM_MAIN_BEACON_STRENGTH ; EEPROM copy of programmed beacon strength +Eep_Pgm_Beacon_Delay: DB DEFAULT_PGM_MAIN_BEACON_DELAY ; EEPROM copy of programmed beacon delay +Eep_Pgm_Throttle_Rate: DB DEFAULT_PGM_MAIN_THROTTLE_RATE ; EEPROM copy of programmed throttle rate +Eep_Pgm_Demag_Comp: DB DEFAULT_PGM_MAIN_DEMAG_COMP ; EEPROM copy of programmed demag compensation +Eep_Pgm_BEC_Voltage_High: DB DEFAULT_PGM_BEC_VOLTAGE_HIGH ; EEPROM copy of programmed BEC voltage +ENDIF + +IF MODE == 1 +_Eep_Pgm_Gov_P_Gain: DB 0FFh +_Eep_Pgm_Gov_I_Gain: DB 0FFh +_Eep_Pgm_Gov_Mode: DB 0FFh + +_Eep_Pgm_Low_Voltage_Lim: DB 0FFh +Eep_Pgm_Motor_Gain: DB DEFAULT_PGM_TAIL_GAIN ; EEPROM copy of programmed tail gain +Eep_Pgm_Motor_Idle: DB DEFAULT_PGM_TAIL_IDLE_SPEED ; EEPROM copy of programmed tail idle speed +Eep_Pgm_Startup_Pwr: DB DEFAULT_PGM_TAIL_STARTUP_PWR ; EEPROM copy of programmed startup power +Eep_Pgm_Pwm_Freq: DB DEFAULT_PGM_TAIL_PWM_FREQ ; EEPROM copy of programmed pwm frequency +Eep_Pgm_Direction_Rev: DB DEFAULT_PGM_TAIL_DIRECTION_REV ; EEPROM copy of programmed rotation direction +Eep_Pgm_Input_Pol: DB DEFAULT_PGM_TAIL_RCP_PWM_POL ; EEPROM copy of programmed input polarity +Eep_Initialized_L: DB 05Ah ; EEPROM initialized signature low byte +Eep_Initialized_H: DB 0A5h ; EEPROM initialized signature high byte +Eep_Enable_TX_Program: DB DEFAULT_PGM_ENABLE_TX_PROGRAM ; EEPROM TX programming enable +_Eep_Main_Rearm_Start: DB 0FFh +_Eep_Pgm_Gov_Setup_Target: DB 0FFh +Eep_Pgm_Startup_Rpm: DB DEFAULT_PGM_TAIL_STARTUP_RPM ; EEPROM copy of programmed startup rpm +Eep_Pgm_Startup_Accel: DB DEFAULT_PGM_TAIL_STARTUP_ACCEL ; EEPROM copy of programmed startup acceleration +_Eep_Pgm_Volt_Comp: DB 0FFh +Eep_Pgm_Comm_Timing: DB DEFAULT_PGM_TAIL_COMM_TIMING ; EEPROM copy of programmed commutation timing +Eep_Pgm_Damping_Force: DB DEFAULT_PGM_TAIL_DAMPING_FORCE ; EEPROM copy of programmed damping force +_Eep_Pgm_Gov_Range: DB 0FFh +Eep_Pgm_Startup_Method: DB DEFAULT_PGM_TAIL_STARTUP_METHOD ; EEPROM copy of programmed startup method +Eep_Pgm_Ppm_Min_Throttle: DB DEFAULT_PGM_PPM_MIN_THROTTLE ; EEPROM copy of programmed minimum throttle (final value is 4x+1000=1148) +Eep_Pgm_Ppm_Max_Throttle: DB DEFAULT_PGM_PPM_MAX_THROTTLE ; EEPROM copy of programmed minimum throttle (final value is 4x+1000=1832) +Eep_Pgm_Beep_Strength: DB DEFAULT_PGM_TAIL_BEEP_STRENGTH ; EEPROM copy of programmed beep strength +Eep_Pgm_Beacon_Strength: DB DEFAULT_PGM_TAIL_BEACON_STRENGTH ; EEPROM copy of programmed beacon strength +Eep_Pgm_Beacon_Delay: DB DEFAULT_PGM_TAIL_BEACON_DELAY ; EEPROM copy of programmed beacon delay +Eep_Pgm_Throttle_Rate: DB DEFAULT_PGM_TAIL_THROTTLE_RATE ; EEPROM copy of programmed throttle rate +Eep_Pgm_Demag_Comp: DB DEFAULT_PGM_TAIL_DEMAG_COMP ; EEPROM copy of programmed demag compensation +Eep_Pgm_BEC_Voltage_High: DB DEFAULT_PGM_BEC_VOLTAGE_HIGH ; EEPROM copy of programmed BEC voltage +ENDIF + +IF MODE == 2 +Eep_Pgm_Fir_Key: DB DEFAULT_PGM_MULTI_FIRST_KEYWORD ;增加首个关键字 2013.8.27 +Eep_Pgm_Gov_P_Gain: DB DEFAULT_PGM_MULTI_P_GAIN ; EEPROM copy of programmed closed loop P gain +Eep_Pgm_Gov_I_Gain: DB DEFAULT_PGM_MULTI_I_GAIN ; EEPROM copy of programmed closed loop I gain +Eep_Pgm_Gov_Mode: DB DEFAULT_PGM_MULTI_GOVERNOR_MODE ; EEPROM copy of programmed closed loop mode + +Eep_Pgm_Low_Voltage_Lim: DB DEFAULT_PGM_MULTI_LOW_VOLTAGE_LIM ; EEPROM copy of programmed low voltage limit +Eep_Pgm_Low_Voltage_Ctl: DB DEFAULT_PGM_MULTI_LOW_VOLTAGE_CTL ; 增加低压保护控制编程 +Eep_Pgm_Motor_Gain: DB DEFAULT_PGM_MULTI_GAIN ; EEPROM copy of programmed tail gain +_Eep_Pgm_Motor_Idle: DB 0FFh ; EEPROM copy of programmed tail idle speed +Eep_Pgm_Startup_Pwr: DB DEFAULT_PGM_MULTI_STARTUP_PWR ; EEPROM copy of programmed startup power +Eep_Pgm_Pwm_Freq: DB DEFAULT_PGM_MULTI_PWM_FREQ ; EEPROM copy of programmed pwm frequency +Eep_Pgm_Direction_Rev: DB DEFAULT_PGM_MULTI_DIRECTION_REV ; EEPROM copy of programmed rotation direction +Eep_Pgm_Input_Pol: DB DEFAULT_PGM_MULTI_RCP_PWM_POL ; EEPROM copy of programmed input polarity +Eep_Initialized_L: DB 055h ; EEPROM initialized signature low byte +Eep_Initialized_H: DB 0AAh ; EEPROM initialized signature high byte +Eep_Enable_TX_Program: DB DEFAULT_PGM_ENABLE_TX_PROGRAM ; EEPROM TX programming enable +_Eep_Main_Rearm_Start: DB 0FFh +_Eep_Pgm_Gov_Setup_Target: DB 0FFh +Eep_Pgm_Startup_Rpm: DB DEFAULT_PGM_MULTI_STARTUP_RPM ; EEPROM copy of programmed startup rpm +Eep_Pgm_Startup_Accel: DB DEFAULT_PGM_MULTI_STARTUP_ACCEL ; EEPROM copy of programmed startup acceleration +_Eep_Pgm_Volt_Comp: DB 0FFh +Eep_Pgm_Comm_Timing: DB DEFAULT_PGM_MULTI_COMM_TIMING ; EEPROM copy of programmed commutation timing +Eep_Pgm_Damping_Force: DB DEFAULT_PGM_MULTI_DAMPING_FORCE ; EEPROM copy of programmed damping force +_Eep_Pgm_Gov_Range: DB 0FFh +;Eep_Pgm_Startup_Method: DB DEFAULT_PGM_MULTI_STARTUP_METHOD ; EEPROM copy of programmed startup method +Eep_Pgm_Ppm_Min_Throttle: DB DEFAULT_PGM_PPM_MIN_THROTTLE ; EEPROM copy of programmed minimum throttle (final value is 4x+1000=1148) +Eep_Pgm_Ppm_Max_Throttle: DB DEFAULT_PGM_PPM_MAX_THROTTLE ; EEPROM copy of programmed minimum throttle (final value is 4x+1000=1832) +Eep_Pgm_Beep_Strength: DB DEFAULT_PGM_MULTI_BEEP_STRENGTH ; EEPROM copy of programmed beep strength +Eep_Pgm_Beacon_Strength: DB DEFAULT_PGM_MULTI_BEACON_STRENGTH ; EEPROM copy of programmed beacon strength +Eep_Pgm_Beacon_Delay: DB DEFAULT_PGM_MULTI_BEACON_DELAY ; EEPROM copy of programmed beacon delay +Eep_Pgm_Throttle_Rate: DB DEFAULT_PGM_MULTI_THROTTLE_RATE ; EEPROM copy of programmed throttle rate +Eep_Pgm_Demag_Comp: DB DEFAULT_PGM_MULTI_DEMAG_COMP ; EEPROM copy of programmed demag compensation +Eep_Pgm_BEC_Voltage_High: DB DEFAULT_PGM_BEC_VOLTAGE_HIGH ; EEPROM copy of programmed BEC voltage +ENDIF + + +Eep_Dummy: DB 0FFh ; EEPROM address for safety reason + +CSEG AT 1A60h +Eep_Name: DB " " ; Name tag (16 Bytes) + +;**** **** **** **** **** + Interrupt_Table_Definition ; SiLabs interrupts +CSEG AT 80h ; Code segment after interrupt vectors + +;**** **** **** **** **** + +; Table definitions +GOV_GAIN_TABLE: DB 02h, 03h, 04h, 06h, 08h, 0Ch, 10h, 18h, 20h, 30h, 40h, 60h, 80h +THROTTLE_RATE_TABLE: DB 02h, 03h, 04h, 06h, 08h, 0Ch, 10h, 18h, 20h, 30h, 40h, 80h, 0FFh +STARTUP_POWER_TABLE: DB 04h, 06h, 08h, 0Ch, 10h, 18h, 20h, 30h, 40h, 60h, 80h, 0A0h, 0C0h +DEMAG_WAIT_TABLE: DB 0, 0, 0, 1, 1 +DEMAG_POWER_TABLE: DB 0, 3, 2, 2, 1 + +;FINISH_KEYWORD_TABLE: DB 066h, 08h, 08h, 03h, 01h, 00h, 02h, 00h +; DB 09h, 01h, 00h, 00h, 00h, 00h, 00h, 00h +; DB 0B4h, 00h, 04h, 00h, 02h, 00h, 00h, 025h +; DB 0D0h, 050h, 064h, 01h, 0Dh, 01h, 00h, 00h ;增加编程默认值表 2013.7.30 ;////////////////////////////////////////// +; DB 00h, 00h, 00h, 00h, 00h, 00h, 00h, 00h +; DB 00h, 00h, 00h, 00h, 00h, 00h, 00h, 00h + +IF MODE == 0 +TX_PGM_PARAMS_MAIN: DB 13, 13, 4, 2, 6, 2, 13, 5, 5, 5, 13, 6, 3, 5, 2, 2 +ENDIF +IF MODE == 1 + IF DAMPED_MODE_ENABLE == 1 +TX_PGM_PARAMS_TAIL: DB 5, 5, 2, 13, 5, 5, 5, 13, 6, 4, 5, 2, 2 + ENDIF + IF DAMPED_MODE_ENABLE == 0 +TX_PGM_PARAMS_TAIL: DB 5, 5, 2, 13, 5, 5, 5, 13, 6, 3, 5, 2, 2 + ENDIF +ENDIF +IF MODE == 2 + IF DAMPED_MODE_ENABLE == 1 +;///////TX_PGM_PARAMS_MULTI: DB 13, 13, 4, 5, 6, 2, 13, 5, 5, 5, 13, 6, 4, 5, 2, 2 + TX_PGM_PARAMS_MULTI: DB 6, 5, 13, 4, 2, 4, 2 + ENDIF + IF DAMPED_MODE_ENABLE == 0 +;///////TX_PGM_PARAMS_MULTI: DB 13, 13, 4, 5, 6, 2, 13, 5, 5, 5, 13, 6, 3, 5, 2, 2 + TX_PGM_PARAMS_MULTI: DB 6, 5, 13, 4, 2, 4, 2 + ENDIF +ENDIF + +;**** **** **** **** **** **** **** **** **** **** **** **** **** +; +; Timer0 interrupt routine +; +; Assumptions: DPTR register must be set to desired pwm_nfet_on label +; Requirements: Temp variables can NOT be used since PWSW.3 is not set +; +;**** **** **** **** **** **** **** **** **** **** **** **** **** +t0_int: ; Used for pwm control + clr EA ; Disable all interrupts + push PSW ; Preserve registers through interrupt + push ACC + ; Check if pwm is on + jb Flags0.PWM_ON, t0_int_pwm_off ; Is pwm on? + + ; Pwm on cycle. + jnb Current_Pwm_Limited.7, t0_int_pwm_on_low_pwm ; Jump for low pwm (<50%) + +t0_int_pwm_on_execute: + clr A + jmp @A+DPTR ; No - jump to pwm on routines. DPTR should be set to one of the pwm_nfet_on labels + +t0_int_pwm_on_low_pwm: + ; Do not execute pwm when stopped + jnb Flags1.MOTOR_SPINNING, t0_int_pwm_on_stopped + +IF MODE == 0 OR MODE == 2 ; Main or multi + jmp t0_int_pwm_on_execute +ENDIF +IF MODE == 1 ; Tail + ; Skip pwm on cycles for very low pwm + inc Pwm_On_Cnt ; Increment event counter + clr C + mov A, #5 ; Only skip for very low pwm + subb A, Current_Pwm_Limited ; Check skipping shall be done (for low pwm only) + jc t0_int_pwm_on_execute + + subb A, Pwm_On_Cnt ; Check if on cycle is to be skipped + jc t0_int_pwm_on_execute + + mov TL0, #120 ; Write start point for timer + mov A, Current_Pwm_Limited + jnz ($+5) + mov TL0, #0 ; Write start point for timer (long time for zero pwm) + jmp t0_int_pwm_on_exit_no_timer_update +ENDIF + +t0_int_pwm_on_stopped: + jmp t0_int_pwm_on_exit + + +t0_int_pwm_off: + jnb Flags1.DIRECT_STARTUP_PHASE, t0_int_pwm_off_start_checked + All_nFETs_Off ; Switch off all nfets early during direct start, for a smooth start +t0_int_pwm_off_start_checked: + ; Pwm off cycle + mov TL0, Current_Pwm_Limited ; Load new timer setting + ; Clear pwm on flag + clr Flags0.PWM_ON + ; Set full PWM (on all the time) if current PWM near max. This will give full power, but at the cost of a small "jump" in power + mov A, Current_Pwm_Limited ; Load current pwm + cpl A ; Full pwm? + jnz ($+4) ; No - branch + ajmp t0_int_pwm_off_fullpower_exit ; Yes - exit + + inc Pwm_Off_Cnt ; Increment event counter + ; Do not execute pwm when stopped + jnb Flags1.MOTOR_SPINNING, t0_int_pwm_off_stopped + + ; If damped operation, set pFETs on in pwm_off + jb Flags2.PGM_PWMOFF_DAMPED, t0_int_pwm_off_damped ; Damped operation? + + ; Separate exit commands here for minimum delay + mov TL1, #0 ; Reset timer1 + pop ACC ; Restore preserved registers + pop PSW + All_nFETs_Off ; Switch off all nfets + setb EA ; Enable all interrupts + reti + +t0_int_pwm_off_stopped: + All_nFETs_Off ; Switch off all nfets + jmp t0_int_pwm_off_exit + +t0_int_pwm_off_damped: + setb Flags2.CURR_PWMOFF_DAMPED ; Set damped status + clr Flags2.CURR_PWMOFF_COMP_ABLE ; Set comparator unusable status + mov A, Damping_On + jz t0_int_pwm_off_do_damped ; Highest damping - apply damping always + + clr C + mov A, Pwm_Off_Cnt ; Is damped on number reached? + dec A + subb A, Damping_On + jc t0_int_pwm_off_do_damped ; No - apply damping + + clr Flags2.CURR_PWMOFF_DAMPED ; Set non damped status + setb Flags2.CURR_PWMOFF_COMP_ABLE ; Set comparator usable status + clr C + mov A, Pwm_Off_Cnt + subb A, Damping_Period ; Is damped period number reached? + jnc t0_int_pwm_off_clr_cnt ; Yes - Proceed + + jmp t0_int_pwm_off_exit ; No - Branch + +t0_int_pwm_off_clr_cnt: + mov Pwm_Off_Cnt, #0 ; Yes - clear counter + jmp t0_int_pwm_off_exit ; Not damped cycle - exit + +t0_int_pwm_off_do_damped: + ; Delay to allow nFETs to go off before pFETs are turned on (only in full damped mode) + jb Flags2.PGM_PWMOFF_DAMPED_LIGHT, t0_int_pwm_off_damped_light ; If damped light operation - branch + +; All_pFETs_Off ; Switch off all nfets +; mov A, #PFETON_DELAY +; djnz ACC, $ +; All_nFETs_On ; Switch on all pfets + jmp t0_int_pwm_off_exit + +t0_int_pwm_off_damped_light: +IF DAMPED_MODE_ENABLE == 1 + setb Flags2.CURR_PWMOFF_COMP_ABLE ; Set comparator usable status always for damped light mode on fully damped capable escs +ENDIF + All_nFETs_Off ; Switch off all nfets + mov A, Comm_Phase ; Turn on pfets according to commutation phase + jb ACC.2, t0_int_pwm_off_comm_4_5_6 + jb ACC.1, t0_int_pwm_off_comm_2_3 + +IF DAMPED_MODE_ENABLE == 0 + AnFET_On ; Comm phase 1 - turn on A +ELSE + mov A, #PFETON_DELAY + djnz ACC, $ + CnFET_On ; Comm phase 1 - turn on C +ENDIF + jmp t0_int_pwm_off_exit + +t0_int_pwm_off_comm_2_3: + jb ACC.0, t0_int_pwm_off_comm_3 +IF DAMPED_MODE_ENABLE == 0 + BnFET_On ; Comm phase 2 - turn on B +ELSE + mov A, #PFETON_DELAY + djnz ACC, $ + CnFET_On ; Comm phase 2 - turn on C +ENDIF + jmp t0_int_pwm_off_exit + +t0_int_pwm_off_comm_3: +IF DAMPED_MODE_ENABLE == 0 + CnFET_On ; Comm phase 3 - turn on C +ELSE + mov A, #PFETON_DELAY + djnz ACC, $ + BnFET_On ; Comm phase 3 - turn on B +ENDIF + jmp t0_int_pwm_off_exit + +t0_int_pwm_off_comm_4_5_6: + jb ACC.1, t0_int_pwm_off_comm_6 + jb ACC.0, t0_int_pwm_off_comm_5 + +IF DAMPED_MODE_ENABLE == 0 + AnFET_On ; Comm phase 4 - turn on A +ELSE + mov A, #PFETON_DELAY + djnz ACC, $ + BnFET_On ; Comm phase 4 - turn on B +ENDIF + jmp t0_int_pwm_off_exit + +t0_int_pwm_off_comm_5: +IF DAMPED_MODE_ENABLE == 0 + BnFET_On ; Comm phase 5 - turn on B +ELSE + mov A, #PFETON_DELAY + djnz ACC, $ + AnFET_On ; Comm phase 5 - turn on A +ENDIF + jmp t0_int_pwm_off_exit + +t0_int_pwm_off_comm_6: +IF DAMPED_MODE_ENABLE == 0 + CnFET_On ; Comm phase 6 - turn on C +ELSE + mov A, #PFETON_DELAY + djnz ACC, $ + AnFET_On ; Comm phase 6 - turn on A +ENDIF + +t0_int_pwm_off_exit: ; Exit from pwm off cycle + mov TL1, #0 ; Reset timer1 + pop ACC ; Restore preserved registers + pop PSW + All_nFETs_Off ; Switch off all nfets + setb EA ; Enable all interrupts + reti + +t0_int_pwm_off_fullpower_exit: ; Exit from pwm off cycle, leaving power on + pop ACC ; Restore preserved registers + pop PSW + setb EA ; Enable all interrupts + reti + + + +pwm_nofet_on: ; Dummy pwm on cycle + ajmp t0_int_pwm_on_exit + +pwm_afet_on: ; Pwm on cycle afet on (bfet off) + AnFET_on + BnFET_off + ajmp t0_int_pwm_on_exit + +pwm_bfet_on: ; Pwm on cycle bfet on (cfet off) + BnFET_on + CnFET_off + ajmp t0_int_pwm_on_exit + +pwm_cfet_on: ; Pwm on cycle cfet on (afet off) + CnFET_on + AnFET_off + ajmp t0_int_pwm_on_exit + +pwm_anfet_bpfet_on_fast: ; Pwm on cycle anfet on (bnfet off) and bpfet on (used in damped state 6) + ApFET_off + AnFET_on ; Switch nFETs + CpFET_off + BnFET_off + ajmp t0_int_pwm_on_exit +pwm_anfet_bpfet_on_safe: ; Pwm on cycle anfet on (bnfet off) and bpfet on (used in damped state 6) + ; Delay from pFETs are turned off (only in damped mode) until nFET is turned on (pFETs are slow) + ApFET_off + CpFET_off + mov A, #NFETON_DELAY ; Set full delay + djnz ACC, $ + AnFET_on ; Switch nFETs + BnFET_off + ajmp t0_int_pwm_on_exit + +pwm_anfet_cpfet_on_fast: ; Pwm on cycle anfet on (bnfet off) and cpfet on (used in damped state 5) + ApFET_off + AnFET_on ; Switch nFETs + BpFET_off + BnFET_off + ajmp t0_int_pwm_on_exit +pwm_anfet_cpfet_on_safe: ; Pwm on cycle anfet on (bnfet off) and cpfet on (used in damped state 5) + ; Delay from pFETs are turned off (only in damped mode) until nFET is turned on (pFETs are slow) + ApFET_off + BpFET_off + mov A, #NFETON_DELAY ; Set full delay + djnz ACC, $ + AnFET_on ; Switch nFETs + BnFET_off + ajmp t0_int_pwm_on_exit + +pwm_bnfet_cpfet_on_fast: ; Pwm on cycle bnfet on (cnfet off) and cpfet on (used in damped state 4) + BpFET_off + BnFET_on ; Switch nFETs + ApFET_off + CnFET_off + ajmp t0_int_pwm_on_exit +pwm_bnfet_cpfet_on_safe: ; Pwm on cycle bnfet on (cnfet off) and cpfet on (used in damped state 4) + ; Delay from pFETs are turned off (only in damped mode) until nFET is turned on (pFETs are slow) + BpFET_off + ApFET_off + mov A, #NFETON_DELAY ; Set full delay + djnz ACC, $ + BnFET_on ; Switch nFETs + CnFET_off + ajmp t0_int_pwm_on_exit + +pwm_bnfet_apfet_on_fast: ; Pwm on cycle bnfet on (cnfet off) and apfet on (used in damped state 3) + BpFET_off + BnFET_on ; Switch nFETs + CpFET_off + CnFET_off + ajmp t0_int_pwm_on_exit +pwm_bnfet_apfet_on_safe: ; Pwm on cycle bnfet on (cnfet off) and apfet on (used in damped state 3) + ; Delay from pFETs are turned off (only in damped mode) until nFET is turned on (pFETs are slow) + BpFET_off + CpFET_off + mov A, #NFETON_DELAY ; Set full delay + djnz ACC, $ + BnFET_on ; Switch nFETs + CnFET_off + ajmp t0_int_pwm_on_exit + +pwm_cnfet_apfet_on_fast: ; Pwm on cycle cnfet on (anfet off) and apfet on (used in damped state 2) + CpFET_off + CnFET_on ; Switch nFETs + BpFET_off + AnFET_off + ajmp t0_int_pwm_on_exit +pwm_cnfet_apfet_on_safe: ; Pwm on cycle cnfet on (anfet off) and apfet on (used in damped state 2) + ; Delay from pFETs are turned off (only in damped mode) until nFET is turned on (pFETs are slow) + CpFET_off + BpFET_off + mov A, #NFETON_DELAY ; Set full delay + djnz ACC, $ + CnFET_on ; Switch nFETs + AnFET_off + ajmp t0_int_pwm_on_exit + +pwm_cnfet_bpfet_on_fast: ; Pwm on cycle cnfet on (anfet off) and bpfet on (used in damped state 1) + CpFET_off + CnFET_on ; Switch nFETs + ApFET_off + AnFET_off + ajmp t0_int_pwm_on_exit +pwm_cnfet_bpfet_on_safe: ; Pwm on cycle cnfet on (anfet off) and bpfet on (used in damped state 1) + ; Delay from pFETs are turned off (only in damped mode) until nFET is turned on (pFETs are slow) + CpFET_off + ApFET_off + mov A, #NFETON_DELAY ; Set full delay + djnz ACC, $ + CnFET_on ; Switch nFETs + AnFET_off + ajmp t0_int_pwm_on_exit + +t0_int_pwm_on_exit: + ; Set timer for coming on cycle length + mov A, Current_Pwm_Limited ; Load current pwm + cpl A ; cpl is 255-x + mov TL0, A ; Write start point for timer + ; Set other variables + mov TL1, #0 ; Reset timer1 + mov Pwm_On_Cnt, #0 ; Reset pwm on event counter + setb Flags0.PWM_ON ; Set pwm on flag +t0_int_pwm_on_exit_no_timer_update: + ; Exit interrupt + pop ACC ; Restore preserved registers + pop PSW + setb EA ; Enable all interrupts + reti + + +;**** **** **** **** **** **** **** **** **** **** **** **** **** +; +; Timer2 interrupt routine +; +; No assumptions +; +;**** **** **** **** **** **** **** **** **** **** **** **** **** +t2_int: ; Happens every 128us for low byte and every 32ms for high byte + clr EA ; Disable all interrupts + push PSW ; Preserve registers through interrupt + push ACC + setb PSW.3 ; Select register bank 1 for interrupt routines + ; Clear low byte interrupt flag + clr TF2L ; Clear interrupt flag + ; Check RC pulse timeout counter + mov A, Rcp_Timeout_Cnt ; RC pulse timeout count zero? + jz t2_int_pulses_absent ; Yes - pulses are absent + + ; Decrement timeout counter (if PWM) +; mov A, #((1 SHL RCP_PWM_FREQ_1KHZ)+(1 SHL RCP_PWM_FREQ_2KHZ)+(1 SHL RCP_PWM_FREQ_4KHZ)+(1 SHL RCP_PWM_FREQ_8KHZ)) +; anl A, Flags3 ; Check pwm frequency flags +; jz t2_int_skip_start ; If no flag is set (PPM) - branch + +; dec Rcp_Timeout_Cnt ; No - decrement + ajmp t2_int_skip_start + +t2_int_pulses_absent: + ; Timeout counter has reached zero, pulses are absent + mov Temp1, #RCP_MIN ; RCP_MIN as default + mov Temp2, #RCP_MIN + Read_Rcp_Int ; Look at value of Rcp_In + jnb ACC.Rcp_In, ($+5) ; Is it high? + mov Temp1, #RCP_MAX ; Yes - set RCP_MAX + Rcp_Int_First ; Set interrupt trig to first again + Rcp_Clear_Int_Flag ; Clear interrupt flag + clr Flags2.RCP_EDGE_NO ; Set first edge flag + Read_Rcp_Int ; Look once more at value of Rcp_In + jnb ACC.Rcp_In, ($+5) ; Is it high? + mov Temp2, #RCP_MAX ; Yes - set RCP_MAX + clr C + mov A, Temp1 + subb A, Temp2 ; Compare the two readings of Rcp_In + jnz t2_int_pulses_absent ; Go back if they are not equal + + jnb Flags0.RCP_MEAS_PWM_FREQ, ($+6) ; Is measure RCP pwm frequency flag set? + + mov Rcp_Timeout_Cnt, #RCP_TIMEOUT ; Yes - set timeout count to start value +; mov Pgm_Pulse_Cnt, #0 ;清除PCA中断计数 +; mov A, #((1 SHL RCP_PWM_FREQ_1KHZ)+(1 SHL RCP_PWM_FREQ_2KHZ)+(1 SHL RCP_PWM_FREQ_4KHZ)+(1 SHL RCP_PWM_FREQ_8KHZ)) +; anl A, Flags3 ; Check pwm frequency flags +; jz t2_int_ppm_timeout_set ; If no flag is set (PPM) - branch + +; mov Rcp_Timeout_Cnt, #RCP_TIMEOUT ; For PWM, set timeout count to start value + +t2_int_ppm_timeout_set: + mov New_Rcp, Temp1 ; Store new pulse length + setb Flags2.RCP_UPDATED ; Set updated flag + + +t2_int_skip_start: + ; Check RC pulse skip counter + mov A, Rcp_Skip_Cnt + jz t2_int_skip_end ; If RC pulse skip count is zero - end skipping RC pulse detection + + ; Decrement skip counter (only if edge counter is zero) + dec Rcp_Skip_Cnt ; Decrement + ajmp t2_int_rcp_update_start + +t2_int_skip_end: +; mov A, #((1 SHL RCP_PWM_FREQ_1KHZ)+(1 SHL RCP_PWM_FREQ_2KHZ)+(1 SHL RCP_PWM_FREQ_4KHZ)+(1 SHL RCP_PWM_FREQ_8KHZ)) +; anl A, Flags3 ; Check pwm frequency flags +; jz t2_int_rcp_update_start ; If no flag is set (PPM) - branch + + ; Skip counter has reached zero, start looking for RC pulses again +; Rcp_Int_Enable ; Enable RC pulse interrupt +; Rcp_Clear_Int_Flag ; Clear interrupt flag + +t2_int_rcp_update_start: + ; Process updated RC pulse + jb Flags2.RCP_UPDATED, ($+5) ; Is there an updated RC pulse available? + ajmp t2_int_pwm_exit ; No - exit + + mov A, New_Rcp ; Load new pulse value + mov Temp1, A + clr Flags2.RCP_UPDATED ; Flag that pulse has been evaluated + ; Use a gain of 1.0625x for pwm input if not governor mode +; mov A, #((1 SHL RCP_PWM_FREQ_1KHZ)+(1 SHL RCP_PWM_FREQ_2KHZ)+(1 SHL RCP_PWM_FREQ_4KHZ)+(1 SHL RCP_PWM_FREQ_8KHZ)) +; anl A, Flags3 ; Check pwm frequency flags +; jz t2_int_pwm_min_run ; If no flag is set (PPM) - branch +;;***************************************************** +;; Closed loop mode 选择 +;;***************************************************** +;IF MODE <= 1 ; Main or tail +; mov Temp2, #Pgm_Gov_Mode ; Governor mode? +; cjne @Temp2, #4, t2_int_pwm_min_run; Yes - branch +;ENDIF +;IF MODE == 2 ; Multi +;;读取Closed loop mode +; mov Temp2, #Pgm_Gov_Mode ; Closed loop mode? +; cjne @Temp2, #4, t2_int_pwm_min_run; Yes - branch +;ENDIF + +; ; Limit the maximum value to avoid wrap when scaled to pwm range +;;Closed loop mode = 第1项 Off +; clr C +; mov A, Temp1 +; subb A, #240 ; 240 = (255/1.0625) Needs to be updated according to multiplication factor below +; jc t2_int_rcp_update_mult + +; mov A, #240 ; Set requested pwm to max +; mov Temp1, A + +;t2_int_rcp_update_mult: +; ; Multiply by 1.0625 (optional adjustment gyro gain) +; mov A, Temp1 +; swap A ; After this "0.0625" +; anl A, #0Fh +; add A, Temp1 +; mov Temp1, A +; ; Adjust tail gain +;;读取 Multi gain +; mov Temp2, #Pgm_Motor_Gain +; cjne @Temp2, #3, ($+5) ; Is gain 1? +; ajmp t2_int_pwm_min_run ; Yes - skip adjustment +;;Multi gain = 第2选项 +; clr C +; rrc A ; After this "0.5" +; clr C +; rrc A ; After this "0.25" +; mov Bit_Access_Int, @Temp2 ; (Temp2 has #Pgm_Motor_Gain) +; jb Bit_Access_Int.0, t2_int_rcp_gain_corr ; Branch if bit 0 in gain is set +;;Multi gain = 第4选项 +; clr C +; rrc A ; After this "0.125" + +;t2_int_rcp_gain_corr: +; jb Bit_Access_Int.2, t2_int_rcp_gain_pos ; Branch if bit 2 in gain is set +;;Multi gain = 第1选项 +; clr C +; xch A, Temp1 +; subb A, Temp1 ; Apply negative correction +; mov Temp1, A +; ajmp t2_int_pwm_min_run +;;Multi gain = 第5选项 +;t2_int_rcp_gain_pos: +; add A, Temp1 ; Apply positive correction +; mov Temp1, A +; jnc t2_int_pwm_min_run ; Above max? + +; mov A, #0FFh ; Yes - limit +; mov Temp1, A +;;Multi gain = 第3选项 +t2_int_pwm_min_run: + ; Limit minimum pwm + clr C + mov A, Temp1 + subb A, Pwm_Motor_Idle ; Is requested pwm lower than minimum? + jnc t2_int_pwm_update ; No - branch + + mov A, Pwm_Motor_Idle ; Yes - limit pwm to Pwm_Motor_Idle + mov Temp1, A + +t2_int_pwm_update: + ; Check if any startup phase flags are set + mov A, Flags1 + anl A, #((1 SHL SETTLE_PHASE)+(1 SHL STEPPER_PHASE)) + jnz t2_int_pwm_exit ; Exit if any startup phase set (pwm controlled by set_startup_pwm) + + ; Update requested_pwm + mov Requested_Pwm, Temp1 ; Set requested pwm + ; Limit pwm during direct start + jnb Flags1.DIRECT_STARTUP_PHASE, t2_int_current_pwm_update + + clr C + mov A, Requested_Pwm ; Limit pwm during direct start + subb A, Pwm_Limit + jc ($+7) + + mov Requested_Pwm, Pwm_Limit + ajmp t2_int_current_pwm_update + + mov A, Requested_Pwm + add A, #11 + mov Requested_Pwm, A + +t2_int_current_pwm_update: +IF MODE <= 1 ; Main or tail + mov Temp1, #Pgm_Gov_Mode ; Governor mode? + cjne @Temp1, #4, t2_int_pwm_exit ; Yes - branch +ENDIF +IF MODE == 2 ; Multi +;读取Closed loop mode + mov Temp1, #Pgm_Gov_Mode ; Closed loop mode? + cjne @Temp1, #1, t2_int_pwm_exit ; Yes - branch +ENDIF + + ; Update current pwm, with limited throttle change rate +;Closed loop mode = Off + clr C + mov A, Requested_Pwm + subb A, Current_Pwm ; Is requested pwm larger than current pwm? + jc t2_int_set_current_pwm ; No - proceed + + mov Temp1, #Pgm_Throttle_Rate_Decoded + subb A, @Temp1 ; Is difference larger than throttle change rate? + jc t2_int_set_current_pwm ; No - proceed + + mov A, Current_Pwm ; Increase current pwm by throttle change rate + add A, @Temp1 + mov Current_Pwm, A + jnc t2_int_current_pwm_done ; Is result above max? + + mov Current_Pwm, #0FFh ; Yes - limit + jmp t2_int_current_pwm_done + +t2_int_set_current_pwm: + mov Current_Pwm, Requested_Pwm ; Set equal as default +t2_int_current_pwm_done: +IF MODE == 1 ; Tail + ; If tail, then set current_pwm_limited + mov Current_Pwm_Limited, Current_Pwm ; Default not limited + clr C + mov A, Current_Pwm ; Check against limit + subb A, Pwm_Limit + jc ($+5) ; If current pwm below limit - branch + + mov Current_Pwm_Limited, Pwm_Limit ; Limit pwm +ENDIF +IF MODE == 2 ; Multi + ; If multi, then set current_pwm_limited + mov Current_Pwm_Limited, Current_Pwm ; Default not limited + clr C + mov A, Current_Pwm ; Check against limit + subb A, Pwm_Limit + jc ($+5) ; If current pwm below limit - branch + + mov Current_Pwm_Limited, Pwm_Limit ; Limit pwm +ENDIF + +t2_int_pwm_exit: + ; Check if high byte flag is set + jb TF2H, t2h_int + pop ACC ; Restore preserved registers + pop PSW + clr PSW.3 ; Select register bank 0 for main program routines + setb EA ; Enable all interrupts + reti + +t2h_int: + ; High byte interrupt (happens every 32ms) + clr TF2H ; Clear interrupt flag + mov Temp1, #GOV_SPOOLRATE ; Load governor spool rate + ; Check RC pulse timeout counter (used here for PPM only) + mov A, Rcp_Timeout_Cnt ; RC pulse timeout count zero? + jz t2h_int_rcp_stop_check ; Yes - do not decrement + + ; Decrement timeout counter (if PPM) +; mov A, #((1 SHL RCP_PWM_FREQ_1KHZ)+(1 SHL RCP_PWM_FREQ_2KHZ)+(1 SHL RCP_PWM_FREQ_4KHZ)+(1 SHL RCP_PWM_FREQ_8KHZ)) +; anl A, Flags3 ; Check pwm frequency flags +; jnz t2h_int_rcp_stop_check ; If a flag is set (PWM) - branch + + dec Rcp_Timeout_Cnt ; No flag set (PPM) - decrement + +t2h_int_rcp_stop_check: + ; Check RC pulse against stop value + clr C + mov A, New_Rcp ; Load new pulse value + subb A, #RCP_STOP +; subb A, #(RCP_STOP+2) ; Check if pulse is below stop value + jc t2h_int_rcp_stop + + ; RC pulse higher than stop value, reset stop counter + mov Rcp_Stop_Cnt, #0 ; Reset rcp stop counter + ajmp t2h_int_rcp_gov_pwm + +t2h_int_rcp_stop: + ; RC pulse less than stop value, increment stop counter + mov A, Rcp_Stop_Cnt ; Load rcp stop counter + inc A ; Check if counter is max + jz t2h_int_rcp_gov_pwm ; Branch if counter is equal to max + + inc Rcp_Stop_Cnt ; Increment stop counter + +t2h_int_rcp_gov_pwm: +IF MODE == 0 ; Main + mov Temp2, #Pgm_Gov_Mode ; Governor target by arm mode? + cjne @Temp2, #2, t2h_int_rcp_gov_by_setup ; No - branch + + mov A, Gov_Active ; Is governor active? + jz t2h_int_rcp_gov_by_tx ; No - branch (this ensures soft spoolup by tx) + + clr C + mov A, Requested_Pwm + subb A, #50 ; Is requested pwm below 20%? + jc t2h_int_rcp_gov_by_tx ; Yes - branch (this enables a soft spooldown) + + mov Requested_Pwm, Gov_Arm_Target ; Yes - load arm target + +t2h_int_rcp_gov_by_setup: + mov Temp2, #Pgm_Gov_Mode ; Governor target by setup mode? + cjne @Temp2, #3, t2h_int_rcp_gov_by_tx ; No - branch + + mov A, Gov_Active ; Is governor active? + jz t2h_int_rcp_gov_by_tx ; No - branch (this ensures soft spoolup by tx) + + clr C + mov A, Requested_Pwm + subb A, #50 ; Is requested pwm below 20%? + jc t2h_int_rcp_gov_by_tx ; Yes - branch (this enables a soft spooldown) +;读取Pgm_Gov_Setup_Target + mov Temp2, #Pgm_Gov_Setup_Target ; Gov by setup - load setup target + mov Requested_Pwm, @Temp2 + +t2h_int_rcp_gov_by_tx: + clr C + mov A, Governor_Req_Pwm + subb A, Requested_Pwm ; Is governor requested pwm equal to requested pwm? + jz t2h_int_rcp_gov_pwm_done ; Yes - branch + + jc t2h_int_rcp_gov_pwm_inc ; No - if lower, then increment + + dec Governor_Req_Pwm ; No - if higher, then decrement + ajmp t2h_int_rcp_gov_pwm_done + +t2h_int_rcp_gov_pwm_inc: + inc Governor_Req_Pwm ; Increment + +t2h_int_rcp_gov_pwm_done: + djnz Temp1, t2h_int_rcp_gov_pwm ; If not number of steps processed - go back + + inc Spoolup_Limit_Cnt ; Increment spoolup count + + jnz ($+4) ; Wrapped? + + dec Spoolup_Limit_Cnt ; Yes - decrement + + djnz Spoolup_Limit_Skip, t2h_int_rcp_exit ; Jump if skip count is not reached + + mov Spoolup_Limit_Skip, #1 ; Reset skip count. Default is fast spoolup + mov Temp1, #3 ; Default fast increase + + clr C + mov A, Spoolup_Limit_Cnt + subb A, #(3*MAIN_SPOOLUP_TIME) ; No spoolup until "30"*32ms + jc t2h_int_rcp_exit + + clr C + mov A, Spoolup_Limit_Cnt + subb A, #(10*MAIN_SPOOLUP_TIME) ; Slow spoolup until "100"*32ms + jnc t2h_int_rcp_limit_middle_ramp + + mov Temp1, #1 ; Slow initial spoolup + mov Spoolup_Limit_Skip, #3 + jmp t2h_int_rcp_set_limit + +t2h_int_rcp_limit_middle_ramp: + clr C + mov A, Spoolup_Limit_Cnt + subb A, #(15*MAIN_SPOOLUP_TIME) ; Faster spoolup until "150"*32ms + jnc t2h_int_rcp_set_limit + + mov Temp1, #1 ; Faster middle spoolup + mov Spoolup_Limit_Skip, #1 + +t2h_int_rcp_set_limit: + mov A, Pwm_Limit_Spoolup ; Increment spoolup pwm + clr C + add A, Temp1 + jnc t2h_int_rcp_no_limit ; If below 255 - branch + + mov Pwm_Limit_Spoolup, #0FFh + ajmp t2h_int_rcp_exit + +t2h_int_rcp_no_limit: + mov Pwm_Limit_Spoolup, A +ENDIF +IF MODE == 2 ; Multi + mov A, Pwm_Limit_Spoolup ; Increment spoolup pwm, for a 0.8 seconds spoolup + clr C + add A, #10 + jnc t2h_int_rcp_no_limit ; If below 255 - branch + + mov Pwm_Limit_Spoolup, #0FFh + ajmp t2h_int_rcp_exit + +t2h_int_rcp_no_limit: + mov Pwm_Limit_Spoolup, A +ENDIF + +t2h_int_rcp_exit: + pop ACC ; Restore preserved registers + pop PSW + clr PSW.3 ; Select register bank 0 for main program routines + setb EA ; Enable all interrupts + reti + + +;**** **** **** **** **** **** **** **** **** **** **** **** **** +; +; Timer3 interrupt routine +; +; No assumptions +; +;**** **** **** **** **** **** **** **** **** **** **** **** **** +t3_int: ; Used for commutation timing + clr EA ; Disable all interrupts + anl TMR3CN, #07Fh ; Clear interrupt flag + clr Flags0.T3_PENDING ; Flag that timer has wrapped + setb EA ; Enable all interrupts + reti + + +;**** **** **** **** **** **** **** **** **** **** **** **** **** +; +; PCA interrupt routine +; +; No assumptions +; +;**** **** **** **** **** **** **** **** **** **** **** **** **** +pca_int: ; Used for RC pulse timing + clr EA ; Disable all interrupts + push PSW ; Preserve registers through interrupt + push ACC + push B + setb PSW.3 ; Select register bank 1 for interrupt routines + +; mov A, Pca_First_Int +; cjne A, #1, ($+5) +; inc Pgm_Pulse_Cnt + ; Get PCA0 capture values + mov Temp1, PCA0CPL0 + mov Temp2, PCA0CPH0 + ; Clear interrupt flag + Rcp_Clear_Int_Flag + ; Check which edge it is + jnb Flags2.RCP_EDGE_NO, ($+5) ; Is it a first edge trig? + ajmp pca_int_second_meas_pwm_freq ; No - branch to second + + Rcp_Int_Second ; Yes - set second edge trig + setb Flags2.RCP_EDGE_NO ; Set second edge flag + ; Read RC signal level + Read_Rcp_Int + ; Test RC signal level + jb ACC.Rcp_In, ($+5) ; Is it high? + ajmp pca_int_fail_minimum ; No - jump to fail minimum + + ; RC pulse was high, store RC pulse start timestamp + mov Rcp_Prev_Edge_L, Temp1 + mov Rcp_Prev_Edge_H, Temp2 + ajmp pca_int_exit ; Exit + +pca_int_fail_minimum: + ; Prepare for next interrupt + Rcp_Int_First ; Set interrupt trig to first again + Rcp_Clear_Int_Flag ; Clear interrupt flag + clr Flags2.RCP_EDGE_NO ; Set first edge flag +; mov A, #((1 SHL RCP_PWM_FREQ_1KHZ)+(1 SHL RCP_PWM_FREQ_2KHZ)+(1 SHL RCP_PWM_FREQ_4KHZ)+(1 SHL RCP_PWM_FREQ_8KHZ)) + mov A, #(1 SHL RCP_PWM_FREQ_1KHZ) + anl A, Flags3 ; Check pwm frequency flags + jnz ($+4) ; If a flag is set (PWM) - proceed + + ajmp pca_int_set_timeout ; If PPM - ignore trig as noise + + mov Temp1, #RCP_MIN ; Set RC pulse value to minimum + Read_Rcp_Int ; Test RC signal level again + jnb ACC.Rcp_In, ($+5) ; Is it high? + ajmp pca_int_set_timeout ; Yes - set new timeout and exit + + mov New_Rcp, Temp1 ; Store new pulse length + ajmp pca_int_set_timeout ; Set new timeout and exit + +pca_int_second_meas_pwm_freq: + ; Prepare for next interrupt + Rcp_Int_First ; Set first edge trig + clr Flags2.RCP_EDGE_NO ; Set first edge flag + ; Check if pwm frequency shall be measured + jb Flags0.RCP_MEAS_PWM_FREQ, ($+5) ; Is measure RCP pwm frequency flag set? + ajmp pca_int_fall ; No - skip measurements + + ; Set second edge trig only during pwm frequency measurement + Rcp_Int_Second ; Set second edge trig + Rcp_Clear_Int_Flag ; Clear interrupt flag + setb Flags2.RCP_EDGE_NO ; Set second edge flag + ; Store edge data to RAM + mov Rcp_Edge_L, Temp1 + mov Rcp_Edge_H, Temp2 + ; Calculate pwm frequency + clr C + mov A, Temp1 + subb A, Rcp_PrePrev_Edge_L + mov Temp1, A ;存低字节差 + mov A, Temp2 + subb A, Rcp_PrePrev_Edge_H + mov Temp2, A ;存高字节差 +; clr A +; mov Temp4, A + ; Check if pwm frequency is 8kHz + mov Temp3, #250 ; Set default period tolerance requirement +; clr C +; mov A, Temp1 +; subb A, #low(360) ; If below 180us, 8kHz pwm is assumed +; mov A, Temp2 +; subb A, #high(360) +; jnc pca_int_check_4kHz + +; clr A +; setb ACC.RCP_PWM_FREQ_8KHZ +; mov Temp4, A +; mov Temp3, #15 ; Set period tolerance requirement +; ajmp pca_int_restore_edge + +;pca_int_check_4kHz: +; ; Check if pwm frequency is 4kHz +; clr C +; mov A, Temp1 +; subb A, #low(720) ; If below 360us, 4kHz pwm is assumed +; mov A, Temp2 +; subb A, #high(720) +; jnc pca_int_check_2kHz + +; clr A +; setb ACC.RCP_PWM_FREQ_4KHZ +; mov Temp4, A +; mov Temp3, #30 ; Set period tolerance requirement +; ajmp pca_int_restore_edge + +;pca_int_check_2kHz: +; ; Check if pwm frequency is 2kHz +; clr C +; mov A, Temp1 +; subb A, #low(1440) ; If below 720us, 2kHz pwm is assumed +; mov A, Temp2 +; subb A, #high(1440) +; jnc pca_int_check_1kHz + +; clr A +; setb ACC.RCP_PWM_FREQ_2KHZ +; mov Temp4, A +; mov Temp3, #60 ; Set period tolerance requirement +; ajmp pca_int_restore_edge + +;pca_int_check_1kHz: + ; Check if pwm frequency is 1kHz + clr C + mov A, Temp1 + subb A, #low(2200) ; If below 1100us, 1kHz pwm is assumed + mov A, Temp2 + subb A, #high(2200) + jnc pca_int_restore_edge + + ajmp pca_int_set_timeout +; clr A +; setb ACC.RCP_PWM_FREQ_1KHZ +; mov Temp4, A +; mov Temp3, #120 ; Set period tolerance requirement + +pca_int_restore_edge: + ; Calculate difference between this period and previous period + clr C + mov A, Temp1 + subb A, Rcp_Prev_Period_L + mov Temp5, A + mov A, Temp2 + subb A, Rcp_Prev_Period_H + mov Temp6, A + ; Make positive + jnb ACC.7, pca_int_check_diff + mov A, Temp5 + cpl A + add A, #1 + mov Temp5, A + mov A, Temp6 + cpl A + mov Temp6, A + +pca_int_check_diff: + ; Check difference + mov Rcp_Period_Diff_Accepted, #0 ; Set not accepted as default + jnz pca_int_store_data ; Check if high byte is zero + + clr C + mov A, Temp5 + subb A, Temp3 ; Check difference + jnc pca_int_store_data + + mov Rcp_Period_Diff_Accepted, #1 ; Set accepted + +pca_int_store_data: + ; Store previous period + mov Rcp_Prev_Period_L, Temp1 + mov Rcp_Prev_Period_H, Temp2 + ; Restore edge data from RAM + mov Temp1, Rcp_Edge_L + mov Temp2, Rcp_Edge_H + ; Store pre previous edge + mov Rcp_PrePrev_Edge_L, Temp1 + mov Rcp_PrePrev_Edge_H, Temp2 + +pca_int_fall: + clr A + mov Temp4, A + ; RC pulse edge was second, calculate new pulse length + clr C + mov A, Temp1 + subb A, Rcp_Prev_Edge_L + mov Temp1, A + mov A, Temp2 + subb A, Rcp_Prev_Edge_H + mov Temp2, A + +; jnb Flags3.RCP_PWM_FREQ_8KHZ, ($+5) ; Is RC input pwm frequency 8kHz? +; ajmp pca_int_pwm_divide_done ; Yes - branch forward + +; jnb Flags3.RCP_PWM_FREQ_4KHZ, ($+5) ; Is RC input pwm frequency 4kHz? +; ajmp pca_int_pwm_divide ; Yes - branch forward + + mov A, Temp2 ; No - 2kHz. Divide by 2 again + clr C + rrc A + mov Temp2, A + mov A, Temp1 + rrc A + mov Temp1, A + +; jnb Flags3.RCP_PWM_FREQ_2KHZ, ($+5) ; Is RC input pwm frequency 2kHz? +; ajmp pca_int_pwm_divide ; Yes - branch forward + + mov A, Temp2 ; No - 1kHz. Divide by 2 again + clr C + rrc A + mov Temp2, A + mov A, Temp1 + rrc A + mov Temp1, A + + clr C + mov A, Temp1 + subb A, #250 ; If below 500us, + mov A, Temp2 + subb A, #0 + jnc ($+9) + + mov A, Initial_Arm + cjne A, #1, ($+5) + + ajmp pca_int_pwm_divide + +; jnb Flags3.RCP_PWM_FREQ_1KHZ, ($+5) ; Is RC input pwm frequency 1kHz? +; ajmp pca_int_pwm_divide ; Yes - branch forward + + mov A, Temp2 ; No - PPM. Divide by 2 (to bring range to 256) and move to Temp5/6 + clr C + rrc A + mov Temp6, A + mov A, Temp1 + rrc A + mov Temp5, A + ; Skip range limitation if pwm frequency measurement + jb Flags0.RCP_MEAS_PWM_FREQ, pca_int_ppm_check_full_range + + ; Check if 2160us or above (in order to ignore false pulses) + clr C + mov A, Temp5 ; Is pulse 2160us or higher? + subb A, #28 + mov A, Temp6 + subb A, #2 + jc ($+5) ; No - proceed + + ljmp pca_int_set_timeout ; Yes - ignore pulse + + ; Check if below 800us (in order to ignore false pulses) + mov A, Temp6 + jnz pca_int_ppm_check_full_range + + clr C + mov A, Temp5 ; Is pulse below 800us? + subb A, #200 + jnc pca_int_ppm_check_full_range ; No - proceed + + jmp pca_int_exit ; Yes - ignore pulse + +pca_int_ppm_check_full_range: + ; Calculate "1000us" plus throttle minimum + mov A, #0 ; Set 1000us as default minimum + jb Flags3.FULL_THROTTLE_RANGE, pca_int_ppm_calculate ; Check if full range is chosen + + mov Temp1, #Pgm_Ppm_Min_Throttle ; Min throttle value is in 4us units + mov A, @Temp1 + +pca_int_ppm_calculate: + add A, #250 + mov Temp7, A + clr A + addc A, #0 + mov Temp8, A + + clr C + mov A, Temp5 ; Subtract minimum + subb A, Temp7 + mov Temp5, A + mov A, Temp6 + subb A, Temp8 + mov Temp6, A + jnc pca_int_ppm_neg_checked ; Is result negative? + + mov Temp1, #RCP_MIN ; Yes - set to minimum + mov Temp2, #0 + ajmp pca_int_pwm_divide_done + +pca_int_ppm_neg_checked: + clr C ; Check that RC pulse is within legal range (1000+4*255=2020) + mov A, Temp5 + subb A, #RCP_MAX + mov A, Temp6 + subb A, #0 + jc pca_int_ppm_max_checked + + mov Temp1, #RCP_MAX + mov Temp2, #0 + ajmp pca_int_pwm_divide_done + +pca_int_ppm_max_checked: + mov A, Temp5 ; Multiply throttle value by gain + mov B, Ppm_Throttle_Gain + mul AB + xch A, B + mov C, B.7 ; Multiply result by 2 (unity gain is 128) + rlc A + mov Temp1, A ; Transfer to Temp1/2 + mov Temp2, #0 + jc pca_int_ppm_limit_after_mult + + jmp pca_int_limited + +pca_int_ppm_limit_after_mult: + mov Temp1, #RCP_MAX + mov Temp2, #0 + jmp pca_int_limited + +pca_int_pwm_divide: +;480us + clr C + mov A, Temp1 + subb A, #240 + mov A, Temp2 + subb A, #0 + jnc pca_int_set_timeout +;40us + clr C + mov A, Temp1 + subb A, #20 + mov A, Temp2 + subb A, #0 + jc pca_int_set_timeout + + clr A + setb ACC.RCP_PWM_FREQ_1KHZ + mov Temp4, A +; mov Rcp_Period_Diff_Accepted, #1 + ajmp pca_int_limited + +pca_int_pwm_divide_done: + ; Check that RC pulse is within legal range + clr C + mov A, Temp1 + subb A, #RCP_MAX + mov A, Temp2 + subb A, #0 + jc pca_int_limited + + mov Temp1, #RCP_MAX + +pca_int_limited: + ; RC pulse value accepted + mov New_Rcp, Temp1 ; Store new pulse length + setb Flags2.RCP_UPDATED ; Set updated flag +; jb Flags0.RCP_MEAS_PWM_FREQ, ($+5) ; Is measure RCP pwm frequency flag set? +; ajmp pca_int_set_timeout ; No - skip measurements + +; mov A, #((1 SHL RCP_PWM_FREQ_1KHZ)+(1 SHL RCP_PWM_FREQ_2KHZ)+(1 SHL RCP_PWM_FREQ_4KHZ)+(1 SHL RCP_PWM_FREQ_8KHZ)) + mov A, #(1 SHL RCP_PWM_FREQ_1KHZ) + cpl A + anl A, Flags3 ; Clear all pwm frequency flags + orl A, Temp4 ; Store pwm frequency value in flags + mov Flags3, A + +pca_int_set_timeout: + mov Rcp_Timeout_Cnt, #RCP_TIMEOUT ; Set timeout count to start value +; mov A, #((1 SHL RCP_PWM_FREQ_1KHZ)+(1 SHL RCP_PWM_FREQ_2KHZ)+(1 SHL RCP_PWM_FREQ_4KHZ)+(1 SHL RCP_PWM_FREQ_8KHZ)) + mov A, #(1 SHL RCP_PWM_FREQ_1KHZ) + anl A, Flags3 ; Check pwm frequency flags + jnz pca_int_ppm_timeout_set ; If a flag is set - branch + + mov Rcp_Timeout_Cnt, #RCP_TIMEOUT_PPM ; No flag set means PPM. Set timeout count + +pca_int_ppm_timeout_set: +; jnb Flags0.RCP_MEAS_PWM_FREQ, ($+5) ; Is measure RCP pwm frequency flag set? +; ajmp pca_int_exit ; Yes - exit + +; mov A, #((1 SHL RCP_PWM_FREQ_1KHZ)+(1 SHL RCP_PWM_FREQ_2KHZ)+(1 SHL RCP_PWM_FREQ_4KHZ)+(1 SHL RCP_PWM_FREQ_8KHZ)) +; anl A, Flags3 ; Check pwm frequency flags +; jz pca_int_exit ; If no flag is set (PPM) - branch + +; Rcp_Int_Disable ; Disable RC pulse interrupt + +pca_int_exit: ; Exit interrupt routine + mov Rcp_Skip_Cnt, #RCP_SKIP_RATE ; Load number of skips +; mov A, #((1 SHL RCP_PWM_FREQ_1KHZ)+(1 SHL RCP_PWM_FREQ_2KHZ)+(1 SHL RCP_PWM_FREQ_4KHZ)+(1 SHL RCP_PWM_FREQ_8KHZ)) + mov A, #(1 SHL RCP_PWM_FREQ_1KHZ) + anl A, Flags3 ; Check pwm frequency flags + jnz ($+5) ; If a flag is set (PWM) - branch + + mov Rcp_Skip_Cnt, #10 ; Load number of skips + + pop B ; Restore preserved registers + pop ACC + pop PSW + clr PSW.3 ; Select register bank 0 for main program routines + setb EA ; Enable all interrupts + reti + + + + +;**** **** **** **** **** **** **** **** **** **** **** **** **** +; +; Wait xms ~(x*4*250) (Different entry points) +; +; No assumptions +; +;**** **** **** **** **** **** **** **** **** **** **** **** **** +wait1ms: + mov Temp2, #1 + ajmp waitxms_o + +wait3ms: + mov Temp2, #3 + ajmp waitxms_o + +wait10ms: + mov Temp2, #10 + ajmp waitxms_o + +wait30ms: + mov Temp2, #30 + ajmp waitxms_o + +wait100ms: + mov Temp2, #100 + ajmp waitxms_o + +wait200ms: + mov Temp2, #200 + ajmp waitxms_o + +waitxms_o: ; Outer loop + mov Temp1, #23 +waitxms_m: ; Middle loop + clr A + djnz ACC, $ ; Inner loop (42.7us - 1024 cycles) + djnz Temp1, waitxms_m + djnz Temp2, waitxms_o + ret +;**;**** **** **** **** **** **** **** **** **** **** **** **** **** +; +; Wait 1 second routine +; +; No assumptions +; +;**** **** **** **** **** **** **** **** **** **** **** **** **** +wait1s: + mov Temp5, #5 +wait1s_loop: + call wait200ms + djnz Temp5, wait1s_loop + ret + + +;**;**** **** **** **** **** **** **** **** **** **** **** **** **** +; +; Success beep routine +; +; No assumptions +; +;**** **** **** **** **** **** **** **** **** **** **** **** **** +success_beep: + clr EA ; Disable all interrupts + call beep_f1 + call beep_f2 + call beep_f3 +; call beep_f4 + call wait10ms + call beep_f1 + call beep_f2 + call beep_f3 +; call beep_f4 +; call wait10ms +; call beep_f1 +; call beep_f2 +; call beep_f3 +; call beep_f4 + setb EA ; Enable all interrupts + ret + + +;**;**** **** **** **** **** **** **** **** **** **** **** **** **** +; +; Success beep inverted routine +; +; No assumptions +; +;**** **** **** **** **** **** **** **** **** **** **** **** **** +success_beep_inverted: + clr EA ; Disable all interrupts +; call beep_f4 + call beep_f3 + call beep_f2 + call beep_f1 + call wait10ms +; call beep_f4 + call beep_f3 + call beep_f2 + call beep_f1 + call wait10ms +; call beep_f4 +; call beep_f3 +; call beep_f2 +; call beep_f1 + setb EA ; Enable all interrupts + ret + + + +;**** **** **** **** **** **** **** **** **** **** **** **** **** +; +; Function and parameter value beep routine +; +; No assumptions +; +;**** **** **** **** **** **** **** **** **** **** **** **** **** +function_paraval_beep: + mov Temp7, Tx_Pgm_Func_No ; Function no + mov Temp8, Tx_Pgm_Paraval_No ; Parameter value no + clr EA ; Disable all interrupts +;//////function_beep: +;////// call beep_f1 +;////// call beep_f1 +;////// call beep_f1 +;////// call wait10ms +;////// djnz Temp7, function_beep +;//////paraval_beep: +;////// call beep_f4 +;////// call wait10ms +;////// djnz Temp8, paraval_beep +;function_beep: + jnb Flags0.PROGRAM_FUNC_FLAG,paraval_beep ;跳到参数选项叫 +function_no_6: + clr C + mov A,Temp7 + subb A,#5 + jc function_below_beep + jz function_beep + mov Temp7, A +function_beep: + call beep_f3 + call beep_f3 + call beep_f3 + call beep_f3 + call beep_f3 + call wait30ms + + cjne Temp7,#5,($+5) + ajmp fun_par_end + + +function_below_beep: + call beep_f1 + call beep_f1 + call beep_f1 + call wait100ms + djnz Temp7, function_below_beep + ajmp fun_par_end + +paraval_beep: + clr A + mov Temp7,A + + clr C + mov A,Temp8 + subb A,#10 ;参数数 - 10 + jc paraval_no_7 ;<10 + inc Temp7 ;>=10 + inc Temp7 + jz paraval_below_beep + mov Temp8,A ;>=存差 + ajmp paraval_below_beep + +paraval_no_7: + clr C + mov A,Temp8 + subb A,#5 + jc paraval_no_below + inc Temp7 + jz paraval_below_beep + mov Temp8,A ;>=存差 + +paraval_below_beep: + call beep_f2 + call beep_f2 + call beep_f2 + call wait30ms + djnz Temp7,paraval_below_beep + cjne Temp8,#10,($+5) + ajmp fun_par_end + cjne Temp8,#5,($+5) + ajmp fun_par_end + +paraval_no_below: + call wait100ms + call beep_f4 + call wait100ms + djnz Temp8, paraval_no_below +fun_par_end: + setb EA ; Enable all interrupts + + ret + + +;**** **** **** **** **** **** **** **** **** **** **** **** **** +; +; 接收一个数据（一个字节） +; +;**** **** **** **** **** **** **** **** **** **** **** **** **** +receive_a_byte: + mov Temp8,#0 + mov Commu_Data_Buffer, #0 + mov Temp4, #8 +wait_high: + + Read_Rcp_Int + ; Test RC signal level + jb ACC.Rcp_In,start_t2 + + jnb TF1, wait_high + +; setb Flags3.ERRO_DATA +; ajmp receive_exit + +start_t2: + mov TL0, #00h + mov TH0, #00h + setb TR0 ;启动T0 +wait_low: + Read_Rcp_Int + ; Test RC signal level + jnb ACC.Rcp_In, measure_wide + + jnb TF1, wait_low + +; setb Flags3.ERRO_DATA +; ajmp receive_exit + +measure_wide: + clr TR0 ;停止T0 +; mov Temp1, TL0 +; mov Temp2, TH0 + +; mov New_Rcp, Temp1 + mov New_Rcp, TL0 + clr C + mov A, New_Rcp + subb A, #20 ;40us + jc receive_a_erro_byte ;<80us 错误字节 + + clr C + mov A, New_Rcp + subb A, #78 ;156us + jnc receive_bit_one ;>160us 进行位1判断 + + mov A, Temp8 ;取0 + rl A + mov Temp8, A + ajmp receive_a_byte_exit + +receive_bit_one: + clr C + mov A, New_Rcp + subb A, #102 ;240us + jc receive_a_erro_byte ;160< New_Rcp <240us 错误字节 + + clr C + mov A, New_Rcp + subb A, #204 ;400us + jnc receive_a_erro_byte ;>400us 错误字节 + + mov A, Temp8 ;取1 + rl A + inc A + mov Temp8, A + ajmp receive_a_byte_exit + +receive_a_erro_byte: + setb Flags3.ERRO_DATA + +receive_a_byte_exit: + jnb TF1, ($+7) + + setb Flags3.ERRO_DATA + ajmp ($+6) + + djnz Temp4, wait_high + mov Commu_Data_Buffer, Temp8 +receive_exit: + ret + +;**** **** **** **** **** **** **** **** **** **** **** **** **** +; +; 接收一组数据 +; +;**** **** **** **** **** **** **** **** **** **** **** **** **** +receive_bytes: + mov Temp5, #48 + mov Temp2, #Tag_Temporary_Storage ; Set RAM address + mov Commu_Data_Buffer, #0 +wait_receive_bytes: + call receive_a_byte + mov @Temp2, Commu_Data_Buffer + inc Temp2 + djnz Temp5, wait_receive_bytes + + ret + +store_tags: +; call store_tags + mov Temp2, #Tag_Temporary_Storage ; Set RAM address + mov Temp5, #48 +store_tag: + cjne Temp5, #45, store_two + mov Temp1, #Pgm_Gov_Mode + jmp store_eep +store_two: + cjne Temp5, #44, store_three + mov Temp1, #Pgm_Low_Voltage_Lim + jmp store_eep +store_three: + cjne Temp5, #43, store_four + mov Temp1, #Pgm_Low_Voltage_Ctl + jmp store_eep +store_four: + cjne Temp5, #40, store_five + mov Temp1, #Pgm_Startup_Pwr + jmp store_eep +store_five: + cjne Temp5, #39, store_six + mov Temp1, #Pgm_Pwm_Freq + jmp store_eep +store_six: + cjne Temp5, #28, store_seven + mov Temp1, #Pgm_Comm_Timing + jmp store_eep +store_seven: + cjne Temp5, #27, store_next + mov Temp1, #Pgm_Damping_Force + +store_eep: + mov Commu_Data_Buffer, @Temp2 +;setb P1.7 + mov @Temp1, Commu_Data_Buffer + + call erase_and_store_all_in_eeprom + clr EA + +store_next: + inc Temp2 + djnz Temp5, store_tag + + ret + +;**** **** **** **** **** **** **** **** **** **** **** **** **** +; +; 发送一个数据（一个字节） +; +;**** **** **** **** **** **** **** **** **** **** **** **** **** +send_a_byte: + clr EA + setb TR0 ;启动T0 + mov Temp4, #8 + mov A, Commu_Data_Buffer ;读取要发送的数据 +wait_send_a_byte: + setb P0.7 ;发送高电平 + +; mov A, Commu_Data_Buffer ;读取要发送的数据 + jnb ACC.7, low_value ;($+8) + + mov TL0, #067h ;发送1脉宽长 + ajmp high_value ;($+5) + +low_value: + mov TL0, #0CDh ;发送0脉宽长 + +high_value: + mov TH0, #0FFh + + clr TF0 ;清T0溢出标志 + jnb TF0, $ ;等待T0溢出 高电平发送完成 + + clr P0.7 ;发送低电平 + mov TL0, #0CDh ; + mov TH0, #0FFh + + clr TF0 ;清T0溢出标志 + jnb TF0, $ ;等待T0溢出 低电平发送完成 + + rl A ;发送下一位 +; mov Commu_Data_Buffer, A + djnz Temp4, wait_send_a_byte + + ret + +;**** **** **** **** **** **** **** **** **** **** **** **** **** +; +; 发送一组数据 +; +;**** **** **** **** **** **** **** **** **** **** **** **** **** +send_bytes: + clr P0.7 +; mov A, P0MDOUT +; orl A, #080h + mov P0MDOUT, #80h ;设置成推挽输出 + mov Temp5, #48 +; mov Temp2, #Tag_Temporary_Storage ; Set RAM address + mov Temp1, #Pgm_Fir_Key +wait_send_bytes: + mov Commu_Data_Buffer, @Temp1 + inc Temp1 + + call send_a_byte ;逐个字节发送 + + djnz Temp5, wait_send_bytes + +; mov A, P0MDOUT +; anl A, #07Fh + mov P0MDOUT, #7Fh ;设置成漏极输出 + setb P0.7 + + ret + + +;**** **** **** **** **** **** **** **** **** **** **** **** **** +; +; 编程卡校验和 +; +;**** **** **** **** **** **** **** **** **** **** **** **** **** +get_commu_buffers_sum: + mov Commu_Sum, #0 + mov Temp5, #48 + mov Temp2, #Tag_Temporary_Storage ; Set RAM address +wait_get_commu_buffers_sum: + mov A, @Temp2 + clr C + addc A, Commu_Sum + mov Commu_Sum, A + inc Temp2 + djnz Temp5, wait_get_commu_buffers_sum + + ret + +;**** **** **** **** **** **** **** **** **** **** **** **** **** +; +; 清零校验和 +; +;**** **** **** **** **** **** **** **** **** **** **** **** **** +set_commu_sum_to_zero: + mov Temp8, #0 + mov Temp5, #47 + mov Temp2, #Tag_Temporary_Storage ; Set RAM address +wait_set_commu_sum_to_zero: + mov A, @Temp2 + clr C + addc A, Temp8 + mov Temp8, A + inc Temp2 + + djnz Temp5, wait_set_commu_sum_to_zero + + cpl A + inc A + mov @Temp2, A ;写最后一个字节 + + ret + +;**** **** **** **** **** **** **** **** **** **** **** **** **** +; +; 读取EEPROM参数 +; +;**** **** **** **** **** **** **** **** **** **** **** **** **** +;check_parameters: +; mov Temp5, #48 ; Number of tags +; mov Temp2, #Tag_Temporary_Storage ; Set RAM address +; mov Temp1, #Bit_Access +; mov DPTR, #Eep_ESC_Layout ; Set flash address +;read_eep: +; call read_eeprom_byte +; mov A, Bit_Access +; mov @Temp2, A ; Write to RAM +; inc Temp2 +; inc DPTR +; djnz Temp5, read_eep + +; call get_commu_buffers_sum + +; mov A, Commu_Sum +; jnz set_parameters_default +;;读取首字节 +; mov Temp2, #Tag_Temporary_Storage ; Set RAM address +; mov Temp1, #Bit_Access +; mov DPTR, #Eep_ESC_Layout ; Set flash address +; call read_eeprom_byte +; mov A, Bit_Access +; cjne A, #66h, set_parameters_default +;;设置默认参数 +;set_parameters_default: +; mov Temp5, #48 +; mov Temp2, #Tag_Temporary_Storage ; Set RAM address +; mov DPTR, #FINISH_KEYWORD_TABLE +;wait_set_parameters_default: +; clr A +; movc A, @A+DPTR +; mov @Temp2, A +; inc Temp2 +; inc DPTR +; djnz Temp5, wait_set_parameters_default + +; call set_commu_sum_to_zero + +; ret + +;**** **** **** **** **** **** **** **** **** **** **** **** **** +; +; 编程卡编程函数 +; +;**** **** **** **** **** **** **** **** **** **** **** **** **** +program_by_card: +; clr EA + mov Commu_Data_Buffer, #0 + call wait10ms + clr Flags3.ERRO_DATA ;清错误字节标志 + + mov TL1, #00h + mov TH1, #00h + setb TR1 ; 启动T1 + clr TF1 ;清T1溢出标志 + + call receive_a_byte ;读取一个字节（关键字） + + jb Flags3.ERRO_DATA, program_by_card ;接收到错误字节，则重新接收 + + mov A, Commu_Data_Buffer ;读接收到的字节 + cjne A, #05h, receive_next_keyword ;判断是否关键字 0x05 + call wait3ms + + call send_bytes + + ljmp program_by_card + +receive_next_keyword: + + cjne A, #09h, program_by_card ;判断是否关键字 0x09 + mov Commu_Data_Buffer, #0 + mov TL1, #00h + mov TH1, #00h + setb TR1 ;启动T1 + clr TF1 ;清T1溢出标志 + + call receive_bytes ;读取一组数据 + + call get_commu_buffers_sum + mov A, Commu_Sum ;读取校验和 + jnz program_by_card ;判断校验和 + + mov Temp2, #Tag_Temporary_Storage ; Set RAM address + mov A, @Temp2 ;读取首字节 + cjne A, #66h, program_by_card ;判断首字节 + + call wait1ms + clr P0.7 +; mov A, P0MDOUT +; orl A, #080h ;设置成推挽输出 + mov P0MDOUT, #080h + mov Commu_Data_Buffer, #088h + + call send_a_byte ;逐个字节发送 +; mov A, P0MDOUT +; anl A, #07Fh ;设置成漏极输出 + mov P0MDOUT, #07Fh + setb P0.7 + call store_tags ;存一组数据 +; call erase_and_store_all_in_eeprom +; clr EA +;clr P1.7 + ljmp program_by_card + + ret + + + + + +;**** **** **** **** **** **** **** **** **** **** **** **** **** +; +; Beeper routines (4 different entry points) +; +; No assumptions +; +;**** **** **** **** **** **** **** **** **** **** **** **** **** +beep_f1: ; Entry point 1, load beeper frequency 1 settings + mov Temp3, #18 ; Off wait loop length + mov Temp4, #100 ; Number of beep pulses Mos开关次数 + ajmp beep + +beep_f2: ; Entry point 2, load beeper frequency 2 settings + mov Temp3, #14 + mov Temp4, #120 ;Mos开关次数 + ajmp beep + +beep_f3: ; Entry point 3, load beeper frequency 3 settings + mov Temp3, #12 + mov Temp4, #160 ;Mos开关次数 + ajmp beep + +beep_f4: ; Entry point 4, load beeper frequency 4 settings + mov Temp3, #9 + mov Temp4, #180 ;Mos开关次数 + ajmp beep + +beep: ; Beep loop start + mov Temp5, Current_Pwm_Limited ; Store value + mov Current_Pwm_Limited, #1 ; Set to a nonzero value + mov Temp2, #2 ; Must be an even number (or direction will change) +beep_onoff: + cpl Flags3.PGM_DIR_REV ; Toggle between using A fet and C fet 切换A、C up导通 + clr A + BpFET_off ; BpFET off + djnz ACC, $ ; Allow some time after pfet is turned off + BnFET_on ; BnFET on (in order to charge the driver of the BpFET) + djnz ACC, $ ; Let the nfet be turned on a while + BnFET_off ; BnFET off again + djnz ACC, $ ; Allow some time after nfet is turned off + BpFET_on ; BpFET on + djnz ACC, $ ; Allow some time after pfet is turned on + ; Turn on nfet + AnFET_on ; AnFET on + mov A, Beep_Strength + djnz ACC, $ + ; Turn off nfet + AnFET_off ; AnFET off + mov A, #100 ; 25祍 off + djnz ACC, $ + djnz Temp2, beep_onoff + ; Copy variable + mov A, Temp3 + mov Temp1, A +beep_off: ; Fets off loop + djnz ACC, $ + djnz Temp1, beep_off + +beep_recharge_done: + djnz Temp4, beep + BpFET_off ; BpFET off + mov Current_Pwm_Limited, Temp5 ; Restore value + ret + + +;**** **** **** **** **** **** **** **** **** **** **** **** **** +; +; Division 16bit unsigned by 16bit unsigned +; +; Dividend shall be in Temp2/Temp1, divisor in Temp4/Temp3 +; Result will be in Temp2/Temp1 +; +;**** **** **** **** **** **** **** **** **** **** **** **** **** +div_u16_by_u16: + clr C + mov Temp5, #0 + mov Temp6, #0 + mov B, #0 +div_u16_by_u16_div1: + inc B ; Increment counter for each left shift + mov A, Temp3 ; Shift left the divisor + rlc A + mov Temp3, A + mov A, Temp4 + rlc A + mov Temp4, A + jnc div_u16_by_u16_div1 ; Repeat until carry flag is set from high-byte +div_u16_by_u16_div2: + mov A, Temp4 ; Shift right the divisor + rrc A + mov Temp4, A + mov A, Temp3 + rrc A + mov Temp3, A + clr C + mov A, Temp2 ; Make a safe copy of the dividend + mov Temp8, A + mov A, Temp1 + mov Temp7, A + mov A, Temp1 ; Move low-byte of dividend into accumulator + subb A, Temp3 ; Dividend - shifted divisor = result bit (no factor, only 0 or 1) + mov Temp1, A ; Save updated dividend + mov A, Temp2 ; Move high-byte of dividend into accumulator + subb A, Temp4 ; Subtract high-byte of divisor (all together 16-bit substraction) + mov Temp2, A ; Save updated high-byte back in high-byte of divisor + jnc div_u16_by_u16_div3 ; If carry flag is NOT set, result is 1 + mov A, Temp8 ; Otherwise result is 0, save copy of divisor to undo subtraction + mov Temp2, A + mov A, Temp7 + mov Temp1, A +div_u16_by_u16_div3: + cpl C ; Invert carry, so it can be directly copied into result + mov A, Temp5 + rlc A ; Shift carry flag into temporary result + mov Temp5, A + mov A, Temp6 + rlc A + mov Temp6,A + djnz B, div_u16_by_u16_div2 ;Now count backwards and repeat until "B" is zero + mov A, Temp6 ; Move result to Temp2/Temp1 + mov Temp2, A + mov A, Temp5 + mov Temp1, A + ret + + +;**** **** **** **** **** **** **** **** **** **** **** **** **** +; +; Multiplication 16bit signed by 8bit unsigned +; +; Multiplicand shall be in Temp2/Temp1, multiplicator in Temp3 +; Result will be in Temp2/Temp1. Result will divided by 16 +; +;**** **** **** **** **** **** **** **** **** **** **** **** **** +mult_s16_by_u8_div_16: + mov A, Temp1 ; Read input to math registers + mov B, Temp2 + mov Bit_Access, Temp3 + setb PSW.4 ; Select register bank 2 for math routines + mov Temp1, A ; Store in math registers + mov Temp2, B + mov Temp4, #0 ; Set sign in Temp4 and test sign + jnb B.7, mult_s16_by_u8_positive + + mov Temp4, #0FFh + cpl A + add A, #1 + mov Temp1, A + mov A, Temp2 + cpl A + addc A, #0 + mov Temp2, A +mult_s16_by_u8_positive: + mov A, Temp1 ; Multiply LSB with multiplicator + mov B, Bit_Access + mul AB + mov Temp6, B ; Place MSB in Temp6 + mov Temp1, A ; Place LSB in Temp1 (result) + mov A, Temp2 ; Multiply MSB with multiplicator + mov B, Bit_Access + mul AB + mov Temp8, B ; Place in Temp8/7 + mov Temp7, A + mov A, Temp6 ; Add up + add A, Temp7 + mov Temp2, A + mov A, #0 + addc A, Temp8 + mov Temp3, A + mov Temp5, #4 ; Set number of divisions +mult_s16_by_u8_div_loop: + clr C ; Rotate right + mov A, Temp3 + rrc A + mov Temp3, A + mov A, Temp2 + rrc A + mov Temp2, A + mov A, Temp1 + rrc A + mov Temp1, A + djnz Temp5, mult_s16_by_u8_div_loop + + mov B, Temp4 ; Test sign + jnb B.7, mult_s16_by_u8_exit + + mov A, Temp1 + cpl A + add A, #1 + mov Temp1, A + mov A, Temp2 + cpl A + addc A, #0 + mov Temp2, A + +mult_s16_by_u8_exit: + mov A, Temp1 ; Store output + mov B, Temp2 + clr PSW.4 ; Select normal register bank + mov Temp1, A + mov Temp2, B + ret + + +;**** **** **** **** **** **** **** **** **** **** **** **** **** +; +; Calculate governor routines +; +; No assumptions +; +; Governs headspeed based upon the Comm_Period4x variable and pwm +; The governor task is split into several routines in order to distribute processing time +; +;**** **** **** **** **** **** **** **** **** **** **** **** **** +; First governor routine - calculate governor target +IF MODE <= 1 ; Main or tail +calc_governor_target: + mov Temp1, #Pgm_Gov_Mode ; Governor mode? + cjne @Temp1, #4, governor_speed_check ; Yes + jmp calc_governor_target_exit ; No + +governor_speed_check: + ; Stop governor for stop RC pulse + clr C + mov A, New_Rcp ; Check RC pulse against stop value + subb A, #RCP_STOP ; Is pulse below stop value? + jc governor_deactivate ; Yes - deactivate + + ; Skip speed check if governor is alrady active + mov A, Gov_Active + jnz governor_target_calc + + ; Check speed (do not run governor for low speeds) + mov Temp1, #05h ; Default high range activation limit value (~62500 eRPM) + clr C + mov Temp2, #Pgm_Gov_Range + cjne @Temp2, #2, ($+5) + + mov Temp1, #12h ; Low range activation limit value (~17400 eRPM) + + clr C + mov A, Comm_Period4x_L + subb A, #00h + mov A, Comm_Period4x_H + subb A, Temp1 + jc governor_activate ; If speed above min limit - run governor + +governor_deactivate: + mov Current_Pwm, Requested_Pwm ; Set current pwm to requested + clr A + mov Gov_Target_L, A ; Set target to zero + mov Gov_Target_H, A + mov Gov_Integral_L, A ; Set integral to zero + mov Gov_Integral_H, A + mov Gov_Integral_X, A + mov Gov_Active, A + jmp calc_governor_target_exit + +governor_activate: + mov Gov_Active, #1 +governor_target_calc: + ; Governor calculations + clr C + mov Temp2, #Pgm_Gov_Range + mov A, @Temp2 ; Check high or low range (Temp2 has #Pgm_Gov_Range) + subb A, #2 + jz calc_governor_target_low + + mov A, Governor_Req_Pwm ; Load governor requested pwm + cpl A ; Calculate 255-pwm (invert pwm) + ; Calculate comm period target (1 + 2*((255-Requested_Pwm)/256) - 0.25) + rlc A ; Msb to carry + rlc A ; To bit0 + mov Temp2, A ; Now 1 lsb is valid for H + rrc A + mov Temp1, A ; Now 7 msbs are valid for L + mov A, Temp2 + anl A, #01h ; Calculate H byte + inc A ; Add 1 + mov Temp2, A + mov A, Temp1 + anl A, #0FEh ; Calculate L byte + clr C + subb A, #40h ; Subtract 0.25 + mov Temp1, A + mov A, Temp2 + subb A, #0 + mov Temp2, A + jmp calc_governor_store_target + +calc_governor_target_low: + mov A, Governor_Req_Pwm ; Load governor requested pwm + cpl A ; Calculate 255-pwm (invert pwm) + ; Calculate comm period target (2 + 8*((255-Requested_Pwm)/256) - 0.25) + rlc A ; Msb to carry + rlc A ; To bit0 + rlc A ; To bit1 + rlc A ; To bit2 + mov Temp2, A ; Now 3 lsbs are valid for H + rrc A + mov Temp1, A ; Now 4 msbs are valid for L + mov A, Temp2 + anl A, #07h ; Calculate H byte + inc A ; Add 1 + inc A ; Add 1 more + mov Temp2, A + mov A, Temp1 + anl A, #0F8h ; Calculate L byte + clr C + subb A, #40h ; Subtract 0.25 + mov Temp1, A + mov A, Temp2 + subb A, #0 + mov Temp2, A + +calc_governor_store_target: + ; Store governor target + mov Gov_Target_L, Temp1 + mov Gov_Target_H, Temp2 +calc_governor_target_exit: + ret +ENDIF +IF MODE == 2 ; Multi +calc_governor_target: +;读取 Closed loop mode + mov Temp1, #Pgm_Gov_Mode ; Closed loop mode? + cjne @Temp1, #1, governor_target_calc ; Yes - branch +;Closed loop mode = 第4项 Off + jmp calc_governor_target_exit ; No + +governor_target_calc: + ; Stop governor for stop RC pulse + clr C + mov A, New_Rcp ; Check RC pulse against stop value + subb A, #RCP_STOP ; Is pulse below stop value? + jc governor_deactivate ; Yes - deactivate + + jmp governor_activate ; No - activate + +governor_deactivate: + mov Current_Pwm, Requested_Pwm ; Set current pwm to requested + clr A + mov Gov_Target_L, A ; Set target to zero + mov Gov_Target_H, A + mov Gov_Integral_L, A ; Set integral to zero + mov Gov_Integral_H, A + mov Gov_Integral_X, A + mov Gov_Active, A + jmp calc_governor_target_exit + +governor_activate: + mov Temp1, #Pgm_Gov_Mode ; Store gov mode + mov A, @Temp1 + mov Temp5, A + mov Gov_Active, #1 + mov A, Requested_Pwm ; Load requested pwm + mov Governor_Req_Pwm, A ; Set governor requested pwm + ; Calculate comm period target 2*(51000/Requested_Pwm) + mov Temp1, #38h ; Load 51000 + mov Temp2, #0C7h + mov Temp3, Comm_Period4x_L ; Load comm period + mov Temp4, Comm_Period4x_H + ; Set speed range. Bare Comm_Period4x corresponds to 400k rpm, because it is 500n units +;Closed loop mode = 第1项 HiRange + clr C + mov A, Temp4 + rrc A + mov Temp4, A + mov A, Temp3 + rrc A + mov Temp3, A ; 200k eRPM range here + ; Check range + mov A, Temp5 + dec A + dec A + dec A + dec A + jz governor_activate_range_set ; 200k eRPM? - branch +;Closed loop mode = 第2项 MidRange +governor_activate_100k: + clr C + mov A, Temp4 + rrc A + mov Temp4, A + mov A, Temp3 + rrc A + mov Temp3, A ; 100k eRPM range here + mov A, Temp5 ; Check range again + dec A + dec A + dec A + jz governor_activate_range_set ; 100k eRPM? - branch +;Closed loop mode = 第3项 LoRange +governor_activate_50k: + clr C + mov A, Temp4 + rrc A + mov Temp4, A + mov A, Temp3 + rrc A + mov Temp3, A ; 50k eRPM range here +governor_activate_range_set: + call div_u16_by_u16 + ; Store governor target + mov Gov_Target_L, Temp1 + mov Gov_Target_H, Temp2 +calc_governor_target_exit: + ret +ENDIF + +; Second governor routine - calculate governor proportional error +calc_governor_prop_error: + ; Exit if governor is inactive + mov A, Gov_Active + jz calc_governor_prop_error_exit + +IF MODE <= 1 ; Main or tail + ; Load comm period and divide by 2 + clr C + mov A, Comm_Period4x_H + rrc A + mov Temp2, A + mov A, Comm_Period4x_L + rrc A + mov Temp1, A + ; Calculate error + clr C + mov A, Gov_Target_L + subb A, Temp1 + mov Temp1, A + mov A, Gov_Target_H + subb A, Temp2 + mov Temp2, A +ENDIF +IF MODE == 2 ; Multi + ; Calculate error + clr C + mov A, Gov_Target_L + subb A, Governor_Req_Pwm + mov Temp1, A + mov A, Gov_Target_H + subb A, #0 + mov Temp2, A +ENDIF + ; Check error and limit + jnc governor_check_prop_limit_pos ; Check carry + + clr C + mov A, Temp1 + subb A, #80h ; Is error too negative? + mov A, Temp2 + subb A, #0FFh + jc governor_limit_prop_error_neg ; Yes - limit + jmp governor_store_prop_error + +governor_check_prop_limit_pos: + clr C + mov A, Temp1 + subb A, #7Fh ; Is error too positive? + mov A, Temp2 + subb A, #00h + jnc governor_limit_prop_error_pos ; Yes - limit + jmp governor_store_prop_error + +governor_limit_prop_error_pos: + mov Temp1, #7Fh ; Limit to max positive (2's complement) + mov Temp2, #00h + jmp governor_store_prop_error + +governor_limit_prop_error_neg: + mov Temp1, #80h ; Limit to max negative (2's complement) + mov Temp2, #0FFh + +governor_store_prop_error: + ; Store proportional + mov Gov_Proportional_L, Temp1 + mov Gov_Proportional_H, Temp2 +calc_governor_prop_error_exit: + ret + + +; Third governor routine - calculate governor integral error +calc_governor_int_error: + ; Exit if governor is inactive + mov A, Gov_Active + jz calc_governor_int_error_exit + + ; Add proportional to integral + mov A, Gov_Proportional_L + add A, Gov_Integral_L + mov Temp1, A + mov A, Gov_Proportional_H + addc A, Gov_Integral_H + mov Temp2, A + mov Bit_Access, Gov_Proportional_H ; Sign extend high byte + clr A + jnb Bit_Access.7, ($+4) + cpl A + addc A, Gov_Integral_X + mov Temp3, A + ; Check integral and limit + jnb ACC.7, governor_check_int_limit_pos ; Check sign bit + + clr C + mov A, Temp3 + subb A, #0F0h ; Is error too negative? + jc governor_limit_int_error_neg ; Yes - limit + jmp governor_check_pwm + +governor_check_int_limit_pos: + clr C + mov A, Temp3 + subb A, #0Fh ; Is error too positive? + jnc governor_limit_int_error_pos ; Yes - limit + jmp governor_check_pwm + +governor_limit_int_error_pos: + mov Temp1, #0FFh ; Limit to max positive (2's complement) + mov Temp2, #0FFh + mov Temp3, #0Fh + jmp governor_check_pwm + +governor_limit_int_error_neg: + mov Temp1, #00h ; Limit to max negative (2's complement) + mov Temp2, #00h + mov Temp3, #0F0h + +governor_check_pwm: + ; Check current pwm + clr C + mov A, Current_Pwm + subb A, Pwm_Limit ; Is current pwm at or above pwm limit? + jnc governor_int_max_pwm ; Yes - branch + + mov A, Current_Pwm ; Is current pwm at zero? + jz governor_int_min_pwm ; Yes - branch + + ajmp governor_store_int_error ; No - store integral error + +governor_int_max_pwm: + mov A, Gov_Proportional_H + jb ACC.7, calc_governor_int_error_exit ; Is proportional error negative - branch (high byte is always zero) + ajmp governor_store_int_error ; Positive - store integral error + +governor_int_min_pwm: + mov A, Gov_Proportional_H + jnb ACC.7, calc_governor_int_error_exit ; Is proportional error positive - branch (high byte is always zero) + +governor_store_int_error: + ; Store integral + mov Gov_Integral_L, Temp1 + mov Gov_Integral_H, Temp2 + mov Gov_Integral_X, Temp3 +calc_governor_int_error_exit: + ret + + +; Fourth governor routine - calculate governor proportional correction +calc_governor_prop_correction: + ; Exit if governor is inactive + mov A, Gov_Active + jnz calc_governor_prop_corr + jmp calc_governor_prop_corr_exit + +calc_governor_prop_corr: + ; Load proportional gain + mov Temp1, #Pgm_Gov_P_Gain_Decoded; Load proportional gain + mov A, @Temp1 + mov Temp3, A ; Store in Temp3 + ; Load proportional + clr C + mov A, Gov_Proportional_L ; Nominal multiply by 2 + rlc A + mov Temp1, A + mov A, Gov_Proportional_H + rlc A + mov Temp2, A + ; Apply gain + call mult_s16_by_u8_div_16 + ; Check error and limit (to low byte) + mov A, Temp2 + jnb ACC.7, governor_check_prop_corr_limit_pos ; Check sign bit + + clr C + mov A, Temp1 + subb A, #80h ; Is error too negative? + mov A, Temp2 + subb A, #0FFh + jc governor_limit_prop_corr_neg ; Yes - limit + ajmp governor_apply_prop_corr + +governor_check_prop_corr_limit_pos: + clr C + mov A, Temp1 + subb A, #7Fh ; Is error too positive? + mov A, Temp2 + subb A, #00h + jnc governor_limit_prop_corr_pos ; Yes - limit + ajmp governor_apply_prop_corr + +governor_limit_prop_corr_pos: + mov Temp1, #7Fh ; Limit to max positive (2's complement) + mov Temp2, #00h + ajmp governor_apply_prop_corr + +governor_limit_prop_corr_neg: + mov Temp1, #80h ; Limit to max negative (2's complement) + mov Temp2, #0FFh + +governor_apply_prop_corr: + ; Test proportional sign + mov A, Temp1 + jb ACC.7, governor_corr_neg_prop ; If proportional negative - go to correct negative + + ; Subtract positive proportional + clr C + mov A, Governor_Req_Pwm + subb A, Temp1 + mov Temp1, A + ; Check result + jc governor_corr_prop_min_pwm ; Is result negative? + + clr C + mov A, Temp1 ; Is result below pwm min? + subb A, #1 + jc governor_corr_prop_min_pwm ; Yes + jmp governor_store_prop_corr ; No - store proportional correction + +governor_corr_prop_min_pwm: + mov Temp1, #1 ; Load minimum pwm + jmp governor_store_prop_corr + +governor_corr_neg_prop: + ; Add negative proportional + mov A, Temp1 + cpl A + add A, #1 + add A, Governor_Req_Pwm + mov Temp1, A + ; Check result + jc governor_corr_prop_max_pwm ; Is result above max? + jmp governor_store_prop_corr ; No - store proportional correction + +governor_corr_prop_max_pwm: + mov Temp1, #255 ; Load maximum pwm +governor_store_prop_corr: + ; Store proportional pwm + mov Gov_Prop_Pwm, Temp1 +calc_governor_prop_corr_exit: + ret + + +; Fifth governor routine - calculate governor integral correction +calc_governor_int_correction: + ; Exit if governor is inactive + mov A, Gov_Active + jnz calc_governor_int_corr + jmp calc_governor_int_corr_exit + +calc_governor_int_corr: + ; Load integral gain + mov Temp1, #Pgm_Gov_I_Gain_Decoded; Load integral gain + mov A, @Temp1 + mov Temp3, A ; Store in Temp3 + ; Load integral + mov Temp1, Gov_Integral_H + mov Temp2, Gov_Integral_X + ; Apply gain + call mult_s16_by_u8_div_16 + ; Check integral and limit + mov A, Temp2 + jnb ACC.7, governor_check_int_corr_limit_pos ; Check sign bit + + clr C + mov A, Temp1 + subb A, #01h ; Is integral too negative? + mov A, Temp2 + subb A, #0FFh + jc governor_limit_int_corr_neg ; Yes - limit + jmp governor_apply_int_corr + +governor_check_int_corr_limit_pos: + clr C + mov A, Temp1 + subb A, #0FFh ; Is integral too positive? + mov A, Temp2 + subb A, #00h + jnc governor_limit_int_corr_pos ; Yes - limit + jmp governor_apply_int_corr + +governor_limit_int_corr_pos: + mov Temp1, #0FFh ; Limit to max positive (2's complement) + mov Temp2, #00h + jmp governor_apply_int_corr + +governor_limit_int_corr_neg: + mov Temp1, #01h ; Limit to max negative (2's complement) + mov Temp2, #0FFh + +governor_apply_int_corr: + ; Test integral sign + mov A, Temp2 + jb ACC.7, governor_corr_neg_int ; If integral negative - go to correct negative + + ; Subtract positive integral + clr C + mov A, Gov_Prop_Pwm + subb A, Temp1 + mov Temp1, A + ; Check result + jc governor_corr_int_min_pwm ; Is result negative? + + clr C + mov A, Temp1 ; Is result below pwm min? + subb A, #1 + jc governor_corr_int_min_pwm ; Yes + jmp governor_store_int_corr ; No - store correction + +governor_corr_int_min_pwm: + mov Temp1, #0 ; Load minimum pwm + jmp governor_store_int_corr + +governor_corr_neg_int: + ; Add negative integral + mov A, Temp1 + cpl A + add A, #1 + add A, Gov_Prop_Pwm + mov Temp1, A + ; Check result + jc governor_corr_int_max_pwm ; Is result above max? + jmp governor_store_int_corr ; No - store correction + +governor_corr_int_max_pwm: + mov Temp1, #255 ; Load maximum pwm +governor_store_int_corr: + ; Store current pwm + mov Current_Pwm, Temp1 +calc_governor_int_corr_exit: + ret + + +;**** **** **** **** **** **** **** **** **** **** **** **** **** +; +; Measure lipo cells +; +; No assumptions +; +; Measure voltage and calculate lipo cells +; +;**** **** **** **** **** **** **** **** **** **** **** **** **** +measure_lipo_cells: +IF MODE == 1 ; Tail + ; If tail, then exit + jmp measure_lipo_exit +ENDIF +measure_lipo_start: + ; Load programmed low voltage limit +;读取Low voltage limit + mov Lipo_Cell_Count, #0 ;2013.8.23 防止接收机拿掉后再接上时，电池检测出错 + mov Temp1, #Pgm_Low_Voltage_Lim ; Load limit + mov A, @Temp1 + mov Bit_Access, A ; Store in Bit_Access + ; Set commutation to BpFET on +; call comm5comm6 + CnFET_off ; Cn off + BnFET_on ; Bn on + Set_Comp_Phase_C ; Set comparator to phase C + mov Comm_Phase, #6 + ; Start adc + Start_Adc + ; Wait for ADC conversion to complete + Get_Adc_Status + jb AD0BUSY, measure_lipo_cells + ; Read ADC result + Read_Adc_Result + ; Stop ADC + Stop_Adc + ; Switch power off + call switch_power_off + ; Set limit step + mov Lipo_Adc_Limit_L, #ADC_LIMIT_L + mov Lipo_Adc_Limit_H, #ADC_LIMIT_H + clr C + mov A, #ADC_LIMIT_H ; Divide 2.8V value by 2 + rrc A + mov Temp6, A + mov A, #ADC_LIMIT_L + rrc A + mov Temp5, A + mov A, #ADC_LIMIT_L ; Calculate 1.4+2.8V=4.2V value + add A, Temp5 + add A, #3 ;加宽一节电池电压范围 4.3V 2013.8.16 + mov Temp5, A + mov A, #ADC_LIMIT_H + addc A, Temp6 + mov Temp6, A + mov A, Temp5 ; Copy step + mov Temp3, A + mov A, Temp6 + mov Temp4, A +;*************************************************** +; Lipo节数检测 +;*************************************************** +measure_lipo_cell_loop: + ; Check voltage against xS lower limit + inc Lipo_Cell_Count ;增加电池节数累加 2013.5.29 + clr C + mov A, Temp1 + subb A, Temp3 ; Voltage above limit? + mov A, Temp2 + subb A, Temp4 + jc measure_lipo_adjust ; No - branch 读取到电压范围 + + ; Set xS voltage limit + mov A, Lipo_Adc_Limit_L + add A, #ADC_LIMIT_L + mov Lipo_Adc_Limit_L, A + mov A, Lipo_Adc_Limit_H + addc A, #ADC_LIMIT_H + mov Lipo_Adc_Limit_H, A + ; Set (x+1)S lower limit + mov A, Temp3 + add A, Temp5 ; Add step + mov Temp3, A + mov A, Temp4 + addc A, Temp6 + mov Temp4, A + jmp measure_lipo_cell_loop ; Check for one more battery cell + +measure_lipo_adjust: + mov Temp7, Lipo_Adc_Limit_L + mov Temp8, Lipo_Adc_Limit_H + ; Calculate 3.125% + clr C + mov A, Lipo_Adc_Limit_H + rrc A + mov Temp2, A + mov A, Lipo_Adc_Limit_L + rrc A + mov Temp1, A ; After this 50% + clr C + mov A, Temp2 + rrc A + mov Temp2, A + mov A, Temp1 + rrc A + mov Temp1, A ; After this 25% +; mov A, Lipo_Adc_Limit_L ; Set adc reference for voltage compensation +; add A, Temp1 ;低压低字节+低压低字节偏移量 +; mov Lipo_Adc_Reference_L, A ;存低压低字节 +; mov A, Lipo_Adc_Limit_H +; addc A, Temp2 ;低压高字节+低压高字节偏移量 +; mov Lipo_Adc_Reference_H, A ;存低压高字节 +; ; Divide three times to get to 3.125% 6.25% 2013.5.30 + mov Temp3, #2 ;3 +measure_lipo_divide_loop: + clr C + mov A, Temp2 + rrc A + mov Temp2, A + mov A, Temp1 + rrc A + mov Temp1, A + djnz Temp3, measure_lipo_divide_loop + + ; Add the programmed number of 0.1V (or 3.125% increments) + mov Temp3, Bit_Access ; Load programmed limit (Bit_Access has Pgm_Low_Voltage_Lim) +; dec Temp3 +; mov A,Temp3 ;增加判断指令，如果没有这条指令能判断？？？？ +; jnz measure_lipo_limit_on ; Is low voltage limiting on? + + cjne Temp3, #4, measure_lipo_limit_on + + mov Lipo_Adc_Limit_L, #0 ; No - set limit to zero + mov Lipo_Adc_Limit_H, #0 + jmp measure_lipo_exit + +measure_lipo_limit_on: + dec Temp3 + mov A, Temp3 + jz measure_lipo_update +;Bit_Access>2时，低压保护值=基值+偏移量 +;Low voltage limit > 第2项时 +measure_lipo_add_loop: + clr C + mov A, Temp7 ; Add 3.125% + add A, Temp1 + mov Temp7, A + mov A, Temp8 + addc A, Temp2 + mov Temp8, A +; clr C +; mov A, Temp7 ; Add 3.125% +; add A, Temp1 +; mov Temp7, A +; mov A, Temp8 +; addc A, Temp2 +; mov Temp8, A + djnz Temp3, measure_lipo_add_loop +;存低压保护值 +;Low voltage limit = 第2项 3.0V +measure_lipo_update: + ; Set ADC limit + mov Lipo_Adc_Limit_L, Temp7 + mov Lipo_Adc_Limit_H, Temp8 +measure_lipo_exit: + ret + + +;**** **** **** **** **** **** **** **** **** **** **** **** **** +; +; Start ADC conversion +; +; No assumptions +; +; Start conversion used for measuring power supply voltage +; +;**** **** **** **** **** **** **** **** **** **** **** **** **** +start_adc_conversion: + ; Start adc + Start_Adc + ret + + +;**** **** **** **** **** **** **** **** **** **** **** **** **** +; +; Check temperature, power supply voltage and limit power +; +; No assumptions +; +; Used to limit main motor power in order to maintain the required voltage +; +;**** **** **** **** **** **** **** **** **** **** **** **** **** +check_temp_voltage_and_limit_power: + ; Load programmed low voltage limit + mov Temp1, #Pgm_Low_Voltage_Lim ;读低压保护选项 + mov A, @Temp1 + mov Temp8, A ; Store in Temp8 + ; Wait for ADC conversion to complete + Get_Adc_Status + jb AD0BUSY, check_temp_voltage_and_limit_power + ; Read ADC result + Read_Adc_Result ;读AD值 + ; Stop ADC + Stop_Adc ;禁止AD转换 + + inc Adc_Conversion_Cnt ; Increment conversion counter + clr C + mov A, Adc_Conversion_Cnt ; Is conversion count equal to temp rate? + subb A, #TEMP_CHECK_RATE + jc check_voltage_start ; No - check voltage AD转换次数 < 8次 ？ + + mov Adc_Conversion_Cnt, #0 ; Yes - temperature check. Reset counter + mov A, Temp2 ; Is temperature reading below 256? + jnz temp_average_inc_dec ; No - proceed + + mov A, Current_Average_Temp ; Yes - decrement average + jz temp_average_updated ; Already zero - no change + jmp temp_average_dec ; Decrement + +temp_average_inc_dec: + clr C + mov A, Temp1 ; Check if current temperature is above or below average + subb A, Current_Average_Temp + jz temp_average_updated_load_acc ; Equal - no change + + mov A, Current_Average_Temp ; Above - increment average + jnc temp_average_inc + + jz temp_average_updated ; Below - decrement average if average is not already zero +temp_average_dec: + dec A ; Decrement average + jmp temp_average_updated + +temp_average_inc: + inc A ; Increment average + jz temp_average_dec + jmp temp_average_updated + +temp_average_updated_load_acc: + mov A, Current_Average_Temp +temp_average_updated: + mov Current_Average_Temp, A + clr C + subb A, #TEMP_LIMIT ; Is temperature below first limit? + mov Temp1, A + jc temp_check_exit ; Yes - exit + + mov Pwm_Limit, #192 ; No - limit pwm + + clr C + mov A, Temp1 ; Is temperature below second limit + subb A, #TEMP_LIMIT_STEP + mov Temp1, A + jc temp_check_exit ; Yes - exit + + mov Pwm_Limit, #128 ; No - limit pwm + + clr C + mov A, Temp1 ; Is temperature below third limit + subb A, #TEMP_LIMIT_STEP + mov Temp1, A + jc temp_check_exit ; Yes - exit + + mov Pwm_Limit, #64 ; No - limit pwm + + clr C + mov A, Temp1 ; Is temperature below final limit + subb A, #TEMP_LIMIT_STEP + mov Temp1, A + jc temp_check_exit ; Yes - exit + + mov Pwm_Limit, #16 ; No - limit pwm 2013.8.5最高温度时速度由0改成16 + +temp_check_exit: + Set_Adc_Ip_Volt ; Select adc input for next conversion + ret + +check_voltage_start: +IF MODE == 0 OR MODE == 2 ; Main or multi + ; Check if low voltage limiting is enabled + mov A, Temp8 + clr C + subb A, #4 ; Is low voltage limit disabled? + jz check_voltage_good ; Yes - voltage declared good + + ; Check if ADC is saturated + clr C + mov A, Temp1 ;读取AD值低字节 + subb A, #0FFh + mov A, Temp2 ;读取AD值高字节 + subb A, #03h ;判断AD是否超出10位AD范围 + jnc check_voltage_good ; ADC saturated, can not make judgement + + ; Check voltage against limit + clr C + mov A, Temp1 + subb A, Lipo_Adc_Limit_L + mov A, Temp2 + subb A, Lipo_Adc_Limit_H + jnc check_voltage_good ; If voltage above limit - branch 电压值 > 低压设置值 + + mov Temp1, #Pgm_Low_Voltage_Ctl ;读低压保护控制方式选项 + mov A, @Temp1 + clr C + subb A, #1 ; + jz check_voltage_next_way + + mov A, Pwm_Limit + subb A, #5 + jnc check_limit_count + setb LOW_LIMIT_STOP ;设置低压保护控制方式2 低压停止标志 + ljmp run_to_wait_for_power_on + +check_voltage_next_way: + ; Decrease pwm limit + mov A, Pwm_Limit + subb A, #80 ;更改低压保护方式 2013.05.31 +;////// jz check_voltage_lim ; If limit zero - branch + jc check_voltage_lim ; If limit <100 - branch +check_limit_count: + mov A, Limit_Count + jz ($+6) + dec Limit_Count ;递减低压保护变量 2013.7.5 + ajmp check_voltage_lim + + mov Limit_Count, #5 ; 2013.7.5 + dec Pwm_Limit ; Decrement limit + jmp check_voltage_lim +;Low voltage limit = 第1项 +check_voltage_good: + ; Increase pwm limit + mov Limit_Count, #5 ; 2013.7.5 + mov A, Pwm_Limit + cpl A + jz check_voltage_lim ; If limit max - branch + + inc Pwm_Limit ; Increment limit + +check_voltage_lim: + mov Temp1, Pwm_Limit ; Set limit + clr C + mov A, Current_Pwm + subb A, Temp1 + jnc check_voltage_spoolup_lim ; If current pwm above limit - branch and limit + + mov Temp1, Current_Pwm ; Set current pwm (no limiting) + +check_voltage_spoolup_lim: + mov Current_Pwm_Limited, Temp1 ;取小值 + ; Slow spoolup + clr C + mov A, Current_Pwm_Limited + subb A, Pwm_Limit_Spoolup + jc check_voltage_exit ; If current pwm below limit - branch + + mov Current_Pwm_Limited, Pwm_Limit_Spoolup ;取小值 + mov A, Pwm_Limit_Spoolup ; Check if spoolup limit is max + cpl A + jz check_voltage_exit ; If max - branch + + mov Pwm_Limit, Pwm_Limit_Spoolup ; Set pwm limit to spoolup limit during ramp (to avoid governor integral buildup) + +check_voltage_exit: +ENDIF + ; Set adc mux for next conversion + clr C + mov A, Adc_Conversion_Cnt ; Is next conversion for temperature? + cjne A, #(TEMP_CHECK_RATE-1), ($+6) + + Set_Adc_Ip_Temp ; Select temp sensor for next conversion + + ret + + +;**** **** **** **** **** **** **** **** **** **** **** **** **** +; +; Set startup PWM routine +; +; No assumptions +; +; Used for pwm control during startup +; +;**** **** **** **** **** **** **** **** **** **** **** **** **** +set_startup_pwm: + ; Set pwm values according to startup phase flags + jnb Flags1.SETTLE_PHASE, ($+5) ; Is it motor start settle phase? 是否启动定位？ + mov Temp1, #PWM_SETTLE ; Yes - set settle power + jnb Flags1.STEPPER_PHASE, ($+5) ; Is it motor start stepper phase? 是否步进启动？ + mov Temp1, #PWM_STEPPER ; Yes - set stepper power + + ; Update pwm variables if any startup phase flag is set + mov A, Flags1 + anl A, #((1 SHL SETTLE_PHASE)+(1 SHL STEPPER_PHASE)) + jz startup_pwm_exit ; If no startup phase set - exit + + ; Adjust startup power + mov A, Temp1 ; Multiply startup power by programmed value + mov Temp2, #Pgm_Startup_Pwr_Decoded + mov B, @Temp2 + mul AB + xch A, B + mov C, B.7 ; Multiply result by 2 (unity gain is 128) + rlc A + mov Temp1, A ; Transfer to Temp1 + clr C + mov A, Temp1 ; Check against limit + subb A, Pwm_Limit + jc startup_pwm_set_pwm ; If pwm below limit - branch + + mov Temp1, Pwm_Limit ; Limit pwm + +startup_pwm_set_pwm: + ; Set pwm variables + mov Requested_Pwm, Temp1 ; Update requested pwm + mov Current_Pwm, Temp1 ; Update current pwm + mov Current_Pwm_Limited, Temp1 ; Update limited version of current pwm + jnb Flags1.SETTLE_PHASE, startup_pwm_exit ; Is it motor start settle phase? + + clr C ; Yes - update spoolup beginning pwm (will use PWM_SETTLE or PWM_SETTLE/2) + mov A, Temp1 + mov Pwm_Spoolup_Beg, A + +startup_pwm_exit: + ret + + +;**** **** **** **** **** **** **** **** **** **** **** **** **** +; +; Initialize all timings routine +; +; No assumptions +; +; Part of initialization before motor start +; +;**** **** **** **** **** **** **** **** **** **** **** **** **** +initialize_all_timings: + ; Load programmed startup rpm +;读取Startup rpm +; mov Temp1, #Pgm_Startup_Rpm ; Load startup rpm +; mov A, @Temp1 +; mov Temp8, A ; Store in Temp8 + ; Check startup rpm setting and set step accordingly +; clr C +; mov A, Temp8 +; subb A, #5 +; jnc stepper_step_high +; clr C +; mov A, Temp8 +; subb A, #4 +; jnc stepper_step_med_high +; clr C +; mov A, Temp8 +; subb A, #3 +; jnc stepper_step_med +; clr C +; mov A, Temp8 +; subb A, #2 +; jnc stepper_step_med_low +; clr C +; mov A, Temp8 +; subb A, #1 +; jnc stepper_step_low +;Startup_Rpm = 第5项 +;stepper_step_high: +; mov Stepper_Step_Beg_L, #low(2000 SHL 1) +; mov Stepper_Step_Beg_H, #high(2000 SHL 1) +; mov Stepper_Step_End_L, #low(670 SHL 1) +; mov Stepper_Step_End_H, #high(670 SHL 1) +; ajmp stepper_step_set +;Startup_Rpm = 第4项 +;stepper_step_med_high: +; mov Stepper_Step_Beg_L, #low(2400 SHL 1) +; mov Stepper_Step_Beg_H, #high(2400 SHL 1) +; mov Stepper_Step_End_L, #low(800 SHL 1) +; mov Stepper_Step_End_H, #high(800 SHL 1) +; ajmp stepper_step_set +;Startup_Rpm = 第3项 +;stepper_step_med: +; mov Stepper_Step_Beg_L, #low(3000 SHL 1) ; ~3300 eRPM +; mov Stepper_Step_Beg_H, #high(3000 SHL 1) +; mov Stepper_Step_End_L, #low(1000 SHL 1) ; ~10000 eRPM +; mov Stepper_Step_End_H, #high(1000 SHL 1) +; ajmp stepper_step_set +;Startup_Rpm = 第2项 +;stepper_step_med_low: +; mov Stepper_Step_Beg_L, #low(3750 SHL 1) +; mov Stepper_Step_Beg_H, #high(3750 SHL 1) +; mov Stepper_Step_End_L, #low(1250 SHL 1) +; mov Stepper_Step_End_H, #high(1250 SHL 1) +; ajmp stepper_step_set +;Startup_Rpm = 第1项 +;stepper_step_low: +; mov Stepper_Step_Beg_L, #low(4500 SHL 1) +; mov Stepper_Step_Beg_H, #high(4500 SHL 1) +; mov Stepper_Step_End_L, #low(1500 SHL 1) +; mov Stepper_Step_End_H, #high(1500 SHL 1) +; ajmp stepper_step_set + +;stepper_step_set: +; mov Wt_Stepper_Step_L, Stepper_Step_Beg_L ; Initialize stepper step time +; mov Wt_Stepper_Step_H, Stepper_Step_Beg_H + mov Comm_Period4x_L, #00h ; Set commutation period registers + mov Comm_Period4x_H, #08h + ret + + +;**** **** **** **** **** **** **** **** **** **** **** **** **** +; +; Calculate next commutation timing routine +; +; No assumptions +; +; Called immediately after each commutation +; Also sets up timer 1 to wait advance timing +; Two entry points are used +; +;**** **** **** **** **** **** **** **** **** **** **** **** **** +;calc_next_comm_timing_start: ; Entry point for startup +; mov Temp1, Wt_Stepper_Step_L ; Set up stepper step wait +; mov Temp2, Wt_Stepper_Step_H +; jmp read_timer + +calc_next_comm_timing: ; Entry point for run phase + mov Temp1, Wt_Advance_L ; Set up advance timing wait + mov Temp2, Wt_Advance_H +read_timer: + ; Set up next wait + mov TMR3CN, #00h ; Timer3 disabled + clr C + clr A + subb A, Temp1 ; Set wait to zero cross scan value + mov TMR3L, A + clr A + subb A, Temp2 + mov TMR3H, A + mov TMR3CN, #04h ; Timer3 enabled + setb Flags0.T3_PENDING + ; Read commutation time + mov TMR2CN, #20h ; Timer2 disabled + mov Temp1, TMR2L ; Load timer value + mov Temp2, TMR2H + mov TMR2CN, #24h ; Timer2 enabled + ; Calculate this commutation time + mov Temp3, Prev_Comm_L + mov Temp4, Prev_Comm_H + mov Prev_Comm_L, Temp1 ; Store timestamp as previous commutation + mov Prev_Comm_H, Temp2 + clr C + mov A, Temp1 + subb A, Temp3 ; Calculate the new commutation time + mov Temp1, A + mov A, Temp2 + subb A, Temp4 + mov Temp2, A + ; Calculate next zero cross scan timeout + mov Temp3, Comm_Period4x_L ; Comm_Period4x(-l-h-x) holds the time of 4 commutations + mov Temp4, Comm_Period4x_H + clr C + mov A, Temp4 + rrc A ; Divide by 2 + mov Temp6, A + mov A, Temp3 + rrc A + mov Temp5, A + clr C + mov A, Temp6 + rrc A ; Divide by 2 again + mov Temp6, A + mov A, Temp5 + rrc A + mov Temp5, A + clr C + mov A, Temp3 + subb A, Temp5 ; Subtract a quarter + mov Temp3, A + mov A, Temp4 + subb A, Temp6 + mov Temp4, A + + mov A, Temp3 + add A, Temp1 ; Add the new time + mov Temp3, A + mov A, Temp4 + addc A, Temp2 + mov Temp4, A + mov Comm_Period4x_L, Temp3 ; Store Comm_Period4x_X + mov Comm_Period4x_H, Temp4 + jc calc_next_comm_slow ; If period larger than 0xffff - go to slow case + + ret + +calc_next_comm_slow: + mov Comm_Period4x_L, #0FFh ; Set commutation period registers to very slow timing (0xffff) + mov Comm_Period4x_H, #0FFh + ret + + +;**** **** **** **** **** **** **** **** **** **** **** **** **** +; +; Wait advance timing routine +; +; No assumptions +; +; Waits for the advance timing to elapse +; Also sets up timer 1 to wait the zero cross scan wait time +; And has a separate entry point for just setting up zero cross scan wait +; +;**** **** **** **** **** **** **** **** **** **** **** **** **** +wait_advance_timing: + jnb Flags0.T3_PENDING, ($+5) + ajmp wait_advance_timing + +setup_zc_scan_wait: + mov TMR3CN, #00h ; Timer3 disabled + clr C + clr A + subb A, Wt_Zc_Scan_L ; Set wait to zero cross scan value + mov TMR3L, A + clr A + subb A, Wt_Zc_Scan_H + mov TMR3H, A + mov TMR3CN, #04h ; Timer3 enabled + setb Flags0.T3_PENDING + ret + + +;**** **** **** **** **** **** **** **** **** **** **** **** **** +; +; Calculate new wait times routine +; +; No assumptions +; +; Calculates new wait times +; +;**** **** **** **** **** **** **** **** **** **** **** **** **** +calc_new_wait_times: + ; Load programmed commutation timing +;读取Commutation timing + mov Temp1, #Pgm_Comm_Timing ; Load timing setting + mov A, @Temp1 + mov Temp8, A ; Store in Temp8 + mov Temp7, #(COMM_TIME_RED SHL 1) + jnb Flags0.DEMAG_DETECTED, calc_new_wait_check_startup ; Demag detected? + + mov Temp8, #5 ; Yes - set high timing + +calc_new_wait_check_startup: + jnb Flags1.DIRECT_STARTUP_PHASE, calc_new_wait_dir_start_set ; Set timing for direct start + + mov Temp8, #3 ; Set medium timing + mov Temp7, #0 ; Set no comm time reduction + +calc_new_wait_dir_start_set: + ; Load current commutation timing + mov Temp2, Comm_Period4x_H ; Load Comm_Period4x + mov Temp1, Comm_Period4x_L + mov Temp3, #4 ; Divide 4 times +divide_wait_times: + clr C + mov A, Temp2 + rrc A ; Divide by 2 + mov Temp2, A + mov A, Temp1 + rrc A + mov Temp1, A + djnz Temp3, divide_wait_times + + clr C + mov A, Temp1 + subb A, Temp7 + mov Temp1, A + mov A, Temp2 + subb A, #0 + mov Temp2, A + jc load_min_time ; Check that result is still positive + + clr C + mov A, Temp1 + subb A, #(COMM_TIME_MIN SHL 1) + mov A, Temp2 + subb A, #0 + jnc adjust_timing ; Check that result is still above minumum + +load_min_time: + mov Temp1, #(COMM_TIME_MIN SHL 1) + clr A + mov Temp2, A + +adjust_timing: + mov A, Temp2 ; Copy values + mov Temp4, A + mov A, Temp1 + mov Temp3, A + clr C + mov A, Temp2 + rrc A ; Divide by 2 + mov Temp6, A + mov A, Temp1 + rrc A + mov Temp5, A + clr C + mov A, Temp8 ; (Temp8 has Pgm_Comm_Timing) + subb A, #3 ; Is timing normal? + jz store_times_decrease ; Yes - branch + + mov A, Temp8 + jb ACC.0, adjust_timing_two_steps ; If an odd number - branch +;Commutation timing = 第2、4项 + mov A, Temp1 ; Add 7.5?and store in Temp1/2 + add A, Temp5 + mov Temp1, A + mov A, Temp2 + addc A, Temp6 + mov Temp2, A + mov A, Temp5 ; Store 7.5?in Temp3/4 + mov Temp3, A + mov A, Temp6 + mov Temp4, A + jmp store_times_up_or_down +;Commutation timing = 第1、5项 +adjust_timing_two_steps: + mov A, Temp1 ; Add 15?and store in Temp1/2 + add A, Temp1 + mov Temp1, A + mov A, Temp2 + addc A, Temp2 + mov Temp2, A + mov Temp3, #(COMM_TIME_MIN SHL 1) ; Store minimum time in Temp3/4 + clr A + mov Temp4, A + +store_times_up_or_down: + clr C + mov A, Temp8 + subb A, #3 ; Is timing higher than normal? + jc store_times_decrease ; No - branch +;Commutation timing = 第4、5项 +store_times_increase: + mov Wt_Comm_L, Temp3 ; Now commutation time (~60? divided by 4 (~15?nominal) + mov Wt_Comm_H, Temp4 + mov Wt_Advance_L, Temp1 ; New commutation advance time (~15?nominal) + mov Wt_Advance_H, Temp2 + mov Wt_Zc_Scan_L, Temp5 ; Use this value for zero cross scan delay (7.5? + mov Wt_Zc_Scan_H, Temp6 + ret +;Commutation timing = 第1、2、3项 +store_times_decrease: + mov Wt_Comm_L, Temp1 ; Now commutation time (~60? divided by 4 (~15?nominal) + mov Wt_Comm_H, Temp2 + mov Wt_Advance_L, Temp3 ; New commutation advance time (~15?nominal) + mov Wt_Advance_H, Temp4 + mov Wt_Zc_Scan_L, Temp5 ; Use this value for zero cross scan delay (7.5? + mov Wt_Zc_Scan_H, Temp6 + ret + + +;**** **** **** **** **** **** **** **** **** **** **** **** **** +; +; Wait before zero cross scan routine +; +; No assumptions +; +; Waits for the zero cross scan wait time to elapse +; Also sets up timer 1 to wait the zero cross scan timeout time +; +;**** **** **** **** **** **** **** **** **** **** **** **** **** +wait_before_zc_scan: + jnb Flags0.T3_PENDING, ($+5) + ajmp wait_before_zc_scan + + mov TMR3CN, #00h ; Timer3 disabled + clr C + clr A + subb A, Comm_Period4x_L ; Set wait to zero comm period 4x value + mov TMR3L, A + clr A + subb A, Comm_Period4x_H + mov TMR3H, A + mov TMR3CN, #04h ; Timer3 enabled + setb Flags0.T3_PENDING + ret + + +;**** **** **** **** **** **** **** **** **** **** **** **** **** +; +; Wait for comparator to go low/high routines +; +; No assumptions +; +; Waits for the zero cross scan wait time to elapse +; Then scans for comparator going low/high +; +;**** **** **** **** **** **** **** **** **** **** **** **** **** +wait_for_comp_out_low: + mov Comp_Wait_Reads, #0 + mov Bit_Access, #00h ; Desired comparator output + jmp wait_for_comp_out_start + +wait_for_comp_out_high: + mov Comp_Wait_Reads, #0 + mov Bit_Access, #40h ; Desired comparator output + +wait_for_comp_out_start: + setb EA ; Enable interrupts + inc Comp_Wait_Reads + jb Flags0.T3_PENDING, ($+4) ; Has zero cross scan timeout elapsed? + ret ; Yes - return + + ; Set default comparator response times + mov CPT0MD, #0 ; Set fast response (100ns) as default +IF COMP1_USED==1 + mov CPT1MD, #0 ; Set fast response (100ns) as default +ENDIF + ; Select number of comparator readings based upon current rotation speed + mov A, Comm_Period4x_H ; Load rotation period + clr C + rrc A ; Divide by 4 + clr C + rrc A + mov Temp1, A + inc Temp1 ; Add one to be sure it is always larger than zero + jz comp_wait_on_comp_able ; If minimum number of readings - jump directly to reading + ; For damped mode, do fewer comparator readings (since comparator info is primarily only available in the pwm on period) + jnb Flags2.PGM_PWMOFF_DAMPED, comp_wait_set_max_readings + + clr C + rrc A ; Divide by 4 again + clr C + rrc A + mov Temp1, A + inc Temp1 ; Add one to be sure it is always larger than zero + +comp_wait_set_max_readings: + clr C + mov A, Temp1 ; Limit to a max of 10 + subb A, #10 + jc ($+4) + + mov Temp1, #10 + + jnb Flags2.PGM_PWM_HIGH_FREQ, comp_wait_set_response_time ; Jump if pwm frequency is low + + clr C + mov A, Temp1 ; Limit to a max of 4 + subb A, #4 + jc ($+4) + + mov Temp1, #4 + +comp_wait_set_response_time: + clr C + mov A, Comm_Period4x_H ; Is Comm_Period4x_H less than 1ms? + subb A, #8 + jc comp_wait_on_comp_able ; Yes - jump + + mov CPT0MD, #2 ; Set medium response (300ns) +IF COMP1_USED==1 + mov CPT1MD, #2 ; Set medium response (300ns) +ENDIF + clr C + mov A, Comm_Period4x_H ; Is Comm_Period4x_H less than 2ms? + subb A, #16 + jc comp_wait_on_comp_able ; Yes - jump + + mov CPT0MD, #3 ; Set slow response (1000ns) +IF COMP1_USED==1 + mov CPT1MD, #3 ; Set slow response (1000ns) +ENDIF + +comp_wait_on_comp_able: + jb Flags0.T3_PENDING, ($+6) ; Has zero cross scan timeout elapsed? + setb EA ; Enable interrupts + ret ; Yes - return + + mov Temp2, #COMP_PWM_HIGH_ON_DELAY ; Wait time after pwm has been switched on (motor wire electrical settling) + jb Flags2.PGM_PWM_HIGH_FREQ, ($+5) + mov Temp2, #COMP_PWM_LOW_ON_DELAY + setb EA ; Enable interrupts + nop ; Allocate only just enough time to capture interrupt + nop + clr EA ; Disable interrupts + jb Flags0.PWM_ON, pwm_wait_startup ; If pwm on - proceed + + mov Temp2, #COMP_PWM_HIGH_OFF_DELAY ; Wait time after pwm has been switched off (motor wire electrical settling) + jb Flags2.PGM_PWM_HIGH_FREQ, ($+5) + mov Temp2, #COMP_PWM_LOW_OFF_DELAY + jnb Flags2.CURR_PWMOFF_COMP_ABLE, comp_wait_on_comp_able ; If comparator is not usable in pwm off - go back + +pwm_wait_startup: + jnb Flags1.DIRECT_STARTUP_PHASE, pwm_wait ; Set a long delay from pwm on/off events during direct startup + + mov Temp2, #120 +pwm_wait: + clr C + mov A, TL1 + subb A, Temp2 +IF DAMPED_MODE_ENABLE==0 + jc comp_wait_on_comp_able ; Re-evaluate pwm cycle for slower escs +ENDIF +IF DAMPED_MODE_ENABLE==1 ; Assume same pwm cycle for fast escs + jb Flags1.DIRECT_STARTUP_PHASE, ($+5) + jc pwm_wait + jc comp_wait_on_comp_able ; Re-evaluate pwm cycle during direct start +ENDIF + +comp_read: + Read_Comp_Out ; Read comparator output + cpl A + anl A, #40h + cjne A, Bit_Access, ($+5) ; If comparator output is correct - proceed + + ajmp wait_for_comp_out_start ; If comparator output is not correct - go back and restart + + djnz Temp1, comp_wait_on_comp_able ; Decrement readings counter - repeat comparator reading if not zero + + setb EA ; Enable interrupts + ret + + +;**** **** **** **** **** **** **** **** **** **** **** **** **** +; +; Evaluate comparator integrity +; +; No assumptions +; +; Checks comparator signal behaviour versus expected behaviour +; +;**** **** **** **** **** **** **** **** **** **** **** **** **** +evaluate_comparator_integrity: + clr Flags0.DEMAG_DETECTED ; Clear demag detected flag + ; Check if demag compensation is enabled +;读取Demag compensation + mov Temp1, #Pgm_Demag_Comp ; Load programmed demag compensation + mov A, @Temp1 + dec A + jz eval_comp_no_demag + + ; Check if a demag situation has occurred + mov A, Comp_Wait_Reads ; Check if there were no waits (there shall be some). If none a demag situation has occurred + dec A + jnz eval_comp_no_demag +;Demag compensation = 第2项 + setb Flags0.DEMAG_DETECTED ; Set demag detected flag +;Demag compensation = 第1项 +eval_comp_no_demag: + jnb Flags1.DIRECT_STARTUP_PHASE, eval_comp_check_timeout + + inc Direct_Startup_Ok_Cnt ; Increment ok counter + jb Flags0.T3_PENDING, eval_comp_exit + + mov Direct_Startup_Ok_Cnt, #0 ; Reset ok counter + jmp eval_comp_exit + +eval_comp_check_timeout: + jb Flags0.T3_PENDING, eval_comp_exit ; Has timeout elapsed? + dec SP ; Routine exit without "ret" command + dec SP + ljmp run_to_wait_for_power_on ; Yes - exit run mode + +eval_comp_exit: + ret + + +;**** **** **** **** **** **** **** **** **** **** **** **** **** +; +; Setup commutation timing routine +; +; No assumptions +; +; Sets up and starts wait from commutation to zero cross +; +;**** **** **** **** **** **** **** **** **** **** **** **** **** +setup_comm_wait: + mov TMR3CN, #00h ; Timer3 disabled + clr C + clr A + subb A, Wt_Comm_L ; Set wait commutation value + mov TMR3L, A + clr A + subb A, Wt_Comm_H + mov TMR3H, A + mov TMR3CN, #04h ; Timer3 enabled + setb Flags0.T3_PENDING + ret + + +;**** **** **** **** **** **** **** **** **** **** **** **** **** +; +; Wait for commutation routine +; +; No assumptions +; +; Waits from zero cross to commutation +; +;**** **** **** **** **** **** **** **** **** **** **** **** **** +wait_for_comm: + ; Store motor power + mov Temp7, Current_Pwm_Limited + ; Check if a demag situation has occurred + jnb Flags0.DEMAG_DETECTED, wait_for_comm_wait; Demag detected? + + ; Load programmed demag compensation + mov Temp1, #Pgm_Demag_Comp_Power_Decoded ; Yes - load programmed demag compensation power decoded + mov A, @Temp1 + mov Temp8, A ; Store in Temp8 + + ; Check for first power off + cjne Temp8, #1, wait_for_comm_blind + + setb Flags0.DEMAG_CUT_POWER ; Turn off motor power + mov Current_Pwm_Limited, #0 + All_nFETs_off + + ; Wait a blind wait +wait_for_comm_blind: + call setup_zc_scan_wait ; Setup a zero cross scan wait (7.5 deg) +wait_demag_default_zc1: + jnb Flags0.DEMAG_CUT_POWER, ($+6) ; Cut motor power if set + mov Current_Pwm_Limited, #0 + jnb Flags0.T3_PENDING, ($+5) + ajmp wait_demag_default_zc1 + + ; Check for second power off + cjne Temp8, #2, wait_for_comm_second_blind_wait + + setb Flags0.DEMAG_CUT_POWER ; Turn off motor power + mov Current_Pwm_Limited, #0 + All_nFETs_off + + ; Check for another blind wait +wait_for_comm_second_blind_wait: + mov Temp1, #Pgm_Demag_Comp_Wait_Decoded ; Yes - load programmed demag compensation wait decoded + cjne @Temp1, #1, wait_for_comm_power3 + + call setup_zc_scan_wait ; Setup a zero cross scan wait (7.5 deg) +wait_demag_default_zc2: + jnb Flags0.DEMAG_CUT_POWER, ($+6) ; Cut motor power if set + mov Current_Pwm_Limited, #0 + jnb Flags0.T3_PENDING, ($+5) + ajmp wait_demag_default_zc2 + +wait_for_comm_power3: + ; Check for third power off + cjne Temp8, #3, wait_for_comm_setup + + setb Flags0.DEMAG_CUT_POWER ; Turn off motor power + mov Current_Pwm_Limited, #0 + All_nFETs_off + +wait_for_comm_setup: + call setup_comm_wait ; Setup commutation wait +wait_for_comm_wait: + jnb Flags0.DEMAG_CUT_POWER, ($+6) ; Cut motor power if set + mov Current_Pwm_Limited, #0 + jnb Flags0.T3_PENDING, ($+5) + ajmp wait_for_comm_wait + + jnb Flags0.DEMAG_DETECTED, wait_for_comm_exit ; Was there a demag situation? + + clr Flags0.DEMAG_CUT_POWER ; Restore motor power again + mov Current_Pwm_Limited, Temp7 + +wait_for_comm_exit: + ret + + +;**** **** **** **** **** **** **** **** **** **** **** **** **** +; +; Commutation routines +; +; No assumptions +; +; Performs commutation switching +; Damped routines uses all pfets on when in pwm off to dampen the motor +; +;**** **** **** **** **** **** **** **** **** **** **** **** **** +;****************************************************** +; 关B down 并 开A down或Cdown +;****************************************************** +comm1comm2: + clr EA ; Disable all interrupts + BpFET_off ; Bp off + jb Flags2.PGM_PWMOFF_DAMPED, comm12_damp + jmp comm12_nondamp +comm12_damp: +IF DAMPED_MODE_ENABLE == 0 + mov DPTR, #pwm_cnfet_apfet_on_fast + jb Flags2.PGM_PWMOFF_DAMPED_LIGHT, comm12_nondamp +ENDIF +IF DAMPED_MODE_ENABLE == 1 + mov DPTR, #pwm_cnfet_apfet_on_safe +ENDIF + jnb Flags2.CURR_PWMOFF_DAMPED, comm12_nondamp ; If pwm off not damped - branch + CpFET_off + mov A, #NFETON_DELAY ; Delay + djnz ACC, $ +comm12_nondamp: + ApFET_on ; Ap on + Set_Comp_Phase_B ; Set comparator to phase B + mov Comm_Phase, #2 + setb EA ; Enable all interrupts + ret + +comm2comm3: + clr EA ; Disable all interrupts + jb Flags2.PGM_PWMOFF_DAMPED, comm23_damp + jmp comm23_nondamp +comm23_damp: +IF DAMPED_MODE_ENABLE == 0 + mov DPTR, #pwm_bnfet_apfet_on_fast +ENDIF +IF DAMPED_MODE_ENABLE == 1 + mov DPTR, #pwm_bnfet_apfet_on_safe +ENDIF + jnb Flags2.CURR_PWMOFF_DAMPED, comm23_nfet ; If pwm off not damped - branch + BpFET_off + CpFET_off + mov A, #NFETON_DELAY ; Delay + djnz ACC, $ + jmp comm23_nfet +comm23_nondamp: + mov DPTR, #pwm_bfet_on +comm23_nfet: + CnFET_off ; Cn off + jnb Flags0.PWM_ON, comm23_cp ; Is pwm on? + BnFET_on ; Yes - Bn on +comm23_cp: + Set_Comp_Phase_C ; Set comparator to phase C + mov Comm_Phase, #3 + setb EA ; Enable all interrupts + ret + +comm3comm4: + clr EA ; Disable all interrupts + ApFET_off ; Ap off + jb Flags2.PGM_PWMOFF_DAMPED, comm34_damp + jmp comm34_nondamp +comm34_damp: +IF DAMPED_MODE_ENABLE == 0 + mov DPTR, #pwm_bnfet_cpfet_on_fast + jb Flags2.PGM_PWMOFF_DAMPED_LIGHT, comm34_nondamp +ENDIF +IF DAMPED_MODE_ENABLE == 1 + mov DPTR, #pwm_bnfet_cpfet_on_safe +ENDIF + jnb Flags2.CURR_PWMOFF_DAMPED, comm34_nondamp ; If pwm off not damped - branch + BpFET_off + mov A, #NFETON_DELAY ; Delay + djnz ACC, $ +comm34_nondamp: + CpFET_on ; Cp on + Set_Comp_Phase_A ; Set comparator to phase A + mov Comm_Phase, #4 + setb EA ; Enable all interrupts + ret + +comm4comm5: + clr EA ; Disable all interrupts + jb Flags2.PGM_PWMOFF_DAMPED, comm45_damp + jmp comm45_nondamp +comm45_damp: +IF DAMPED_MODE_ENABLE == 0 + mov DPTR, #pwm_anfet_cpfet_on_fast +ENDIF +IF DAMPED_MODE_ENABLE == 1 + mov DPTR, #pwm_anfet_cpfet_on_safe +ENDIF + jnb Flags2.CURR_PWMOFF_DAMPED, comm45_nfet ; If pwm off not damped - branch + ApFET_off + BpFET_off + mov A, #NFETON_DELAY ; Delay + djnz ACC, $ + jmp comm45_nfet +comm45_nondamp: + mov DPTR, #pwm_afet_on +comm45_nfet: + BnFET_off ; Bn off + jnb Flags0.PWM_ON, comm45_cp ; Is pwm on? + AnFET_on ; Yes - An on +comm45_cp: + Set_Comp_Phase_B ; Set comparator to phase B + mov Comm_Phase, #5 + setb EA ; Enable all interrupts + ret + +comm5comm6: + clr EA ; Disable all interrupts + CpFET_off ; Cp off + jb Flags2.PGM_PWMOFF_DAMPED, comm56_damp + jmp comm56_nondamp +comm56_damp: +IF DAMPED_MODE_ENABLE == 0 + mov DPTR, #pwm_anfet_bpfet_on_fast + jb Flags2.PGM_PWMOFF_DAMPED_LIGHT, comm56_nondamp +ENDIF +IF DAMPED_MODE_ENABLE == 1 + mov DPTR, #pwm_anfet_bpfet_on_safe +ENDIF + jnb Flags2.CURR_PWMOFF_DAMPED, comm56_nondamp ; If pwm off not damped - branch + ApFET_off + mov A, #NFETON_DELAY ; Delay + djnz ACC, $ +comm56_nondamp: + BpFET_on ; Bp on + Set_Comp_Phase_C ; Set comparator to phase C + mov Comm_Phase, #6 + setb EA ; Enable all interrupts + ret + +comm6comm1: + clr EA ; Disable all interrupts + jb Flags2.PGM_PWMOFF_DAMPED, comm61_damp + jmp comm61_nondamp +comm61_damp: +IF DAMPED_MODE_ENABLE == 0 + mov DPTR, #pwm_cnfet_bpfet_on_fast +ENDIF +IF DAMPED_MODE_ENABLE == 1 + mov DPTR, #pwm_cnfet_bpfet_on_safe +ENDIF + jnb Flags2.CURR_PWMOFF_DAMPED, comm61_nfet ; If pwm off not damped - branch + ApFET_off + CpFET_off + mov A, #NFETON_DELAY ; Delay + djnz ACC, $ + jmp comm61_nfet +comm61_nondamp: + mov DPTR, #pwm_cfet_on +comm61_nfet: + AnFET_off ; An off + jnb Flags0.PWM_ON, comm61_cp ; Is pwm on? + CnFET_on ; Yes - Cn on +comm61_cp: + Set_Comp_Phase_A ; Set comparator to phase A + mov Comm_Phase, #1 + setb EA ; Enable all interrupts + ret + + +;**** **** **** **** **** **** **** **** **** **** **** **** **** +; +; Switch power off routine +; +; No assumptions +; +; Switches all fets off +; +;**** **** **** **** **** **** **** **** **** **** **** **** **** +switch_power_off: + mov DPTR, #pwm_nofet_on ; Set DPTR register to pwm_nofet_on label + All_pFETs_Off ; Turn off all pfets + All_nFETs_Off ; Turn off all nfets + ret + + +;**** **** **** **** **** **** **** **** **** **** **** **** **** +; +; Decrement stepper step routine +; +; No assumptions +; +; Decrements the stepper step +; +;**** **** **** **** **** **** **** **** **** **** **** **** **** +;decrement_stepper_step: +; clr C +; mov A, Wt_Stepper_Step_L +; subb A, Stepper_Step_End_L ; Minimum Stepper_Step_End +; mov A, Wt_Stepper_Step_H +; subb A, Stepper_Step_End_H +; jnc decrement_step ; Branch if same or higher than minimum +; ret + +;decrement_step: + ; Load programmed startup acceleration +;读取Startup acceleration +; mov Temp1, #Pgm_Startup_Accel ; Load startup accel +; mov A, @Temp1 +; mov Temp8, A ; Store in Temp8 + ; Check acceleration setting and set step size accordingly +; clr C +; mov A, Temp8 +; subb A, #5 +; jnc dec_step_high +; clr C +; mov A, Temp8 +; subb A, #4 +; jnc dec_step_med_high +; clr C +; mov A, Temp8 +; subb A, #3 +; jnc dec_step_med +; clr C +; mov A, Temp8 +; subb A, #2 +; jnc dec_step_med_low +; clr C +; mov A, Temp8 +; subb A, #1 +; jnc dec_step_low +;Start acceleration = 第5项 +;dec_step_high: +; clr C +; mov A, Wt_Stepper_Step_L +; subb A, #low(30 SHL 1) +; mov Temp1, A +; jmp decrement_step_exit +;Start acceleration = 第4项 +;dec_step_med_high: +; clr C +; mov A, Wt_Stepper_Step_L +; subb A, #low(20 SHL 1) +; mov Temp1, A +; jmp decrement_step_exit +;Start acceleration = 第3项 +;dec_step_med: +; clr C +; mov A, Wt_Stepper_Step_L +; subb A, #low(13 SHL 1) +; mov Temp1, A +; jmp decrement_step_exit +;Start acceleration = 第2项 +;dec_step_med_low: +; clr C +; mov A, Wt_Stepper_Step_L +; subb A, #low(9 SHL 1) +; mov Temp1, A +; jmp decrement_step_exit +;Start acceleration = 第1项 +;dec_step_low: +; clr C +; mov A, Wt_Stepper_Step_L +; subb A, #low(5 SHL 1) +; mov Temp1, A +; jmp decrement_step_exit + +;decrement_step_exit: +; mov A, Wt_Stepper_Step_H +; subb A, #0 +; mov Temp2, A +; mov Wt_Stepper_Step_L, Temp1 +; mov Wt_Stepper_Step_H, Temp2 +; ret + + +;**** **** **** **** **** **** **** **** **** **** **** **** **** +; +; Stepper timer wait +; +; No assumptions +; +; Waits for the stepper step timer to elapse +; +;**** **** **** **** **** **** **** **** **** **** **** **** **** +;stepper_timer_wait: +; jnb Flags0.T3_PENDING, ($+6) ; Timer pending? +; ljmp stepper_timer_wait ; Yes, go back +; ret + + +;**** **** **** **** **** **** **** **** **** **** **** **** **** +; +; Set default parameters +; +; No assumptions +; +; Sets default programming parameters +; +;**** **** **** **** **** **** **** **** **** **** **** **** **** +set_default_parameters: +IF MODE == 0 ; Main + mov Temp1, #Pgm_Gov_P_Gain + mov @Temp1, #DEFAULT_PGM_MAIN_P_GAIN + mov Temp1, #Pgm_Gov_I_Gain + mov @Temp1, #DEFAULT_PGM_MAIN_I_GAIN + mov Temp1, #Pgm_Gov_Mode + mov @Temp1, #DEFAULT_PGM_MAIN_GOVERNOR_MODE + mov Temp1, #Pgm_Gov_Range + mov @Temp1, #DEFAULT_PGM_MAIN_GOVERNOR_RANGE + mov Temp1, #Pgm_Low_Voltage_Lim + mov @Temp1, #DEFAULT_PGM_MAIN_LOW_VOLTAGE_LIM + mov Temp1, #Pgm_Startup_Pwr + mov @Temp1, #DEFAULT_PGM_MAIN_STARTUP_PWR + mov Temp1, #Pgm_Startup_Rpm + mov @Temp1, #DEFAULT_PGM_MAIN_STARTUP_RPM + mov Temp1, #Pgm_Startup_Accel + mov @Temp1, #DEFAULT_PGM_MAIN_STARTUP_ACCEL + mov Temp1, #Pgm_Startup_Method + mov @Temp1, #DEFAULT_PGM_MAIN_STARTUP_METHOD + mov Temp1, #Pgm_Comm_Timing + mov @Temp1, #DEFAULT_PGM_MAIN_COMM_TIMING + mov Temp1, #Pgm_Throttle_Rate + mov @Temp1, #DEFAULT_PGM_MAIN_THROTTLE_RATE + mov Temp1, #Pgm_Damping_Force + mov @Temp1, #DEFAULT_PGM_MAIN_DAMPING_FORCE + mov Temp1, #Pgm_Pwm_Freq + mov @Temp1, #DEFAULT_PGM_MAIN_PWM_FREQ + mov Temp1, #Pgm_Demag_Comp + mov @Temp1, #DEFAULT_PGM_MAIN_DEMAG_COMP + mov Temp1, #Pgm_Direction_Rev + mov @Temp1, #DEFAULT_PGM_MAIN_DIRECTION_REV + mov Temp1, #Pgm_Input_Pol + mov @Temp1, #DEFAULT_PGM_MAIN_RCP_PWM_POL + mov Temp1, #Pgm_Motor_Idle + mov @Temp1, #0 +ENDIF +IF MODE == 1 ; Tail + mov Temp1, #Pgm_Motor_Gain + mov @Temp1, #DEFAULT_PGM_TAIL_GAIN + mov Temp1, #Pgm_Motor_Idle + mov @Temp1, #DEFAULT_PGM_TAIL_IDLE_SPEED + mov Temp1, #Pgm_Startup_Pwr + mov @Temp1, #DEFAULT_PGM_TAIL_STARTUP_PWR + mov Temp1, #Pgm_Startup_Rpm + mov @Temp1, #DEFAULT_PGM_TAIL_STARTUP_RPM + mov Temp1, #Pgm_Startup_Accel + mov @Temp1, #DEFAULT_PGM_TAIL_STARTUP_ACCEL + mov Temp1, #Pgm_Startup_Method + mov @Temp1, #DEFAULT_PGM_TAIL_STARTUP_METHOD + mov Temp1, #Pgm_Comm_Timing + mov @Temp1, #DEFAULT_PGM_TAIL_COMM_TIMING + mov Temp1, #Pgm_Throttle_Rate + mov @Temp1, #DEFAULT_PGM_TAIL_THROTTLE_RATE + mov Temp1, #Pgm_Damping_Force + mov @Temp1, #DEFAULT_PGM_TAIL_DAMPING_FORCE + mov Temp1, #Pgm_Pwm_Freq + mov @Temp1, #DEFAULT_PGM_TAIL_PWM_FREQ + mov Temp1, #Pgm_Demag_Comp + mov @Temp1, #DEFAULT_PGM_TAIL_DEMAG_COMP + mov Temp1, #Pgm_Direction_Rev + mov @Temp1, #DEFAULT_PGM_TAIL_DIRECTION_REV + mov Temp1, #Pgm_Input_Pol + mov @Temp1, #DEFAULT_PGM_TAIL_RCP_PWM_POL + mov Temp1, #Pgm_Gov_Mode + mov @Temp1, #4 +ENDIF +IF MODE == 2 ; Multi + mov Temp1, #Pgm_Fir_Key ;2013.8.27 增加关键字默认值 + mov @Temp1, #DEFAULT_PGM_MULTI_FIRST_KEYWORD + mov Temp1, #Pgm_Gov_P_Gain + mov @Temp1, #DEFAULT_PGM_MAIN_P_GAIN ;Pgm_Gov_P_Gain=9 P增益 + mov Temp1, #Pgm_Gov_I_Gain + mov @Temp1, #DEFAULT_PGM_MAIN_I_GAIN ;Pgm_Gov_I_Gain=9 I增益 + mov Temp1, #Pgm_Gov_Mode + mov @Temp1, #DEFAULT_PGM_MAIN_GOVERNOR_MODE ;Pgm_Gov_Mode=4 + mov Temp1, #Pgm_Motor_Gain + mov @Temp1, #DEFAULT_PGM_MULTI_GAIN ;gm_Motor_Gain=3 + mov Temp1, #Pgm_Low_Voltage_Lim + mov @Temp1, #DEFAULT_PGM_MULTI_LOW_VOLTAGE_LIM ;Pgm_Low_Voltage_Lim=1 低压保护：1=Off 2=3.0V/c 3=3.1V/c 4=3.2V/c 5=3.3V/c 6=3.4V/c + mov Temp1, #Pgm_Low_Voltage_Ctl + mov @Temp1, #DEFAULT_PGM_MULTI_LOW_VOLTAGE_CTL ;Pgm_Low_Voltage_Ctl=1 低压保护: 1=功率逐渐降低到31% 2=关闭输出 + mov Temp1, #Pgm_Startup_Pwr + mov @Temp1, #DEFAULT_PGM_MULTI_STARTUP_PWR ;Pgm_Startup_Pwr=10 + mov Temp1, #Pgm_Startup_Rpm + mov @Temp1, #DEFAULT_PGM_MULTI_STARTUP_RPM ;Pgm_Startup_Rpm=1 启动转速：1=0.67 2=0.8 3=1.00 4=1.25 5=1.5 + mov Temp1, #Pgm_Startup_Accel + mov @Temp1, #DEFAULT_PGM_MULTI_STARTUP_ACCEL ;Pgm_Startup_Accel=5 +; mov Temp1, #Pgm_Startup_Method +; mov @Temp1, #DEFAULT_PGM_MULTI_STARTUP_METHOD ;Pgm_Startup_Method=2 启动方式：1=步进启动 2=直接启动 + mov Temp1, #Pgm_Comm_Timing + mov @Temp1, #DEFAULT_PGM_MULTI_COMM_TIMING ;Pgm_Comm_Timing=3 进角时间：1=Low 2=MediumLow 3=Medium 4=MediumHigh 5=High + mov Temp1, #Pgm_Throttle_Rate + mov @Temp1, #DEFAULT_PGM_MULTI_THROTTLE_RATE ;Pgm_Throttle_Rate=13 油门范围：1=2 2=3 3=4 4=6 5=8 6=12 7=16 8=24 9=32 10=48 11=64 12=128 13=255 + mov Temp1, #Pgm_Damping_Force + mov @Temp1, #DEFAULT_PGM_MULTI_DAMPING_FORCE ;Pgm_Damping_Force=6 刹车力度：1=VeryLow 2=Low 3=MediumLow 4=MediumHigh 5=High 6=Highest + mov Temp1, #Pgm_Pwm_Freq + mov @Temp1, #DEFAULT_PGM_MULTI_PWM_FREQ ;Pgm_Pwm_Freq=1 1=Low 2=High 3=DampedLight 4=Damped + mov Temp1, #Pgm_Demag_Comp + mov @Temp1, #DEFAULT_PGM_MULTI_DEMAG_COMP ;Pgm_Demag_Comp=2 1=Disabled 2=15/0 3=15/7.5 4=7.5/7.5 5=7.5/15 (degrees blind advance / power off) + mov Temp1, #Pgm_Direction_Rev + mov @Temp1, #DEFAULT_PGM_MULTI_DIRECTION_REV ;Pgm_Direction_Rev=1 方向设置：1=正转 2=反转 + mov Temp1, #Pgm_Input_Pol + mov @Temp1, #DEFAULT_PGM_MULTI_RCP_PWM_POL ;Pgm_Input_Pol=1 接收信号极性设置：1=Positive（正） 2=Negative（负） + mov Temp1, #Pgm_Motor_Idle + mov @Temp1, #0 ;Pgm_Motor_Idle=0 +ENDIF + mov Temp1, #Pgm_Enable_TX_Program + mov @Temp1, #DEFAULT_PGM_ENABLE_TX_PROGRAM ;Pgm_Enable_TX_Program=1 1=Enabled 0=Disabled + mov Temp1, #Pgm_Main_Rearm_Start + mov @Temp1, #DEFAULT_PGM_MAIN_REARM_START ;Pgm_Main_Rearm_Start=0 1=Enabled 0=Disabled + mov Temp1, #Pgm_Gov_Setup_Target + mov @Temp1, #DEFAULT_PGM_MAIN_GOV_SETUP_TARGET ;Pgm_Gov_Setup_Target=180 Target for governor in setup mode. Corresponds to 70% throttle + mov Temp1, #Pgm_Ppm_Min_Throttle + mov @Temp1, #DEFAULT_PGM_PPM_MIN_THROTTLE ;Pgm_Ppm_Min_Throttle=37 最小油门：4*37+1000=1148 + mov Temp1, #Pgm_Ppm_Max_Throttle + mov @Temp1, #DEFAULT_PGM_PPM_MAX_THROTTLE ;Pgm_Ppm_Max_Throttle=208 最大油门：4*208+1000=1832 + mov Temp1, #Pgm_Beep_Strength + mov @Temp1, #DEFAULT_PGM_MAIN_BEEP_STRENGTH ;Pgm_Beep_Strength=120 声强设置 + mov Temp1, #Pgm_Beacon_Strength + mov @Temp1, #DEFAULT_PGM_MAIN_BEACON_STRENGTH ;Pgm_Beacon_Strength=200 灯亮长Beacon strength？？？？ + mov Temp1, #Pgm_Beacon_Delay + mov @Temp1, #DEFAULT_PGM_MAIN_BEACON_DELAY ;Pgm_Beacon_Delay=4 灯亮时间？？？？1=30s 2=1m 3=2m 4=3m 5=Infinite + mov Temp1, #Pgm_BEC_Voltage_High + mov @Temp1, #DEFAULT_PGM_BEC_VOLTAGE_HIGH ;Pgm_BEC_Voltage_High=0 0=Low 1= High + ret + + +;**** **** **** **** **** **** **** **** **** **** **** **** **** +; +; Decode parameters +; +; No assumptions +; +; Decodes programming parameters +; +;**** **** **** **** **** **** **** **** **** **** **** **** **** +decode_parameters: + ; Load programmed damping force +;读取Damping force + mov Temp1, #Pgm_Damping_Force; Load damping force + mov A, @Temp1 + mov Temp8, A ; Store in Temp8 + ; Decode damping +;Damping force = 第1项 + clr Flags2.PGM_PWMOFF_DAMPED + clr Flags2.PGM_PWMOFF_DAMPED_LIGHT + clr Flags2.PGM_PWMOFF_DAMPED_FULL + clr Flags2.CURR_PWMOFF_DAMPED + setb Flags2.CURR_PWMOFF_COMP_ABLE + mov Damping_Period, #9 ; Set default + mov Damping_On, #1 + mov Rcp_Stop_Limit,#250 + clr C + cjne Temp8, #1, decode_damping_2 ; Look for 2 + jmp decode_damping_done + +;Damping force = 第2项 +decode_damping_2: + setb Flags2.PGM_PWMOFF_DAMPED +; setb Flags2.PGM_PWMOFF_DAMPED_LIGHT +; clr Flags2.PGM_PWMOFF_DAMPED_FULL + setb Flags2.CURR_PWMOFF_DAMPED + clr Flags2.CURR_PWMOFF_COMP_ABLE + mov Damping_Period, #5 + mov Damping_On, #1 + mov Rcp_Stop_Limit,#60 + clr C + cjne Temp8, #2, decode_damping_3 ; Look for 3 + jmp decode_damping_done + +;Damping force = 第3项 +decode_damping_3: +; setb Flags2.PGM_PWMOFF_DAMPED + setb Flags2.PGM_PWMOFF_DAMPED_LIGHT +; clr Flags2.PGM_PWMOFF_DAMPED_FULL +; setb Flags2.CURR_PWMOFF_DAMPED +; clr Flags2.CURR_PWMOFF_COMP_ABLE + mov Damping_Period, #5 + mov Damping_On, #2 + mov Rcp_Stop_Limit,#30 + clr C + cjne Temp8, #3, decode_damping_4 ; Look for 4 + jmp decode_damping_done + +;Damping force = 第4项 +decode_damping_4: +; setb Flags2.PGM_PWMOFF_DAMPED +; setb Flags2.PGM_PWMOFF_DAMPED_LIGHT +; clr Flags2.PGM_PWMOFF_DAMPED_FULL +; setb Flags2.CURR_PWMOFF_DAMPED +; clr Flags2.CURR_PWMOFF_COMP_ABLE + mov Damping_Period, #5 + mov Damping_On, #3 + mov Rcp_Stop_Limit,#25 + clr C + cjne Temp8, #4, decode_damping_5 ; Look for 5 + jmp decode_damping_done + +;Damping force = 第5项 +decode_damping_5: +; setb Flags2.PGM_PWMOFF_DAMPED +; setb Flags2.PGM_PWMOFF_DAMPED_LIGHT + setb Flags2.PGM_PWMOFF_DAMPED_FULL +; setb Flags2.CURR_PWMOFF_DAMPED +; clr Flags2.CURR_PWMOFF_COMP_ABLE + mov Damping_Period, #5 + mov Damping_On, #4 + mov Rcp_Stop_Limit,#20 + clr C + cjne Temp8, #5, decode_damping_6; Look for 6 + jmp decode_damping_done + +;Damping force = 第6项 +decode_damping_6: +; setb Flags2.PGM_PWMOFF_DAMPED +; setb Flags2.PGM_PWMOFF_DAMPED_LIGHT +; setb Flags2.PGM_PWMOFF_DAMPED_FULL +; setb Flags2.CURR_PWMOFF_DAMPED +; clr Flags2.CURR_PWMOFF_COMP_ABLE + mov Damping_Period, #5 + mov Damping_On, #5 + mov Rcp_Stop_Limit,#10 + +;*********************************************** +; 读取编程PWM频率(1) +;带硬刹/软刹 +;*********************************************** +decode_damping_done: + ; Load programmed pwm frequency +;读取Pwm frequency + mov Temp1, #Pgm_Pwm_Freq ; Load pwm freq + mov A, @Temp1 + mov Temp8, A ; Store in Temp8 +IF MODE == 0 ; Main + clr Flags2.PGM_PWMOFF_DAMPED_LIGHT + clr C + cjne Temp8, #3, ($+5) + setb Flags2.PGM_PWMOFF_DAMPED_LIGHT + clr Flags2.PGM_PWMOFF_DAMPED_FULL +ENDIF +IF MODE >= 1 ; Tail or multi +;////// clr Flags2.PGM_PWMOFF_DAMPED_LIGHT +;////// clr C +;////// cjne Temp8, #3, ($+5) +;Pwm frequency = 第3项 +;////// setb Flags2.PGM_PWMOFF_DAMPED_LIGHT +;////// clr Flags2.PGM_PWMOFF_DAMPED_FULL +;////// clr C +;////// cjne Temp8, #4, ($+5) +;Pwm frequency = 第4项 +;////// setb Flags2.PGM_PWMOFF_DAMPED_FULL +ENDIF +;Pwm frequency = 第1项 +;////// clr Flags2.PGM_PWMOFF_DAMPED ; Set damped flag if fully damped or damped light is set +;////// mov A, #((1 SHL PGM_PWMOFF_DAMPED_FULL)+(1 SHL PGM_PWMOFF_DAMPED_LIGHT)) +;////// anl A, Flags2 ; Check if any damped mode is set +;////// jz ($+4) +;Pwm frequency = 第2项 +;////// setb Flags2.PGM_PWMOFF_DAMPED +;Pwm frequency = 第1项 +;////// clr Flags2.CURR_PWMOFF_DAMPED ; Set non damped status as start +;////// jz ($+4) +;Pwm frequency = 第2项 +;////// setb Flags2.CURR_PWMOFF_DAMPED ; Set non damped status as start if damped +;Pwm frequency = 第1项 +;////// setb Flags2.CURR_PWMOFF_COMP_ABLE ; Set comparator usable status +;////// jz ($+4) +;Pwm frequency = 第2项 +;////// clr Flags2.CURR_PWMOFF_COMP_ABLE ; Set comparator not usable status if damped +;*********************************************** +; 读取编程电机旋转方向 +;*********************************************** +;读取Rotation direction +;Rotation direction = 第1项 + clr Flags3.PGM_DIR_REV + mov Temp1, #Pgm_Direction_Rev + mov A, @Temp1 + jnb ACC.1, ($+5) +;Rotation direction = 第2项 + setb Flags3.PGM_DIR_REV +;*********************************************** +; 读取编程输入信号RC PWM脉冲有效极性 +;*********************************************** +;读取Input pwm polarity +;Input pwm polarity = 第1项 + clr Flags3.PGM_RCP_PWM_POL + mov Temp1, #Pgm_Input_Pol + mov A, @Temp1 + jnb ACC.1, ($+5) +;Input pwm polarity = 第2项 + setb Flags3.PGM_RCP_PWM_POL +;*********************************************** +; 读取编程PWM频率(2) +;不带硬刹/软刹 +;*********************************************** + clr C + mov A, Temp8 + subb A, #1 + jz decode_pwm_freq_low +;Pwm frequency = 第1项 + mov CKCON, #01h ; Timer0 set for clk/4 (22kHz pwm) + setb Flags2.PGM_PWM_HIGH_FREQ + jmp decode_pwm_freq_end +;Pwm frequency = 第2项 +decode_pwm_freq_low: + mov CKCON, #00h ; Timer0 set for clk/12 (8kHz pwm) + clr Flags2.PGM_PWM_HIGH_FREQ + +decode_pwm_freq_end: + ret + + +;**** **** **** **** **** **** **** **** **** **** **** **** **** +; +; Decode governor gain +; +; No assumptions +; +; Decodes governor gains +; +;**** **** **** **** **** **** **** **** **** **** **** **** **** +decode_governor_gains: + ; Decode governor gains +;读取 Closed loop P gain + mov Temp1, #Pgm_Gov_P_Gain ; Decode governor P gain + mov A, @Temp1 + dec A + mov DPTR, #GOV_GAIN_TABLE + movc A, @A+DPTR + mov Temp1, #Pgm_Gov_P_Gain_Decoded + mov @Temp1, A +;读取 Closed loop I gain + mov Temp1, #Pgm_Gov_I_Gain ; Decode governor P gain + mov A, @Temp1 + dec A + mov DPTR, #GOV_GAIN_TABLE + movc A, @A+DPTR + mov Temp1, #Pgm_Gov_I_Gain_Decoded + mov @Temp1, A + call switch_power_off ; Reset DPTR + ret + + +;**** **** **** **** **** **** **** **** **** **** **** **** **** +; +; Decode throttle rate +; +; No assumptions +; +; Decodes throttle rate +; +;读取中点油门范围 +;**** **** **** **** **** **** **** **** **** **** **** **** **** +decode_throttle_rate: + ; Decode throttle rate +;读取 Throttle change rate + mov Temp1, #Pgm_Throttle_Rate + mov A, @Temp1 + dec A + mov DPTR, #THROTTLE_RATE_TABLE + movc A, @A+DPTR + mov Temp1, #Pgm_Throttle_Rate_Decoded + mov @Temp1, A + call switch_power_off ; Reset DPTR + ret + + +;**** **** **** **** **** **** **** **** **** **** **** **** **** +; +; Decode startup power +; +; No assumptions +; +; Decodes startup power +; +;编程启动力度 +;**** **** **** **** **** **** **** **** **** **** **** **** **** +decode_startup_power: + ; Decode startup power +;读取 Startup power + mov Temp1, #Pgm_Startup_Pwr + mov A, @Temp1 + dec A + mov DPTR, #STARTUP_POWER_TABLE + movc A, @A+DPTR + mov Temp1, #Pgm_Startup_Pwr_Decoded + mov @Temp1, A + call switch_power_off ; Reset DPTR + ret + + +;**** **** **** **** **** **** **** **** **** **** **** **** **** +; +; Decode demag compensation +; +; No assumptions +; +; Decodes throttle rate +; +;编程demag compensation参数 +;**** **** **** **** **** **** **** **** **** **** **** **** **** +decode_demag_comp: + ; Decode demag compensation +;读取Demag compensation + mov Temp1, #Pgm_Demag_Comp + mov A, @Temp1 + dec A + mov DPTR, #DEMAG_WAIT_TABLE + movc A, @A+DPTR + mov Temp1, #Pgm_Demag_Comp_Wait_Decoded + mov @Temp1, A + mov Temp1, #Pgm_Demag_Comp + mov A, @Temp1 + dec A + mov DPTR, #DEMAG_POWER_TABLE + movc A, @A+DPTR + mov Temp1, #Pgm_Demag_Comp_Power_Decoded + mov @Temp1, A + call switch_power_off ; Reset DPTR + ret + + +;**** **** **** **** **** **** **** **** **** **** **** **** **** +; +; Set BEC voltage +; +; No assumptions +; +; Sets the BEC output voltage low or high +; +;读取 BEC +;**** **** **** **** **** **** **** **** **** **** **** **** **** +set_bec_voltage: + ; Set bec voltage +IF DUAL_BEC_VOLTAGE == 1 + Set_BEC_Lo ; Set default to low +;读取 Pgm_BEC_Voltage_High + mov Temp1, #Pgm_BEC_Voltage_High + mov A, @Temp1 + jz set_bec_voltage_exit + + Set_BEC_Hi ; Set to high + +set_bec_voltage_exit: +ENDIF + ret + + +;**** **** **** **** **** **** **** **** **** **** **** **** **** +; +; Find throttle gain +; +; The difference between max and min throttle must be more than 520us (a Pgm_Ppm_xxx_Throttle difference of 130) +; +; Finds throttle gain from throttle calibration values +; +;**** **** **** **** **** **** **** **** **** **** **** **** **** +find_throttle_gain: + ; Load programmed minimum and maximum throttle +;读取Pgm_Ppm_Min_Throttle和Pgm_Ppm_Max_Throttle增量 + mov Temp1, #Pgm_Ppm_Min_Throttle + mov A, @Temp1 + mov Temp3, A + mov Temp1, #Pgm_Ppm_Max_Throttle + mov A, @Temp1 + mov Temp4, A + ; Check if full range is chosen + jnb Flags3.FULL_THROTTLE_RANGE, find_throttle_gain_calculate + + mov Temp3, #0 + mov Temp4, #255 + +find_throttle_gain_calculate: + ; Calculate difference + clr C + mov A, Temp4 + subb A, Temp3 + mov Temp5, A + ; Check that difference is minimum 130 + clr C + subb A, #130 + jnc ($+4) + + mov Temp5, #130 + + ; Find gain + mov Ppm_Throttle_Gain, #0 +test_gain: + inc Ppm_Throttle_Gain + mov A, Temp5 + mov B, Ppm_Throttle_Gain ; A has difference, B has gain + mul AB + clr C + mov A, B + subb A, #128 + jc test_gain + ret + + + + +;**** **** **** **** **** **** **** **** **** **** **** **** **** +;**** **** **** **** **** **** **** **** **** **** **** **** **** +;**** **** **** **** **** **** **** **** **** **** **** **** **** +; +; Main program start +; +;**** **** **** **** **** **** **** **** **** **** **** **** **** +;**** **** **** **** **** **** **** **** **** **** **** **** **** +;**** **** **** **** **** **** **** **** **** **** **** **** **** + +reset: + ; Select register bank 0 for main program routines + clr PSW.3 ; Select register bank 0 for main program routines + ; Disable the WDT. + anl PCA0MD, #NOT(40h) ; Clear watchdog enable bit + ; Initialize stack + mov SP, #0c0h ; Stack = 64 upper bytes of RAM + ; Initialize VDD monitor + orl VDM0CN, #080h ; Enable the VDD monitor + + mov Temp2, #3 +wait_100us: + djnz ACC, $ + djnz Temp2,wait_100us + +; call wait1ms ; Wait at least 100us + mov RSTSRC, #02h ; Set VDD monitor as a reset source (PORSF) + ; Set clock frequency + orl OSCICN, #03h ; Set clock divider to 1 + mov A, OSCICL + add A, #04h ; 24.5MHz to 24MHz (~0.5% per step) + jc reset_cal_done ; Is carry set? - skip next instruction + + mov OSCICL, A + +reset_cal_done: + ; Ports initialization + mov P0, #P0_INIT + mov P0MDOUT, #P0_PUSHPULL + mov P0MDIN, #P0_DIGITAL + mov P0SKIP, #P0_SKIP + mov P1, #P1_INIT + mov P1MDOUT, #P1_PUSHPULL + mov P1MDIN, #P1_DIGITAL + mov P1SKIP, #P1_SKIP +IF PORT3_EXIST == 1 + mov P2, #P2_INIT +ENDIF + mov P2MDOUT, #P2_PUSHPULL +IF PORT3_EXIST == 1 + mov P2MDIN, #P2_DIGITAL + mov P2SKIP, #P2_SKIP + mov P3, #P3_INIT + mov P3MDOUT, #P3_PUSHPULL + mov P3MDIN, #P3_DIGITAL +ENDIF + mov XBR1, #41h ; Xbar enabled, CEX0 routed to pin Rcp_In + ; Switch power off + call switch_power_off + ; Clear RAM + clr A ; Clear accumulator + mov Temp1, A ; Clear Temp1 +clear_ram: + mov @Temp1, A ; Clear RAM + djnz Temp1, clear_ram ; Is A not zero? - jump + ; Set default programmed parameters + call set_default_parameters + ; Read all programmed parameters + call read_all_eeprom_parameters + ; Decode parameters + call decode_parameters + ; Decode governor gains + call decode_governor_gains + ; Decode throttle rate + call decode_throttle_rate + ; Decode startup power + call decode_startup_power + ; Decode demag compensation + call decode_demag_comp + ; Set BEC voltage + call set_bec_voltage + ; Find throttle gain from stored min and max settings + call find_throttle_gain + ; Set beep strength +;读取超强设置 + mov Temp1, #Pgm_Beep_Strength + mov Beep_Strength, @Temp1 + ; Switch power off + call switch_power_off + ; Timer control + mov TCON, #50h ; Timer0 and timer1 enabled + ; Timer mode + mov TMOD, #02h ; Timer0 as 8bit + ; Timer2: clk/12 for 128us and 32ms interrupts + mov TMR2CN, #24h ; Timer2 enabled, low counter interrups enabled + ; Timer3: clk/12 for commutation timing + mov TMR3CN, #04h ; Timer3 enabled + ; PCA + mov PCA0CN, #40h ; PCA enabled + ; Initializing beep 上电叫3声 + call wait1s + call wait1s + + ; Enable interrupts + mov IE, #22h ; Enable timer0 and timer2 interrupts + mov IP, #02h ; High priority to timer0 interrupts + mov EIE1, #90h ; Enable timer3 and PCA0 interrupts + mov EIP1, #10h ; High priority to PCA interrupts + ; Initialize comparator + mov CPT0CN, #80h ; Comparator enabled, no hysteresis + mov CPT0MD, #03h ; Comparator response time 1us +IF COMP1_USED==1 + mov CPT1CN, #80h ; Comparator enabled, no hysteresis + mov CPT1MD, #03h ; Comparator response time 1us +ENDIF + ; Initialize ADC + Initialize_Adc ; Initialize ADC operation + call wait1ms + setb EA ; Enable all interrupts + ; Measure number of lipo cells + call Measure_Lipo_Cells ; Measure number of lipo cells + ; Initialize rc pulse + Rcp_Int_Enable ; Enable interrupt + Rcp_Int_First ; Enable interrupt and set to first edge + Rcp_Clear_Int_Flag ; Clear interrupt flag + clr Flags2.RCP_EDGE_NO ; Set first edge flag + call wait200ms + ; Set initial arm variable + mov Initial_Arm, #1 +; mov Pca_First_Int, #1 + + ; Measure PWM frequency +measure_pwm_freq_init: + setb Flags0.RCP_MEAS_PWM_FREQ ; Set measure pwm frequency flag +; clr C ;2014.08.08 信号滤波 +; mov A, Pgm_Pulse_Cnt ;2014.08.08 信号滤波 +; subb A, #5 ;2014.08.08 信号滤波 +; jc measure_pwm_freq_init ;2014.08.08 信号滤波 +; mov Pca_First_Int, #0 ;2014.08.08 信号滤波 +; call wait200ms +measure_pwm_freq_start: + mov Temp3, #5 ; Number of pulses to measure +; mov Temp3, #1 +measure_pwm_freq_loop: + ; Check if period diff was accepted + mov A, Rcp_Period_Diff_Accepted +; jnz ($+4) + + jnz measure_pwm + call wait3ms + mov A, New_RCP + clr C + subb A,#230 + jc ($+7) + mov Pgm_Pulse_Cnt, #0 +; mov Temp3, #5 + ajmp measure_pwm_freq_start + + mov A, New_RCP + clr C + subb A,#30 + jnc ($+7) + mov Pgm_Pulse_Cnt, #0 +; mov Temp3, #5 + ajmp measure_pwm_freq_start + + inc Pgm_Pulse_Cnt + mov A, Pgm_Pulse_Cnt + clr C + subb A, #5 + jnc ($+6) + mov Temp3, #5 ; Reset number of pulses to measure + ajmp measure_pwm_freq_loop +; mov Temp3, #1 +measure_pwm: + call wait3ms ; Wait for next pulse (NB: Uses Temp1/2!) + mov A, New_Rcp ; Load value + clr C + subb A, #RCP_VALIDATE ; Higher than validate level? + jc measure_pwm_freq_start ; No - start over + + mov A, Flags3 ; Check pwm frequency flags +; anl A, #((1 SHL RCP_PWM_FREQ_1KHZ)+(1 SHL RCP_PWM_FREQ_2KHZ)+(1 SHL RCP_PWM_FREQ_4KHZ)+(1 SHL RCP_PWM_FREQ_8KHZ)) + anl A, #(1 SHL RCP_PWM_FREQ_1KHZ) + mov Prev_Rcp_Pwm_Freq, Curr_Rcp_Pwm_Freq ; Store as previous flags for next pulse + mov Curr_Rcp_Pwm_Freq, A ; Store current flags for next pulse + cjne A, Prev_Rcp_Pwm_Freq, measure_pwm_freq_start ; Go back if new flags not same as previous + + djnz Temp3, measure_pwm_freq_loop ; Go back if not required number of pulses seen + + ; Clear measure pwm frequency flag + clr Flags0.RCP_MEAS_PWM_FREQ + ; Set up RC pulse interrupts after pwm frequency measurement + Rcp_Int_First ; Enable interrupt and set to first edge + Rcp_Clear_Int_Flag ; Clear interrupt flag + clr Flags2.RCP_EDGE_NO ; Set first edge flag + call wait100ms ; Wait for new RC pulse + + ; Validate RC pulse +;Pgm_Main_Rearm_Start = 第1项 enabled +validate_rcp_start: + call wait3ms ; Wait for next pulse (NB: Uses Temp1/2!) + mov Temp1, #RCP_VALIDATE ; Set validate level as default +; mov A, #((1 SHL RCP_PWM_FREQ_1KHZ)+(1 SHL RCP_PWM_FREQ_2KHZ)+(1 SHL RCP_PWM_FREQ_4KHZ)+(1 SHL RCP_PWM_FREQ_8KHZ)) + mov A, #(1 SHL RCP_PWM_FREQ_1KHZ) + anl A, Flags3 ; Check pwm frequency flags + jnz ($+4) ; If a flag is set (PWM) - branch + + mov Temp1, #0 ; Set level to zero for PPM (any level will be accepted) + + clr C + mov A, New_Rcp ; Load value + subb A, Temp1 ; Higher than validate level? + jc validate_rcp_start ; No - start over + + ; Beep arm sequence start signal +;上电检测到信号后叫第1声（信号准备就绪） +;////// clr EA ; Disable all interrupts +;////// call beep_f1 ; Signal that RC pulse is ready +;////// call beep_f1 +;////// call beep_f1 +;////// setb EA ; Enable all interrupts + call wait200ms + + ; Arming sequence start + mov Gov_Arm_Target, #0 ; Clear governor arm target +arming_start: + call wait3ms +;读取Pgm_Enable_TX_Program + mov Temp1, #Pgm_Enable_TX_Program; Yes - start programming mode entry if enabled + mov A, @Temp1 + clr C + subb A, #1 ; Is TX programming enabled? + jnc arming_initial_arm_check ; Yes - proceed + + jmp program_by_tx_checked ; No - branch +;Pgm_Enable_TX_Program = 1 enabled +arming_initial_arm_check: + mov A, Initial_Arm ; Yes - check if it is initial arm sequence + clr C + subb A, #1 ; Is it the initial arm sequence? + jnc arming_ppm_check ; Yes - proceed + + jmp wait_for_power_on ; No - branch + +arming_ppm_check: + mov Temp1, #Pgm_Ppm_Min_Throttle ; Store + mov A, @Temp1 + mov Min_Throttle, A +; mov A, #((1 SHL RCP_PWM_FREQ_1KHZ)+(1 SHL RCP_PWM_FREQ_2KHZ)+(1 SHL RCP_PWM_FREQ_4KHZ)+(1 SHL RCP_PWM_FREQ_8KHZ)) + mov A, #(1 SHL RCP_PWM_FREQ_1KHZ) + anl A, Flags3 ; Check pwm frequency flags + jz throttle_high_cal_start ; If no flag is set (PPM) - branch + + ; PWM tx program entry +; clr C +; mov A, New_Rcp ; Load new RC pulse value +; subb A, #200 ; Is RC pulse max? +; jc program_by_tx_entry_wait_pwm ; Yes - proceed +; subb A, #RCP_MAX ; Is RC pulse max? +; jnc program_by_tx_entry_pwm ; Yes - proceed + +; jmp program_by_tx_checked ; No - branch + +;program_by_tx_entry_pwm: +; clr EA ; Disable all interrupts +; call beep_f4 +; setb EA ; Enable all interrupts +; call wait100ms +; clr C +; mov A, New_Rcp ; Load new RC pulse value +; subb A, #RCP_STOP ; Below stop? +; subb A, #200 +; jnc program_by_tx_entry_pwm ; No - start over + +;program_by_tx_entry_wait_pwm: + + clr EA + call beep_f2 + call beep_f3 + call beep_f1 + + mov TMOD, #11h ;T0/T1 工作方式1 + mov CKCON, #02h ;T0/T1 48分频 + mov P0MDIN, #80h + mov P0SKIP, #0FFh + call program_by_card ; Yes - enter programming mode +; ajmp program_by_card_entry + +;program_by_tx_entry_wait_pwm: +; clr EA ; Disable all interrupts +; call beep_f1 +; call wait10ms +; call beep_f1 +; setb EA ; Enable all interrupts +; call wait100ms +; clr C +; mov A, New_Rcp ; Load new RC pulse value +; subb A, #RCP_MAX ; At or above max? +; jc program_by_tx_entry_wait_pwm ; No - start over + +; call program_by_tx ; Yes - enter programming mode +; jmp program_by_tx_checked + + ; PPM throttle calibration and tx program entry +;计算PPM最大，最小油门并存储 +throttle_high_cal_start: + mov Temp8, #5 ; Set 3 seconds wait time +throttle_high_cal: + setb Flags3.FULL_THROTTLE_RANGE ; Set range to 1000-2020us + call Find_Throttle_Gain ; Set throttle gain + call wait100ms ; Wait for new throttle value + clr EA ; Disable interrupts (freeze New_Rcp value) + clr Flags3.FULL_THROTTLE_RANGE ; Set programmed range + call Find_Throttle_Gain ; Set throttle gain + clr C + mov A, New_Rcp ; Load new RC pulse value + subb A, #220 ; Is RC pulse above midstick? 1840 + setb EA ; Enable interrupts + jc ($+6) + djnz Temp8, throttle_high_cal + ajmp throttle_high_cal_save + + clr C + mov A, New_Rcp ; Load new RC pulse value + subb A, Min_Throttle ; Is RC pulse above midstick? 1148 + jnc ($+4) + ajmp arm_target_updated ; No - branch 检测低油门 + + clr EA + call beep_f1; + call wait100ms + setb EA + ajmp throttle_high_cal_start + +throttle_high_cal_save: +; call wait1s + clr C + mov A, New_Rcp ; Limit to max 250 + subb A, #5 ; Subtract about 2% and ensure that it is 250 or lower + mov Temp1, #Pgm_Ppm_Max_Throttle ; Store + mov @Temp1, A + call set_commu_sum_to_zero ;////////////////////////////////////************************** + call erase_and_store_all_in_eeprom + clr EA + call beep_f1;/////////////////////////////////////////成功存储最大油门叫声 + call beep_f1;/////////////////////////////////////////成功存储最大油门叫声 + call wait30ms;/////////////////////////////////////////成功存储最大油门叫声 + call beep_f4;/////////////////////////////////////////成功存储最大油门叫声 + call beep_f4;/////////////////////////////////////////成功存储最大油门叫声 + setb EA + + call wait1s + call wait1s +wait_loop_1: + clr C + mov A, New_Rcp ; Load new RC pulse value + subb A, #215 ;Is RC pulse above midstick? + jnc program_by_tx_entry_wait_ppm + clr C + mov A, New_Rcp ; Load new RC pulse value + subb A, #60 ;Is RC pulse above midstick? + jnc wait_loop_1 + ajmp throttle_low_cal_start + + ;PPM编程模式 +program_by_tx_entry_wait_ppm: + call program_by_tx ; Yes - enter programming mode 成功进入编程模式 + +;最小油门设置及退出 +throttle_low_cal_start: + mov Temp8, #5 ; Set 3 seconds wait time +throttle_low_cal: +; call wait1s + setb Flags3.FULL_THROTTLE_RANGE ; Set range to 1000-2020us + call Find_Throttle_Gain ; Set throttle gain + call wait100ms + clr EA ; Disable interrupts (freeze New_Rcp value) + clr Flags3.FULL_THROTTLE_RANGE ; Set programmed range + call Find_Throttle_Gain ; Set throttle gain + clr C + mov A, New_Rcp ; Load new RC pulse value + subb A, #60 ; Below midstick? + setb EA ; Enable interrupts + jnc throttle_low_cal_start ; No - start over 在中点油门以上，则继续等待，直到检测到在中点油门以下 + djnz Temp8, throttle_low_cal ; Yes - continue to wait +; call wait3ms + mov A, New_Rcp + add A, #5 ; Add about 2% + mov Temp1, #Pgm_Ppm_Min_Throttle ; Store + mov @Temp1, A + call set_commu_sum_to_zero ;////////////////////////////////////************************** + call erase_and_store_all_in_eeprom + +; clr EA ; Disable all interrupts +; mov RSTSRC, #12h ; Generate hardware reset 强制复位系统 + + ; Set default programmed parameters +; call set_default_parameters + ; Read all programmed parameters + call read_all_eeprom_parameters + ; Decode parameters + call decode_parameters + ; Decode governor gains + call decode_governor_gains + ; Decode throttle rate + call decode_throttle_rate + ; Decode startup power + call decode_startup_power + ; Decode demag compensation + call decode_demag_comp + ; Set BEC voltage + call set_bec_voltage + ; Find throttle gain from stored min and max settings + call find_throttle_gain + +program_by_tx_checked: + clr C + mov A, New_Rcp ; Load new RC pulse value + subb A, Gov_Arm_Target ; Is RC pulse larger than arm target? + jc arm_target_updated ; No - do not update + + mov Gov_Arm_Target, New_Rcp ; Yes - update arm target + +arm_target_updated: + call wait100ms ; Wait for new throttle value + clr C + mov A, New_Rcp ; Load new RC pulse value + subb A, #RCP_STOP ; Below stop? + jc arm_end_beep ; Yes - proceed ;最小油门计算好 及 编程结束叫声 + jmp arm_target_updated ; No - start over + +;上电检测到信号后叫第2声（信号检测结束） +arm_end_beep: +;改变上电叫方式 + clr EA ; Disable all interrupts + call beep_f1 + call beep_f1 + call beep_f1 + call wait1s + ; Beep arm sequence end signal + +;************************************************* +; 增加Lipo节数叫声 2013.5.29 +;************************************************* + mov Temp8,Lipo_Cell_Count ; +lipo_cell_beep: + call beep_f1 + call beep_f1 + call wait30ms + djnz Temp8,lipo_cell_beep + call wait200ms + call wait200ms +;///// call beep_f4 ; Signal that rcpulse is ready +;///// call beep_f4 +;///// call beep_f4 +;改变信号检测OK叫声方式 2013.5.29 + call beep_f1 + call wait30ms + call wait30ms + call beep_f2 + call wait30ms + call wait30ms + call beep_f3 + call wait30ms + call wait30ms + setb EA ; Enable all interrupts + call wait100ms + + ; Measure number of lipo cells + call Measure_Lipo_Cells ; Measure number of lipo cells + + ; Clear initial arm variable + mov Initial_Arm, #0 + + ; Armed and waiting for power on +wait_for_power_on: + mov Temp8, #50 + clr LOW_LIMIT_STOP ; 清低压保护控制方式2 停止标志 +;////// clr A +;////// mov Power_On_Wait_Cnt_L, A ; Clear wait counter +;////// mov Power_On_Wait_Cnt_H, A +wait_for_power_on_loop: +;////// inc Power_On_Wait_Cnt_L ; Increment low wait counter +;////// mov A, Power_On_Wait_Cnt_L +;////// cpl A +;////// jnz wait_for_power_on_no_beep; Counter wrapping (about 1 sec)? + +;////// inc Power_On_Wait_Cnt_H ; Increment high wait counter +;******************************************************** +; 读取油门最低未操作等待叫声时间 +;******************************************************** +;读取Pgm_Beacon_Delay +;////// mov Temp1, #Pgm_Beacon_Delay +;////// mov A, @Temp1 +;////// mov Temp1, #40 ; Approximately 30 sec +;////// dec A +;////// jz beep_delay_set + +;////// mov Temp1, #80 ; Approximately 1 min +;////// dec A +;////// jz beep_delay_set + +;////// mov Temp1, #160 ; Approximately 2 min +;////// dec A +;////// jz beep_delay_set + +;////// mov Temp1, #240 ; Approximately 3 min +;////// dec A +;////// jz beep_delay_set + +;////// mov Power_On_Wait_Cnt_H, #0 ; Reset counter for infinite delay + +;//////beep_delay_set: +;////// clr C +;////// mov A, Power_On_Wait_Cnt_H +;////// subb A, Temp1 ; Check against chosen delay +;////// jc wait_for_power_on_no_beep; Has delay elapsed? +;******************************************************** +; 读取油门最低未操作等待叫声声强设置 +;******************************************************** +;////// dec Power_On_Wait_Cnt_H ; Decrement high wait counter +;读取Pgm_Beacon_Strength +;////// mov Temp1, #Pgm_Beacon_Strength +;////// mov Beep_Strength, @Temp1 +;////// clr EA ; Disable all interrupts +;////// All_pFETs_Off;///////////////////////////////////////***************************** +;////// call beep_f4 ; Signal that there is no signal +;////// setb EA ; Enable all interrupts +;读取Pgm_Beep_Strength +;////// mov Temp1, #Pgm_Beep_Strength +;////// mov Beep_Strength, @Temp1 +;////// call wait100ms ; Wait for new RC pulse to be measured + +wait_for_power_on_no_beep: + call wait3ms + mov A, Rcp_Timeout_Cnt ; Load RC pulse timeout counter value + jnz wait_for_power_on_ppm_not_missing ; If it is not zero - proceed + +; mov A, #((1 SHL RCP_PWM_FREQ_1KHZ)+(1 SHL RCP_PWM_FREQ_2KHZ)+(1 SHL RCP_PWM_FREQ_4KHZ)+(1 SHL RCP_PWM_FREQ_8KHZ)) +; anl A, Flags3 ; Check pwm frequency flags +; jnz wait_for_power_on_ppm_not_missing ; If a flag is set (PWM) - branch + + jmp measure_pwm_freq_init ; If ppm and pulses missing - go back to measure pwm frequency + +wait_for_power_on_ppm_not_missing: + clr C + mov A, New_Rcp ; Load new RC pulse value +; subb A, #RCP_STOP ; Higher than stop (plus some hysteresis)? + subb A, #(RCP_STOP+7) ; Higher than stop (plus some hysteresis)? + jc wait_for_power_on ; No - start over + djnz Temp8, wait_for_power_on_no_beep + jb LOW_LIMIT_STOP, wait_for_power_on_loop + call wait100ms ; Wait to see if start pulse was only a glitch + mov A, Rcp_Timeout_Cnt ; Load RC pulse timeout counter value + jnz ($+5) ; If it is not zero - proceed + + ljmp measure_pwm_freq_init ; If it is zero (pulses missing) - go back to measure pwm frequency + + +;**** **** **** **** **** **** **** **** **** **** **** **** **** +; +; Start entry point +; +;**** **** **** **** **** **** **** **** **** **** **** **** **** +init_start: + setb ET0 + call switch_power_off + clr A + mov Requested_Pwm, A ; Set requested pwm to zero + mov Governor_Req_Pwm, A ; Set governor requested pwm to zero + mov Current_Pwm, A ; Set current pwm to zero + mov Current_Pwm_Limited, A ; Set limited current pwm to zero + mov Pwm_Limit, #0FFh ; Set pwm limit to max + mov Temp1, #Pgm_Motor_Idle + mov Pwm_Motor_Idle, @Temp1 ; Set idle pwm to programmed value + mov Gov_Target_L, A ; Set target to zero + mov Gov_Target_H, A + mov Gov_Integral_L, A ; Set integral to zero + mov Gov_Integral_H, A + mov Gov_Integral_X, A + mov Adc_Conversion_Cnt, A + mov Gov_Active, A + mov Flags0, A ; Clear flags0 + mov Flags1, A ; Clear flags1 + mov Rcp_Stop_Cnt, A ; Set RC pulse stop count to zero + mov Rcp_Stop_Limit, A + mov Lipo_Cell_Count, A + mov Limit_Count, A + mov New_Rcp, #Rcp_MIN + call initialize_all_timings ; Initialize timing + ;**** **** **** **** **** + ; Settle phase beginning + ;**** **** **** **** **** + mov Adc_Conversion_Cnt, #TEMP_CHECK_RATE ; Make sure a temp reading is done + Set_Adc_Ip_Temp + call wait1ms + call start_adc_conversion +read_initial_temp: + Get_Adc_Status + jb AD0BUSY, read_initial_temp + Read_Adc_Result ; Read initial temperature + mov A, Temp2 + jnz ($+3) ; Is reading below 256? + + mov Temp1, A ; Yes - set average temperature value to zero + + mov Current_Average_Temp, Temp1 ; Set initial average temperature + call check_temp_voltage_and_limit_power + mov Adc_Conversion_Cnt, #TEMP_CHECK_RATE ; Make sure a temp reading is done next time + Set_Adc_Ip_Temp + + ; Go to the desired startup mode +; mov Temp1, #Pgm_Startup_Method +; mov A, @Temp1 +; jnb ACC.0, direct_method_start + +; jmp stepper_method_start + +direct_method_start: + ; Set up start operating conditions + mov Temp1, #Pgm_Pwm_Freq + mov A, @Temp1 + mov Temp7, A ; Store setting in Temp7 + mov @Temp1, #1 ; Set nondamped low frequency pwm mode + call decode_parameters ; (Decode_parameters uses Temp1 and Temp8) + mov Temp1, #Pgm_Pwm_Freq + mov A, Temp7 + mov @Temp1, A ; Restore settings + ; Set max allowed power + setb Flags1.SETTLE_PHASE ; Set settle phase power as max + clr EA ; Disable interrupts to avoid that Requested_Pwm is overwritten + call set_startup_pwm + mov Pwm_Limit, Requested_Pwm + mov Pwm_Limit_Spoolup, Requested_Pwm + setb EA + clr Flags1.SETTLE_PHASE + mov Current_Pwm_Limited, #0 ; Set low pwm again after calling set_startup_pwm + mov Spoolup_Limit_Cnt, #0 + mov Spoolup_Limit_Skip, #1 + ; Begin startup sequence + setb Flags1.MOTOR_SPINNING ; Set motor spinning flag + setb Flags1.DIRECT_STARTUP_PHASE ; Set direct startup phase flag + mov Direct_Startup_Ok_Cnt, #0 ; Reset ok counter + call comm5comm6 ; Initialize commutation + call comm6comm1 + call calc_next_comm_timing ; Set virtual commutation point + call initialize_all_timings ; Initialize timing + jmp run1 + + +;stepper_method_start: +; ; Set up start operating conditions +; mov Temp1, #Pgm_Pwm_Freq +; mov A, @Temp1 +; mov Temp7, A ; Store setting in Temp7 +; mov @Temp1, #3 ; Set damped light mode +; mov Temp1, #Pgm_Damping_Force +; mov A, @Temp1 +; mov Temp6, A ; Store setting in Temp6 +; mov @Temp1, #5 ; Set high damping force +; call decode_parameters ; (Decode_parameters uses Temp1 and Temp8) +; mov Temp1, #Pgm_Pwm_Freq +; mov A, Temp7 +; mov @Temp1, A ; Restore settings +; mov Temp1, #Pgm_Damping_Force +; mov A, Temp6 +; mov @Temp1, A + ; Begin startup sequence +; setb Flags1.MOTOR_SPINNING ; Set motor spinning flag +; setb Flags1.SETTLE_PHASE ; Set motor start settling phase flag +; setb Flags2.CURR_PWMOFF_DAMPED; Set damped status, in order to ensure that pfets will be turned off in an initial pwm on +; call comm5comm6 ; Initialize commutation +; call comm6comm1 +; call set_startup_pwm +; call wait1ms +; call comm1comm2 +; call wait1ms +; call wait1ms +; call comm2comm3 +; call wait3ms +; call comm3comm4 +; call wait3ms +; call wait3ms +; call comm4comm5 +; call wait10ms ; Settle rotor +; call comm5comm6 +; call wait3ms +; call wait1ms +; clr Flags1.SETTLE_PHASE ; Clear settling phase flag +; setb Flags1.STEPPER_PHASE ; Set motor start stepper phase flag + +; ;**** **** **** **** **** +; ; Stepper phase beginning +; ;**** **** **** **** **** +;stepper_rot_beg: +; call start_adc_conversion +; call check_temp_voltage_and_limit_power +; call set_startup_pwm +; mov Adc_Conversion_Cnt, #TEMP_CHECK_RATE ; Make sure a temp reading is done next time +; Set_Adc_Ip_Temp + +; call comm6comm1 ; Commutate +; call calc_next_comm_timing_start ; Update timing and set timer +; call calc_new_wait_times +; call decrement_stepper_step +; call stepper_timer_wait + +; call comm1comm2 +; call calc_next_comm_timing_start +; call calc_new_wait_times +; call decrement_stepper_step +; call stepper_timer_wait + +; call comm2comm3 +; call calc_next_comm_timing_start +; call calc_new_wait_times +; call decrement_stepper_step +; call stepper_timer_wait + +; call comm3comm4 +; call calc_next_comm_timing_start +; call calc_new_wait_times +; call decrement_stepper_step +; call stepper_timer_wait + +; call comm4comm5 +; call calc_next_comm_timing_start +; call calc_new_wait_times +; call decrement_stepper_step +; call stepper_timer_wait + +; call comm5comm6 +; call calc_next_comm_timing_start +; call calc_new_wait_times +; call decrement_stepper_step +; ; Check stepper step versus end criteria +; clr C +; mov A, Wt_Stepper_Step_L +; subb A, Stepper_Step_End_L ; Minimum Stepper_Step_End +; mov A, Wt_Stepper_Step_H +; subb A, Stepper_Step_End_H +; jc stepper_rot_exit ; Branch if lower than minimum + +; ; Wait for step +; call stepper_timer_wait +; clr C +; mov A, New_Rcp ; Load new pulse value +; subb A, #RCP_STOP ; Check if pulse is below stop value +; jnc stepper_rot_beg + +; jmp run_to_wait_for_power_on + +;stepper_rot_exit: +; ; Wait for step +; call stepper_timer_wait +; ; Clear stepper phase +; clr Flags1.STEPPER_PHASE ; Clear motor start stepper phase flag +; ; Set dondamped low pwm frequency +; mov Temp1, #Pgm_Pwm_Freq +; mov A, @Temp1 +; mov Temp7, A ; Store setting in Temp7 +; mov @Temp1, #2 ; Set nondamped low frequency pwm mode +; call decode_parameters ; (Decode_parameters uses Temp1 and Temp8) +; mov Temp1, #Pgm_Pwm_Freq +; mov A, Temp7 +; mov @Temp1, A ; Restore settings +; ; Set spoolup power variables (power is now controlled from RCP) +; mov Pwm_Limit, Requested_Pwm +; mov Pwm_Limit_Spoolup, Pwm_Spoolup_Beg +; mov Current_Pwm_Limited, Pwm_Spoolup_Beg +; mov Spoolup_Limit_Cnt, #0 +; mov Spoolup_Limit_Skip, #1 +; ; Set direct startup phase to aquire sync quickly +; setb Flags1.DIRECT_STARTUP_PHASE ; Set direct startup phase flag +; mov Direct_Startup_Ok_Cnt, #0 ; Reset ok counter +; clr EA ; Disable interrupts +; ApFET_off ; Ap off. Turn off unused pfets (to turn off damping fets that might be on) +; CpFET_off ; Cp off +; mov A, #45 ; 8us delay for pfets to go off +; djnz ACC, $ +; setb EA ; Enable interrupts +; call comm6comm1 +; call calc_next_comm_timing ; Calculate next timing and start advance timing wait +; call wait_advance_timing ; Wait advance timing and start zero cross wait +; call calc_new_wait_times +; call wait_before_zc_scan ; Wait zero cross wait and start zero cross timeout +; mov Adc_Conversion_Cnt, #0 ; Make sure a voltage reading is done next time +; Set_Adc_Ip_Volt ; Set adc measurement to voltage +; jmp run1 + + + +;**** **** **** **** **** **** **** **** **** **** **** **** **** +; +; Run entry point +; +;**** **** **** **** **** **** **** **** **** **** **** **** **** +damped_transition: + ; Transition from nondamped to damped if applicable + call decode_parameters ; Set programmed parameters + call comm6comm1 + mov Adc_Conversion_Cnt, #0 ; Make sure a voltage reading is done next time + Set_Adc_Ip_Volt ; Set adc measurement to voltage + +; Run 1 = B(p-on) + C(n-pwm) - comparator A evaluated +; Out_cA changes from high to low +run1: + call wait_for_comp_out_high ; Wait zero cross wait and wait for high + call evaluate_comparator_integrity ; Check whether comparator reading has been normal + call setup_comm_wait ; Setup wait time from zero cross to commutation + call calc_governor_target ; Calculate governor target + call wait_for_comm ; Wait from zero cross to commutation + call comm1comm2 ; Commutate + call calc_next_comm_timing ; Calculate next timing and start advance timing wait + call wait_advance_timing ; Wait advance timing and start zero cross wait + call calc_new_wait_times + call wait_before_zc_scan ; Wait zero cross wait and start zero cross timeout + +; Run 2 = A(p-on) + C(n-pwm) - comparator B evaluated +; Out_cB changes from low to high +run2: + call wait_for_comp_out_low + call evaluate_comparator_integrity + call setup_comm_wait + call calc_governor_prop_error + call wait_for_comm + call comm2comm3 + call calc_next_comm_timing + call wait_advance_timing + call calc_new_wait_times + call wait_before_zc_scan + +; Run 3 = A(p-on) + B(n-pwm) - comparator C evaluated +; Out_cC changes from high to low +run3: + call wait_for_comp_out_high + call evaluate_comparator_integrity + call setup_comm_wait + call calc_governor_int_error + call wait_for_comm + call comm3comm4 + call calc_next_comm_timing + call wait_advance_timing + call calc_new_wait_times + call wait_before_zc_scan + +; Run 4 = C(p-on) + B(n-pwm) - comparator A evaluated +; Out_cA changes from low to high +run4: + call wait_for_comp_out_low + call evaluate_comparator_integrity + call setup_comm_wait + call calc_governor_prop_correction + call wait_for_comm + call comm4comm5 + call calc_next_comm_timing + call wait_advance_timing + call calc_new_wait_times + call wait_before_zc_scan + +; Run 5 = C(p-on) + A(n-pwm) - comparator B evaluated +; Out_cB changes from high to low +run5: + call wait_for_comp_out_high + call evaluate_comparator_integrity + call setup_comm_wait + call calc_governor_int_correction + call wait_for_comm + call comm5comm6 + call calc_next_comm_timing + call wait_advance_timing + call calc_new_wait_times + call wait_before_zc_scan + +; Run 6 = B(p-on) + A(n-pwm) - comparator C evaluated +; Out_cC changes from low to high +run6: + call wait_for_comp_out_low + call start_adc_conversion + call evaluate_comparator_integrity + call setup_comm_wait + call check_temp_voltage_and_limit_power + call wait_for_comm + call comm6comm1 + call calc_next_comm_timing + call wait_advance_timing + call calc_new_wait_times + call wait_before_zc_scan + + ; Check if it is direct startup + jnb Flags1.DIRECT_STARTUP_PHASE, normal_run_checks + + ; Set spoolup power variables +IF MODE == 0 OR MODE == 2 + mov Pwm_Limit, Pwm_Spoolup_Beg ; Set initial max power + mov Pwm_Limit_Spoolup, Pwm_Spoolup_Beg ; Set initial slow spoolup power +ENDIF +IF MODE == 1 + mov Pwm_Limit, #0FFh ; Allow full power + mov Pwm_Limit_Spoolup, #0FFh +ENDIF + mov Spoolup_Limit_Cnt, #0 + mov Spoolup_Limit_Skip, #1 + ; Check startup ok counter + clr C + mov A, Direct_Startup_Ok_Cnt ; Load ok counter + subb A, #100 ; Is counter above requirement? + jc direct_start_check_rcp ; No - proceed + + clr Flags1.DIRECT_STARTUP_PHASE ; Clear direct startup phase flag + setb Flags1.INITIAL_RUN_PHASE ; Set initial run phase flag + mov Startup_Rot_Cnt, #20 ; Set startup rotation count + jmp normal_run_checks + +direct_start_check_rcp: + clr C + mov A, New_Rcp ; Load new pulse value + subb A, #RCP_STOP ; Check if pulse is below stop value + jc ($+5) + + ljmp run1 ; Continue to run + + jmp run_to_wait_for_power_on + + +normal_run_checks: + ; Check if it is initial run phase + jnb Flags1.INITIAL_RUN_PHASE, initial_run_phase_done; If not initial run phase - branch + + ; Decrement startup rotaton count + mov A, Startup_Rot_Cnt + dec A + ; Check number of nondamped rotations + jnz normal_run_check_startup_rot ; Branch if counter is not zero + + clr Flags1.INITIAL_RUN_PHASE ; Clear initial run phase flag + ljmp damped_transition ; Do damped transition if counter is zero + +normal_run_check_startup_rot: + mov Startup_Rot_Cnt, A ; Not zero - store counter + + clr C + mov A, New_Rcp ; Load new pulse value + subb A, #RCP_STOP ; Check if pulse is below stop value + jc ($+5) + + ljmp run1 ; Continue to run + + jmp run_to_wait_for_power_on + + +initial_run_phase_done: + ; Exit run loop after a given time + clr C + mov A, Rcp_Stop_Cnt ; Load stop RC pulse counter value +;///// subb A, #RCP_STOP_LIMIT ; Is number of stop RC pulses above limit? + subb A, Rcp_Stop_Limit ; Is number of stop RC pulses above limit? + jnc run_to_wait_for_power_on ; Yes, go back to wait for poweron + +run6_check_rcp_timeout: +; mov A, #((1 SHL RCP_PWM_FREQ_1KHZ)+(1 SHL RCP_PWM_FREQ_2KHZ)+(1 SHL RCP_PWM_FREQ_4KHZ)+(1 SHL RCP_PWM_FREQ_8KHZ)) +; anl A, Flags3 ; Check pwm frequency flags +; jnz run6_check_speed ; If a flag is set (PWM) - branch + + mov A, Rcp_Timeout_Cnt ; Load RC pulse timeout counter value + jz run_to_wait_for_power_on ; If it is zero - go back to wait for poweron + +run6_check_speed: + clr C + mov A, Comm_Period4x_H ; Is Comm_Period4x more than 32ms (~1220 eRPM)? + subb A, #0F0h + jnc run_to_wait_for_power_on ; Yes - go back to motor start + jmp run1 ; Go back to run 1 + + +run_to_wait_for_power_on: + + call switch_power_off + mov Temp1, #Pgm_Pwm_Freq + mov A, @Temp1 + mov Temp7, A ; Store setting in Temp7 + mov @Temp1, #1 ; Set low pwm mode (in order to turn off damping) + call decode_parameters ; (Decode_parameters uses Temp1 and Temp8) + mov Temp1, #Pgm_Pwm_Freq + mov A, Temp7 + mov @Temp1, A ; Restore settings + clr A + mov Requested_Pwm, A ; Set requested pwm to zero + mov Governor_Req_Pwm, A ; Set governor requested pwm to zero + mov Current_Pwm, A ; Set current pwm to zero + mov Current_Pwm_Limited, A ; Set limited current pwm to zero + mov Pwm_Motor_Idle, A ; Set motor idle to zero + clr Flags1.MOTOR_SPINNING ; Clear motor spinning flag + call wait1ms ; Wait for pwm to be stopped + call switch_power_off + call wait10ms + clr ET0 + jb Flags2.PGM_PWMOFF_DAMPED, light_damp + ajmp damp_exit + +light_damp: + jb Flags2.PGM_PWMOFF_DAMPED_LIGHT, ($+7) + setb P1.BnFET + ajmp damp_exit + jb Flags2.PGM_PWMOFF_DAMPED_FULL, high_damp + A_B_nFETs_On + ajmp damp_exit +high_damp: + All_nFETs_On +damp_exit: + +IF MODE == 0 ; Main + mov A, #((1 SHL RCP_PWM_FREQ_1KHZ)+(1 SHL RCP_PWM_FREQ_2KHZ)+(1 SHL RCP_PWM_FREQ_4KHZ)+(1 SHL RCP_PWM_FREQ_8KHZ)) + anl A, Flags3 ; Check pwm frequency flags + jnz run_to_next_state_main ; If a flag is set (PWM) - branch + + mov A, Rcp_Timeout_Cnt ; Load RC pulse timeout counter value + jnz run_to_next_state_main ; If it is not zero - branch + + jmp measure_pwm_freq_init ; If it is zero (pulses missing) - go back to measure pwm frequency + +run_to_next_state_main: + mov Temp1, #Pgm_Startup_Method ; Check if it is stepped startup + mov A, @Temp1 + jnb ACC.0, run_to_next_state_main_wait_done ; If direct startup - jump + + call wait1s ; 3 second delay before new startup (in stepped mode) + call wait1s + call wait1s +run_to_next_state_main_wait_done: +;读取Pgm_Main_Rearm_Start + mov Temp1, #Pgm_Main_Rearm_Start + mov A, @Temp1 + clr C + subb A, #1 ; Is re-armed start enabled? + jc jmp_wait_for_power_on ; No - do like tail and start immediately + + jmp validate_rcp_start ; Yes - go back to validate RC pulse +;Pgm_Main_Rearm_Start = 第2项 disabled +jmp_wait_for_power_on: + jmp wait_for_power_on ; Go back to wait for power on +ENDIF +IF MODE >= 1 ; Tail or multi +; mov A, #((1 SHL RCP_PWM_FREQ_1KHZ)+(1 SHL RCP_PWM_FREQ_2KHZ)+(1 SHL RCP_PWM_FREQ_4KHZ)+(1 SHL RCP_PWM_FREQ_8KHZ)) +; anl A, Flags3 ; Check pwm frequency flags +; jnz jmp_wait_for_power_on ; If a flag is set (PWM) - branch + + mov A, Rcp_Timeout_Cnt ; Load RC pulse timeout counter value + jnz jmp_wait_for_power_on ; If it is not zero - go back to wait for poweron + + jmp measure_pwm_freq_init ; If it is zero (pulses missing) - go back to measure pwm frequency + +jmp_wait_for_power_on: + jmp wait_for_power_on_loop ; Go back to wait for power on +ENDIF + +;**** **** **** **** **** **** **** **** **** **** **** **** **** + +$include (BLHeliTxPgm.inc) ; Include source code for programming the ESC with the TX + +;**** **** **** **** **** **** **** **** **** **** **** **** **** + + + + +END