├── .gitignore
├── project.uvproj
└── src
    ├── STARTUP.A51
    ├── STC15Fxxxx.H
    ├── adsensor.c
    ├── adsensor.h
    ├── bit_ops.h
    ├── button.c
    ├── button.h
    ├── config.h
    ├── ds1302.c
    ├── ds1302.h
    ├── events.c
    ├── events.h
    ├── global.h
    ├── main.c
    ├── random.c
    ├── random.h
    ├── rs485.c
    ├── rs485.h
    ├── scheduler.c
    ├── scheduler.h
    ├── seg_led.c
    ├── seg_led.h
    ├── semaphore.c
    ├── semaphore.h
    ├── spin.c
    ├── spin.h
    ├── stack.c
    ├── stack.h
    ├── stack.inc
    ├── stc15fxxxx.inc
    ├── syscall.a51
    ├── syscall.h
    ├── syscall_c.c
    ├── timer0_isr.a51
    ├── timer0_isr.h
    ├── timer0_isr_c.c
    ├── usbcom.c
    ├── usbcom.h
    ├── xbp_helper.a51
    ├── xstack.c
    ├── xstack.h
    └── xstack.inc


/.gitignore:
--------------------------------------------------------------------------------
1 | /Listings
2 | /Objects
3 | *.bak
4 | *.uvgui.*
5 | *.uvopt
6 | 


--------------------------------------------------------------------------------
/project.uvproj:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="UTF-8" standalone="no" ?>
  2 | <Project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="project_proj.xsd">
  3 | 
  4 |   <SchemaVersion>1.1</SchemaVersion>
  5 | 
  6 |   <Header>### uVision Project, (C) Keil Software</Header>
  7 | 
  8 |   <Targets>
  9 |     <Target>
 10 |       <TargetName>Target 1</TargetName>
 11 |       <ToolsetNumber>0x0</ToolsetNumber>
 12 |       <ToolsetName>MCS-51</ToolsetName>
 13 |       <TargetOption>
 14 |         <TargetCommonOption>
 15 |           <Device>STC15F2K60S2</Device>
 16 |           <Vendor>STC</Vendor>
 17 |           <Cpu>IRAM(0-0xFF) XRAM(0-0x6FF) IROM(0-0xEFF8) CLOCK(35000000) MODP2</Cpu>
 18 |           <FlashUtilSpec></FlashUtilSpec>
 19 |           <StartupFile>"LIB\STARTUP.A51" ("Standard 8051 Startup Code")</StartupFile>
 20 |           <FlashDriverDll></FlashDriverDll>
 21 |           <DeviceId>62472</DeviceId>
 22 |           <RegisterFile>STC15F2K60S2.H</RegisterFile>
 23 |           <MemoryEnv></MemoryEnv>
 24 |           <Cmp></Cmp>
 25 |           <Asm></Asm>
 26 |           <Linker></Linker>
 27 |           <OHString></OHString>
 28 |           <InfinionOptionDll></InfinionOptionDll>
 29 |           <SLE66CMisc></SLE66CMisc>
 30 |           <SLE66AMisc></SLE66AMisc>
 31 |           <SLE66LinkerMisc></SLE66LinkerMisc>
 32 |           <SFDFile></SFDFile>
 33 |           <UseEnv>0</UseEnv>
 34 |           <BinPath></BinPath>
 35 |           <IncludePath></IncludePath>
 36 |           <LibPath></LibPath>
 37 |           <RegisterFilePath>STC\</RegisterFilePath>
 38 |           <DBRegisterFilePath>STC\</DBRegisterFilePath>
 39 |           <TargetStatus>
 40 |             <Error>0</Error>
 41 |             <ExitCodeStop>0</ExitCodeStop>
 42 |             <ButtonStop>0</ButtonStop>
 43 |             <NotGenerated>0</NotGenerated>
 44 |             <InvalidFlash>1</InvalidFlash>
 45 |           </TargetStatus>
 46 |           <OutputDirectory>.\Objects\</OutputDirectory>
 47 |           <OutputName>project</OutputName>
 48 |           <CreateExecutable>1</CreateExecutable>
 49 |           <CreateLib>0</CreateLib>
 50 |           <CreateHexFile>1</CreateHexFile>
 51 |           <DebugInformation>1</DebugInformation>
 52 |           <BrowseInformation>1</BrowseInformation>
 53 |           <ListingPath>.\Listings\</ListingPath>
 54 |           <HexFormatSelection>0</HexFormatSelection>
 55 |           <Merge32K>0</Merge32K>
 56 |           <CreateBatchFile>0</CreateBatchFile>
 57 |           <BeforeCompile>
 58 |             <RunUserProg1>0</RunUserProg1>
 59 |             <RunUserProg2>0</RunUserProg2>
 60 |             <UserProg1Name></UserProg1Name>
 61 |             <UserProg2Name></UserProg2Name>
 62 |             <UserProg1Dos16Mode>0</UserProg1Dos16Mode>
 63 |             <UserProg2Dos16Mode>0</UserProg2Dos16Mode>
 64 |             <nStopU1X>0</nStopU1X>
 65 |             <nStopU2X>0</nStopU2X>
 66 |           </BeforeCompile>
 67 |           <BeforeMake>
 68 |             <RunUserProg1>0</RunUserProg1>
 69 |             <RunUserProg2>0</RunUserProg2>
 70 |             <UserProg1Name></UserProg1Name>
 71 |             <UserProg2Name></UserProg2Name>
 72 |             <UserProg1Dos16Mode>0</UserProg1Dos16Mode>
 73 |             <UserProg2Dos16Mode>0</UserProg2Dos16Mode>
 74 |           </BeforeMake>
 75 |           <AfterMake>
 76 |             <RunUserProg1>0</RunUserProg1>
 77 |             <RunUserProg2>0</RunUserProg2>
 78 |             <UserProg1Name></UserProg1Name>
 79 |             <UserProg2Name></UserProg2Name>
 80 |             <UserProg1Dos16Mode>0</UserProg1Dos16Mode>
 81 |             <UserProg2Dos16Mode>0</UserProg2Dos16Mode>
 82 |           </AfterMake>
 83 |           <SelectedForBatchBuild>0</SelectedForBatchBuild>
 84 |           <SVCSIdString></SVCSIdString>
 85 |         </TargetCommonOption>
 86 |         <CommonProperty>
 87 |           <UseCPPCompiler>0</UseCPPCompiler>
 88 |           <RVCTCodeConst>0</RVCTCodeConst>
 89 |           <RVCTZI>0</RVCTZI>
 90 |           <RVCTOtherData>0</RVCTOtherData>
 91 |           <ModuleSelection>0</ModuleSelection>
 92 |           <IncludeInBuild>1</IncludeInBuild>
 93 |           <AlwaysBuild>0</AlwaysBuild>
 94 |           <GenerateAssemblyFile>0</GenerateAssemblyFile>
 95 |           <AssembleAssemblyFile>0</AssembleAssemblyFile>
 96 |           <PublicsOnly>0</PublicsOnly>
 97 |           <StopOnExitCode>3</StopOnExitCode>
 98 |           <CustomArgument></CustomArgument>
 99 |           <IncludeLibraryModules></IncludeLibraryModules>
100 |           <BankNo>65535</BankNo>
101 |         </CommonProperty>
102 |         <DllOption>
103 |           <SimDllName>S8051.DLL</SimDllName>
104 |           <SimDllArguments></SimDllArguments>
105 |           <SimDlgDll>DP51.DLL</SimDlgDll>
106 |           <SimDlgDllArguments>-pDP8051</SimDlgDllArguments>
107 |           <TargetDllName>S8051.DLL</TargetDllName>
108 |           <TargetDllArguments></TargetDllArguments>
109 |           <TargetDlgDll>TP51.DLL</TargetDlgDll>
110 |           <TargetDlgDllArguments>-p51</TargetDlgDllArguments>
111 |         </DllOption>
112 |         <DebugOption>
113 |           <OPTHX>
114 |             <HexSelection>0</HexSelection>
115 |             <HexRangeLowAddress>0</HexRangeLowAddress>
116 |             <HexRangeHighAddress>0</HexRangeHighAddress>
117 |             <HexOffset>0</HexOffset>
118 |             <Oh166RecLen>16</Oh166RecLen>
119 |           </OPTHX>
120 |           <Simulator>
121 |             <UseSimulator>1</UseSimulator>
122 |             <LoadApplicationAtStartup>1</LoadApplicationAtStartup>
123 |             <RunToMain>1</RunToMain>
124 |             <RestoreBreakpoints>1</RestoreBreakpoints>
125 |             <RestoreWatchpoints>1</RestoreWatchpoints>
126 |             <RestoreMemoryDisplay>1</RestoreMemoryDisplay>
127 |             <RestoreFunctions>1</RestoreFunctions>
128 |             <RestoreToolbox>1</RestoreToolbox>
129 |             <LimitSpeedToRealTime>0</LimitSpeedToRealTime>
130 |           </Simulator>
131 |           <Target>
132 |             <UseTarget>0</UseTarget>
133 |             <LoadApplicationAtStartup>1</LoadApplicationAtStartup>
134 |             <RunToMain>0</RunToMain>
135 |             <RestoreBreakpoints>1</RestoreBreakpoints>
136 |             <RestoreWatchpoints>1</RestoreWatchpoints>
137 |             <RestoreMemoryDisplay>1</RestoreMemoryDisplay>
138 |             <RestoreFunctions>0</RestoreFunctions>
139 |             <RestoreToolbox>1</RestoreToolbox>
140 |             <RestoreTracepoints>1</RestoreTracepoints>
141 |           </Target>
142 |           <RunDebugAfterBuild>0</RunDebugAfterBuild>
143 |           <TargetSelection>-1</TargetSelection>
144 |           <SimDlls>
145 |             <CpuDll></CpuDll>
146 |             <CpuDllArguments></CpuDllArguments>
147 |             <PeripheralDll></PeripheralDll>
148 |             <PeripheralDllArguments></PeripheralDllArguments>
149 |             <InitializationFile></InitializationFile>
150 |           </SimDlls>
151 |           <TargetDlls>
152 |             <CpuDll></CpuDll>
153 |             <CpuDllArguments></CpuDllArguments>
154 |             <PeripheralDll></PeripheralDll>
155 |             <PeripheralDllArguments></PeripheralDllArguments>
156 |             <InitializationFile></InitializationFile>
157 |             <Driver></Driver>
158 |           </TargetDlls>
159 |         </DebugOption>
160 |         <Utilities>
161 |           <Flash1>
162 |             <UseTargetDll>0</UseTargetDll>
163 |             <UseExternalTool>0</UseExternalTool>
164 |             <RunIndependent>0</RunIndependent>
165 |             <UpdateFlashBeforeDebugging>0</UpdateFlashBeforeDebugging>
166 |             <Capability>0</Capability>
167 |             <DriverSelection>-1</DriverSelection>
168 |           </Flash1>
169 |           <Flash2></Flash2>
170 |           <Flash3></Flash3>
171 |           <Flash4></Flash4>
172 |         </Utilities>
173 |         <Target51>
174 |           <Target51Misc>
175 |             <MemoryModel>2</MemoryModel>
176 |             <RTOS>0</RTOS>
177 |             <RomSize>2</RomSize>
178 |             <DataHold>0</DataHold>
179 |             <XDataHold>0</XDataHold>
180 |             <UseOnchipRom>0</UseOnchipRom>
181 |             <UseOnchipArithmetic>0</UseOnchipArithmetic>
182 |             <UseMultipleDPTR>0</UseMultipleDPTR>
183 |             <UseOnchipXram>0</UseOnchipXram>
184 |             <HadIRAM>1</HadIRAM>
185 |             <HadXRAM>1</HadXRAM>
186 |             <HadIROM>1</HadIROM>
187 |             <Moda2>0</Moda2>
188 |             <Moddp2>0</Moddp2>
189 |             <Modp2>1</Modp2>
190 |             <Mod517dp>0</Mod517dp>
191 |             <Mod517au>0</Mod517au>
192 |             <Mode2>0</Mode2>
193 |             <useCB>0</useCB>
194 |             <useXB>0</useXB>
195 |             <useL251>1</useL251>
196 |             <useA251>1</useA251>
197 |             <Mx51>0</Mx51>
198 |             <ModC812>0</ModC812>
199 |             <ModCont>0</ModCont>
200 |             <Lp51>0</Lp51>
201 |             <useXBS>0</useXBS>
202 |             <ModDA>0</ModDA>
203 |             <ModAB2>0</ModAB2>
204 |             <Mx51P>0</Mx51P>
205 |             <hadXRAM2>0</hadXRAM2>
206 |             <uocXram2>0</uocXram2>
207 |             <ModC2>0</ModC2>
208 |             <ModH2>0</ModH2>
209 |             <Mdu_R515>0</Mdu_R515>
210 |             <Mdu_F120>0</Mdu_F120>
211 |             <Psoc>0</Psoc>
212 |             <hadIROM2>0</hadIROM2>
213 |             <ModSmx2>0</ModSmx2>
214 |             <cBanks>0</cBanks>
215 |             <xBanks>0</xBanks>
216 |             <OnChipMemories>
217 |               <RCB>
218 |                 <Type>0</Type>
219 |                 <StartAddress>0x0</StartAddress>
220 |                 <Size>0xffff</Size>
221 |               </RCB>
222 |               <RXB>
223 |                 <Type>0</Type>
224 |                 <StartAddress>0x0</StartAddress>
225 |                 <Size>0x0</Size>
226 |               </RXB>
227 |               <Ocm1>
228 |                 <Type>0</Type>
229 |                 <StartAddress>0x0</StartAddress>
230 |                 <Size>0x0</Size>
231 |               </Ocm1>
232 |               <Ocm2>
233 |                 <Type>0</Type>
234 |                 <StartAddress>0x0</StartAddress>
235 |                 <Size>0x0</Size>
236 |               </Ocm2>
237 |               <Ocm3>
238 |                 <Type>0</Type>
239 |                 <StartAddress>0x0</StartAddress>
240 |                 <Size>0x0</Size>
241 |               </Ocm3>
242 |               <Ocr1>
243 |                 <Type>0</Type>
244 |                 <StartAddress>0x0</StartAddress>
245 |                 <Size>0x0</Size>
246 |               </Ocr1>
247 |               <Ocr2>
248 |                 <Type>0</Type>
249 |                 <StartAddress>0x0</StartAddress>
250 |                 <Size>0x0</Size>
251 |               </Ocr2>
252 |               <Ocr3>
253 |                 <Type>0</Type>
254 |                 <StartAddress>0x0</StartAddress>
255 |                 <Size>0x0</Size>
256 |               </Ocr3>
257 |               <IRO>
258 |                 <Type>1</Type>
259 |                 <StartAddress>0x0</StartAddress>
260 |                 <Size>0xeff9</Size>
261 |               </IRO>
262 |               <IRA>
263 |                 <Type>0</Type>
264 |                 <StartAddress>0x0</StartAddress>
265 |                 <Size>0x100</Size>
266 |               </IRA>
267 |               <XRA>
268 |                 <Type>0</Type>
269 |                 <StartAddress>0x0</StartAddress>
270 |                 <Size>0x700</Size>
271 |               </XRA>
272 |               <XRA512>
273 |                 <Type>0</Type>
274 |                 <StartAddress>0x0</StartAddress>
275 |                 <Size>0x0</Size>
276 |               </XRA512>
277 |               <IROM512>
278 |                 <Type>0</Type>
279 |                 <StartAddress>0x0</StartAddress>
280 |                 <Size>0x0</Size>
281 |               </IROM512>
282 |             </OnChipMemories>
283 |           </Target51Misc>
284 |           <C51>
285 |             <RegisterColoring>0</RegisterColoring>
286 |             <VariablesInOrder>0</VariablesInOrder>
287 |             <IntegerPromotion>1</IntegerPromotion>
288 |             <uAregs>0</uAregs>
289 |             <UseInterruptVector>1</UseInterruptVector>
290 |             <Fuzzy>3</Fuzzy>
291 |             <Optimize>0</Optimize>
292 |             <WarningLevel>2</WarningLevel>
293 |             <SizeSpeed>1</SizeSpeed>
294 |             <ObjectExtend>1</ObjectExtend>
295 |             <ACallAJmp>0</ACallAJmp>
296 |             <InterruptVectorAddress>0</InterruptVectorAddress>
297 |             <VariousControls>
298 |               <MiscControls></MiscControls>
299 |               <Define></Define>
300 |               <Undefine></Undefine>
301 |               <IncludePath></IncludePath>
302 |             </VariousControls>
303 |           </C51>
304 |           <Ax51>
305 |             <UseMpl>0</UseMpl>
306 |             <UseStandard>1</UseStandard>
307 |             <UseCase>0</UseCase>
308 |             <UseMod51>0</UseMod51>
309 |             <VariousControls>
310 |               <MiscControls></MiscControls>
311 |               <Define></Define>
312 |               <Undefine></Undefine>
313 |               <IncludePath></IncludePath>
314 |             </VariousControls>
315 |           </Ax51>
316 |           <Lx51>
317 |             <useFile>0</useFile>
318 |             <linkonly>0</linkonly>
319 |             <UseMemoryFromTarget>1</UseMemoryFromTarget>
320 |             <CaseSensitiveSymbols>0</CaseSensitiveSymbols>
321 |             <WarningLevel>2</WarningLevel>
322 |             <DataOverlaying>1</DataOverlaying>
323 |             <OverlayString></OverlayString>
324 |             <MiscControls></MiscControls>
325 |             <DisableWarningNumbers></DisableWarningNumbers>
326 |             <LinkerCmdFile></LinkerCmdFile>
327 |             <Assign></Assign>
328 |             <ReserveString></ReserveString>
329 |             <CClasses></CClasses>
330 |             <UserClasses></UserClasses>
331 |             <CSection></CSection>
332 |             <UserSection></UserSection>
333 |             <CodeBaseAddress></CodeBaseAddress>
334 |             <XDataBaseAddress></XDataBaseAddress>
335 |             <PDataBaseAddress></PDataBaseAddress>
336 |             <BitBaseAddress></BitBaseAddress>
337 |             <DataBaseAddress></DataBaseAddress>
338 |             <IDataBaseAddress></IDataBaseAddress>
339 |             <Precede></Precede>
340 |             <Stack></Stack>
341 |             <CodeSegmentName></CodeSegmentName>
342 |             <XDataSegmentName></XDataSegmentName>
343 |             <BitSegmentName></BitSegmentName>
344 |             <DataSegmentName></DataSegmentName>
345 |             <IDataSegmentName></IDataSegmentName>
346 |           </Lx51>
347 |         </Target51>
348 |       </TargetOption>
349 |       <Groups>
350 |         <Group>
351 |           <GroupName>stack</GroupName>
352 |           <Files>
353 |             <File>
354 |               <FileName>stack.c</FileName>
355 |               <FileType>1</FileType>
356 |               <FilePath>.\src\stack.c</FilePath>
357 |             </File>
358 |             <File>
359 |               <FileName>stack.inc</FileName>
360 |               <FileType>5</FileType>
361 |               <FilePath>.\src\stack.inc</FilePath>
362 |             </File>
363 |             <File>
364 |               <FileName>stack.h</FileName>
365 |               <FileType>5</FileType>
366 |               <FilePath>.\src\stack.h</FilePath>
367 |             </File>
368 |           </Files>
369 |         </Group>
370 |         <Group>
371 |           <GroupName>xstack</GroupName>
372 |           <Files>
373 |             <File>
374 |               <FileName>xstack.c</FileName>
375 |               <FileType>1</FileType>
376 |               <FilePath>.\src\xstack.c</FilePath>
377 |             </File>
378 |             <File>
379 |               <FileName>xstack.h</FileName>
380 |               <FileType>5</FileType>
381 |               <FilePath>.\src\xstack.h</FilePath>
382 |             </File>
383 |             <File>
384 |               <FileName>xstack.inc</FileName>
385 |               <FileType>5</FileType>
386 |               <FilePath>.\src\xstack.inc</FilePath>
387 |             </File>
388 |             <File>
389 |               <FileName>xbp_helper.a51</FileName>
390 |               <FileType>2</FileType>
391 |               <FilePath>.\src\xbp_helper.a51</FilePath>
392 |             </File>
393 |           </Files>
394 |         </Group>
395 |         <Group>
396 |           <GroupName>utils</GroupName>
397 |           <Files>
398 |             <File>
399 |               <FileName>random.c</FileName>
400 |               <FileType>1</FileType>
401 |               <FilePath>.\src\random.c</FilePath>
402 |             </File>
403 |             <File>
404 |               <FileName>spin.c</FileName>
405 |               <FileType>1</FileType>
406 |               <FilePath>.\src\spin.c</FilePath>
407 |             </File>
408 |             <File>
409 |               <FileName>random.h</FileName>
410 |               <FileType>5</FileType>
411 |               <FilePath>.\src\random.h</FilePath>
412 |             </File>
413 |             <File>
414 |               <FileName>spin.h</FileName>
415 |               <FileType>5</FileType>
416 |               <FilePath>.\src\spin.h</FilePath>
417 |             </File>
418 |             <File>
419 |               <FileName>bit_ops.h</FileName>
420 |               <FileType>5</FileType>
421 |               <FilePath>.\src\bit_ops.h</FilePath>
422 |             </File>
423 |           </Files>
424 |         </Group>
425 |         <Group>
426 |           <GroupName>drivers</GroupName>
427 |           <Files>
428 |             <File>
429 |               <FileName>adsensor.c</FileName>
430 |               <FileType>1</FileType>
431 |               <FilePath>.\src\adsensor.c</FilePath>
432 |             </File>
433 |             <File>
434 |               <FileName>button.c</FileName>
435 |               <FileType>1</FileType>
436 |               <FilePath>.\src\button.c</FilePath>
437 |             </File>
438 |             <File>
439 |               <FileName>ds1302.c</FileName>
440 |               <FileType>1</FileType>
441 |               <FilePath>.\src\ds1302.c</FilePath>
442 |             </File>
443 |             <File>
444 |               <FileName>rs485.c</FileName>
445 |               <FileType>1</FileType>
446 |               <FilePath>.\src\rs485.c</FilePath>
447 |             </File>
448 |             <File>
449 |               <FileName>usbcom.c</FileName>
450 |               <FileType>1</FileType>
451 |               <FilePath>.\src\usbcom.c</FilePath>
452 |             </File>
453 |             <File>
454 |               <FileName>adsensor.h</FileName>
455 |               <FileType>5</FileType>
456 |               <FilePath>.\src\adsensor.h</FilePath>
457 |             </File>
458 |             <File>
459 |               <FileName>button.h</FileName>
460 |               <FileType>5</FileType>
461 |               <FilePath>.\src\button.h</FilePath>
462 |             </File>
463 |             <File>
464 |               <FileName>ds1302.h</FileName>
465 |               <FileType>5</FileType>
466 |               <FilePath>.\src\ds1302.h</FilePath>
467 |             </File>
468 |             <File>
469 |               <FileName>rs485.h</FileName>
470 |               <FileType>5</FileType>
471 |               <FilePath>.\src\rs485.h</FilePath>
472 |             </File>
473 |             <File>
474 |               <FileName>usbcom.h</FileName>
475 |               <FileType>5</FileType>
476 |               <FilePath>.\src\usbcom.h</FilePath>
477 |             </File>
478 |             <File>
479 |               <FileName>seg_led.c</FileName>
480 |               <FileType>1</FileType>
481 |               <FilePath>.\src\seg_led.c</FilePath>
482 |             </File>
483 |             <File>
484 |               <FileName>seg_led.h</FileName>
485 |               <FileType>5</FileType>
486 |               <FilePath>.\src\seg_led.h</FilePath>
487 |             </File>
488 |           </Files>
489 |         </Group>
490 |         <Group>
491 |           <GroupName>semaphore</GroupName>
492 |           <Files>
493 |             <File>
494 |               <FileName>semaphore.c</FileName>
495 |               <FileType>1</FileType>
496 |               <FilePath>.\src\semaphore.c</FilePath>
497 |             </File>
498 |             <File>
499 |               <FileName>semaphore.h</FileName>
500 |               <FileType>5</FileType>
501 |               <FilePath>.\src\semaphore.h</FilePath>
502 |             </File>
503 |           </Files>
504 |         </Group>
505 |         <Group>
506 |           <GroupName>events</GroupName>
507 |           <Files>
508 |             <File>
509 |               <FileName>events.c</FileName>
510 |               <FileType>1</FileType>
511 |               <FilePath>.\src\events.c</FilePath>
512 |             </File>
513 |             <File>
514 |               <FileName>events.h</FileName>
515 |               <FileType>5</FileType>
516 |               <FilePath>.\src\events.h</FilePath>
517 |             </File>
518 |           </Files>
519 |         </Group>
520 |         <Group>
521 |           <GroupName>scheduler</GroupName>
522 |           <Files>
523 |             <File>
524 |               <FileName>scheduler.c</FileName>
525 |               <FileType>1</FileType>
526 |               <FilePath>.\src\scheduler.c</FilePath>
527 |             </File>
528 |             <File>
529 |               <FileName>scheduler.h</FileName>
530 |               <FileType>5</FileType>
531 |               <FilePath>.\src\scheduler.h</FilePath>
532 |             </File>
533 |           </Files>
534 |         </Group>
535 |         <Group>
536 |           <GroupName>timer0_isr</GroupName>
537 |           <Files>
538 |             <File>
539 |               <FileName>timer0_isr_c.c</FileName>
540 |               <FileType>1</FileType>
541 |               <FilePath>.\src\timer0_isr_c.c</FilePath>
542 |             </File>
543 |             <File>
544 |               <FileName>timer0_isr.h</FileName>
545 |               <FileType>5</FileType>
546 |               <FilePath>.\src\timer0_isr.h</FilePath>
547 |             </File>
548 |             <File>
549 |               <FileName>timer0_isr.a51</FileName>
550 |               <FileType>2</FileType>
551 |               <FilePath>.\src\timer0_isr.a51</FilePath>
552 |             </File>
553 |           </Files>
554 |         </Group>
555 |         <Group>
556 |           <GroupName>syscall</GroupName>
557 |           <Files>
558 |             <File>
559 |               <FileName>syscall_c.c</FileName>
560 |               <FileType>1</FileType>
561 |               <FilePath>.\src\syscall_c.c</FilePath>
562 |             </File>
563 |             <File>
564 |               <FileName>syscall.h</FileName>
565 |               <FileType>5</FileType>
566 |               <FilePath>.\src\syscall.h</FilePath>
567 |             </File>
568 |             <File>
569 |               <FileName>syscall.a51</FileName>
570 |               <FileType>2</FileType>
571 |               <FilePath>.\src\syscall.a51</FilePath>
572 |             </File>
573 |           </Files>
574 |         </Group>
575 |         <Group>
576 |           <GroupName>startup</GroupName>
577 |           <Files>
578 |             <File>
579 |               <FileName>main.c</FileName>
580 |               <FileType>1</FileType>
581 |               <FilePath>.\src\main.c</FilePath>
582 |             </File>
583 |             <File>
584 |               <FileName>STARTUP.A51</FileName>
585 |               <FileType>2</FileType>
586 |               <FilePath>.\src\STARTUP.A51</FilePath>
587 |             </File>
588 |           </Files>
589 |         </Group>
590 |         <Group>
591 |           <GroupName>stc</GroupName>
592 |           <Files>
593 |             <File>
594 |               <FileName>global.h</FileName>
595 |               <FileType>5</FileType>
596 |               <FilePath>.\src\global.h</FilePath>
597 |             </File>
598 |             <File>
599 |               <FileName>STC15Fxxxx.H</FileName>
600 |               <FileType>5</FileType>
601 |               <FilePath>.\src\STC15Fxxxx.H</FilePath>
602 |             </File>
603 |             <File>
604 |               <FileName>stc15fxxxx.inc</FileName>
605 |               <FileType>5</FileType>
606 |               <FilePath>.\src\stc15fxxxx.inc</FilePath>
607 |             </File>
608 |             <File>
609 |               <FileName>config.h</FileName>
610 |               <FileType>5</FileType>
611 |               <FilePath>.\src\config.h</FilePath>
612 |             </File>
613 |           </Files>
614 |         </Group>
615 |       </Groups>
616 |     </Target>
617 |   </Targets>
618 | 
619 | </Project>
620 | 


--------------------------------------------------------------------------------
/src/STARTUP.A51:
--------------------------------------------------------------------------------
  1 | $NOMOD51
  2 | ;------------------------------------------------------------------------------
  3 | ;  This file is part of the C51 Compiler package
  4 | ;  Copyright (c) 1988-2005 Keil Elektronik GmbH and Keil Software, Inc.
  5 | ;  Version 8.01
  6 | ;
  7 | ;  *** <<< Use Configuration Wizard in Context Menu >>> ***
  8 | ;------------------------------------------------------------------------------
  9 | ;  STARTUP.A51:  This code is executed after processor reset.
 10 | ;
 11 | ;  To translate this file use A51 with the following invocation:
 12 | ;
 13 | ;     A51 STARTUP.A51
 14 | ;
 15 | ;  To link the modified STARTUP.OBJ file to your application use the following
 16 | ;  Lx51 invocation:
 17 | ;
 18 | ;     Lx51 your object file list, STARTUP.OBJ  controls
 19 | ;
 20 | ;------------------------------------------------------------------------------
 21 | ;
 22 | ;  User-defined <h> Power-On Initialization of Memory
 23 | ;
 24 | ;  With the following EQU statements the initialization of memory
 25 | ;  at processor reset can be defined:
 26 | ;
 27 | ; <o> IDATALEN: IDATA memory size <0x0-0x100>
 28 | ;     <i> Note: The absolute start-address of IDATA memory is always 0
 29 | ;     <i>       The IDATA space overlaps physically the DATA and BIT areas.
 30 | IDATALEN        EQU     256
 31 | ;
 32 | ; <o> XDATASTART: XDATA memory start address <0x0-0xFFFF> 
 33 | ;     <i> The absolute start address of XDATA memory
 34 | XDATASTART      EQU     0     
 35 | ;
 36 | ; <o> XDATALEN: XDATA memory size <0x0-0xFFFF> 
 37 | ;     <i> The length of XDATA memory in bytes.
 38 | XDATALEN        EQU     2048-256      
 39 | ;
 40 | ; <o> PDATASTART: PDATA memory start address <0x0-0xFFFF> 
 41 | ;     <i> The absolute start address of PDATA memory
 42 | PDATASTART      EQU     0H
 43 | ;
 44 | ; <o> PDATALEN: PDATA memory size <0x0-0xFF> 
 45 | ;     <i> The length of PDATA memory in bytes.
 46 | PDATALEN        EQU     0H
 47 | ;
 48 | ;</h>
 49 | ;------------------------------------------------------------------------------
 50 | ;
 51 | ;<h> Reentrant Stack Initialization
 52 | ;
 53 | ;  The following EQU statements define the stack pointer for reentrant
 54 | ;  functions and initialized it:
 55 | ;
 56 | ; <h> Stack Space for reentrant functions in the SMALL model.
 57 | ;  <q> IBPSTACK: Enable SMALL model reentrant stack
 58 | ;     <i> Stack space for reentrant functions in the SMALL model.
 59 | IBPSTACK        EQU     0       ; set to 1 if small reentrant is used.
 60 | ;  <o> IBPSTACKTOP: End address of SMALL model stack <0x0-0xFF>
 61 | ;     <i> Set the top of the stack to the highest location.
 62 | IBPSTACKTOP     EQU     0xFF +1     ; default 0FFH+1  
 63 | ; </h>
 64 | ;
 65 | ; <h> Stack Space for reentrant functions in the LARGE model.      
 66 | ;  <q> XBPSTACK: Enable LARGE model reentrant stack
 67 | ;     <i> Stack space for reentrant functions in the LARGE model.
 68 | XBPSTACK        EQU     1       ; set to 1 if large reentrant is used.
 69 | ;  <o> XBPSTACKTOP: End address of LARGE model stack <0x0-0xFFFF>
 70 | ;     <i> Set the top of the stack to the highest location.
 71 | XBPSTACKTOP     EQU     0xFFFF +1   ; default 0FFFFH+1 
 72 | ; </h>
 73 | ;
 74 | ; <h> Stack Space for reentrant functions in the COMPACT model.    
 75 | ;  <q> PBPSTACK: Enable COMPACT model reentrant stack
 76 | ;     <i> Stack space for reentrant functions in the COMPACT model.
 77 | PBPSTACK        EQU     0       ; set to 1 if compact reentrant is used.
 78 | ;
 79 | ;   <o> PBPSTACKTOP: End address of COMPACT model stack <0x0-0xFFFF>
 80 | ;     <i> Set the top of the stack to the highest location.
 81 | PBPSTACKTOP     EQU     0xFF +1     ; default 0FFH+1  
 82 | ; </h>
 83 | ;</h>
 84 | ;------------------------------------------------------------------------------
 85 | ;
 86 | ;  Memory Page for Using the Compact Model with 64 KByte xdata RAM
 87 | ;  <e>Compact Model Page Definition
 88 | ;
 89 | ;  <i>Define the XDATA page used for PDATA variables. 
 90 | ;  <i>PPAGE must conform with the PPAGE set in the linker invocation.
 91 | ;
 92 | ; Enable pdata memory page initalization
 93 | PPAGEENABLE     EQU     0       ; set to 1 if pdata object are used.
 94 | ;
 95 | ; <o> PPAGE number <0x0-0xFF> 
 96 | ; <i> uppermost 256-byte address of the page used for PDATA variables.
 97 | PPAGE           EQU     0
 98 | ;
 99 | ; <o> SFR address which supplies uppermost address byte <0x0-0xFF> 
