Course Website for CSCI E-92 Spring 2024

Final Project Presentation Slots:

Time	Slot	Available
6:45 PM - 7:00 PM	Slot 1	Filled by Keenan
7:00 PM - 7:15 PM	Slot 2	Filled by Pierre-David
7:15 PM - 7:30 PM	Slot 3	Filled by Nathan
7:30 PM - 7:45 PM	Slot 4	Filled by Lucas
7:45 PM - 8:00 PM	Slot 5	Filled by Justin
8:00 PM - 8:15 PM	Slot 6	Filled by Alejandro
8:15 PM - 8:30 PM	Slot 7	Filled by Julian
8:30 PM - 8:45 PM	Slot 8	Filled by Aliya
8:45 PM - 9:00 PM	Slot 9	Filled by Adi
9:00 PM - 9:15 PM	Slot 10	Filled by Leonid

After the current Spring 2024 semester, the next time CSCI E-92 will be offered is in the Fall 2025 semester.

We will be holding our first section meeting on Tuesday, January 23, 2024 at 6:45 PM ET. Note that this section meeting is *before* our first class meeting. Both section and class meetings are live streamed and are also available after class for later viewing and reviewing.

Many links in the course website are not yet available. They will be activated as the course progresses.

Tuesdays 8:00-10:15 PM in 53 Church Street, Room L01. Students can attend in person on campus, participate live online at the time the class meets via web conference, or watch the recorded video on demand. Recorded sessions are typically available within a few hours of the end of class and no later than the following business day. Students who attend this course in person must comply with the Harvard Extension School mandatory COVID-19 immunization documentation policy. See Immunization Requirements.

In addition to being able to participate in section & class in person, both are live streamed and also recorded. Students are encouraged to share their video feed and to ask questions verbally using their audio/video link in Zoom. The section & class live video stream is available through the class Canvas web site under Zoom.

Questions can also be asked using the text Chat facility in Zoom during class meetings & during section meetings. Please use the chat feature available in Zoom rather than Canvas chat. We will *not* be monitoring Canvas chat.

Our midterm exam is a three hour long proctored exam that will be available on-line through Canvas with integrity protected by Proctorio. Students must start the exam within the 24-hour period that begins at the designated start time of our midterm exam and ends 24 hours later. Students will have three hours to complete the exam independent of when they start. More information will be available about the exam later in the semester.

The exam does not allow access to any books or notes, but relevant course slides will be made available. No electronic devices are allowed.

Knowledge of data structures and programming experience, such as is taught in CSCI E-22 (formerly CSCI E-119) (Data Structures), is required. Experience using UNIX/Linux or equivalent at the shell level and the system programming level is strongly recommended, but not required. Students must have sufficient experience to write programming projects of modest size and complexity in the C Programming Language that utilize a variety of data structures. This course does *not* teach programming.

This course examines the role of operating systems: process synchronization and scheduling; memory management including virtual memory, swapping, paging, and segmentation; file management; protection and security; input/output techniques, buffering, and resource allocation; deadlock detection and avoidance; system modeling; performance measurement and evaluation; and operating system case studies. An extensive lab project will be required of all students.

Students will come away with both a theoretical and practical understanding of the workings of operating systems. The material forms a strong underpinning for all programmers and results in methodologies for effective use of concurrency/parallelism, I/O and file systems, security, virtual memory, and virtual machines. In this course, we will study processes, threads, and schedulers, address spaces, virtual memory, memory protection, file systems, security and protection. In addition to writing an operating system, material covered in this class includes information about utilizing an ARM processor at the lowest level, the ARM instruction set, navigating through hardware schematics, interfacing to a variety of I/O devices, designing a device-independent interface to I/O systems, and creating a multiprocessing scheduler. The knowledge and skills learned in this course will benefit every student throughout their future careers.

Computer Science E-92 is a detailed exploration of the internal algorithms and design of operating systems. Students are expected to be comfortable with designing, coding, and debugging programs of reasonable complexity while employing good programming style and structured techniques. In particular, knowledge of C, terminal and text file I/O, iterative and conditional control structures, parameter passing and recursion, and data structures is presumed. During this class, students will use some UNIX system calls to complete the assignments.

