📄 sch51a.lst
字号:
=2 #define INTERRUPT_Timer_2_Overflow 5
=2
=2 // Additional interrupts (used in shared-clock schedulers)
=2 #define INTERRUPT_EXTERNAL_0 0
=2 #define INTERRUPT_EXTERNAL_1 2
=2 #define INTERRUPT_UART_Rx_Tx 4
=2 #define INTERRUPT_CAN_c515c 17
=2
=2 //------------------------------------------------------------------
=2 // Error codes
=2 // - see Chapter 14.
=2 //------------------------------------------------------------------
=2
=2 #define ERROR_SCH_TOO_MANY_TASKS (1)
=2 #define ERROR_SCH_CANNOT_DELETE_TASK (2)
=2
=2 #define ERROR_SCH_WAITING_FOR_SLAVE_TO_ACK (3)
=2 #define ERROR_SCH_WAITING_FOR_START_COMMAND_FROM_MASTER (3)
=2
=2 #define ERROR_SCH_ONE_OR_MORE_SLAVES_DID_NOT_START (4)
=2 #define ERROR_SCH_LOST_SLAVE (5)
=2
C51 COMPILER V6.10 SCH51A 04/09/2001 15:00:14 PAGE 10
=2 #define ERROR_SCH_CAN_BUS_ERROR (6)
=2
=2 #define ERROR_I2C_WRITE_BYTE (10)
=2 #define ERROR_I2C_READ_BYTE (11)
=2 #define ERROR_I2C_WRITE_BYTE_AT24C64 (12)
=2 #define ERROR_I2C_READ_BYTE_AT24C64 (13)
=2 #define ERROR_I2C_DS1621 (14)
=2
=2 #define ERROR_USART_TI (21)
=2 #define ERROR_USART_WRITE_CHAR (22)
=2
=2 #define ERROR_SPI_EXCHANGE_BYTES_TIMEOUT (31)
=2 #define ERROR_SPI_X25_TIMEOUT (32)
=2 #define ERROR_SPI_MAX1110_TIMEOUT (33)
=2
=2 #define ERROR_ADC_MAX150_TIMEOUT (44)
=2
=2 #endif
115 =2
116 =2 /*------------------------------------------------------------------*-
117 =2 ---- END OF FILE -------------------------------------------------
118 =2 -*------------------------------------------------------------------*/
28 =1
29 =1 // ------ Public data type declarations ----------------------------
30 =1
31 =1 // Store in DATA area, if possible, for rapid access
32 =1 // Total memory per task is 5 bytes
33 =1 typedef data struct
34 =1 {
35 =1 // Pointer to the task (must be a 'void (void)' function)
36 =1 void (code * pTask)(void);
37 =1
38 =1 // Delay (ticks) until the function will (next) be run
39 =1 // - see SCH_Add_Task() for further details
40 =1 tByte Delay;
41 =1
42 =1 // Interval (ticks) between subsequent runs.
43 =1 // - see SCH_Add_Task() for further details
44 =1 tByte Period;
45 =1
46 =1 // Incremented (by scheduler) when task is due to execute
47 =1 tByte RunMe;
48 =1 } sTask;
49 =1
50 =1 // ------ Public function prototypes -------------------------------
51 =1
52 =1 // Core scheduler functions
53 =1 void SCH_Dispatch_Tasks(void);
54 =1 tByte SCH_Add_Task(void (code*) (void), const tByte, const tByte);
55 =1 bit SCH_Delete_Task(const tByte);
56 =1 void SCH_Report_Status(void);
57 =1
58 =1 // ------ Public constants -----------------------------------------
59 =1
60 =1 // The maximum number of tasks required at any one time
61 =1 // during the execution of the program
62 =1 //
63 =1 // MUST BE ADJUSTED FOR EACH NEW PROJECT
64 =1 #define SCH_MAX_TASKS (3)
65 =1
66 =1 #endif
67 =1
C51 COMPILER V6.10 SCH51A 04/09/2001 15:00:14 PAGE 11
68 =1 /*------------------------------------------------------------------*-
69 =1 ---- END OF FILE -------------------------------------------------
70 =1 -*------------------------------------------------------------------*/
71 =1
40
41 // ------ Public variable definitions ------------------------------
42
43 // The array of tasks
44 sTask SCH_tasks_G[SCH_MAX_TASKS];
45
46 // Used to display the error code
47 // See Main.H for details of error codes
48 // See Port.H for details of the error port
49 tByte Error_code_G = 0;
50
51 // ------ Private function prototypes ------------------------------
52
53 static void SCH_Go_To_Sleep(void);
54
55 // ------ Private variables ----------------------------------------
56
57 // Keeps track of time since last error was recorded (see below)
58 static tWord Error_tick_count_G;
59
60 // The code of the last error (reset after ~1 minute)
61 static tByte Last_error_code_G;
62
63
64 /*------------------------------------------------------------------*-
65
66 SCH_Dispatch_Tasks()
67
68 This is the 'dispatcher' function. When a task (function)
69 is due to run, SCH_Dispatch_Tasks() will run it.
70 This function must be called (repeatedly) from the main loop.
71
72 -*------------------------------------------------------------------*/
73 void SCH_Dispatch_Tasks(void)
74 {
75 1 tByte Index;
76 1
77 1 // Dispatches (runs) the next task (if one is ready)
78 1 for (Index = 0; Index < SCH_MAX_TASKS; Index++)
79 1 {
80 2 if (SCH_tasks_G[Index].RunMe > 0)
81 2 {
82 3 (*SCH_tasks_G[Index].pTask)(); // Run the task
83 3
84 3 SCH_tasks_G[Index].RunMe -= 1; // Reset / reduce RunMe flag
85 3
86 3 // Periodic tasks will be scheduled to run again
87 3 // - if this is a 'one shot' task, remove it from the array
88 3 if (SCH_tasks_G[Index].Period == 0)
89 3 {
90 4 SCH_Delete_Task(Index);
91 4 }
92 3 }
93 2 }
94 1
95 1 // Report system status
96 1 SCH_Report_Status();
97 1
C51 COMPILER V6.10 SCH51A 04/09/2001 15:00:14 PAGE 12
98 1 // The scheduler enters idle mode at this point
99 1 SCH_Go_To_Sleep();
100 1 }
101
102 /*------------------------------------------------------------------*-
103
104 SCH_Add_Task()
105
106 Causes a task (function) to be executed at regular intervals
107 or after a user-defined delay
108
109 Fn_P - The name of the function which is to be scheduled.
110 NOTE: All scheduled functions must be 'void, void' -
111 that is, they must take no parameters, and have
112 a void return type.
113
114 DELAY - The interval (TICKS) before the task is first executed
115
116 REPEAT - If 'REPEAT' is 0, the function is only called once,
117 at the time determined by 'DELAY'. If REPEAT is non-zero,
118 then the function is called repeatedly at an interval
119 determined by the value of REPEAT (see below for examples
120 which should help clarify this).
121
122
123 RETURN VALUE:
124
125 Returns the position in the task array at which the task has been
126 added. If the return value is SCH_MAX_TASKS then the task could
127 not be added to the array (there was insufficient space). If the
128 return value is < SCH_MAX_TASKS, then the task was added
129 successfully.
130
131 Note: this return value may be required, if a task is
132 to be subsequently deleted - see SCH_Delete_Task().
133
134 EXAMPLES:
135
136 Task_ID = SCH_Add_Task(Do_X,1000,0);
137 Causes the function Do_X() to be executed once after 1000 sch ticks.
138
139 Task_ID = SCH_Add_Task(Do_X,0,1000);
140 Causes the function Do_X() to be executed regularly, every 1000 sch ticks.
141
142 Task_ID = SCH_Add_Task(Do_X,300,1000);
143 Causes the function Do_X() to be executed regularly, every 1000 ticks.
144 Task will be first executed at T = 300 ticks, then 1300, 2300, etc.
145
146 -*------------------------------------------------------------------*/
147 tByte SCH_Add_Task(void (code * pFunction)(),
148 const tByte DELAY,
149 const tByte PERIOD)
150 {
151 1 tByte Index = 0;
152 1
153 1 // First find a gap in the array (if there is one)
154 1 while ((SCH_tasks_G[Index].pTask != 0) && (Index < SCH_MAX_TASKS))
155 1 {
156 2 Index++;
157 2 }
158 1
159 1 // Have we reached the end of the list?
C51 COMPILER V6.10 SCH51A 04/09/2001 15:00:14 PAGE 13
160 1 if (Index == SCH_MAX_TASKS)
161 1 {
162 2 // Task list is full
163 2 //
164 2 // Set the global error variable
165 2 Error_code_G = ERROR_SCH_TOO_MANY_TASKS;
166 2
167 2 // Also return an error code
168 2 return SCH_MAX_TASKS;
169 2 }
170 1
171 1 // If we're here, there is a space in the task array
172 1 SCH_tasks_G[Index].pTask = pFunction;
173 1
174 1 SCH_tasks_G[Index].Delay = DELAY;
175 1 SCH_tasks_G[Index].Period = PERIOD;
176 1
177 1 SCH_tasks_G[Index].RunMe = 0;
178 1
179 1 return Index; // return position of task (to allow later deletion)
180 1 }
181
182 /*------------------------------------------------------------------*-
183
184 SCH_Delete_Task()
185
186 Removes a task from the scheduler. Note that this does
187 *not* delete the associated function from memory:
188 it simply means that it is no longer called by the scheduler.
189
190 TASK_INDEX - The task index. Provided by SCH_Add_Task().
191
192 RETURN VALUE: RETURN_ERROR or RETURN_NORMAL
193
194 -*------------------------------------------------------------------*/
195 bit SCH_Delete_Task(const tByte TASK_INDEX)
196 {
197 1 bit Return_code;
198 1
199 1 if (SCH_tasks_G[TASK_INDEX].pTask == 0)
200 1 {
201 2 // No task at this location...
202 2 //
203 2 // Set the global error variable
204 2 Error_code_G = ERROR_SCH_CANNOT_DELETE_TASK;
205 2
206 2 // ...also return an error code
207 2 Return_code = RETURN_ERROR;
208 2 }
209 1 else
210 1 {
211 2 Return_code = RETURN_NORMAL;
212 2 }
213 1
214 1 SCH_tasks_G[TASK_INDEX].pTask = 0x0000;
215 1 SCH_tasks_G[TASK_INDEX].Delay = 0;
216 1 SCH_tasks_G[TASK_INDEX].Period = 0;
217 1
218 1 SCH_tasks_G[TASK_INDEX].RunMe = 0;
219 1
220 1 return Return_code; // return status
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -