HomeKnowledge BaseFAQs
Raspberry Pi

Raspberry PI is about the size of a credit card, has a 32-bit ARM processor and uses a Fedora distribution of Linux for its default operating system (OS).

BeagleBone Black

BeagleBone Black is a low-cost, community-supported development platform for developers and hobbyists.

Open Source

The term usually means that the information regarding Hardware and Software is easily available. There are no hassles for working with them and you can experiment with them.


The AVR is a modified Harvard architecture 8-bit RISC single chip micro controller.


The BeagleBoard-xM is a 1 GHz ARM Cortex-A8 core designed with community inputs in mind. This open hardware design brings the previous generations' laptop-like performance and expandability to the next level.

Our Tweets

On Facebook



    • What is Python?

Python is an interpreted, interactive, object-oriented programming language. It incorporates modules, exceptions, dynamic typing, very high level dynamic data types, and classes. Python combines remarkable power with very clear syntax. It has interfaces to many system calls and libraries, as well as to various window systems, and is extensible in C or C++. It is also usable as an extension language for applications that need a programmable interface. Finally, Python is portable: it runs on many Unix variants, on the Mac, and on PCs under MS-DOS, Windows, Windows NT, and OS/2.

    • What is Python good for?

Python is a high-level general-purpose programming language that can be applied to many different classes of problems.