A significant portion of the class will involve the design and implementation of a major term project. The project will be developed by each student working alone. That project is the core of a new operating system implemented from scratch for an ARM processor. Initially, both the classroom lectures and the section meetings will be covering material important to the design and implementation of the final project. Later in the semester, advanced topics will be covered in class; however, both the class and sections will continue to support students as term projects progress. For the term project, students will continue working on and debugging their projects leading to their complete implementation and a final demonstration.

Because the course includes a required and significant term project involving both programming and hardware implementation, the assignments will be time-consuming; therefore, a significant time commitment to the course is necessary. Although the relevant experience of students in the class is usually quite diverse, depending on background, it is not unusual for students to spend 10-15 hours per week or more completing the readings and homework assignments. Although the computers are available more-or-less around the clock, occasionally they will suddenly become unavailable (this is known as a crash). As with all such events, they always seem to occur at the worst possible time. Plan your computer work so that it is complete in advance of the deadlines. Check in your code to the required class git repository frequently. You have now been forewarned!

All course books are available from the Harvard Coop and are available for on-line ordering. A link to course materials at the Coop is available for on-line purchasing. Keep in mind that Coop members receive a 10% discount. There are links available on Canvas to find the Library Reserves and, for some books, these include ONLINE ACCESS versions. In addition, all registered students will be eligible for library services (access, borrowing privileges, group study rooms) in FAS libraries, just like any other student in FAS. The Harvard Library website includes information about how to access library materials both in person and remotely. All registered students will continue to have access to Harvard Library on-line resources.

Pro Git, 2nd Edition; Scott Chacon and Ben Straub; Apress, 2014; ISBN-13 978-1-4842-0077-3. This is a comprehensive book about git. It is also available for free download at the web site above.

We have two Teaching Assistants (TAs) for this course. The TAs hold a weekly section meeting and office hours as described below. The information delivered during the TAs' section meeting is a required component of the course. Course material will be covered in section -- either in toto or in more detail -- that time does not permit to be covered in class meetings. For example, this material includes use of git and GitHub; general approaches to solving the problem sets; overviews of algorithms, code snippets, and data structures. Also, the section meetings provide a venue in which it may be easier to ask more lengthy questions. When appropriate to send e-mail, please send e-mail to both TAs and to the course instructor.

TA	Section Meeting Time/Place	Office Hours Time/Place	E-mail Address/Phone
Daniel Willenson , Section Site	Tuesday, 6:45-7:45 PM ET, 53 Church Street, Room L01	Thursday, 8:30-9:30 PM ET by appt., Via web conference	E-mail: ; +1 571.265.2932 (Weekdays: 10:00 AM - 10:00 PM ET). If there's no answer, please leave a message with your name and a call-back number. Questions whose answers would be relevant to the whole class should be posed via Ed Discussion. When e-mail is appropriate (for grading questions, personal issues, etc.), e-mail should be sent to both TAs and also to the professor.
Stephen Benjamin , Section Site	Tuesday, 6:45-7:45 PM ET, 53 Church Street, Room L01	Wednesday, 7:00-8:00 PM ET by appt., Via web conference	E-mail: ; +1.617.401.8836 (11:00 AM - 9:00 PM ET). If there's no answer, please leave a message with your name and a call-back number. Questions whose answers would be relevant to the whole class should be posed via Ed Discussion. When e-mail is appropriate (for grading questions, personal issues, etc.), e-mail should be sent to both TAs and also to the professor.

When posing questions or bringing up issues of a non-personal nature, please use the class Ed Discussion Forum. Answers to questions posed on Ed Discussion benefit the whole class and allow the course staff to answer questions once for all students. Questions that include code or other information that shouldn't be shared with other students should be sent via e-mail to all course staff at the same time in order to increase the probability of a rapid response.

Using any tool of your choosing (perhaps a cell phone selfie or the camera on your laptop), please record and post a short video (maybe just one to three minutes in length) in Canvas Discussions as a reply to my Say Hello! discussion to introduce yourself to the class. With everyone being remote, anything we can do to create a community for our class would be great. Please tell us a little about yourself possibly including where you are located, your background, what you do when you're not taking classes, and your goals for this class.