100 | ; <i> most 8051 variants use P2 as uppermost address byte
101 | PPAGE_SFR       DATA    0A0H
102 | ;
103 | ; </e>
104 | ;------------------------------------------------------------------------------
105 | 
106 | ; Standard SFR Symbols 
107 | ACC     DATA    0E0H
108 | B       DATA    0F0H
109 | SP      DATA    81H
110 | DPL     DATA    82H
111 | DPH     DATA    83H
112 | 
113 |                 NAME    ?C_STARTUP
114 | 
115 | 
116 | ?C_C51STARTUP   SEGMENT   CODE
117 | ?STACK          SEGMENT   IDATA
118 | 
119 |                 RSEG    ?STACK
120 |                 DS      1
121 | 
122 |                 EXTRN CODE (?C_START)
123 |                 PUBLIC  ?C_STARTUP
124 | 
125 |                 CSEG    AT      0
126 | ?C_STARTUP:     LJMP    STARTUP1
127 | 
128 |                 RSEG    ?C_C51STARTUP
129 | 
130 | STARTUP1:
131 | 
132 | IF IDATALEN <> 0
133 |                 MOV     R0,#IDATALEN - 1
134 |                 CLR     A
135 | IDATALOOP:      MOV     @R0,A
136 |                 DJNZ    R0,IDATALOOP
137 | ENDIF
138 | 
139 | IF XDATALEN <> 0
140 |                 MOV     DPTR,#XDATASTART
141 |                 MOV     R7,#LOW (XDATALEN)
142 |   IF (LOW (XDATALEN)) <> 0
143 |                 MOV     R6,#(HIGH (XDATALEN)) +1
144 |   ELSE
145 |                 MOV     R6,#HIGH (XDATALEN)
146 |   ENDIF
147 |                 CLR     A
148 | XDATALOOP:      MOVX    @DPTR,A
149 |                 INC     DPTR
150 |                 DJNZ    R7,XDATALOOP
151 |                 DJNZ    R6,XDATALOOP
152 | ENDIF
153 | 
154 | IF PPAGEENABLE <> 0
155 |                 MOV     PPAGE_SFR,#PPAGE
156 | ENDIF
157 | 
158 | IF PDATALEN <> 0
159 |                 MOV     R0,#LOW (PDATASTART)
160 |                 MOV     R7,#LOW (PDATALEN)
161 |                 CLR     A
162 | PDATALOOP:      MOVX    @R0,A
163 |                 INC     R0
164 |                 DJNZ    R7,PDATALOOP
165 | ENDIF
166 | 
167 | IF IBPSTACK <> 0
168 | EXTRN DATA (?C_IBP)
169 | 
170 |                 MOV     ?C_IBP,#LOW IBPSTACKTOP
171 | ENDIF
172 | 
173 | IF XBPSTACK <> 0
174 | EXTRN DATA (?C_XBP)
175 | 
176 |                 MOV     ?C_XBP,#HIGH XBPSTACKTOP
177 |                 MOV     ?C_XBP+1,#LOW XBPSTACKTOP
178 | ENDIF
179 | 
180 | IF PBPSTACK <> 0
181 | EXTRN DATA (?C_PBP)
182 |                 MOV     ?C_PBP,#LOW PBPSTACKTOP
183 | ENDIF
184 | 
185 |                 MOV     SP,#?STACK-1
186 | 
187 | ; This code is required if you use L51_BANK.A51 with Banking Mode 4
188 | ;<h> Code Banking
189 | ; <q> Select Bank 0 for L51_BANK.A51 Mode 4
190 | #if 0   
191 | ;     <i> Initialize bank mechanism to code bank 0 when using L51_BANK.A51 with Banking Mode 4.
192 | EXTRN CODE (?B_SWITCH0)
193 |                 CALL    ?B_SWITCH0      ; init bank mechanism to code bank 0
194 | #endif
195 | ;</h>
196 |                 LJMP    ?C_START
197 | 
198 |                 END
199 | 


--------------------------------------------------------------------------------
/src/STC15Fxxxx.H:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/FishyFizz/STC-B-OS/743279ab40fb298dc0140349a8d9971048b70a1b/src/STC15Fxxxx.H


--------------------------------------------------------------------------------
/src/adsensor.c:
--------------------------------------------------------------------------------
 1 | #include "adsensor.h"
 2 | 
 3 | XDATA u8 adc_initialized = 0;
 4 | void adc_init()
 5 | {
 6 |     if(adc_initialized)
 7 |         return;
 8 | 
 9 |     /*
10 |     Initalize ADC:
11 |         P1.2 for HALL sensor
12 |         P1.3 for Temperature sensor
13 |         P1.4 for Light sensor
14 |         P1.7 for Button3 and Navigation Button
15 |     */
16 |     P1ASF = ADC_P12 | ADC_P13 | ADC_P14 | ADC_P17;
17 | 
18 |     ADC_CONTR |= 0x80; //Power On
19 |     ADC_CONTR = (ADC_CONTR & ~ADC_90T) | ADC_90T; //Speed select
20 |     PCON2 &= ~(1<<5); //result byte order: high->ADC_RES
21 |     EADC = 0; //use polling, no interrupt
22 | 
23 |     adc_initialized = 1;
24 | }
25 | 
26 | u8 adc_read(u8 channel) //u8
27 | {
28 |     XDATA u8 timeout;
29 | 	ADC_RES = 0;
30 | 
31 | 	ADC_CONTR = (ADC_CONTR & 0xe0) | ADC_START | channel; //select channel
32 | 	NOP(4);
33 | 
34 |     //poll
35 | 	for(timeout=0; timeout<250; timeout++)	
36 | 	{
37 | 		if(ADC_CONTR & ADC_FLAG)
38 | 		{
39 | 			ADC_CONTR &= ~ADC_FLAG;
40 | 			return ADC_RES;
41 | 		}
42 | 	}
43 | 
44 |    	return 0;
45 | }


--------------------------------------------------------------------------------
/src/adsensor.h:
--------------------------------------------------------------------------------
 1 | #ifndef _ADSENSOR_H_
 2 | #define _ADSENSOR_H_
 3 | 
 4 | #include "global.h"
 5 | 	
 6 | #define	ADC_P12		0x04    //HALL
 7 | #define	ADC_P13		0x08	//Temperature
 8 | #define	ADC_P14		0x10	//Light
 9 | #define	ADC_P17		0x80	//Button3 / Nav
10 | #define ADC_90T		(3<<5)
11 | 
12 | #define ADC_HALL    2
13 | #define ADC_TEMP    3
14 | #define ADC_LIGHT   4
15 | #define ADC_NAV     7
16 | 
17 | #define ADC_FLAG	(1<<4)  //ADC OK (flag reset by software)
18 | #define ADC_START	(1<<3)  //ADC Start (flag reset by hardware)
19 | 
20 | extern XDATA u8 adc_initialized;
21 | void adc_init();
22 | u8 adc_read(u8 channel);
23 | 
24 | #endif


--------------------------------------------------------------------------------
/src/bit_ops.h:
--------------------------------------------------------------------------------
 1 | 
 2 | #define BIT(x) ((u8)(1<<(x)))
 3 | #define CLEARBIT(var, bit) {(var) &= ~(1<<(bit));}
 4 | #define SETBIT(var, bit) {(var) |= (1<<(bit));}
 5 | #define INVOF(bit) ((bit==0)?1:0)
 6 | #define WRITEBIT(var, bit, wrt) {CLEARBIT(var,bit); var|=(((u8)(wrt))<<(bit));}
 7 | #define GETBIT(var,bit) (((var)&BIT(bit))?1:0)
 8 | 
 9 | #define RSL(var) (((var)<<1) + ((var)>>7))
10 | #define HIGH8(x) 	((x)&0xff00)
11 | #define LOW8(x) 	((x)&0x00ff)
12 | #define HIGH16(x)	(((x)&0xffff0000)>>16)
13 | #define LOW16(x)	((x)&0x0000ffff)


--------------------------------------------------------------------------------
/src/button.c:
--------------------------------------------------------------------------------
 1 | #include "button.h"
 2 | 
 3 | XDATA u8 __nav_btn3_state = 0xff;
 4 | XDATA u8 btnstate_posedge   =0;
 5 | XDATA u8 btnstate_negedge   =0;
 6 | XDATA u8 last_btn_states[BTN_DENOISE_LEVEL];
 7 | 
 8 | void buttons_init()
 9 | {
10 |     //Initialize ADC for Nav and Button3
11 |     adc_init();
12 | 
13 |     //Set Button1 and Button2 pin to Weak Pullup (M1 = 0, M0 = 0)
14 |     P3M1 &= 0xF3;   // 1111 0011
15 |     P3M0 &= 0xF3;   // 1111 0011
16 | 
17 |     //Set P17 to Weak Pullup (M1 = 0, M0 = 0)
18 |     //P17 Pullup -> Key3 -> Nav Button(different resistance) -> GND
19 |     P1M1 &= 0x7F; // 0111 1111
20 |     P1M0 &= 0x7F; // 0111 1111
21 | }
22 | 
23 | void update_button_state()
24 | {
25 | 		XDATA u8 i; //Only use this function in timer0 isr. this variable prevents reentrancy.
26 | 		
27 | 		btnstate_posedge = btnstate_negedge = 0;
28 | 		
29 | 		//rotate previous button states. older one replaced by newer one.
30 | 		for(i = BTN_DENOISE_LEVEL-1; i>=1; i--)
31 | 			last_btn_states[i] = last_btn_states[i-1];	
32 | 		
33 | 		//update current button state, and cauculate bit flags
34 |     update_nav_btn3_state();
35 | 		last_btn_states[0]  = 0;
36 |     last_btn_states[0] |= BUTTON1       ?BTNSTATE_B1    :0;
37 |     last_btn_states[0] |= BUTTON2       ?BTNSTATE_B2    :0;
38 |     last_btn_states[0] |= IS_BTN3_PUSH  ?BTNSTATE_B3    :0;
39 |     last_btn_states[0] |= IS_NAV_LEFT   ?BTNSTATE_LEFT  :0;
40 |     last_btn_states[0] |= IS_NAV_RIGHT  ?BTNSTATE_RIGHT :0;
41 |     last_btn_states[0] |= IS_NAV_UP     ?BTNSTATE_UP    :0;
42 |     last_btn_states[0] |= IS_NAV_DOWN   ?BTNSTATE_DOWN  :0;
43 |     last_btn_states[0] |= IS_NAV_PUSH  ?BTNSTATE_PUSH  :0;
44 | 
45 | 		//check new state hold
46 | 		for(i=0;i<BTN_DENOISE_LEVEL-1;i++)
47 | 		{
48 | 				if(last_btn_states[i] != last_btn_states[0])
49 | 					return;
50 | 		}
51 | 		
52 | 		//different from old states, and currently set -> posedge
53 | 		btnstate_posedge = (last_btn_states[0] ^ last_btn_states[BTN_DENOISE_LEVEL-1]) & (last_btn_states[0]);   
54 | 
55 | 		//different from old states, and previously set -> negedge
56 | 		btnstate_negedge = (last_btn_states[0] ^ last_btn_states[BTN_DENOISE_LEVEL-1]) & (last_btn_states[BTN_DENOISE_LEVEL-1]);
57 | }


--------------------------------------------------------------------------------
/src/button.h:
--------------------------------------------------------------------------------
 1 | #ifndef _BUTTON_H_
 2 | #define _BUTTON_H_
 3 | 
 4 | #include "global.h"
 5 | #include "adsensor.h"
 6 | 
 7 | //Button is connected to Weak Pullup pin. When pushed, the pin is pulled down.
 8 | //True if button is pushed down.
 9 | #define BUTTON1 (~P32)  
10 | #define BUTTON2 (~P33)
11 | 
12 | //Navigation Button and Button3 are connected to analog input.
13 | 
14 | //Get raw analog data.
15 | #define nav_btn3_adc() adc_read(ADC_NAV)
16 | 
17 | 
18 | #define BTNSTATE_B1     0x1
19 | #define BTNSTATE_B2     0x2
20 | #define BTNSTATE_B3     0x4
21 | #define BTNSTATE_UP     0x8
22 | #define BTNSTATE_DOWN   0x10
23 | #define BTNSTATE_LEFT   0x20
24 | #define BTNSTATE_RIGHT  0x40
25 | #define BTNSTATE_PUSH   0x80
26 | 
27 | #define BTN_DENOISE_LEVEL 20
28 | 
29 | extern XDATA u8 btnstate_posedge;
30 | extern XDATA u8 btnstate_negedge;
31 | extern XDATA u8 last_btn_states[BTN_DENOISE_LEVEL];
32 | 
33 | /*
34 |     Usage:
35 | 
36 |     update_nav_btn3_state();
37 |     if(IS_NAV_LEFT)
38 |         ......
39 |     
40 | */
41 | extern XDATA u8 __nav_btn3_state;
42 | #define update_nav_btn3_state() {__nav_btn3_state = adc_read(ADC_NAV);}
43 | 
44 | #define IS_NAV_BTN3_IDLE    ((__nav_btn3_state) >> 5 >= 6)     // 110 or 111
45 | #define IS_NAV_UP           ((__nav_btn3_state) >> 5 == 5)            // 101
46 | #define IS_NAV_LEFT         ((__nav_btn3_state) >> 5 == 4)          // 100
47 | #define IS_NAV_PUSH         ((__nav_btn3_state) >> 5 == 3)          // 011
48 | #define IS_NAV_DOWN         ((__nav_btn3_state) >> 5 == 2)          // 010
49 | #define IS_NAV_RIGHT        ((__nav_btn3_state) >> 5 == 1)         // 001
50 | #define IS_BTN3_PUSH        ((__nav_btn3_state) >> 5 == 0)         // 000
51 | 
52 | void buttons_init();
53 | void update_button_state();
54 | 
55 | #endif //_BUTTON_H_


