Term Project Proposal

		 Harvard Extension School CSCI E-92:
		   Principles of Operating Systems

			     Spring 2024

	   Due: April 7, 2024 at Midnight ET (Eastern Time)


Total of 30 Points

1. (30 Points) Term Project Proposal.  Required from all students
taking the course for credit.  Write a textual proposal describing the
term project you wish to pursue.  The project should be an extension
to the problem sets we are working on in class that are leading toward
an operating system kernel to run on the NXP/Freescale K70 Tower Kit.
It should expand upon topics covered in class or in the readings.

This assignment will count toward the grade for the final project not
toward the grade for problem sets.

Keep in mind that all projects will be presented during our combined
final section and class meeting.  We will be holding an elongated
class during Final Exam Period (on Tuesday night, May 7th) that will
begin at 6:45 PM ET and will encompass the time of both section and
class.  This entire class meeting will begin at 6:45 PM ET and will be
held in Zoom lecture room where class lectures are normally held.
During that final class meeting, each class member will be responsible
for presenting their operating system final project to the class.

Each student will be given fifteen minutes for their presentation.  To
keep our final presentations on track, you will create a ten minute
(timing will be enforced) *pre-recorded* audio and video presentation
of your operating system followed by a five minute question and answer
session.  We will be enforcing the ten minute time constraint.  Your
video presentation is a required part of your participation and grade
in the course.  Your video presentation must be available over the
Internet.  In advance of the class meeting -- by 4 PM ET on Tuesday,
May 7, 2024, all students should send to the course staff the URL for
their ten minute pre-recorded presentation.  For this event, plan to
present a small number of slides and choose suitable shell commands
and programs to be executed so that they demonstrate the capabilities
of your operating system.  You should demonstrate the multiprocessing
aspects of your OS including the "multitask" command from Problem Set
6.  Of course, you should demonstrate any novel features in your
operating system.

All students may participate in the question and answer session via
Zoom.  We may have a number of guests joining us for the final class
meeting.

By midnight ET on Saturday, May 11th, each class member should submit
(using git) a Final Project report which will include the slides used
during your presentation, a final version of all of the
fully-documented code in your operating system, makefiles, test
programs, etc.

Please submit your term project proposal using "git" with named branch
project-proposal and please submit the final term project with named
branch term-project.