When using "git" and GitHub, make sure to follow the information on using "git" and setting up your GitHub repository that is available on the section web site.

All problem sets and programming assignments are due at midnight Eastern Time on Sunday night (i.e., midnight between Sunday and Monday) unless otherwise stated in the assignment or in the syllabus. Unless otherwise stated, all programming assignment solutions must be written in the ISO/ANSI C Programming Language. All code must build, be tested, and run on cscie92.dce.harvard.edu or on the NXP/Freescale K70 Tower computer systems, as appropriate; be submitted using "git" on GitHub (or, in dire circumstances, via e-mail only if agreed to by the course staff); be well-written (clear coding style, modular structure, appropriately commented and documented in English); and tested (include any programs and/or shell scripts used in testing your solution as part of your submission). Remember, in addition to handing in all parts of the problem set solution or programming assignment program, sample runs of the program which demonstrate that the program works must be attached. In addition, each submission must include a makefile to build the assignment. The grade for programming assignments will include all of these attributes.

Of course, the solutions may be written and tested using any system of the student's choosing; however, when the solution is complete, it must be tested on the cscie92.dce.harvard.edu computer and pushed to the git code repository on GitHub. You may choose to develop under your own Unix/Linux system or under Cygwin under Windows, but testing and grading of your programming assignments will take place on the cscie92.dce.harvard.edu computer. To reiterate, we will be grading the solutions based on their behavior on the cscie92.dce.harvard.edu computer.

The first step to begin to use our computer resources is to ensure that your HarvardKey account has been established. Use a browser to connect to https://key.harvard.edu. From that page, you can claim a new HarvardKey if you don't already have one. There, you can also manage your HarvardKey account. On the "Manage Your HarvardKey Account" page, in addition to your "Login Name," you can see your NetID. Your NetID will be required to login to our instance named cscie92.dce.harvard.edu.

Access to our cscie92.dce.harvard.edu instance requires that a VPN (Virtual Private Network) connection to the Harvard network is established first. The Cisco AnyConnect VPN application can be downloaded by logging into https://vpn.harvard.edu. Then, you can run the Cisco AnyConnect to complete the VPN connection. For creating the VPN, use vpn.harvard.edu as the hostname and click on "Connect." On the two-step verification pop-up window, enter your HarvardKey Login Name as your Username, and for the Password, enter your HarvardKey Password. Do *not* enter a Two-Step Verification Code. You should receive a request for approval via your Duo Mobile app before the VPN can be established.

After establishing a VPN connection to the Harvard network, you can set up an account on cscie92.dce.harvard.edu. Access our cscie92.dce.harvard.edu instance for remote login using "ssh" over the Internet. Your username is your HarvardKey NetID and your password is your HarvardKey password. On your first attempt to login to our instance, your account will be configured. Files may be transferred to these systems using "secure ftp" (SFTP). If you are using a Windows system, the SecureCRT and SecureFX programs are available from Harvard University Information Technology (HUIT) at https://downloads.fas.harvard.edu/download; these programs implement "ssh" and "secure ftp," respectively. On Unix/Linux systems, the shell commands "ssh" and "sftp"/"scp" can be used for ssh and SFTP, respectively.

Separate documentation is available describing how to install and use git and GitHub on the section web site.

Some assignments may include Extra Credit programming problems. The Extra Credit programming problems can be completed to earn points that can increase the overall grade on the programming portion of your problem set; however, the grade on the programming portion of a problem set including extra credit will ever exceed the full credit possible grade on the programming portion. That is, the Extra Credit programming problem(s) can be used to make up for deficiencies in other programming portions of the problem set to allow a higher grade to be earned. Extra Credit points from one problem set are not transferrable and may not be used on any other problem sets.

All problem sets except for Problem Set 0 may be submitted late for partial credit. A late homework will lose 5% of its original grade for each day it is late (e.g. an assignment handed in two and a half days late will receive its original grade multiplied by 0.85). Late assignments may be submitted via "git" and an e-mail message notifying the instructor and the teaching assistants should be sent immediately after the late assignment is submitted. In addition, each student is given five free late days that may be used freely during the semester. However, keep in mind that almost all of the assignments are built on the previous assignments; handing in one assignment late does not extend the due date for subsequent assignments. The scope and difficultly level of the assignments increases during the class; therefore, we recommend against using the five free late days early in the class.