--------------------------------------------------------------------------------
/src/config.h:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/FishyFizz/STC-B-OS/743279ab40fb298dc0140349a8d9971048b70a1b/src/config.h


--------------------------------------------------------------------------------
/src/ds1302.c:
--------------------------------------------------------------------------------
  1 | #include "ds1302.h"
  2 | #include "seg_led.h"
  3 | 
  4 | void ds1302_writebyte(u8 addr, u8 write)
  5 | {
  6 |     ds1302_dout();
  7 | 
  8 |     DS1302_RST = 1; //Initiate communication
  9 | 
 10 |     DS1302_IO = 0;  //WRITE
 11 |     ds1302_clockpulse();
 12 | 
 13 |     //address
 14 |     {
 15 |         DS1302_IO = GETBIT(addr,0);
 16 |         ds1302_clockpulse();
 17 | 
 18 |         DS1302_IO = GETBIT(addr,1);
 19 |         ds1302_clockpulse();
 20 | 
 21 |         DS1302_IO = GETBIT(addr,2);
 22 |         ds1302_clockpulse();
 23 | 
 24 |         DS1302_IO = GETBIT(addr,3);
 25 |         ds1302_clockpulse();
 26 | 
 27 |         DS1302_IO = GETBIT(addr,4);
 28 |         ds1302_clockpulse();
 29 | 
 30 |         DS1302_IO = GETBIT(addr,5); // 0-> Time, 1-> RAM
 31 |         ds1302_clockpulse();
 32 |     }
 33 | 
 34 |     DS1302_IO = 1;
 35 |     ds1302_clockpulse();
 36 | 
 37 |     
 38 |     //data
 39 |     {
 40 |         DS1302_IO = GETBIT(write,0);
 41 |         ds1302_clockpulse();
 42 | 
 43 |         DS1302_IO = GETBIT(write,1);
 44 |         ds1302_clockpulse();
 45 | 
 46 |         DS1302_IO = GETBIT(write,2);
 47 |         ds1302_clockpulse();
 48 | 
 49 |         DS1302_IO = GETBIT(write,3);
 50 |         ds1302_clockpulse();
 51 | 
 52 |         DS1302_IO = GETBIT(write,4);
 53 |         ds1302_clockpulse();
 54 | 
 55 |         DS1302_IO = GETBIT(write,5);
 56 |         ds1302_clockpulse();
 57 | 
 58 |         DS1302_IO = GETBIT(write,6);
 59 |         ds1302_clockpulse();
 60 | 
 61 |         DS1302_IO = GETBIT(write,7);
 62 |         ds1302_clockpulse();
 63 |     }
 64 | 
 65 | 
 66 |     //reset pins
 67 |     DS1302_SCLK = 0;
 68 |     DS1302_IO = 0;
 69 |     DS1302_RST = 0;
 70 | }
 71 | 
 72 | 
 73 | u8 ds1302_readbyte(u8 addr) 
 74 | {
 75 |     XDATA u8 read = 0;
 76 | 		
 77 |     ds1302_dout();
 78 | 
 79 |     DS1302_RST = 1; //Initiate communication
 80 | 
 81 |     DS1302_IO = 1;  //READ
 82 |     ds1302_clockpulse();
 83 | 
 84 |     //address
 85 |     {
 86 |         DS1302_IO = GETBIT(addr,0);
 87 |         ds1302_clockpulse();
 88 | 
 89 |         DS1302_IO = GETBIT(addr,1);
 90 |         ds1302_clockpulse();
 91 | 
 92 |         DS1302_IO = GETBIT(addr,2);
 93 |         ds1302_clockpulse();
 94 | 
 95 |         DS1302_IO = GETBIT(addr,3);
 96 |         ds1302_clockpulse();
 97 | 
 98 |         DS1302_IO = GETBIT(addr,4);
 99 |         ds1302_clockpulse();
100 | 
101 |         DS1302_IO = GETBIT(addr,5); // 0-> Time, 1-> RAM
102 |         ds1302_clockpulse();
103 |     }
104 | 
105 |     DS1302_IO = 1;
106 |     ds1302_clockpulse();
107 | 
108 |     ds1302_din();
109 |     //data
110 |     {
111 |         WRITEBIT(read, 0, DS1302_IO);
112 |         ds1302_clockpulse();
113 | 
114 |         WRITEBIT(read, 1, DS1302_IO);
115 |         ds1302_clockpulse();
116 | 
117 |         WRITEBIT(read, 2, DS1302_IO);
118 |         ds1302_clockpulse();
119 | 
120 |         WRITEBIT(read, 3, DS1302_IO);
121 |         ds1302_clockpulse();
122 | 
123 |         WRITEBIT(read, 4, DS1302_IO);
124 |         ds1302_clockpulse();
125 | 
126 |         WRITEBIT(read, 5, DS1302_IO);
127 |         ds1302_clockpulse();
128 | 
129 |         WRITEBIT(read, 6, DS1302_IO);
130 |         ds1302_clockpulse();
131 | 
132 |         WRITEBIT(read, 7, DS1302_IO);
133 |         ds1302_clockpulse();
134 |     }
135 | 
136 |     //reset pins
137 |     DS1302_RST = 0;
138 |     DS1302_SCLK = 0;
139 |     DS1302_IO = 0;
140 | 		
141 | 		return read;
142 | }
143 | 


--------------------------------------------------------------------------------
/src/ds1302.h:
--------------------------------------------------------------------------------
 1 | #ifndef _DS1302_H_
 2 | #define _DS1302_H_
 3 | 
 4 | #include "global.h"
 5 | #include "bit_ops.h"
 6 | #include "scheduler.h"
 7 | 
 8 | #define DS1302_RST  P16
 9 | #define DS1302_SCLK P15
10 | #define DS1302_IO   P54
11 | 
12 | #define DS1302_SEC 0
13 | #define DS1302_MIN 1
14 | #define DS1302_HR  2
15 | 
16 | #define DS1302_DATE  3
17 | #define DS1302_MON  4
18 | #define DS1302_DAY   5
19 | #define DS1302_YEAR 6     
20 | 
21 | #define DS1302_WP   7    
22 | 
23 | void ds1302_writebyte(u8 addr, u8 write);
24 | 
25 | u8 ds1302_readbyte(u8 addr);
26 | 
27 | // P54->HiZ
28 | #define ds1302_din() {SETBIT(P5M1, 4); CLEARBIT(P5M0, 4);}
29 | 
30 | // P54->Push-Pull
31 | #define ds1302_dout() {CLEARBIT(P5M1, 4); CLEARBIT(P5M0, 4);}
32 | 
33 | // P15,P16 -> Push-Pull, P54 -> Push-Pull
34 | #define ds1302_init()\
35 | {\
36 |     ds1302_dout();\
37 |     CLEARBIT(P1M1,5); SETBIT(P1M0,5);\
38 |     CLEARBIT(P1M1,6); SETBIT(P1M0,6);\
39 |     DS1302_RST = 0;\
40 |     DS1302_SCLK = 0;\
41 |     DS1302_IO = 0;\
42 | }
43 | 
44 | #define ds1302_clockpulse()\
45 | {\
46 |     DS1302_SCLK = 1;\
47 |     DS1302_SCLK = 0;\
48 | }
49 | 
50 | #define DS1302_CONVERTSEC(x) (((x)&0x0f) + ((x&0x70)>>4)*10)
51 | #define DS1302_CONVERTMIN(x) DS1302_CONVERTSEC(x)
52 | #define DS1302_CONVERTHOUR(x) ((x&0x80) ? \
53 | 															(((x&0x0f)+((x&0x10)>>4)*10)+((x&0x20)?12:0)) : \
54 | 															((x&0x30>>4)*10+(x&0x0f))) 
55 | #define DS1302_CONVERTDATE(x)  DS1302_CONVERTSEC(x)
56 | #define DS1302_CONVERTMONTH(x) DS1302_CONVERTSEC(x)
57 | #define DS1302_CONVERTDAY(x) (x)
58 | #define DS1302_CONVERTYEAR(x) (((x)&0x0f)+((((x)&0xf0)>>4) *10))
59 | 
60 | #endif


--------------------------------------------------------------------------------
/src/events.c:
--------------------------------------------------------------------------------
 1 | #include "events.h"
 2 | 
 3 | XDATA u32 curr_events = 0;
 4 | XDATA u8 proc_waiting_evt = 0;
 5 | XDATA u32 proc_listening_list[8] = {0,0,0,0,0,0,0,0};
 6 | /*
 7 |     Example: process P waiting on event EVT_XXX and EVT_YYY
 8 |     proc_waiting_evt.bit[P] = 1;
 9 |     proc_listening_list[P] = EVT_XXX | EVT_YYY;
10 | */
11 | 
12 | void dispatch_events(u8 pid)
13 | {
14 |     if(proc_waiting_evt & BIT(pid))
15 |     {
16 |         if(proc_listening_list[pid] & curr_events)
17 |         {
18 |             /*
19 |             process can read this to know which of 
20 |             the listened events is actually occured.
21 |             */
22 |             proc_listening_list[pid] = curr_events; 
23 |             CLEARBIT(proc_waiting_evt, pid);
24 |         }
25 | 				else if((proc_listening_list[pid] & EVT_TIMER) && (proc_sleep_countdown[pid]==0))
26 | 				{
27 | 					  proc_listening_list[pid] = EVT_TIMER; 
28 |             CLEARBIT(proc_waiting_evt, pid);
29 | 				}
30 |     }
31 | }
32 | 
33 | void collect_btnevts()
34 | {
35 | 		update_button_state();
36 | 
37 |     if(btnstate_posedge & BTNSTATE_B1) curr_events |= EVT_BTN1_DN;
38 |     if(btnstate_posedge & BTNSTATE_B2) curr_events |= EVT_BTN2_DN;
39 |     if(btnstate_posedge & BTNSTATE_B3) curr_events |= EVT_BTN3_DN;
40 |     if(btnstate_posedge & BTNSTATE_UP)      curr_events |= EVT_NAV_U;
41 |     if(btnstate_posedge & BTNSTATE_DOWN)    curr_events |= EVT_NAV_D;
42 |     if(btnstate_posedge & BTNSTATE_LEFT)    curr_events |= EVT_NAV_L;
43 |     if(btnstate_posedge & BTNSTATE_RIGHT)   curr_events |= EVT_NAV_R;
44 |     if(btnstate_posedge & BTNSTATE_PUSH)    curr_events |= EVT_NAV_PUSH;
45 |     
46 |     if(btnstate_negedge & BTNSTATE_B1) curr_events |= EVT_BTN1_UP;
47 |     if(btnstate_negedge & BTNSTATE_B2) curr_events |= EVT_BTN2_UP;
48 |     if(btnstate_negedge & BTNSTATE_B3) curr_events |= EVT_NAV_BTN3_RESET;
49 |     if(btnstate_negedge & BTNSTATE_UP)      curr_events |= EVT_NAV_BTN3_RESET;
50 |     if(btnstate_negedge & BTNSTATE_DOWN)    curr_events |= EVT_NAV_BTN3_RESET;
51 |     if(btnstate_negedge & BTNSTATE_LEFT)    curr_events |= EVT_NAV_BTN3_RESET;
52 |     if(btnstate_negedge & BTNSTATE_RIGHT)   curr_events |= EVT_NAV_BTN3_RESET;
53 |     if(btnstate_negedge & BTNSTATE_PUSH)    curr_events |= EVT_NAV_BTN3_RESET;
54 | }
55 | 
56 | 
57 | void collect_uartevts() //VOID
58 | {
59 | 	if(rs485_evtstate)
60 | 	{
61 | 			rs485_evtstate = 0;
62 | 			curr_events |= EVT_UART2_RECV;
63 | 	}
64 | 	if(usbcom_evtstate)
65 | 	{
66 | 		usbcom_evtstate = 0;
67 | 		curr_events |= EVT_UART1_RECV;
68 | 	}
69 | }
70 | 
71 | 
72 | void process_events() //VOID
73 | {
74 |     curr_events = 0;
75 |     
76 |     collect_btnevts();
77 |     collect_uartevts();
78 | 
79 | 		dispatch_events(0);
80 | 		dispatch_events(1);
81 | 		dispatch_events(2);
82 | 		dispatch_events(3);
83 | 		dispatch_events(4);
84 | 		dispatch_events(5);
85 | 		dispatch_events(6);
86 | 		dispatch_events(7);
87 | }


--------------------------------------------------------------------------------
/src/events.h:
--------------------------------------------------------------------------------
 1 | #ifndef _EVENTS_H_
 2 | #define _EVENTS_H_
 3 | 
 4 | #include "global.h"
 5 | #include "button.h"
 6 | #include "bit_ops.h"
 7 | #include "scheduler.h"
 8 | #include "syscall.h"
 9 | #include "usbcom.h"
10 | #include "rs485.h"
11 | 
12 | 
13 | //BUTTON EVENTS================================
14 | #define EVT_BTN1_DN     0x1
15 | #define EVT_BTN1_UP     0x2
16 | 
17 | #define EVT_BTN2_DN     0x4
18 | #define EVT_BTN2_UP     0x8
19 | 
20 | #define EVT_BTN3_DN     0x10
21 | #define EVT_NAV_L       0x20    
22 | #define EVT_NAV_R       0x40
23 | #define EVT_NAV_U       0x80
24 | #define EVT_NAV_D       0x100
25 | #define EVT_NAV_PUSH    0x200
26 | 
27 | #define EVT_NAV_BTN3_RESET  0x400
28 | 
29 | 
30 | //UART EVENTS==================================
31 | #define EVT_UART1_RECV  0x800
32 | #define EVT_UART2_RECV  0x1000
33 | 
34 | //TIMER EVENT==================================
35 | #define EVT_TIMER 0x2000
36 | 
37 | //USER EVENT===================================
38 | #define EVT_USER1 0x4000
39 | #define EVT_USER2 0x8000
40 | #define EVT_USER3 0x10000
41 | #define EVT_USER4 0x20000
42 | 
43 | extern XDATA u32 curr_events;
44 | extern XDATA u8 proc_waiting_evt;
45 | extern XDATA u32 proc_listening_list[8];
46 | #define MY_EVENTS (proc_listening_list[current_process])
47 | 
48 | void process_events();
49 | void dispatch_events(u8);
50 | void collect_btnevts();
51 | void collect_uartevts();
52 | 
53 | #endif //_EVENTS_H_


--------------------------------------------------------------------------------
/src/global.h:
--------------------------------------------------------------------------------
 1 | #ifndef _GLOBAL_H_
 2 | #define _GLOBAL_H_
 3 | 
 4 | #include "config.h"
 5 | 
 6 | #define STC
 7 | 
 8 | #ifndef STC
 9 |     #define XDATA