One category of program ideas might be the implementation of one or
more of the following operating system components:

    o User identities and permissions (perhaps including groups) to
      require user's to log into your OS before commands may be
      executed
    o Creating both regular and privileged login accounts; Requiring
      some shell commands to be executed by privileged users
    o Storing the passwords in an encrypted representation
    o Turning off echoing of input when a password is entered
    o Storing the accounts/passwords in a FAT32 hidden file
    o A complete semaphore implementation
    o An advanced multiprogramming scheduler (e.g. adding priority
      levels)
    o If you've implemented a priority-based scheduler, you can choose
      to add priority inheritance as an option (see the "Mars Rover
      Pathfinder mission involving priority inversion" article on the
      class web site for further information)
    o A memory protection system using the K70 Memory Protection Unit
      (MPU) (see Chapter 19 in the K70 Sub-Family Reference Manual)
    o Extend your serial port (UART) implementation to include flow
      control (either software -- Control-S and Control-Q -- or
      hardware -- CTS and RTS)
    o Extend your serial port (UART) implementation to include
      extended device attributes/characteristics (see stty)
      (e.g. should characters be echoed when read using getc, should a
      bell be output when the input buffer is full, what is the tab
      spacing, output the appropriate number of spaces for a tab, how
      many characters are in each line, should wrapping occur if line
      size is reached) line wrapping occur, allow baud rate to be
      altered)
    o Add support for multiple serial ports and demonstrate this by
      running a shell on each one -- this requires some electrical
      hardware to be assembled to support more than UART5
    o Pipes for interprocess communication
    o Implement automatic enabling and disabling of clocks to K70
      components (ports, devices) as they are opened by the first user
      and closed by the last user, respectively
    o When there are no ready or running processes, put the ARM
      processor into wait for interrupt mode (see the WFI instruction)
    o Determine when it is possible to enter ARM Stop Mode (see the
      WFE instruction) and implement that change when possible
    o Determine the applicability of Very Low Power, Low Leakage, or
      Very Low Leakage states and implement those changes when
      possible -- possibly invoked via a shell command
    o Implement a USB device using the USB OTG interface -- requires
      significant USB code to be implemented
    o Implement a USB host controller using the USB OTG interface --
      requires significant USB code to be implemented
    o Implement Control-C to terminate a running program
    o A mechanism for interprocessor communication
    o A simple distributed OS concept using the RS232 port
    o Dynamic device drivers (i.e., allow devices to be dynamically
      installed and, possibly, uninstalled while the OS is running)
    o Additional devices (e.g. the three-axis accelerometer, infrared
      LEDs for communication (serial data, IrDA, remote control))
    o Support the TWR-LCD-RGB as an output device
    o Add extended LCD capabilites (e.g. implementing windows, blinking
      cursor)
    o Allow image files stored in the FAT32 file system to be displayed
    o Additional TWR-LCD-RGB hardware features (e.g. the resistive
      touch overlay, the four-way capacitive navigation, the graphics
      window)
    o Encryption using the K70 Cryptographic Acceleration Unit (CAU)
    o Data tamper detection using the K70 Cyclic Redundancy Check
      (CRC) Unit
    o Furnish random numbers using the K70 Random Number Generator
      Accelerator (RNGA)
    o Enhancing the "ls" shell command to have a terse mode as its
      usual output and to allow a "-l" switch to output all
      directory/file information
    o Enhancing the "ls" shell command to not display hidden files
      unless the "-a" switch is given (-a)
    o Event logging
    o Utilize files in the FAT32 file system to add capabilities to
      your OS (e.g. log events to a log file, implement loadable
      executable program files, etc.)
    o If you didn't do so already, add support for multi-level
      directories in your FAT32 file system implementation
    o If you didn't do so already, add support for long filenames
      in your FAT32 file system implementation
    o Add a shell command and an system call to allow FAT32 files to
      be renamed
    o Add symbolic links to your FAT32 file system by using a
      specially-named hidden file in each directory that contains
      possible mappings from symbolic link file names to actual file
      names (e.g. symlinks.sys); these symlinks would work only in
      your OS
    o Using the TWR-K70F120M NAND Flash memory for an additional file
      system (with the K70 NAND Flash Controller (NFC))
    o Management of time/date using the K70 RTC Oscillator (real-time
      clock)
    o Add additional devices to your operating system.  We have a
      variety of additional Freescale Tower boards available including
      TWR-SENSOR-PAK (includes temperature/humidity sensor, ambient
      light sensor, barometer, accelerometer, infrared receiver,
      capacitive touch keypad), TWR-AUDIO-SGTL (audio peripheral
      module with SGTL5000 codec), TWR-ADCDAC-LTC (high-precision
      analog module), TWR-RF-SNAP (802.15.4 RF wireless mesh
      networking module), TWR-SER2 (dual-role high-speed USB,
      host-only USB, 2x Ethernet ports, serial-to-USB, RS232),
      TWR-WIFI-RS2101 (802.11n Wi-Fi), TWR-MC-LV3PH (low-voltage,
      three-phase motor control module), FSLBOT (Tower mechatronics
      board and robot kit)
    o If implementing audio, use FAT32 file system to store audio files
      and play them (e.g., implement an audio player)
    o Interface to external sensors and transducers with which you are
      already familiar
    o Per-process signals (in the style of Unix signals)
    o OS alarms
    o Use the K70 Watchdog Timer (WDOG) to reset the processor if the
      system should become unresponsive
    o Use the PSP (Process Stack Pointer) for user processes and the
      MSP (Main Stack Pointer) for handler code -- NOTE: Implementing
      an OS with both SPs will require making SVCs be
      non-interruptable and non-blocking; thus, no SVCs can be
      long-lived
    o Ethernet communication capability.  Do not choose this option
      unless you already have substantial experience with Ethernet
      protocols.  (In the simplest case this might be an
      implementation of TCP/IP and/or UDP/IP under your operating
      system.  In more complex implementations, it might include FTP
      or remote access to files over NFS, SSH, RCP, etc.  If remote
      access to files were implemented, then a "real" shell that could
      load programs would be possible.)
    o Add a new output driver for the LEDs that outputs characters in
      Morse code
    o Add a new input driver that decodes Morse code characters from
      key presses of either the pushbuttons or the touch sensors
    o Cross-process debugger.  One process can examine the saved
      registers of another blocked process.  This project would
      include the ability to block and wake another process, examine
      and change its registers, examine and change memory, and
      possibly disassemble machine code.

The program should exhibit your ability to design and implement a
significant operating system concept in a C/Assembler program.

You should assume a starting point after our sixth assignment of an
operating system kernel that provides: device independent I/O, memory
allocation, and round-robin multiprocessing and scheduling using timer
interrupts.

If possible, try to choose a subject area that complements your
personal or business interests.

Discuss your project ideas with the teaching assistant or the
professor to try to find an appropriate topic.  The proposal should
describe the overall topic, the specific problem to be dealt with in
the paper or program, the scope of the project, a preliminary
break-down of the project into smaller tasks including the
functions/components/modules to be written, the algorithms to be
created, how a user would interact with the program, what input the
program will consume and what output the program will create.

If the proposed project involves knowledge outside the scope of this
class, please include a description of your preparedness to undertake
this project.

After receiving feedback from the course staff on your term project
proposal, you will be able to revise your proposal and resubmit it.
Resubmission will also allow you to improve your grade on the term
project proposal.


			Last revised 29-Mar-24