After a programming assignment has been initially submitted, we will award additional partial credit for corrections made to that assignment. We encourage students to correct any errors found in their code and to make improvements and enhancements. This will improve your grade and, in many cases, will be required to allow the next phase of your compiler to function correctly. No additional partial credit will be awarded for Problem Set 0 or for book problems.

In the "Grading: Problem Sets" section above, the phrase "commented and documented" is used; this paragraph will clarify the necessary comments and documentation that should be provided with all programs. First, there should be a description of the entire application. This should include the user interface (i.e., how a user interacts with the program) and an explanation of what the program does. This documentation may be in a separate file from the program itself. Second, there should be a description at the beginning of each file which outlines the contents of that file. Third, each routine, function, method, etc. must be preceded by a section describing: (1) the name of the routine, (2) the purpose/function of the routine, (3) the parameters to the routine (name, type, meaning), (4) the return value from the routine (type, meaning), and (5) any side-effects (including modifying global variables, performing I/O, modifying heap-based storage, etc.) that the routine may cause. Fourth, declarations of variables should be commented with their purpose. Fifth, blocks of code should be commented to describe the purpose of the code section. Sixth, any complex or difficult to understand code statements or fragments should be commented to clarify their behavior.

In addition to programming in a conventional language (the C Programming Language), students will learn how to write code in ARM/Thumb assembly language. These are the low-level languages used by ARM computers. All students are required to use Special Edition CodeWarrior for Microcontrollers, Version 11.1 from NXP/Freescale. This software may be downloaded from the www.nxp.com web site, is free, and no license is required. The Special Edition CodeWarrior for Microcontrollers software runs only on x86 Windows, but it also runs on an Apple Macintosh x86 under a Windows 11 virtual machine. In addition, CodeWarrior runs on an Apple Silicon M-Series Macintosh under the emulation layer built into Windows 11 for ARM.

This website also includes information about using Kinetis Design Studio (KDS), Version 3.2.0, but we have now standardized on using CodeWarrior, Version 11.1. In the past, the Kinetis Design Studio software ran on either Windows, Mac, or Linux (DEB or RPM), but this is no longer the case.

When using "git" and https://github.com/, make sure to follow the information on using "git" and setting up your repository that is available on the section web site. Create a named branch for each of your problem sets as follows: specify "problem-set-0" for Problem Set 0 (the course questionnaire, fix this program, and word count), specify "problem-set-1" for Problem Set 1, "problem-set-2" for Problem Set 2, etc., specify "project-proposal" for the Term Project Proposal, and specify "term-project" for the Term Project.

All work should be the personal creation of the individual student. Students are free to consult with each other and to study together, but all problem set solutions, programming assignments, exams, and the final project must be the personal contribution of each individual student. More explicitly, whenever a concept is reduced to a detailed algorithm or a program, no collaboration is allowed. If a paper, assignment, exam, program, or final project contains any information, algorithms, program fragments or other intellectual property taken from another source, that source and material must be explicitly identified and credit given. If you have any questions about this policy, it is the student's responsibility to clarify whether their activity is considered plagiarism.