10 |     #define IDATA
11 |     #define DATA
12 |     #define CODE
13 |     #define INTERRUPT
14 | 	#define VFUNC
15 | #else
16 |     #define XDATA       xdata
17 |     #define IDATA       idata
18 |     #define DATA        data
19 |     #define CODE        code
20 |     #define INTERRUPT   interrupt
21 | 	#define VFUNC		small
22 | #endif
23 | 
24 | 
25 | #endif //_GLOBAL_H_


--------------------------------------------------------------------------------
/src/main.c:
--------------------------------------------------------------------------------
  1 | #include "global.h"
  2 | #include "stack.h"
  3 | #include "xstack.h"
  4 | #include "scheduler.h"
  5 | #include "bit_ops.h"
  6 | #include "timer0_isr.h"
  7 | #include "syscall.h"
  8 | #include "semaphore.h"
  9 | #include "events.h"
 10 | #include "seg_led.h"
 11 | #include "button.h"
 12 | #include "usbcom.h"
 13 | #include "rs485.h"
 14 | #include "random.h"
 15 | 
 16 | #define TIMESLICE_MS	1
 17 | #define T12RL		(65536 - MAIN_Fosc*TIMESLICE_MS/12/1000) 
 18 | 
 19 | 
 20 | void testproc(u16 param) large reentrant
 21 | {
 22 | 	while(1)
 23 | 	{
 24 | 		if((timer0_cnt>>5) & BIT(param))
 25 | 		{
 26 | 			SETBIT(led_display_content, param);
 27 | 		}
 28 | 		else
 29 | 		{
 30 | 			CLEARBIT(led_display_content, param);
 31 | 		}
 32 | 	}
 33 | }
 34 | 
 35 | void testproc2(u16 param) large reentrant
 36 | {
 37 | 	while(1)
 38 | 	{
 39 | 		proc_sleep(param);
 40 | 		led_display_content = ~led_display_content;
 41 | 	}
 42 | }
 43 | 
 44 | void testproc3(u16 param) large reentrant
 45 | {
 46 | 	while(1)
 47 | 	{
 48 | 		proc_sleep(param);
 49 | 		led_display_content ^= 0x0f;
 50 | 	}
 51 | }
 52 | 
 53 | void testproc4() large reentrant
 54 | {
 55 | 	while(1)
 56 | 	{
 57 | 		proc_sleep(500);
 58 | 		sem_post(0);
 59 | 		led_display_content |= 0x80;
 60 | 		sem_wait(0);
 61 | 		led_display_content &= ~0x80;
 62 | 	}
 63 | }
 64 | 
 65 | void testproc5() large reentrant
 66 | {
 67 | 	sem_init(0,0);
 68 | 	while(1)
 69 | 	{
 70 | 		sem_wait(0);
 71 | 		led_display_content |= 0x40;
 72 | 		proc_sleep(500);
 73 | 		sem_post(0);
 74 | 		led_display_content &= ~0x40;
 75 | 	}
 76 | }
 77 | 
 78 | void testproc6(u16 param) large reentrant
 79 | {
 80 | 	while(1)
 81 | 	{
 82 | 		proc_wait_evts(EVT_BTN1_DN);
 83 | 		seg_set_str("HELLO   ");
 84 | 		usbcom_write("hello \0",0);
 85 | 		proc_wait_evts(EVT_NAV_R);
 86 | 		seg_set_str("WORLD   ");
 87 | 		usbcom_write("world\r\n\0",0);
 88 | 		proc_wait_evts(EVT_UART1_RECV);
 89 | 		seg_set_str(usbcom_buf);
 90 | 	}
 91 | }
 92 | 
 93 | void testproc7(u16 param) large reentrant
 94 | {
 95 | 	while(1)
 96 | 	{
 97 | 		proc_wait_evts(EVT_UART2_RECV | EVT_BTN1_DN);
 98 | 		if(MY_EVENTS & EVT_BTN1_DN)
 99 | 		{
100 | 			*((u32 *)rs485_buf) = rand32();
101 | 			rs485_write(rs485_buf, 4);
102 | 			seg_set_number(*((u32 *)rs485_buf));
103 | 		}
104 | 		else
105 | 		{
106 | 			seg_set_number(*((u32 *)rs485_buf));
107 | 		}
108 | 	}
109 | }
110 | 
111 | main()
112 | {
113 | 	//initialize kernel stack and xstack pointer
114 | 	SP = kernel_stack;
115 | 	setxbp(kernel_xstack + KERNEL_XSTACKSIZE);
116 | 	
117 | 	//set process stacks and swap stacks owner
118 | 	process_stack[0][PROCESS_STACKSIZE-1] = 0;
119 | 	process_stack[1][PROCESS_STACKSIZE-1] = 1;
120 | 	process_stack[2][PROCESS_STACKSIZE-1] = 2;
121 | 	process_stack[3][PROCESS_STACKSIZE-1] = 3;
122 | 	process_stack[4][PROCESS_STACKSIZE-1] = 4;
123 | 	process_stack_swap[0][PROCESS_STACKSIZE-1] = 5;
124 | 	process_stack_swap[1][PROCESS_STACKSIZE-1] = 6;
125 | 	process_stack_swap[2][PROCESS_STACKSIZE-1] = 7;
126 | 	
127 | 	//initialize LED pins
128 | 	P0M1 &= 0x00;
129 | 	P0M0 |= 0xff;
130 | 	P2M1 &= 0xf0;
131 | 	P2M0 |= 0x0f;
132 | 	//select LED, set all off
133 | 	P23 = 1;
134 | 	P0 = 0;
135 | 
136 | 	//initialize buttons
137 | 	buttons_init();
138 | 	
139 | 	//initialize serial ports
140 | 	usbcom_init(115200);
141 | 	rs485_init(115200);
142 | 		
143 | 	//start process
144 | 
145 | 		
146 | 		
147 | 	//initialize PCA2 interrupt (as syscall interrupt)
148 | 	//clear CCF2
149 | 	CCON &= ~0x04;
150 | 	//disable PCA2 module and set ECCF2
151 | 	CCAPM2 = 1;
152 | 	//low priority interrupt
153 | 	PPCA = 0;
154 | 	
155 | 	//start main timer
156 | 	TR0 = 0;														//stop timer
157 | 	TMOD &= 0xF0;												//timer mode, 16b autoreload
158 | 	AUXR &= 0x7F;												//12T mode
159 | 	TL0 = T12RL & 0xff;							//set reload value
160 | 	TH0 = (T12RL & 0xff00) >> 8;
161 | 	ET0 = EA = 1;												//set interrupt enable
162 | 	PT0 = 0;														//set priority to low
163 | 	TR0 = 1;														//start timer
164 | 	
165 | 	//spin
166 | 	while(1);
167 | }


--------------------------------------------------------------------------------
/src/random.c:
--------------------------------------------------------------------------------
 1 | #include "random.h"
 2 | 
 3 | XDATA u32 __rndseed = 0xf2e0062c;
 4 | 
 5 | u32 rand32() large reentrant
 6 | {
 7 |     //LCG: (aX+c)%m
 8 |     __rndseed = ((__rndseed * 1103515245) + 12345) & 0x7fffffff;
 9 |     return __rndseed;
10 | }
11 | 
12 | 
13 | void srand()
14 | {
15 | 	XDATA u8 tmp;
16 | 	tmp = ds1302_readbyte(DS1302_SEC);
17 | 	__rndseed = tmp;
18 | 	tmp = ds1302_readbyte(DS1302_MIN);
19 | 	__rndseed += tmp;
20 | 	tmp = ds1302_readbyte(DS1302_HR);
21 | 	__rndseed += tmp;
22 | }
23 | 


--------------------------------------------------------------------------------
/src/random.h:
--------------------------------------------------------------------------------
 1 | #ifndef _RANDOM_H_
 2 | #define _RANDOM_H_
 3 | 
 4 | #include "global.h"
 5 | #include "ds1302.h"
 6 | 
 7 | u32 rand32() large reentrant;
 8 | void srand();
 9 | 
10 | #endif


--------------------------------------------------------------------------------
/src/rs485.c:
--------------------------------------------------------------------------------
  1 | #include "rs485.h"
  2 | 
  3 | void rs485_init(u32 baudrate)
  4 | {
  5 |     //Set TX/DR pins (P37, P47) to Push-Pull, RX pin (P46) to input.
  6 |     {
  7 |         P4M1 &= 0x3F;	// 0111 1111
  8 |         P4M0 |= 0xC0;   // 1000 0000
  9 | 
 10 |         P3M1 &= 0x7F;   // 0111 1111
 11 |         P3M0 |= 0x80;   // 1000 0000
 12 | 
 13 |         P4M1 |= 0x40;   // 0100 0000
 14 |         P4M0 &= 0xBF;   // 1011 1111
 15 |     }
 16 | 
 17 |     //Configure baudrate timer
 18 |     {
 19 |         XDATA u16 reload = 65536 - ((MAIN_Fosc / 4) / baudrate);	//1T
 20 |         AUXR &= ~(1<<4);	//Timer stop
 21 |         AUXR &= ~(1<<3);	//Timer2 set As Timer
 22 |         AUXR |=  (1<<2);	//Timer2 set as 1T mode
 23 |         IE2  &= ~(1<<2);	//Disable interrupt
 24 | 
 25 |         TH2 = (u8)(reload>>8);
 26 |         TL2 = (u8)reload;
 27 |         AUXR |=  (1<<4);	//Timer run enable
 28 |     }
 29 | 
 30 |     //Initialize UART2 on P46 and P47
 31 |     {
 32 |         IP2 |=  1;  //High priority interrupt
 33 |         S2CON &= ~(1<<7); //8bit mode
 34 |         S2CON |=  (1<<4); //Enable Rx
 35 |         P_SW2 = (P_SW2 & ~1) | (1 & 0x01); //Select IO port P46/P47
 36 |         RS485_STATE = RS485_R; //Half duplex mode set to Rx
 37 |         IE2 |= 1; //Enable interrupt (wait for incoming data)
 38 |     }
 39 | }
 40 | 
 41 | //this function blocks current process until all data is sent
 42 | void __rs485_write(u8* buf, u8 len)
 43 | {
 44 |     u8 i;
 45 |     //Tx enable.
 46 |     RS485_STATE = RS485_D;
 47 |     //Disable UART2 interrupt (Tx uses polling mode)
 48 |     IE2 &= ~1;
 49 | 
 50 | 		if(len)
 51 | 		{
 52 | 			for(i=0;i<len;i++)
 53 | 			{
 54 | 					//clear TX end flag
 55 | 					S2CON &= ~2;
 56 | 					//feed byte into UART2 buffer
 57 | 					S2BUF = buf[i];
 58 | 					//spin until TX end flag is set (by hardware)
 59 | 					while((S2CON & 2) == 0);
 60 | 			}
 61 | 		}
 62 | 		else
 63 | 		{
 64 | 			for(i=0;;i++)
 65 | 			{
 66 | 					//clear TX end flag
 67 | 					S2CON &= ~2;
 68 | 					//feed byte into UART2 buffer
 69 | 					if(buf[i] == '\0') break;		
 70 | 					S2BUF = buf[i];
 71 | 					//spin until TX end flag is set (by hardware)
 72 | 					while((S2CON & 2) == 0);
 73 | 			}
 74 | 		}
 75 |     //Tx disable.
 76 |     RS485_STATE = RS485_R;
 77 | 
 78 |     //Enable UART2 interrupt
 79 |     //(Rx uses interrupt to trigger, but still runs in polling mode)
 80 |     S2CON &= ~1;   //Reset all flags
 81 |     S2CON &= ~2;
 82 |     IE2 |= 1;
 83 | }
 84 | 
 85 | 
 86 | XDATA u8 rs485_buf[128];
 87 | XDATA u8 rs485_rxcnt;
 88 | XDATA u32 rs485_timeout;
 89 | XDATA u8 rs485_evtstate = 0;
 90 | 
 91 | void rs485_interrupt (void) interrupt UART2_VECTOR
 92 | {
 93 | 	//Tx uses polling mode, INT source can only be RX
 94 | 
 95 |     //Disable UART2 interrupt
 96 |     //(Rx uses interrupt to trigger, but still runs in polling mode)
 97 |     IE2 &= ~1;
 98 | 
 99 |     rs485_rxcnt = 0;
100 |     while(1)
101 |     {
102 |         S2CON &= ~1; //Remove RX end flag.
103 |         rs485_buf[rs485_rxcnt++] = S2BUF; //Retrieve byte.
104 | 
105 |         //Spin until RX end flag is set (by hardware)
106 |         rs485_timeout = 500;//You have to try out a proper value for specific baud and clock frequency settings
107 |         while((S2CON & 1)==0) 
108 |         {
109 |             if(--rs485_timeout == 0)
110 |                 goto RX_END;
111 |         }
112 |     }
113 | 
114 |     RX_END:;
115 |     
116 |     S2CON &= ~1;  //Reset all flags
117 |     S2CON &= ~2;
118 |     IE2 |= 1; //Enable UART2 interrupt
119 | 
120 |     rs485_evtstate = 1;
121 | }


--------------------------------------------------------------------------------
/src/rs485.h:
--------------------------------------------------------------------------------
 1 | #ifndef _RS485_H_
 2 | #define _RS485_H_
 3 | 
 4 | #include "global.h"
 5 | 
 6 | #define RS485_STATE P37
 7 | #define RS485_R    0
 8 | #define RS485_D    1
 9 | 
10 | extern XDATA u8 rs485_buf[128];
11 | extern XDATA u8 rs485_rxcnt;
12 | extern XDATA u32 rs485_timeout;
13 | extern XDATA u8 rs485_evtstate;
14 | 
15 | void rs485_init(u32 baudrate);
16 | 
17 | #define rs485_write(buf,len) NOINT_ATOMIC(__rs485_write(buf,len);)
18 | void __rs485_write(u8* buf, u8 len);
19 | 
20 | #endif //_RS485_H_