The language comes with a large standard library that covers areas such as string processing (regular expressions, Unicode, calculating differences between files), Internet protocols (HTTP, FTP, SMTP, XML-RPC, POP, IMAP, CGI programming), software engineering (unit testing, logging, profiling, parsing Python code), and operating system interfaces (system calls, filesystems, TCP/IP sockets

    • I’ve never programmed before. Is there a Python tutorial?

There are numerous tutorials and books available. The standard documentation includes The Python Tutorial.

Consult the Beginner’s Guide to find information for beginning Python programmers, including lists of tutorials.

    • Are there any books on Python?

Yes, there are many, and more are being published. See the python.org wiki at http://wiki.python.org/moin/PythonBooks for a list.

You can also search online bookstores for “Python” and filter out the Monty Python references; or perhaps search for “Python” and “language”.

    • Why are Python strings immutable?

There are several advantages.

One is performance: knowing that a string is immutable makes it easy to lay it out at construction time -- fixed and unchanging storage requirements. This is also one of the reasons for the distinction between tuples and lists.

The other is that strings in Python are considered as "elemental" as numbers. No amount of activity will change the value 8 to anything else, and in Python, no amount of activity will change the string "eight" to anything else.

    • What’s a negative index?

Python sequences are indexed with positive numbers and negative numbers. For positive numbers 0 is the first index 1 is the second index and so forth. For negative indices -1 is the last index and -2 is the penultimate (next to last) index and so forth. Think of seq[-n] as the same as seq[len(seq)-n].

Using negative indices can be very convenient. For example S[:-1] is all of the string except for its last character, which is useful for removing the trailing newline from a string.

    • How does Python manage memory?

The details of Python memory management depend on the implementation. The standard C implementation of Python uses reference counting to detect inaccessible objects, and another mechanism to collect reference cycles, periodically executing a cycle detection algorithm which looks for inaccessible cycles and deletes the objects involved. The gc module provides functions to perform a garbage collection, obtain debugging statistics, and tune the collector's parameters.

    • Why are there separate tuple and list data types?

Lists and tuples, while similar in many respects, are generally used in fundamentally different ways. Tuples can be thought of as being similar to Pascal records or C structs; they're small collections of related data which may be of different types which are operated on as a group. For example, a Cartesian coordinate is appropriately represented as a tuple of two or three numbers.

Lists, on the other hand, are more like arrays in other languages. They tend to hold a varying number of objects all of which have the same type and which are operated on one-by-one. For example, os.listdir('.') returns a list of strings representing the files in the current directory. Functions which operate on this output would generally not break if you added another file or two to the directory.

Tuples are immutable, meaning that once a tuple has been created, you can't replace any of its elements with a new value. Lists are mutable, meaning that you can always change a list's elements. Only immutable elements can be used as dictionary keys, and hence only tuples and not lists can be used as keys.

    • How are lists implemented?

Python's lists are really variable-length arrays, not Lisp-style linked lists. The implementation uses a contiguous array of references to other objects, and keeps a pointer to this array and the array's length in a list head structure.

This makes indexing a list a[i] an operation whose cost is independent of the size of the list or the value of the index.

When items are appended or inserted, the array of references is resized. Some cleverness is applied to improve the performance of appending items repeatedly; when the array must be grown, some extra space is allocated so the next few times don't require an actual resize.

    • How are dictionaries implemented?

Python's dictionaries are implemented as resizable hash tables. Compared to B-trees, this gives better performance for lookup (the most common operation by far) under most circumstances, and the implementation is simpler.

Dictionaries work by computing a hash code for each key stored in the dictionary using the hash() built-in function. The hash code varies widely depending on the key; for example, "Python" hashes to -539294296 while "python", a string that differs by a single bit, hashes to 1142331976. The hash code is then used to calculate a location in an internal array where the value will be stored. Assuming that you're storing keys that all have different hash values, this means that dictionaries take constant time -- O(1), in computer science notation -- to retrieve a key. It also means that no sorted order of the keys is maintained, and traversing the array as the .keys() and .items() do will output the dictionary's content in some arbitrary jumbled order.

    • What are the rules for local and global variables in Python?

In Python, variables that are only referenced inside a function are implicitly global. If a variable is assigned a new value anywhere within the function’s body, it’s assumed to be a local. If a variable is ever assigned a new value inside the function, the variable is implicitly local, and you need to explicitly declare it as ‘global’.

Though a bit surprising at first, a moment’s consideration explains this. On one hand, requiring global for assigned variables provides a bar against unintended side-effects. On the other hand, if global was required for all global references, you’d be using global all the time. You’d have to declare as global every reference to a built-in function or to a component of an imported module. This clutter would defeat the usefulness of the global declaration for identifying side-effects.

    • How do I share global variables across modules?

The canonical way to share information across modules within a single program is to create a special module (often called config or cfg). Just import the config module in all modules of your application; the module then becomes available as a global name. Because there is only one instance of each module, any changes made to the module object get reflected everywhere.

    • What is the difference between arguments and parameters?

Parameters are defined by the names that appear in a function definition, whereas arguments are the values actually passed to a function when calling it. Parameters define what types of arguments a function can accept. For example, given the function definition

    • Is there a scanf() or sscanf() equivalent?

Not as such.

For simple input parsing, the easiest approach is usually to split the line into whitespace-delimited words using the split() method of string objects and then convert decimal strings to numeric values using int() or float(). split() supports an optional “sep” parameter which is useful if the line uses something other than whitespace as a separator

    • What is a class?

A class is the particular object type created by executing a class statement. Class objects are used as templates to create instance objects, which embody both the data (attributes) and code (methods) specific to a datatype.

A class can be based on one or more other classes, called its base class(es). It then inherits the attributes and methods of its base classes. This allows an object model to be successively refined by inheritance. You might have a generic Mailbox class that provides basic accessor methods for a mailbox, and subclasses such as MboxMailbox, MaildirMailbox, OutlookMailbox that handle various specific mailbox formats.

    • What is a method?

A method is a function on some object x that you normally call as x.name(arguments...). Methods are defined as functions inside the class definition

    • What is self?

Self is merely a conventional name for the first argument of a method. A method defined as meth(self, a, b, c) should be called as x.meth(a, b, c) for some instance x of the class in which the definition occurs; the called method will think it is called as meth(x, a, b, c).

Beagle Boards

    • What are the Beagles?

BeagleBone Black:

BeagleBone Black is the newest member of the open hardware Beagle family. Incorporating Texas Instruments’ 1GHz AM335x ARM® Cortex-A8 processor, plus new HDMI functionality for $45, this tiny “pup” has a very big bark. Additional expanded peripherals, low power consumption and open-source software compatibility make this Beagle stand out among the pack.


BeagleBone is a bare-bones Beagle board that acts as a USB or Ethernet connected expansion companion for physical computing. BeagleBone is small even by BeagleBoard standards and with the high-performance ARM capabilities you expect from a BeagleBoard, the BeagleBone brings full-featured Linux to places it has never gone before.


Designed with the community inputs in mind, this open hardware design improves upon the laptop-like performance and expandability, while keeping at hand-held power levels. Direct connectivity is supported by the on-board four-port hub with 10/100 Ethernet, while maintaining a tiny 3.25" × 3.25" footprint


The USB-powered Beagle Board is a low-cost, fan-less single board computer utilizing Texas Instruments' OMAP3530 processor that unleashes laptop-like performance and expansion without the bulk, expense, or noise of typical desktop machines.


    • What is an Arduino?

Arduino is the popular open-source electronics prototyping platform based on easy-to-use hardware and software. It's intended for artists, designers, hobbyists, and anyone interested in creating interactive objects or environments and is designed to be as flexible as possible to fit your project's needs.

    • Why Arduino?

There are many other microcontrollers and microcontroller platforms available for physical computing. Parallax Basic Stamp, Netmedia's BX-24, Phidgets, MIT's Handyboard, and many others offer similar functionality. All of these tools take the messy details of microcontroller programming and wrap it up in an easy-to-use package. Arduino also simplifies the process of working with microcontrollers, but it offers some advantage for teachers, students, and interested amateurs over other systems:

Inexpensive - Arduino boards are relatively inexpensive compared to other microcontroller platforms. The least expensive version of the Arduino module can be assembled by hand, and even the pre-assembled Arduino modules cost less than $50

Cross-platform - The Arduino software runs on Windows, Macintosh OSX, and Linux operating systems. Most microcontroller systems are limited to Windows.

Simple, clear programming environment - The Arduino programming environment is easy-to-use for beginners, yet flexible enough for advanced users to take advantage of as well. For teachers, it's conveniently based on the Processing programming environment, so students learning to program in that environment will be familiar with the look and feel of Arduino

Open source and extensible software- The Arduino software is published as open source tools, available for extension by experienced programmers. The language can be expanded through C++ libraries, and people wanting to understand the technical details can make the leap from Arduino to the AVR C programming language on which it's based. Similarly, you can add AVR-C code directly into your Arduino programs if you want to.

Open source and extensible hardware - The Arduino is based on Atmel's ATMEGA8 and ATMEGA168 microcontrollers. The plans for the modules are published under a Creative Commons license, so experienced circuit designers can make their own version of the module, extending it and improving it. Even relatively inexperienced users can build the breadboard version of the module in order to understand how it works and save money.

    • What do you mean by open-source hardware?

Open-source hardware shares much of the principles and approach of free and open-source software. In particular, we believe that people should be able to study our hardware to understand how it works, make changes to it, and share those changes. To facilitate this, we release all of the original design files (Eagle CAD) for the Arduino hardware. These files are licensed under a Creative Commons Attribution Share-Alike license, which allows for both personal and commercial derivative works, as long as they credit Arduino and release their designs under the same license.

The Arduino software is also open-source. The source code for the Java environment is released under the GPL and the C/C++ microcontroller libraries are under the LGPL.

    • How can I get an Arduino board?

You can buy an Arduino board from the official store online or from one of the distributors listed on the buy page. If you'd prefer to build your own, see the Arduino Single-Sided Serial board, which can be easily etched and assembled.

    • Who makes Arduino boards?

Most of the official Arduino boards are manufactured by SmartProjects in Italy. The Arduino Pro, Pro Mini, and LilyPad are manufactured by SparkFun Electronics (a US company). The Arduino Nano is manufactured by Gravitech (also a US company).

    • I want to design my own board; what should I do?

The reference designs for the Arduino boards are available from the hardware page. They're licensed under a Creative Commons Attribution Share-Alike license, so you are free to use and adapt them for your own needs without asking permission or paying a fee. If you're looking to make something of interest to the community, we'd encourage you to discuss your ideas on the hardware development forum so that potential users can offer suggestions.

    • Can I build a commercial product based on Arduino?

Yes, with the following conditions:

Physically embedding an Arduino board inside a commercial product does not require you to disclose or open-source any information about its design.

Deriving the design of a commercial product from the Eagle files for an Arduino board requires you to release the modified files under the same Creative Commons Attribution Share-Alike license. You may manufacture and sell the resulting product.

Using the Arduino core and libraries for the firmware of a commercial product does not require you to release the source code for the firmware. The LGPL does, however, require you to make available object files that allow for the relinking of the firmware against updated versions of the Arduino core and libraries. Any modifications to the core and libraries must be released under the LGPL.

The source code for the Arduino environment is covered by the GPL, which requires any modifications to be open-sourced under the same license. It does not prevent the sale of derivative software or its inclusion in commercial products.

In all cases, the exact requirements are determined by the applicable license. Additionally, see the previous question for information about the use of the name “Arduino”.

    • Can I program the Arduino board in C?

In fact, you already are; the Arduino language is merely a set of C/C++ functions that can be called from your code. Your sketch undergoes minor changes (e.g. automatic generation of function prototypes) and then is passed directly to a C/C++ compiler (avr-g++). All standard C and C++ constructs supported by avr-g++ should work in Arduino.

    • Can I use a different IDE to program the Arduino board?

It is possible to compile programs for the Arduino using other build tools (e.g. Makefiles and/or AVR Studio). You'll need to configure these to link against the appropriate files in the Arduino core libraries. See the description of the Arduino build process.

    • Can I use an Arduino board without the Arduino software?

Sure. It's just an AVR development board, you can use straight AVR C or C++ (with avr-gcc and avrdude or AVR Studio) to program it.

    • Can I use the Arduino software with other AVR boards?

Yes, although it may require some modifications to the Arduino core libraries.

Raspberry Pi


The Raspberry Pi is a credit-card sized computer that plugs into your TV and a keyboard. It is a capable little computer which can be used in electronics projects, and for many of the things that your desktop PC does, like spreadsheets, word-processing and games. It also plays high-definition video. We want to see it being used by kids all over the world to learn programming.


The Model A costs $25 and the Model B costs $35, plus local taxes and shipping/handling fees.


The default username for Raspbian is “pi” (without any quote marks) and the default password is “raspberry” (again, do not include the quote marks).


To protect your information, Linux does not display anything when typing in passwords in the bash prompt or the terminal. As long as you were able to see the username being typed in, your keyboard is working correctly.


The Model A has 256MB RAM, one USB port and no Ethernet (network connection). The Model B has 512MB RAM, 2 USB ports and an Ethernet port. See the products pages for more details.


There is no on/off switch!

To switch on: just plug it in.

To switch off: If you are in the graphical environment, either exit to the bash prompt or open the terminal. From the bash prompt or terminal shut down the Raspberry Pi by entering “sudo halt -h” (without the quote marks). Wait until all the LEDs except the power LED are off, then wait an additional second to make sure the SD card can finish its wear leveling tasks and write actions. You can now safely unplug the Raspberry Pi. Failure to properly shut the Raspberry Pi may corrupt your SD card, and you will have to re-image it.


The SoC is a Broadcom BCM2835. This contains an ARM1176JZFS, with floating point, running at 700Mhz; and a Videocore 4 GPU. The GPU is capable of BluRay quality playback, using H.264 at 40MBits/s. It has a fast 3D core accessed using the supplied OpenGL ES2.0 and OpenVG libraries.


SoC, or System on a Chip, is a method of placing all necessary electronics for running a computer on a single chip. Instead of having an individual chip for the CPU, GPU, USB controller, RAM, Northbridge, Southbridge, etc., everything is compressed down into one tidy package.


All the files necessary for booting are installed in a FAT32 partition of the SD card. The Raspberry Pi has to have an SD card installed to boot from, but a USB HD can “take over” after the initial boot. You cannot boot without an SD card.


The expectation is that non-network connected units will have their clocks updated manually at startup. Adding an RTC is surprisingly expensive, once you have factored in batteries, area and componentry, and would have pushed us above our target price. You can add one yourself using the GPIO pins if you’re after an interesting electronics project


No. The RAM is a Package on Package (POP) on top of the SoC, so it is not removable or swappable, and 512 MB is the maximum RAM the Raspberry Pi can support since there are no manufacturers making larger-capacity compatible devices.


The Raspberry Pi Foundation recommends Python as a language for learners.

Any language which will compile for ARMv6 can be used with the Raspberry Pi, though; so you are not limited to using Python. C, C++, Java, Scratch, and Ruby all come installed by default on the Raspberry Pi.


    • What is a Real Time Operating System (RTOS)?

A Real Time Operating System is an operating system that is optimized for use in embedded/real time applications. Their primary objective is to ensure a timely and deterministic response to events. An event can be external, like a limit switch being hit, or internal like a character being received.

Using a real time operating system allows a software application to be written as a set of independent tasks. Each task is assigned a priority and it is the responsibility of the Real Time Operating System to ensure that the task with the highest priority that is able to run is the task that is running. Examples of when a task may not be able to run include when a task is waiting for an external event to occur, or when a task is waiting for a fixed time period.

    • What is a Real Time Kernel?

A Real Time Operating System can provide many resources to application writers - including TCP/IP stacks, files systems, etc. The Kernel is the part of the operating system that is responsible for task management, and intertask communication and synchronization. FreeRTOS is a real time kernel.

    • What is a Real Time Scheduler?

Real Time Scheduler and Real Time Kernel are sometimes used interchangeably. Specifically, the Real Time Scheduler is the part of the RTOS kernel that is responsible for deciding which task should be executing

    • How do I use FreeRTOS?

FreeRTOS is supplied as source code. The source code should be included in your application project. Doing so makes the public API interface available to your application source code.

When using FreeRTOS your application should be written as a set of independent tasks. This means your main() function does not contain the application functionality, but instead creates the application tasks, then starts the RTOS kernel. See the main.c and project files (makefile or equivalent) included with each port for examples.

    • Why use an RTOS?

You do not need to use an RTOS to write good embedded software. At some point though, as your application grows in size or complexity, the services of an RTOS might become beneficial for one or more of the reasons listed below. These are not absolutes, but opinion. As with everything else, selecting the right tools for the job in hand is an important first step in any project.

  • Basic functions of RTOS ?
    1. Task mangement
    2. Interrupt handling
    3. Memory management
    4. Exception handling
    5. Task synchronization
    6. Task scheduling
    7. Time management
  • Features of current RTOS
    1. Multi-tasking
    2. Priority-based scheduling
    3. Application tasks should be programmed to suit ...
    4. Ability to quickly respond to external interrupts
    5. Basic mechanisms for process communication and synchronization
    6. Small kernal and fast context switch
    7. Support of a real time clock as an internal time reference
    • What is the Real Time System? Difference between Hard and Soft Real-Time Systems

Real Time System : There is also a Operating System which is known as Real Time Processing System. In this Response Time is already fixed. Means time to Display the Results after Possessing has fixed by the Processor or CPU. Real Time System is used at those Places in which we Requires higher and Timely Response. These Types of Systems are used in Bomb and Reservation. So When we Specify the Request , the CPU will Perform at that Time. There are two Types of Real Time System

A Hard Real-Time System guarantees that critical tasks complete on time. This goal requires that all delays in the system be bounded from the retrieval of the stored data to the time that it takes the operating system to finish any request made of it.

A Soft Real Time System where a critical real-time task gets priority over other tasks and retains that priority until it completes. As in hard real time systems kernel delays need to be bounded.

Embedded Systems:

    • What is an embedded system?

An embedded system is a special purpose computer system which is completely encapsulated by device it control. It is a programmed hardware device in which the hardware chip is programmed with specific function. It is a combination of hardware and software.

    • What are the characteristics of embedded system?

The Characteristics of the embedded systems are as follows:

    1. Sophisticated functionality
    2. Real time behavior
    3. Low manufacturing cost
    4. Low power consumption
    5. User friendly
    6. Small size
    • What are the types of embedded system?

They are of 4 types

    1. General computing
    2. Control System
    3. Digital Signal Processing
    4. Communication and network
    • What is digital signal controller?

DSC is 16 bit RISC machine that combines control advantages of micro-controller and digital signal processing to produce tightly coupled single chip-single instruction stream solution for embedded system design.

    • What are the components of embedded system?

Microcontroller, microprocessor, DSC, DSP, busses, system clock, Read only Memory(ROM), RAM, Real time clock these are the components of embedded system.

    • Why we use embedded systems?

Embedded systems avoid lots of electronic components and they have rich built in functionality. They reduces the cost and maintenance cost and the probability of failure of embedded system is less so embedded system are in very much use now a days.

    • What are the languages used in embedded system?

Assembly language and C are basically used for embedded system. Java and ADA are also preferred.

    • How does combination of functions reduce memory requirement in embedded system?

By using functions the amount of code that has to be dealt with is reduced thus redundancy is eliminated for everything common in function.

    • What is the significance of watchdog timer in ES?

It is a timing device which is set to predefined time interval and some task is to be performed at that time. It is used to reset original state when an inappropriate event take place.It is usually operated by counter device.

    • What is the difference between mutexes and semaphores?

Semaphores are the synchronization tool to overcome critical section problem. Mutex is also a tool that is used to provide deadlock free mutual exclusion. It protects access to every critical data item, if the data is locked and is in use,it either waits for the thread to finish or awakened to release the lock from its inactive state.

    • What language do you write code in?

Typically C with assembler where necessary.

    • Isn't C++ better?

We have found that sometimes C++ can produce very bloated code.

    • What is the best compiler for embedded programming?

Each compiler has its own charm, strengths and weaknesses. The key thing is to get to know it well and use it appropriately. Best learning exercise ever is to port a compiler to another processor. This opens your eyes as to why compilers do what they do.

  • What are the best four things to remember when doing embedded programming?
    1. The processor that took men to the moon had less processing power than your microwave oven.
    2. Embedded software looks like hardware to the customer.
    3. Embedded code's lifetime can be more than 20 years.
    4. You cannot solve the impossible problem until you have to.
    • Do you use version control?

Yes. We use a check out/check in system. We also archive development tools.

    • What sort of software modeling do you use?

We find that the UML is a good tool