The CONRO project focuses on building modular robots that can change their shape. A robot is composed of identical, self-sufficient modules. The modules can connect to each other along two different axes to create robots of different shapes. My primary task was to design a real-time operating system, firmware and communication protocol stack for the second-generation CONRO modules. I also debugged, tested and made modifications to the hardware of the modules.

A CONRO robot is a distributed real-time system. Individual modules of a CONRO robot need to perform tasks singly and as a group. The real-time operating system running on the modules has to provide facilities for reliable and timely communication between the modules in addition  to real-time resource management and scheduling. Missed deadlines and lost or delayed messages can lead to an awkward robot gait or broken hardware. The operating system must have a small memory footprint and be capable of satisfying real-time constraints while executing on  a computation and power constrained platform.

The real-time operating system I implemented has the following features:

• Fully preemptive, multitasking kernel
  
• Support for real-time scheduling using a Maximum Urgency First (MUF) scheduler. There is also a fixed priority scheduler that schedules non-realtime tasks.
  
• Separation of  the address spaces of user tasks, without a hardware memory management unit.
  
• A slab memory allocator for handling real-time memory allocation and a first-fit algorithm based memory allocator for handling non-realtime memory requests.
  
• Signals, semaphores, and shared memory for inter-process communication (IPC).
  
• A communication protocol stack that ensures reliable and timely delivery of messages.
  
• One-shot and periodic real-time timers.
• A modular device driver interface to dynamically load and unload device drivers from the kernel.
• A user event signaling mechanism that allows user tasks to directly respond to hardware and software events thereby ensuring fast response times.

There is a technical report available if you wish to know more.



Undergraduate

A Protected-mode, SMP-safe Multitasking Microkernel for the x86 Architecture

This was my course project for my undergraduate operating systems course. I implemented the process management, memory management, interrupt handling and kernel initialization from scratch. I also ported the MINIX filesystem to the microkernel. The kernel creates a flat 4GB address space and manages the address space using hardware paging mechanism of the x86 platform. Kernel synchronization uses kernel semaphores and spin locks. The kernel has a round-robin scheduler. I used the hardware context switching mechanism of the x86 to do the actual context switch since the limit on the number of tasks that is imposed by the size of the GDT is not a problem for a prototype kernel. The most difficult part to implement was kernel initialization since it involved coding in a mixture of assembler and C and keeping track of all the quirks of the IBM PC architecture.

A Debugger for 8086 Assembler on DOS

I did this project for my compilers class. The debugger supports debugging of DOS .com, .exe and Terminate and Stay Resident (TSR) programs. There are facilities for single stepping, setting code breakpoints and conditional breakpoints, and observing and modifying contents of the stack and data segments and the CPU registers. The program has three parts - the user interface, the object code disassembler, and TSRs for the keyboard interrupt, single-step interrupt and breakpoint interrupts. There is also a generic TSR to hook any interrupt to enable TSRs to be debugged. The user interface is similar to Borland's Turbo Debugger for DOS.