--------------------------------------------------------------------------------
/src/scheduler.c:
--------------------------------------------------------------------------------
  1 | #include "scheduler.h"
  2 | 
  3 | XDATA u8 process_context[8][18];
  4 | XDATA u8 current_process = 8;
  5 | DATA u8 flag_nosched = 0;
  6 | XDATA u8 process_slot = 0;
  7 | XDATA u8 remaining_timeslices = DEFAULT_TIMESLICES;
  8 | XDATA u8 proc_time_share[8];
  9 | //This determines the number of timeslices assigned when each process is scheduled
 10 | //proc_time_share[0] in filled upon initialization. other elements will be filled when
 11 | //corresponding process gets started
 12 | 
 13 | //Only processes with 0 sleep countdown can be scheduled
 14 | XDATA u16 proc_sleep_countdown[8] ={0, 0, 0, 0, 0, 0, 0, 0};
 15 | 
 16 | void start_process(u16 entry, u16 pid, u32 param)
 17 | {
 18 | 	//XBPH,L
 19 | 	process_context[pid][13] = (((u16)process_xstack[pid] + PROCESS_XSTACKSIZE)&0xff00)>>8;
 20 | 	process_context[pid][14] = ((u16)process_xstack[pid] + PROCESS_XSTACKSIZE)&0x00ff;
 21 | 
 22 | 	//PCH, PCL
 23 | 	process_context[pid][15] = (entry&0xff00) >> 8; 
 24 | 	process_context[pid][16] = (entry&0x00ff);
 25 | 
 26 | 	
 27 | 	//SP
 28 | 	if(get_stack_index(pid)!=-1)
 29 | 		process_context[pid][17] = process_stack[get_stack_index(pid)]; //stack present in memory, use absolute address
 30 | 	else
 31 | 		process_context[pid][17] = 0; //stack in stackswap space, use address relative to stack start
 32 | 	
 33 | 	//R4-R7 (param)
 34 | 	process_context[pid][9] = (param & 0xff000000) >> 24;
 35 | 	process_context[pid][10] = (param & 0x00ff0000) >> 16;
 36 | 	process_context[pid][11] = (param & 0x0000ff00) >> 8;
 37 | 	process_context[pid][12] = (param & 0x000000ff);
 38 | 
 39 | 	proc_time_share[pid] = DEFAULT_TIMESLICES;
 40 | 	process_slot |= BIT(pid);
 41 | } 
 42 | 
 43 | 
 44 | u8 select_process()
 45 | {
 46 | 		XDATA u8 tmp_process;
 47 | 		
 48 | 		//current_process can be 8 (kernel startup) or 9 (idle spin)
 49 | 		//so we have to set current_process to 0 in that situation.
 50 | 		if(current_process >= 8) current_process = 0;
 51 | 		tmp_process = current_process;
 52 |     
 53 | 
 54 |     //sequentially check other processes
 55 |     while((tmp_process = NEXT(tmp_process)) != current_process)
 56 |         if(process_ready(tmp_process))
 57 |         	goto SCHEDULER_END;
 58 | 
 59 |     //if no other process can run, check if current process can run again
 60 |     if (process_ready(current_process))
 61 |     {
 62 | 		tmp_process = current_process;
 63 | 		goto SCHEDULER_END;
 64 | 	}
 65 |     
 66 |   //Can't find a process to run, reuturn 9(invalid)
 67 | 	//ISR should recognize this and put system to spin until next interrupt
 68 | 	tmp_process = 9;
 69 | 	
 70 | 	SCHEDULER_END:;
 71 | 	return tmp_process;
 72 | }
 73 | 
 74 | u8 process_ready(u8 pid)
 75 | {
 76 |     //Check process exists
 77 |     if(!PROC_EXISTS(pid))
 78 |         return 0;
 79 | 
 80 |     //Check process is not waiting for semaphore
 81 |     if(proc_waiting_sem & BIT(pid))
 82 |         return 0;
 83 | 
 84 |     //Check process is not sleeping or waitiong for events
 85 |     if(proc_waiting_evt & BIT(pid))
 86 |         return 0;
 87 |  
 88 | 		return 1;
 89 | }
 90 | 
 91 | //ONLY CALL THIS FUNCTION ATOMICALLY IN ISR!!!
 92 | void reschedule()
 93 | {
 94 | 	//kernel or spin context doesn't need to be saved
 95 | 	if(current_process < 8) 
 96 | 		save_current_context();
 97 | 	
 98 | 	//select a process to run
 99 | 	current_process = select_process();
100 | 	if(current_process == 9) goto IDLE_SPIN;
101 | 	
102 | 	//allocate timeslices and load context
103 | 	remaining_timeslices = proc_time_share[current_process];
104 | 	if(get_stack_index(current_process) == -1)
105 | 		stackswap(get_stackswap_index(current_process));
106 | 		//do stack swap.
107 | 	load_current_context();
108 | 	return;
109 | 	
110 | 	IDLE_SPIN:;
111 | 	//load address of spin() into interrupt context.
112 | 	//allocate 1 timeslice to it.
113 | 	interrupt_context[15] = HIGH16((u16)spin);
114 | 	interrupt_context[16] = LOW16((u16)spin);
115 | 	remaining_timeslices = 1;
116 | 	return;
117 | }
118 | 
119 | void decrement_sleep_counters()
120 | {
121 |     COUNTDOWN(proc_sleep_countdown[0], interrupt_counter);
122 |     COUNTDOWN(proc_sleep_countdown[1], interrupt_counter);
123 |     COUNTDOWN(proc_sleep_countdown[2], interrupt_counter);
124 |     COUNTDOWN(proc_sleep_countdown[3], interrupt_counter);
125 |     COUNTDOWN(proc_sleep_countdown[4], interrupt_counter);
126 |     COUNTDOWN(proc_sleep_countdown[5], interrupt_counter);
127 |     COUNTDOWN(proc_sleep_countdown[6], interrupt_counter);
128 |     COUNTDOWN(proc_sleep_countdown[7], interrupt_counter);
129 | }
130 | 
131 | 
132 | 
133 | 


--------------------------------------------------------------------------------
/src/scheduler.h:
--------------------------------------------------------------------------------
 1 | #ifndef _SCHEDULER_H_
 2 | #define _SCHEDULER_H_
 3 | 
 4 | #include "global.h"
 5 | #include "timer0_isr.h"
 6 | #include "xstack.h"
 7 | #include "stack.h"
 8 | #include "bit_ops.h"
 9 | #include "spin.h"
10 | #include "semaphore.h"
11 | #include "events.h"
12 | /*
13 | 
14 | #include "mem.h"
15 | #include "vstack.h"
16 | 
17 | #include "semaphore.h"
18 | #include "spin.h"
19 | */
20 | 
21 | #define DEFAULT_TIMESLICES 3
22 | #define NEXT(x) (((x)+1) & 0x7)
23 | #define PROC_EXISTS(x) ((process_slot & BIT(x))>0)
24 | 
25 | 
26 | extern XDATA u8 process_context[8][18];
27 | 
28 | extern XDATA u8 current_process;
29 | extern DATA u32 timer0_cnt;
30 | extern XDATA u8 process_slot;
31 | 
32 | extern XDATA u8 remaining_timeslices;
33 | extern XDATA u8 proc_time_share[8];
34 | 
35 | #define COUNTDOWN(from, cnt) {if((from)>=(cnt)) (from)-=(cnt); else (from)=0;}
36 | extern XDATA u16 proc_sleep_countdown[8];
37 | 
38 | /*
39 |   PUSH32 	arg32
40 | */
41 | void start_process(u16 entry, u16 pid, u32 param);
42 | u8 select_process();
43 | u8 process_ready(u8 pid);
44 | void decrement_sleep_counters();
45 | void reschedule();
46 | 
47 | 
48 | /*
49 | This variable MUST be in DATA memory, because write or read to this
50 | variable must be done atomically (single instruction), otherwise
51 | rescheduel may happen during data access.
52 | 
53 | When set to 1, no rescheduling is performed in ISR, but system time
54 | counter is incremented.
55 | */
56 | extern DATA u8 flag_nosched;
57 | #define ATOMIC_START() {flag_nosched = 1;}
58 | #define ATOMIC_END() {flag_nosched = 0;}
59 | #define ATOMIC(atomic_code)\
60 | {\
61 |     flag_nosched = 1;\
62 |     {atomic_code;}\
63 |     flag_nosched = 0;\
64 | }
65 | 
66 | #define NOINT_ATOMIC_START(){TR0 = 0;}
67 | #define NOINT_ATOMIC_END(){TR0 = 1;}
68 | #define NOINT_ATOMIC(atomic_code)\
69 | {\
70 |     TR0 = 0;\
71 |     {atomic_code;}\
72 |     TR0 = 1;\
73 | }
74 | 
75 | 
76 | #endif


--------------------------------------------------------------------------------
/src/seg_led.c:
--------------------------------------------------------------------------------
 1 | #include "seg_led.h"
 2 | 
 3 | XDATA u8 seg_display_content[8] = {0,0,0,0,0,0,0,0};
 4 | XDATA u8 led_display_content = 0;
 5 | XDATA u8 seg_led_current = 0;
 6 | 
 7 | CODE u8 seg_decoder[128] ={
 8 |     0x3f, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7d, 0x07, 0x7f, 0x6f, 0x77,0x7c,0x39,0x5e,0x79,0x71,      //hex 0~F
 9 |     0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0,
10 | 
11 |     0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, //space and others
12 |     0x3f, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7d, 0x07, 0x7f, 0x6f,                                     //numbers
13 |     0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,                                                       //others
14 |     0x77,0x7c,0x39,0x5e,0x79,0x71,0x3d,0x76,0x0f,0x0e,0x75,0x38,0x37,0x54,0x5c,0x73,0x67,0x31,0x6d/*s:0x49, 5:0x6d*/,0x78,0x3e,0x1c,0x7e,0x64,0x6e,0x59, //A-Z
15 |     0x80, 0x80, 0x80, 0x80, 0x80, 0x80,                                                             //others
16 |     0x77,0x7c,0x39,0x5e,0x79,0x71,0x3d,0x76,0x0f,0x0e,0x75,0x38,0x37,0x54,0x5c,0x73,0x67,0x31,0x6d/*s:0x49, 5:0x6d*/,0x78,0x3e,0x1c,0x7e,0x64,0x6e,0x59, //a-z
17 |     0x80, 0x80, 0x80, 0x80, 0x80                                                                    //others
18 | };
19 | 
20 | void seg_set_str(char* str) large reentrant
21 | {
22 | 	seg_display_content[0] = seg_decoder[str[0]];
23 | 	seg_display_content[1] = seg_decoder[str[1]];
24 | 	seg_display_content[2] = seg_decoder[str[2]];
25 | 	seg_display_content[3] = seg_decoder[str[3]];
26 | 	seg_display_content[4] = seg_decoder[str[4]];
27 | 	seg_display_content[5] = seg_decoder[str[5]];
28 | 	seg_display_content[6] = seg_decoder[str[6]];
29 | 	seg_display_content[7] = seg_decoder[str[7]];
30 | }
31 | 
32 | void seg_set_number(u32 n) large reentrant
33 | {
34 |     seg_display_content[7] = seg_decoder[n%10]; n/=10;
35 |     seg_display_content[6] = seg_decoder[n%10]; n/=10;
36 |     seg_display_content[5] = seg_decoder[n%10]; n/=10;
37 |     seg_display_content[4] = seg_decoder[n%10]; n/=10;
38 |     seg_display_content[3] = seg_decoder[n%10]; n/=10;
39 |     seg_display_content[2] = seg_decoder[n%10]; n/=10;
40 |     seg_display_content[1] = seg_decoder[n%10]; n/=10;
41 |     seg_display_content[0] = seg_decoder[n%10]; n/=10;
42 | }
43 | 
44 | //this function should be called in system timer ISR
45 | //no reentrancy is supported
46 | void seg_led_scan_next()
47 | {
48 |     switch(seg_led_current)
49 |     {
50 |         case 0: DISP_SEG(0)     seg_led_current++; break;
51 |         case 1: DISP_SEG(1)     seg_led_current++; break;
52 |         case 2: DISP_SEG(2)     seg_led_current++; break;
53 |         case 3: DISP_SEG(3)     seg_led_current++; break;
54 |         case 4: DISP_SEG(4)     seg_led_current++; break;
55 |         case 5: DISP_SEG(5)     seg_led_current++; break;
56 |         case 6: DISP_SEG(6)     seg_led_current++; break;
57 |         case 7: DISP_SEG(7)     seg_led_current++; break;
58 |         case 8: DISP_LED()      seg_led_current=0; break;
59 | 		default: seg_led_current = 0;
60 |     }
61 | }


--------------------------------------------------------------------------------
/src/seg_led.h:
--------------------------------------------------------------------------------
 1 | #ifndef _SEG_LED_H_
 2 | #define _SEG_LED_H_
 3 | 
 4 | #include "global.h"
 5 | 
 6 | //LED Pins:
 7 | #define LED0 P00
 8 | #define LED1 P01
 9 | #define LED2 P02
10 | #define LED3 P03
11 | #define LED4 P04
12 | #define LED5 P05
13 | #define LED6 P06
14 | #define LED7 P07
15 | #define LEDs P0
16 | 
17 | //Segment Selection Pins:
18 | #define SEGA P00
19 | #define SEGB P01
20 | #define SEGC P02
21 | #define SEGD P03
22 | #define SEGE P04
23 | #define SEGF P05
24 | #define SEGG P06
25 | #define SEGH P07
26 | #define SEGs P0
27 | 
28 | //Digit Selection Pins:
29 | #define SEG_DIGIT_SEL0 P20
30 | #define SEG_DIGIT_SEL1 P21
31 | #define SEG_DIGIT_SEL2 P22
32 | 
33 | /*
34 | Board Tracing:
35 | P23 -> NOT -> EN_138_Decoder -> Segments
36 |          `--> VDD_LEDs
37 | */
38 | 
39 | #define LED_SEG_SWITCH P23  // USE_LED or USE_SEG
40 | #define USE_LED 1
41 | #define USE_SEG 0
42 | 
43 | //set all related pins to Push-Pull mode (P0, P20-P23)
44 | #define seg_led_init()\ 
45 | {\
46 |     P0M1 &= 0x00;\
47 |     P0M0 |= 0xff;\
48 |     P2M1 &= 0xf0;\
49 |     P2M0 |= 0x0f;\
50 | }
51 | 
52 | #define seg_digit_sel(x)\
53 | {\
54 |     SEG_DIGIT_SEL0 = x&1;\
55 |     SEG_DIGIT_SEL1 = (x&2) > 0;\
56 |     SEG_DIGIT_SEL2 = (x&4) > 0;\
57 | }
58 | 
59 | #define DISP_SEG(x)\
60 | {\
61 |     SEGs = seg_display_content[x];\
62 |     seg_digit_sel(x);\
63 |     LED_SEG_SWITCH = USE_SEG;\
64 | }
65 | 
66 | #define DISP_LED()\
67 | {\
68 |     LEDs = led_display_content;\
69 |     LED_SEG_SWITCH = USE_LED;\
70 | }
71 | 
72 | extern XDATA u8 seg_display_content[8];
73 | extern XDATA u8 led_display_content;
74 | extern CODE u8 seg_decoder[128];
75 | extern XDATA u8 seg_led_current;
76 | 
77 | //VPUSH void* str
78 | void seg_set_str(char* str) large reentrant;
79 | void seg_set_number(u32 n) large reentrant;
80 | void seg_led_scan_next();
81 | 
82 | #endif


--------------------------------------------------------------------------------
/src/semaphore.c:
--------------------------------------------------------------------------------
 1 | #include "semaphore.h"
 2 | 
 3 | 
 4 | XDATA char semaphores[MAX_SEMAPHORES];
 5 | XDATA u8 proc_sem_wait_flag[MAX_SEMAPHORES];
 6 | XDATA u8 sem_wake_round[MAX_SEMAPHORES];
 7 | XDATA u8 proc_waiting_sem = 0;
 8 | 
 9 | void __sem_init(u8 sem_id, char val)
10 | {
11 |     proc_sem_wait_flag[sem_id] = 0;
12 |     sem_wake_round[sem_id] = 1;
13 |     semaphores[sem_id] = val;
14 | }
15 | 
16 | void __sem_post(u8 sem_id)
17 | {
18 |     XDATA u8 select_wake;
19 | 
20 |     //No process is waiting, only increment semaphore
21 |     if(!proc_sem_wait_flag[sem_id])
22 |     {
23 |         semaphores[sem_id]++;
24 |         return;
25 |     }
26 | 
27 |     //Find first process waiting on the semaphore
28 |     select_wake = RSL(sem_wake_round[sem_id]);
29 |     while ((select_wake & proc_sem_wait_flag[sem_id]) == 0)
30 |         select_wake = RSL(select_wake);
31 | 
32 |     //Remove the waiting flag of the process
33 |     proc_sem_wait_flag[sem_id] &= ~select_wake;
34 |     proc_waiting_sem &= ~select_wake;
35 | 
36 |     //Record the last waked process
37 |     sem_wake_round[sem_id] = select_wake;
38 | }
39 | 
40 | u8 __sem_wait(u8 sem_id)
41 | {
42 |     //semaphore currently idle, decrement value and return.
43 |     if(semaphores[sem_id])
44 |     {
45 |         semaphores[sem_id] --;
46 |         return 1;
47 |     }
48 | 
49 |     /*  
50 |         set current process waiting on semaphore, yield
51 |         (and the process won't be selected by scheduler 
52 |         until wait flag is cleared by some sem_post)
53 |     */
54 |     proc_sem_wait_flag[sem_id] |= BIT(current_process);
55 |     proc_waiting_sem |= BIT(current_process);
56 | 
57 | 		return 0; //returning 0 means a reschedule should be done.
58 | }
59 | 