You are responsible for understanding Harvard Extension School policies on academic integrity (https://www.extension.harvard.edu/resources-policies/student-conduct/academic-integrity) and how to use sources responsibly. Not knowing the rules, misunderstanding the rules, running out of time, submitting the wrong draft, or being overwhelmed with multiple demands are not acceptable excuses. There are no excuses for failure to uphold academic integrity. To support your learning about academic citation rules, please visit the Harvard Extension School Tips to Avoid Plagiarism ((https://www.extension.harvard.edu/resources-policies/resources/tips-avoid-plagiarism), where you'll find links to the Harvard Guide to Using Sources and two free online 15-minute tutorials to test your knowledge of academic citation policy. The tutorials are anonymous open-learning tools.

Major course objectives, in addition to writing an operating system, are for students to gain a deep understanding of deadlocks, multiprocessing, scheduling, processes, security, protection, etc. and to gain a working knowledge of how to use low-level hardware systems. These are knowledge and skills that will benefit every student throughout their future careers. In order to meet these goals, we specifically forbid the use of ChatGPT or any other generative artificial intelligence (AI) tools at all stages of the work process, including preliminary ones. It is the responsibility of each student to check with the course staff for any other exceptions to this policy. Violations of this policy will be considered academic misconduct.

We draw your attention to the fact that different classes at Harvard could implement different AI policies, and it is the student's responsibility to conform to expectations for each course.

Students may not post, publish, sell, or otherwise publicly distribute course materials without the written permission of the course instructor. Such materials include, but are not limited to, the following: lecture notes, lecture slides, video, or audio recordings, assignments, problem sets, examinations, other students' work, and answer keys. Students who sell, post, publish, or distribute course materials without written permission, whether for the purposes of soliciting answers or otherwise, may be subject to disciplinary action, up to and including requirement to withdraw. Further, students may not make video or audio recordings of class sessions for their own use without written permission of the instructor.

November 2023	Description
2	Course registration opens at 9 AM for degree candidates and Premedical Program admitted candidates
6	Course registration opens at 9 AM for all students

January 2024	Description
4	Full payment deadline
15	Martin Luther King Jr. Day
18	Registration deadline
19-28	Course change period for registered students only
22	Classes begin
23	First class meeting. Introduction, course information & policies, outline, schedule. Review of the C Programming Language. Devices. Abstractions provided by the operating system. Operating system structure.
28 at Midnight	Problem Set 0 (the course questionnaire, fix-this-program.c & word-count.c) due.
28	Course changes deadline; Course drop deadline for full-tuition refund
30	Second class meeting. Processes. Synchronization, scheduling. For today, read Tanenbaum 5/e chapters 1 "Introduction" and 2 "Processes and Threads".

February 2024	Description
4	Course drop deadline for half-tuition refund
6	Third class meeting. Finish covering processes. K70 hardware platform. CodeWarrior development environment. Basic Electronics. Projects DataSizes, FlashLED, and Pushbutton. Distribute hardware.
11 at Midnight	Problem Set 1 due.
13	Fourth class meeting. Finish covering projects FlashLED and Pushbutton. Memory management. Virtual memory, swapping, paging, and segmentation. For today, read Tanenbaum 5/e chapter 3 "Memory Management".
19	Presidents' Day
20	Fifth class meeting. Input/Output systems, file systems, buffering. Numerical encodings. For today, read Tanenbaum 5/e chapters 4 "File Systems" and 5 "Input/Output".
25 at Midnight	Problem Set 2 due.
27	Sixth class meeting. Finish covering Hamming Codes in Input/Output systems. Serial Communication. Project SerialIO. Deadlocks: definition, detection, recovery, avoidance, and prevention. For today, read Tanenbaum 5/e chapter 6 "Deadlocks".

March 2024	Description
5	Midterm exam. (Seventh class meeting.) There will not be a usual class meeting held today. The midterm exam will start at the time class would normally begin. Students will have three hours to complete the exam. Section will still be held today at its usual time, but no material or questions relevant to the midterm exam will be discussed in section today.
10-16	Spring Break
March 15-April 15	Degree program application period for spring
17 at Midnight	Problem Set 3 due.
19	Eighth class meeting. Application Notes. Details of SerialIO project. Projects MCGInit, sdramTest, and LCDRGB. Discuss UART2 problem on some Windows 10 computers and fix. Demonstrate UART2 use in SerialIO and in LCDRGB projects.
26	Ninth class meeting. Introduce concepts and code for using TWR-LCD-RGB, capacitive pads, A-to-D conversion, Supervisor calls, and privileged execution state.
31 at Midnight	Problem Set 4 due.

April 2024	Description
2	Tenth class meeting. Security and protection. For today, read Tanenbaum 5/e chapter 9 "Security".
7 at Midnight	Term Project Proposal due.
9	Eleventh class meeting. Introduction to parallel systems, data parallelism, communication, gang scheduling. For today, review Tanenbaum 5/e chapter 8 "Multiple Processor Systems".
14 at Midnight	Problem Set 5 due.
16	Twelfth class meeting. Synchronization, threads, RPC. System modeling, performance measurement and evaluation. Introduction to distributed systems, DCE/Encina. Distributed file systems. Fault tolerance, replication, redundancy. Case study of UNIX/Linux/Android. For today, review Tanenbaum 5/e chapter 2 "Processes and Threads". For today, read Tanenbaum 5/e chapter 10 "Case Study 1: Unix, Linux, and Android".
19	Withdrawal deadline (no tuition refund). Course on record with WD (withdrawal) grade.
23	Thirteenth class meeting. Case study of Windows 8/Windows 11. For today, read Tanenbaum 4/e chapter 11 "Case Study 2: Windows 8" or Tanenbaum 5/e chapter 11 "Case Study 2: Windows 11".
28 at Midnight	Problem Set 6 due.
30	Fourteenth class meeting. Operating system design, Virtualization, and additional topics. For today, read Tanenbaum 5/e chapter 7 "Virtualization and the Cloud" and chapter 12 "Operating System Design".

May 2024	Description
6-11	Final exams and last class meetings
7 by 4 PM ET	URL for ten minute pre-recorded final project presentation sent to course staff.
7	Final Class Meeting during usual section and class time. Student project presentations/demonstrations.
11	All Term Project code, documentation, and presentation material must be submitted.
21	Grades available online in Online Services
23	Commencement
27	Memorial Day

July 2024	Description
July 1-August 1	Degree program application period for summer

System files for the Kinetis K70F120M/MK70FN1M0 (120 MHz), NXP/Freescale Toolchain:

Declarations of processor specific registers (in C): derivative.h
Declarations of processor specific registers (in C): MK70F12.h
Declarations of memory layout (in linker) for RAM targets: MK70FN1M0_ram.lcf
Declarations of memory layout (in linker) for Flash targets: MK70FN1M0_flash.lcf
Metrowerks ARM Runtime Support Library/Entry point for ARM programs (functions in C): startup.c
Kinetis ARM specific initial startup code (in C): kinetis_sysinit.c
Kinetis ARM specific initial header file (in C): kinetis_sysinit.h
Kinetis TWR-K70F120M tower CPU specific header file (in C): twr-k70f120m.h

The Renesas Technology M16C:

The Renesas SKP16C62P StarterKit Plus is an evaluation kit for the M30626 microcontroller. The M30626 microcontroller contains an M16C processor core with memory, peripherals, and an LCD controller. The Renesas SKPCOMMS Communications Applications card is a daughter board for SKP StarterKits that adds SRAM, two RS-232 ports, Ethernet, and two CAN ports.

The Renesas Technology Web Site.
The Renesas M16C/62P Group (M16C/62P, M16C/62PT) Datasheet.
The Renesas M16C/62P Group (M16C/62P, M16C/62PT) Hardware Manual.
The Renesas M16C/60 M16C/20 M16C/Tiny Series Software Manual.
The Renesas Application Notes.
The Renesas NC30 V.5.30 C Compiler User's Manual.
The Renesas AS30 V.5.10 User's Manual.
The Renesas FoUSB USB Flash Writer for M16C Family.
The Renesas USB Flash Writer User's Manual, Rev. 4.01.
The Renesas High-performance Embedded Workshop (HEW) V.4.06 User's Manual.
The Mitsubishi Electric Semiconductor Division Web Site.

AZ Displays, Inc. Specifications for the ACM 802C Series Liquid Crystal Display (LCD).

The Samsung KS0066U Driver and Controller for Dot Matrix LCD.

Stack contents for hardware and software interrupt service routines on the M30626 when used via C

Memory map of the M30626 on the SKP16C62P StarterKit with the SKPCOMMS daughter board

All system files and sample programs below zipped together: M16Cfiles.zip

System files for the M30626:

Declarations of special function registers (in C): sfr62p.h
Declarations of special function registers (in assembler): sfr_62p.a30
Declarations of memory layout (in assembler): sect30.inc
Initial C run-time program (in assembler): ncrt0.a30
LCD manipulation (in C): skp_lcd.h and skp_lcd.c
Board specific header file (in C): skp_bsp.h

Sample programs for the M30626:

Useful constants: constants.h
Delay generation: delay.h and delay.c
LED manipulation: led.h and led.c
Low-level pushbutton manipulation: pushbutton.h and pushbutton.c
Higher-level pushbutton manipulation: switchcmd.h and switchcmd.c
LCD manipulation: lcd.h and lcd.c
Main program to flash the red LED: flashled.h and flashled.c
Main program to scroll all possible characters on the LCD display: lcdtest.h and lcdtest.c
Main program to output a message on the serial port connected to UART0: SerialOutput.c
Main program to echo input on the serial port connected to UART0: SerialEcho.c
Main program to output a message with software flow control on the serial port connected to UART0: SerialOutputWithFlowControl.c
A-D conversion: a2d.h and a2d.c
Utility routines (unsigned char to ASCII conversion): util.h and util.c
Main program to demonstrate using A-D conversion with potentiometer R1: a2d_test.h and a2d_test.c
Timer manipulation: timer.h and timer.c
Main program to demonstrate using timer interrupts: int_test.h, int_test.c, and its modified sect30.inc
Software interrupt routine to implement a supervisor call: svcLED.h (the header file for use where svcLED is called), svcLEDinternal.h (the header file for use where svcLED is defined), and svcLED.c
Main program to demonstrate using a software interrupt routine to implement a supervisor call: soft_int.h, soft_int.c, and its modified sect30.inc
Software interrupt routine to implement a supervisor call (including using local variables in the software interrupt routine and showing how to return a value from the software interrupt routine): svcLED_locals.h (the header file for use where svcLED is called) and svcLED_locals.c
Main program to demonstrate using a software interrupt routine to implement a supervisor call (including using local variables in the software interrupt routine and showing how to return a value from the software interrupt routine): soft_int_locals.c, and its modified sect30.inc
Enhanced timer manipulation: enhanced_timer.h and enhanced_timer.c
Main program to demonstrate using both free-running and one-shot timer interrupts: one_shot.h, one_shot.c, and its modified sect30.inc
FC32 enhanced timer manipulation: enhanced_timer_fc32.h and enhanced_timer_fc32.c
Main program to demonstrate using both fc32 derived from Xcin and the clock derived from Xin with both free-running and one-shot timer interrupts: one_shot_fc32.h and one_shot_fc32.c, and its modified sect30.inc
Routines to initialize access to the SRAM on the SKPCOMMS board: sram.h and sram.c
Main program to test the SKPCOMMS SRAM: sram_test.h and sram_test.c

The Microchip Technology PIC:

The example PIC assembly language program, blink.asm, from class to blink the LED's.

The computers for programming PIC's and testing PIC software are available in the PC Lab at 53a Church Street.

The Microchip Technology Web Site.
The Microchip PIC16C77 Datasheet (Users' Manual) in PDF.
The MPLAB Integrated Development Environment.

Other Components:

The Maxim Integrated Products Web Site.
The Maxim MAX233CPP Datasheet in PDF.

The Epson Electronics America, Inc. Web Site.
The Cylindrical high-frequency crystal, type CA-301 Datasheet in PDF.

The ring terminal at the end of the common point ground wire should be attached to the nearest electrical outlet faceplace using the screw between the outlets of a duplex outlet. Note that the alligator clips connected to the wires on both the anti-static mat and the wrist strap are removeable. The alligator clips are actually adapters from banana plugs to alligator clips similar to the Mueller Electric BU-60

. After the alligator clip adapter is pulled off, the banana plug can be plugged into one of the two banana jacks on the common point ground. Both the anti-static mat's banana plug and the wrist strap's banana plug should be plugged into the common point ground.

Course Website for

Harvard Extension School CSCI E-92

Principles of Operating Systems (26605)

Spring 2024
Site last revised 10:15 PM ET 6-May-2024

Dr. James L. Frankel

Course Website for

Harvard Extension School CSCI E-92

Principles of Operating Systems (26605)

Spring 2024 Site last revised 10:15 PM ET 6-May-2024

Dr. James L. Frankel

Spring 2024
Site last revised 10:15 PM ET 6-May-2024