--------------------------------------------------------------------------------
/src/semaphore.h:
--------------------------------------------------------------------------------
 1 | #ifndef _SEMAPHORE_H_
 2 | #define _SEMAPHORE_H_
 3 | 
 4 | #include "global.h"
 5 | #include "bit_ops.h"
 6 | #include "scheduler.h"
 7 | 
 8 | #define MAX_SEMAPHORES 8
 9 | 
10 | extern XDATA char semaphores[MAX_SEMAPHORES];
11 | extern XDATA u8 proc_sem_wait_flag[MAX_SEMAPHORES];
12 | extern XDATA u8 sem_wake_round[MAX_SEMAPHORES];
13 | extern XDATA u8 proc_waiting_sem;
14 | /*
15 |     If process P is waiting for semaphore SEM,
16 |     then bit P of proc_sem_wait_flag[SEM] is set,
17 |     and 
18 | 
19 |     If process P is the last process that has 
20 |     been waked by semaphore SEM, then bit P of
21 |     sem_wake_round[SEM] is set.
22 | 
23 |     When a semaphore is waking up a process, it
24 |     will find the first process waiting for it,
25 |     starting from the [pid last waked]+1.
26 | 
27 |     For example, when SEM1 waked up PROC3 last time,
28 |     it will find a process to wake up from PROC4,5,6,...
29 |     This behaviour can prevent starving some process.
30 | */
31 | 
32 | void __sem_init(u8 sem_id, char val);
33 | void __sem_post(u8 sem_id);
34 | u8 __sem_wait(u8 sem_id);
35 | 
36 | #endif


--------------------------------------------------------------------------------
/src/spin.c:
--------------------------------------------------------------------------------
1 | #include "spin.h"
2 | 
3 | void spin()
4 | {
5 | 	while(1)
6 | 	{
7 | 	}
8 | }
9 | 


--------------------------------------------------------------------------------
/src/spin.h:
--------------------------------------------------------------------------------
1 | #ifndef _SPIN_H_
2 | #define _SPIN_H_
3 | #include "global.h"
4 | void spin();
5 | 
6 | #endif


--------------------------------------------------------------------------------
/src/stack.c:
--------------------------------------------------------------------------------
 1 | #include "stack.h"
 2 | 
 3 | IDATA u8 kernel_stack[KERNEL_STACKSIZE];
 4 | IDATA u8 process_stack[5][PROCESS_STACKSIZE];
 5 | XDATA u8 process_stack_swap[3][PROCESS_STACKSIZE];
 6 | 
 7 | /*
 8 | 		OS allows 8 processes maximum, but there are only
 9 | 		5 process stacks allowed in memory due to size 
10 | 		limitations.
11 | 		
12 | 		the process stacks can be swapped out to xdata 
13 | 		swap area if there are more than 5 processes at
14 | 		the same time.
15 | */
16 | 
17 | char get_stack_index(u8 pid)
18 | {
19 | 	XDATA u8 i;
20 | 	for(i=0;i<5;i++)
21 | 		if(process_stack[i][PROCESS_STACKSIZE-1] == pid)
22 | 			return i;
23 | 	
24 | 	return -1;
25 | }
26 | 
27 | char get_stackswap_index(u8 pid)
28 | {
29 | 	XDATA u8 i;
30 | 	for(i=0;i<3;i++)
31 | 		if(process_stack_swap[i][PROCESS_STACKSIZE-1] == pid)
32 | 			return i;
33 | 	
34 | 	return -1;
35 | }
36 | 
37 | 
38 | extern XDATA u8 process_context[8][18];
39 | extern XDATA u8 process_slot;
40 | void stackswap(u8 swap_index)
41 | {
42 | 	XDATA u8 i, temp, physical_index;
43 | 	
44 | 	//first try to find a stack slot that's not being used
45 | 	physical_index = 0xff;
46 | 	for(i=0;i<5;i++)
47 | 	{
48 | 		if(process_slot & BIT(process_stack[i][PROCESS_STACKSIZE-1]) == 0)
49 | 		{
50 | 			physical_index = i;
51 | 			break;
52 | 		}
53 | 	}
54 | 	
55 | 	//if there's no free stack slot, select random victim
56 | 	physical_index = rand32()%5;
57 | 	
58 | 	for(i=0; i<PROCESS_STACKSIZE; i++)
59 | 	{
60 | 		temp = process_stack[physical_index][i];
61 | 		process_stack[physical_index][i] = process_stack_swap[swap_index][i];
62 | 		process_stack_swap[swap_index][i] = temp;
63 | 	}
64 | 	
65 | 	//convert context SP of process whose stack is being swapped out to a relative address
66 | 	process_context[process_stack_swap[swap_index][PROCESS_STACKSIZE-1]][17] -= (u8)process_stack[physical_index];
67 | 	
68 | 	//convert context SP of process whose stack is being swapped in to an absolute address
69 |   process_context[process_stack[physical_index][PROCESS_STACKSIZE-1]][17] += (u8)process_stack[physical_index];
70 | }


--------------------------------------------------------------------------------
/src/stack.h:
--------------------------------------------------------------------------------
 1 | #include "global.h"
 2 | #include "random.h"
 3 | #include "bit_ops.h"
 4 | 
 5 | //physical stack = stack + 1byte indicating which process is using the stack.
 6 | #define KERNEL_STACKSIZE 14+1	
 7 | #define PROCESS_STACKSIZE 20+1
 8 | //the size settings must match stack.inc
 9 | 
10 | 
11 | extern IDATA u8 kernel_stack[KERNEL_STACKSIZE];
12 | extern IDATA u8 process_stack[5][PROCESS_STACKSIZE];
13 | extern XDATA u8 process_stack_swap[3][PROCESS_STACKSIZE];
14 | char get_stack_index(u8 pid);
15 | char get_stackswap_index(u8 pid);
16 | void stackswap(u8 swap_index);


--------------------------------------------------------------------------------
/src/stack.inc:
--------------------------------------------------------------------------------
1 | KERNEL_STACKSIZE EQU 14+1
2 | PROCESS_STACKSIZE EQU 20+1
3 | 
4 | EXTERN IDATA (KERNEL_STACK, PROCESS_STACK)
5 | EXTERN XDATA (PROCESS_STACK_SWAP)


--------------------------------------------------------------------------------
/src/stc15fxxxx.inc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/FishyFizz/STC-B-OS/743279ab40fb298dc0140349a8d9971048b70a1b/src/stc15fxxxx.inc


--------------------------------------------------------------------------------
/src/syscall.a51:
--------------------------------------------------------------------------------
 1 | #include "STC15FXXXX.inc"
 2 | #include "xstack.inc"
 3 | #include "stack.inc"
 4 | 
 5 | EXTERN DATA (INTERRUPT_CONTEXT)
 6 | EXTERN CODE (PCA_ISR_C)
 7 | 
 8 | SEG_SYSCALL_ENTRY SEGMENT CODE AT 0x003B
 9 | RSEG SEG_SYSCALL_ENTRY
10 | 	LJMP SYSCALL_ISR
11 | 	
12 | SEG_SYSCALL_ISR SEGMENT CODE
13 | RSEG SEG_SYSCALL_ISR
14 | 	SYSCALL_ISR:
15 | 		;SAVE CURRENT STATE
16 | 		MOV INTERRUPT_CONTEXT, DPH
17 | 		MOV INTERRUPT_CONTEXT+1, DPL
18 | 		MOV INTERRUPT_CONTEXT+2, A
19 | 		MOV INTERRUPT_CONTEXT+3, B
20 | 		MOV INTERRUPT_CONTEXT+4, PSW
21 | 		MOV INTERRUPT_CONTEXT+5, R0
22 | 		MOV INTERRUPT_CONTEXT+6, R1
23 | 		MOV INTERRUPT_CONTEXT+7, R2
24 | 		MOV INTERRUPT_CONTEXT+8, R3
25 | 		MOV INTERRUPT_CONTEXT+9, R4
26 | 		MOV INTERRUPT_CONTEXT+10, R5
27 | 		MOV INTERRUPT_CONTEXT+11, R6
28 | 		MOV INTERRUPT_CONTEXT+12, R7
29 | 		MOV INTERRUPT_CONTEXT+13, ?C_XBP 
30 | 		MOV INTERRUPT_CONTEXT+14, ?C_XBP + 1
31 | 
32 | 		POP	INTERRUPT_CONTEXT+15
33 | 		POP INTERRUPT_CONTEXT+16
34 | 		MOV INTERRUPT_CONTEXT+17, SP
35 | 		;STATE SAVED
36 | 		
37 | 		;START TO MOVE TO KERNEL CONTEXT
38 | 		;Kernel uses it's own stack and xstack
39 | 		MOV SP, #KERNEL_STACK
40 | 		MOV ?C_XBP 		, #HIGH (KERNEL_STACK + KERNEL_XSTACKSIZE)
41 | 		MOV ?C_XBP + 1  , #LOW 	(KERNEL_STACK + KERNEL_XSTACKSIZE)
42 | 	
43 | 		CALL PCA_ISR_C
44 | 		
45 | 		;Kernel processing end.
46 | 		;Load process state.
47 | 		MOV SP, INTERRUPT_CONTEXT+17
48 | 		PUSH INTERRUPT_CONTEXT+16
49 | 		PUSH INTERRUPT_CONTEXT+15
50 | 
51 | 		MOV DPH, INTERRUPT_CONTEXT
52 | 		MOV DPL, INTERRUPT_CONTEXT+1
53 | 		MOV A, INTERRUPT_CONTEXT+2
54 | 		MOV B, INTERRUPT_CONTEXT+3
55 | 		MOV PSW, INTERRUPT_CONTEXT+4
56 | 		MOV R0, INTERRUPT_CONTEXT+5
57 | 		MOV R1, INTERRUPT_CONTEXT+6
58 | 		MOV R2, INTERRUPT_CONTEXT+7
59 | 		MOV R3, INTERRUPT_CONTEXT+8
60 | 		MOV R4, INTERRUPT_CONTEXT+9
61 | 		MOV R5, INTERRUPT_CONTEXT+10
62 | 		MOV R6, INTERRUPT_CONTEXT+11
63 | 		MOV R7, INTERRUPT_CONTEXT+12
64 | 		MOV ?C_XBP, INTERRUPT_CONTEXT+13
65 | 		MOV ?C_XBP + 1, INTERRUPT_CONTEXT+14
66 | 		RETI
67 | 
68 | SEG_SYSCALL_INVOKE SEGMENT CODE
69 | RSEG SEG_SYSCALL_INVOKE
70 | 	PUBLIC SYSCALL, _SYSCALL
71 | 	_SYSCALL:
72 | 	SYSCALL:
73 | 		;syscall id in R7
74 | 		;syscall parameter in R4R5, R2R3
75 | 		ORL CCON, #4	;CCON^2 = 1, interrupt on next instruction
76 | 		RET
77 | 		
78 | END


--------------------------------------------------------------------------------
/src/syscall.h:
--------------------------------------------------------------------------------
 1 | #ifndef _SYSCALL_H_
 2 | #define _SYSCALL_H_
 3 | 
 4 | #include "xstack.h"
 5 | #include "timer0_isr.h"
 6 | #include "scheduler.h"
 7 | #include "bit_ops.h"
 8 | #include "semaphore.h"
 9 | #include "events.h"
10 | //#include "seg_led.h"
11 | 
12 | 
13 | void syscall(u8 syscallid, u16 payload1, u16 payload2) small;
14 | 
15 | void syscall_c();
16 | 
17 | void pca_isr_c();
18 | 
19 | 
20 | #define proc_exit() 					{syscall(0,0,0);}
21 | #define proc_yield() 					{syscall(1,0,0);}
22 | #define proc_sleep(t) 				{syscall(2,t,0);}
23 | #define sem_init(sem_id,val) 	{syscall(4,sem_id,val);}
24 | #define sem_post(sem_id) 			{syscall(5,sem_id,0);}
25 | #define sem_wait(sem_id) 			{syscall(6,sem_id,0);}
26 | #define proc_wait_evts(e) 		{syscall(3,e,0);}
27 | #define proc_wait_evts_timeout(e, t)  {syscall(3,(e)|EVT_TIMER,t);}
28 | #define deliver_event(pid, e) {syscall(7,pid,e);}
29 | 
30 | #endif


--------------------------------------------------------------------------------
/src/syscall_c.c:
--------------------------------------------------------------------------------
 1 | #include "syscall.h"
 2 | 
 3 | void syscall_c()
 4 | {
 5 | 	XDATA u8 syscall_id;
 6 | 	XDATA u16 syscall_data, syscall_data2;
 7 | 	
 8 | 	syscall_id = interrupt_context[12]; //R7 of the process invoking syscall
 9 | 	//payload1: MSB in R4, LSB in R5
10 | 	syscall_data = interrupt_context[10] + (interrupt_context[9] << 8);
11 | 	//payload2: MSB in R2, LSB in R3
12 | 	syscall_data2 = interrupt_context[8] + (interrupt_context[7] << 8);
13 | 	
14 | 	//syscall 1: process yield it's remaining timeslices
15 | 	if (syscall_id == 1)
16 | 	{
17 | 		SYSCALL_YIELD:;
18 | 		reschedule();
19 | 		return;
20 | 	}
21 | 	
22 | 	//syscall 2: process sleep, payload1 = time
23 | 	else if (syscall_id == 2)
24 | 	{
25 | 		SETBIT(proc_waiting_evt, current_process);
26 | 		proc_listening_list[current_process] = EVT_TIMER;
27 | 		proc_sleep_countdown[current_process] = syscall_data;
28 | 		goto SYSCALL_YIELD;
29 | 	}	
30 | 
31 | 	//syscall 3: process wait on event, payload1 = events
32 | 	else if (syscall_id == 3)
33 | 	{
34 | 		SETBIT(proc_waiting_evt, current_process);
35 | 		proc_listening_list[current_process] = syscall_data;
36 | 		proc_sleep_countdown[current_process] = syscall_data2;
37 | 		goto SYSCALL_YIELD;
38 | 	}
39 | 
40 | 	//syscall 0: process exit
41 | 	else if(syscall_id == 0)
42 | 	{
43 | 		CLEARBIT(process_slot, current_process);
44 | 		return;
45 | 	}
46 | 
47 | 	//syscall 4: semaphore init
48 | 	else if (syscall_id == 4)
49 | 	{
50 | 		__sem_init(syscall_data, syscall_data2);
51 | 		return;
52 | 	}
53 | 	
54 | 	//syscall 5: semaphore post
55 | 	else if (syscall_id == 5)
56 | 	{
57 | 		__sem_post(syscall_data);
58 | 		return;
59 | 	}
60 | 	
61 | 	//syscall 6: semaphore wait
62 | 	else if (syscall_id == 6)
63 | 	{
64 | 		if(__sem_wait(syscall_data))
65 | 			return;
66 | 		else
67 | 			goto SYSCALL_YIELD;
68 | 	}
69 | 	
70 | 	//syscall 7: deliver event
71 | 	else if (syscall_id == 7)
72 | 	{
73 | 		if((proc_waiting_evt & BIT(syscall_data)) && 
74 | 				proc_listening_list[syscall_data] & syscall_data2)
75 | 		{
76 | 			proc_listening_list[syscall_data] = curr_events; 
77 | 			CLEARBIT(proc_waiting_evt, syscall_data);
78 | 		}
79 | 	}
80 | }
81 | 
82 | void pca_isr_c()
83 | {
84 | 	//CCF2 -> syscall
85 | 	if(CCON & 4)
86 | 	{
87 | 		CCON &= ~4;
88 | 		syscall_c();
89 | 	}
90 | 	else
91 | 	{
92 | 	}
93 | }
94 | 


--------------------------------------------------------------------------------
/src/timer0_isr.a51:
--------------------------------------------------------------------------------
 1 | #include "stc15fxxxx.inc"
 2 | #include "xstack.inc"
 3 | #include "stack.inc"
 4 | 
 5 | EXTERN DATA (INTERRUPT_COUNTER, FLAG_NOSCHED, INTERRUPT_CONTEXT)
 6 | 
 7 | SEG_TIMER0_ISR_ENTRY SEGMENT CODE AT 000Bh
 8 | RSEG SEG_TIMER0_ISR_ENTRY
 9 | 	LJMP TIMER0_ISR
10 | 	
11 | SEG_TIMER0_ISR SEGMENT CODE
12 | RSEG SEG_TIMER0_ISR
13 | 	TIMER0_ISR:
14 | 		INC INTERRUPT_COUNTER
15 | 		XCH A, FLAG_NOSCHED
16 | 		JNZ T0ISR_SKIP
17 | 			XCH A, FLAG_NOSCHED
18 | 			;SAVE CURRENT STATE
19 | 			MOV INTERRUPT_CONTEXT, DPH
20 | 			MOV INTERRUPT_CONTEXT+1, DPL
21 | 			MOV INTERRUPT_CONTEXT+2, A
22 | 			MOV INTERRUPT_CONTEXT+3, B
23 | 			MOV INTERRUPT_CONTEXT+4, PSW
24 | 			MOV INTERRUPT_CONTEXT+5, R0
25 | 			MOV INTERRUPT_CONTEXT+6, R1
26 | 			MOV INTERRUPT_CONTEXT+7, R2
27 | 			MOV INTERRUPT_CONTEXT+8, R3
28 | 			MOV INTERRUPT_CONTEXT+9, R4
29 | 			MOV INTERRUPT_CONTEXT+10, R5
30 | 			MOV INTERRUPT_CONTEXT+11, R6
31 | 			MOV INTERRUPT_CONTEXT+12, R7
32 | 			MOV INTERRUPT_CONTEXT+13, ?C_XBP 
33 | 			MOV INTERRUPT_CONTEXT+14, ?C_XBP + 1
34 | 	
35 | 			POP	INTERRUPT_CONTEXT+15
36 | 			POP INTERRUPT_CONTEXT+16
37 | 			MOV INTERRUPT_CONTEXT+17, SP
38 | 			;STATE SAVED
39 | 			
40 | 			;START TO MOVE TO KERNEL CONTEXT
41 | 			;Kernel uses it's own stack and xstack
42 | 			MOV SP, #KERNEL_STACK
43 | 			MOV ?C_XBP 		, #HIGH (KERNEL_STACK + KERNEL_XSTACKSIZE)
44 | 			MOV ?C_XBP + 1  , #LOW 	(KERNEL_STACK + KERNEL_XSTACKSIZE)
45 | 			
46 | 			EXTERN CODE (TIMER0_ISR_C)
47 | 			CALL TIMER0_ISR_C
48 | 			;Kernel processing end.
49 | 			
50 | 			;Load process state.
51 | 			MOV SP, INTERRUPT_CONTEXT+17
52 | 			PUSH INTERRUPT_CONTEXT+16
53 | 			PUSH INTERRUPT_CONTEXT+15
54 | 	
55 | 			MOV DPH, INTERRUPT_CONTEXT
56 | 			MOV DPL, INTERRUPT_CONTEXT+1
57 | 			MOV A, INTERRUPT_CONTEXT+2
58 | 			MOV B, INTERRUPT_CONTEXT+3
59 | 			MOV PSW, INTERRUPT_CONTEXT+4
60 | 			MOV R0, INTERRUPT_CONTEXT+5
61 | 			MOV R1, INTERRUPT_CONTEXT+6
62 | 			MOV R2, INTERRUPT_CONTEXT+7
63 | 			MOV R3, INTERRUPT_CONTEXT+8
64 | 			MOV R4, INTERRUPT_CONTEXT+9
65 | 			MOV R5, INTERRUPT_CONTEXT+10
66 | 			MOV R6, INTERRUPT_CONTEXT+11
67 | 			MOV R7, INTERRUPT_CONTEXT+12
68 | 			MOV ?C_XBP, INTERRUPT_CONTEXT+13
69 | 			MOV ?C_XBP + 1, INTERRUPT_CONTEXT+14
70 | 			RETI
71 | 		 
72 | 		T0ISR_SKIP:
73 | 		XCH A, FLAG_NOSCHED
74 | 		RETI
75 | 
76 | END
77 | 	
78 | 	


--------------------------------------------------------------------------------
/src/timer0_isr.h:
--------------------------------------------------------------------------------
 1 | #ifndef _TIMER0_ISR_H_
 2 | #define _TIMER0_ISR_H_
 3 | 
 4 | #include "global.h"
 5 | #include "scheduler.h"
 6 | #include "spin.h"
 7 | #include "seg_led.h"
 8 | /*
 9 | #include "vstack.h"
10 | #include "bit_ops.h"
11 | #include "events.h"
12 | */
13 | 
14 | extern DATA u32 timer0_cnt;
15 | extern DATA u8 interrupt_counter;
16 | extern DATA u8 interrupt_context[18];
17 | 
18 | void timer0_isr_c();
19 | void save_current_context();
20 | void load_current_context();
21 | 
22 | #endif


--------------------------------------------------------------------------------
/src/timer0_isr_c.c:
--------------------------------------------------------------------------------
 1 | #include "timer0_isr.h"
 2 | 
 3 | DATA u32 timer0_cnt = 0;
 4 | DATA u8 interrupt_counter = 0;
 5 | DATA u8 interrupt_context[18];
 6 | 
 7 | 
 8 | void save_current_context()
 9 | {
10 | 	XDATA u8 i;
11 | 	for(i=0;i<18;i++)
12 | 		process_context[current_process][i] = interrupt_context[i];
13 | }
14 | 
15 | void load_current_context()
16 | {
17 | 	XDATA u8 i;
18 | 	for(i=0;i<18;i++)
19 | 		interrupt_context[i] = process_context[current_process][i];
20 | }
21 | 
22 | void timer0_isr_c()
23 | {	
24 | 	//increment system time, and update all counters
25 | 	timer0_cnt += interrupt_counter;
26 | 	COUNTDOWN(remaining_timeslices, interrupt_counter);	
27 | 	decrement_sleep_counters();
28 | 	interrupt_counter = 0;
29 | 	
30 | 	//Update display
31 | 	seg_led_scan_next();
32 | 	
33 | 	//Process events
34 | 	process_events();
35 | 
36 | 	/*
37 | 	Timer0 and Syscall interrupt at the same CPU cycle.
38 | 	If a task switch is done, current_process is modified,
39 | 	syscall won't be able to determine the correct process 
40 | 	calling it.
41 | 	*/
42 | 	if (CCON&4)
43 | 		goto SKIPSCHED;
44 | 	if(remaining_timeslices > 0)
45 | 		goto SKIPSCHED;
46 | 		
47 | 	reschedule();
48 | 
49 | 	SKIPSCHED: 
50 | 		return;
51 | }
52 | 


--------------------------------------------------------------------------------
/src/usbcom.c:
--------------------------------------------------------------------------------
  1 | #include "usbcom.h"
  2 | 
  3 | 
  4 | void usbcom_init(u32 baudrate) 
  5 | {
  6 | 		XDATA u16 reload;
  7 | 		
  8 |     //Set TXD(P31) to Push-Pull RXD(P30) to HiZ
  9 |     {
 10 | 		CLEARBIT(P3M1, 1);
 11 | 		SETBIT(P3M0, 1);
 12 | 		
 13 | 		SETBIT(P3M1, 0);
 14 | 		CLEARBIT(P3M0, 0);
 15 | 	}
 16 | 
 17 |     //Configure baudrate timer
 18 |     {
 19 |         reload = 65536 - (MAIN_Fosc / 4) / baudrate;
 20 |         
 21 |         AUXR |= 0x01;		//S1 BRT Use Timer2;
 22 |         AUXR &= ~(1<<4);	//Timer stop
 23 |         AUXR &= ~(1<<3);	//Timer2 set As Timer
 24 |         AUXR |=  (1<<2);	//Timer2 set as 1T mode
 25 |         IE2  &= ~(1<<2);	//Disable interrup
 26 | 
 27 |         TH2 = (u8)(reload>>8);
 28 |         TL2 = (u8)reload;
 29 |         AUXR |=  (1<<4);	//Timer run enable
 30 |     }
 31 | 
 32 |     //Initialize UART1 on P30 and P31
 33 |     {
 34 |         PS = 1;	//High priority interrupt
 35 |         SCON = (SCON & 0x3f) | (1<<6); //8bit mode
 36 |         REN = 1; //Enable Rx
 37 |         P_SW1 = (P_SW1 & 0x3f) | (0 & 0xc0);	//Select IO port P30/P31
 38 |         ES = 1;	//Enable interrupt (wait for incoming data)
 39 |     }
 40 | }
 41 | 
 42 | 
 43 | //this function blocks current process until all data is sent
 44 | //not a VFUNC because there's no reentrancy support
 45 | void __usbcom_write(u8* buf, u8 len) small
 46 | {
 47 |     u8 i;
 48 | 	
 49 |     //Disable interrupt (Tx uses polling mode)
 50 |     ES = 0;
 51 | 
 52 | 		//length is set
 53 | 		if(len)
 54 | 		{
 55 | 			for(i=0;i<len;i++)
 56 | 			{
 57 | 					//clear TX end flag
 58 | 					TI = 0;
 59 | 					//feed byte into UART1 buffer
 60 | 					SBUF = buf[i];
 61 | 					//spin until TX end flag is set (by hardware)
 62 | 					while(TI == 0);
 63 | 			}
 64 | 		}
 65 | 		else
 66 | 		{
 67 | 			//length is 0, auto detect '\0'
 68 | 			for(i=0;;i++)
 69 | 			{
 70 | 					//clear TX end flag
 71 | 					TI = 0;
 72 | 					//feed byte into UART1 buffer
 73 | 					if(buf[i] == '\0') break;		
 74 | 					SBUF = buf[i];
 75 | 					//spin until TX end flag is set (by hardware)
 76 | 					while(TI == 0);
 77 | 			}
 78 | 		}
 79 |     //Enable UART1 interrupt
 80 |     //(Rx uses interrupt to trigger, but still runs in polling mode)
 81 | 		RI = 0;//Reset all flags
 82 |     TI = 0;
 83 |     ES = 1;
 84 | }
 85 | 
 86 | XDATA u8 usbcom_buf[128];
 87 | XDATA u8 usbcom_rxcnt;
 88 | XDATA u32 usbcom_timeout;
 89 | XDATA u8 usbcom_evtstate = 0;
 90 | 
 91 | void usbcom_interrupt (void) interrupt UART1_VECTOR
 92 | {
 93 | 	//Tx uses polling mode, INT source can only be RX
 94 | 
 95 |     //Disable UART1 interrupt
 96 |     //(Rx uses interrupt to trigger, but still runs in polling mode)
 97 |     ES = 0;
 98 | 
 99 |     usbcom_rxcnt = 0;
100 |     while(1)
101 |     {
102 |         RI = 0; //Remove RX end flag.
103 |         usbcom_buf[usbcom_rxcnt++] = SBUF; //Retrieve byte.
104 | 
105 |         //Spin until RX end flag is set (by hardware)
106 |         usbcom_timeout = 500;//You have to try out a proper value for specific baud and clock frequency settings
107 |         while(RI==0) 
108 |         {
109 |             if(--usbcom_timeout == 0)
110 |                 goto RX_END;
111 |         }
112 |     }
113 | 
114 |     RX_END:;
115 |     
116 |     TI = 0;  //Reset all flags
117 |     RI = 0;
118 |     ES = 1; //Enable UART1 interrupt
119 | 
120 |     usbcom_evtstate = 1;
121 | }


--------------------------------------------------------------------------------
/src/usbcom.h:
--------------------------------------------------------------------------------
 1 | #ifndef _USBCOM_H_
 2 | #define _USBCOM_H_
 3 | 
 4 | #include "global.h"
 5 | #include "scheduler.h"
 6 | #include "bit_ops.h"
 7 | 
 8 | extern XDATA u8 usbcom_buf[128];
 9 | extern XDATA u8 usbcom_rxcnt;
10 | extern XDATA u32 usbcom_timeout;
11 | extern XDATA u8 usbcom_evtstate;
12 | 
13 | void usbcom_init(u32 baudrate); //VCALL_UL
14 | 
15 | #define usbcom_write(buf,len) NOINT_ATOMIC(__usbcom_write(buf,len);)
16 | void __usbcom_write(u8* buf, u8 len) small;
17 | 
18 | #endif


--------------------------------------------------------------------------------
/src/xbp_helper.a51:
--------------------------------------------------------------------------------
 1 | #include "stc15fxxxx.inc"
 2 | 
 3 | EXTERN DATA (?C_XBP)
 4 | 
 5 | SEG_XBPHELPER SEGMENT CODE
 6 | RSEG SEG_XBPHELPER
 7 | 
 8 | 	PUBLIC _GETXBP, GETXBP
 9 | 	_GETXBP:
10 | 	GETXBP:
11 | 		JBC EA, GETXBP_SETEA
12 | 			MOV R6, ?C_XBP
13 | 			MOV R7, ?C_XBP + 1
14 | 			RET
15 | 		GETXBP_SETEA:
16 | 			MOV R6, ?C_XBP
17 | 			MOV R7, ?C_XBP + 1
18 | 			SETB	EA
19 | 			RET
20 | 
21 | 	PUBLIC _SETXBP, SETXBP
22 | 	_SETXBP:
23 | 	SETXBP:
24 | 		JBC EA, SETXBP_SETEA
25 | 			MOV ?C_XBP, R6
26 | 			MOV ?C_XBP + 1, R7
27 | 			RET
28 | 		SETXBP_SETEA:
29 | 			MOV ?C_XBP, R6
30 | 			MOV ?C_XBP + 1, R7
31 | 			SETB	EA
32 | 			RET
33 | 
34 | 
35 | 
36 | 
37 | END


--------------------------------------------------------------------------------
/src/xstack.c:
--------------------------------------------------------------------------------
1 | #include "xstack.h"
2 | 
3 | XDATA u8 kernel_xstack[KERNEL_XSTACKSIZE];
4 | XDATA u8 process_xstack[8][PROCESS_XSTACKSIZE];


--------------------------------------------------------------------------------
/src/xstack.h:
--------------------------------------------------------------------------------
 1 | #include "global.h"
 2 | 
 3 | #define KERNEL_XSTACKSIZE 32
 4 | #define PROCESS_XSTACKSIZE 64
 5 | 
 6 | extern XDATA u8 kernel_xstack[KERNEL_XSTACKSIZE];
 7 | extern XDATA u8 process_xstack[8][PROCESS_XSTACKSIZE];
 8 | 
 9 | u16 getxbp() small;
10 | void setxbp(u16 xbp) small;


--------------------------------------------------------------------------------
/src/xstack.inc:
--------------------------------------------------------------------------------
1 | KERNEL_XSTACKSIZE EQU 32
2 | PROCESS_XSTACKSIZE EQU 64
3 | 
4 | EXTERN XDATA (KERNEL_XSTACK, PROCESS_XSTACK)
5 | EXTERN DATA (?C_XBP)
6 | EXTERN CODE (GETXBP, SETXBP)


--------------------------------------------------------------------------------