Name: Experiments 2.5: Digital Logic - Karnaugh Maps (Part 2) @DerekMolloyatDCU
Uploaded: 2026-09-18T08:17:00-05:00
Duration: 8 min 17 s
Description: Experiments 2.5: Digital Logic - Karnaugh Maps (Part 2)

Experiments 2.5: Digital Logic - Karnaugh Maps (Part 2)

Derek Molloy 2026-09-18 | Experiments 2.5: Digital Logic - Karnaugh Maps (Part 2)

Laboratory 6 Outcome

Derek Molloy 2021-11-18 | This video is part of an materials on modules taught by Derek Molloy, School of Electronic Engineering at Dublin City University, Ireland: http://www.eeng.dcu.ie/~molloyd/

Installing Eclipse CDT and MinGW under Windows (2020)

Derek Molloy 2020-10-08 | Further information on the videos on this channel can be found at the website http://www.derekmolloy.ie/ including update blogs, source code, text guides and structured instruction.

www.derekmolloy.ie

The MSP432: Introduction to the Launchpad, its RTOS, and IDEs (Energia, CCSv6)

Derek Molloy 2015-05-10 | In this video I introduce the Texas Instruments MSP432 and its associated Launchpad board that is available for only $13. This board is ideal if you want to learn about real-time operating systems (RTOS). I also introduce examples under the Energia IDE, the Code Composer Studio development environment and I mention the Code composer studio cloud IDE. I demonstrate various different examples, including those that take advantage of the TI-RTOS (formally SYS/BIOS) on the MSP432.

Please see my blog at: www.derekmolloy.ie

Debian C/C++ Cross-Compilation for Embedded Linux using Eclipse (Luna), CDT, RSE & Remote Debug

Derek Molloy 2015-05-07 | This video introduces C/C++ cross-compilation on the BeagleBone platform, and is applicable to any embedded Linux development. I show the steps that are necessary to set up a toolchain, the Eclipse CDT environment and use the Target Management RSE (Remote System Environment) plugin to communicate with the BeagleBone. Finally, I demonstrate how you can set up a cross-platform debugging environment within Eclipse, where you can use gdbserver on the ARM device and gdb-multiarch on the client device to establish a full debugging environment.

This video supports Chapter 7 in the book "Exploring BeagleBone" -- please see more at www.exploringbeaglebone.com

BeagleBone: GPIO Linux Loadable Kernel Module (LKM) Development Demonstration

Derek Molloy 2015-04-26 | This video supports the third article in a series: “Writing a Linux Kernel Module — Part 3: Buttons and LEDs”. See http://www.derekmolloy.ie/kernel-gpio-programming-buttons-and-leds/

The article is focused on education and training rather than a deep practical need. There are three different LKMs demonstrated in this video, each with its own individual purpose and needs:

Example 1: Button Press, LED Light: In this example an LED lights when a button is pressed. To perform this task, kernel interrupts are required and the use of linux/gpio.h. This example is used to test the interrupt performance.

Example 2: Enhanced Button GPIO Driver: This example is used to introduce kobjects and a mechanism for adding new entries to Sysfs. This allows you to send data to and receive data from the LKM at run time. The example also introduces the use of timing in kernel code.

Example 3: Enhanced LED GPIO Driver: This example is used to flash an LED, which allows for a discussion on Linux kthreads. Essentially, an LED is flashed at a frequency using a kernel module, which can be controlled from Linux user space.

All my articles are available at: http://www.derekmolloy.ie/ and my book is available at http://www.exploringbeaglebone.com

BeagleBone: C/C++ Cross-Compilation for Embedded Linux using Eclipse (Luna), CDT, RSE & Remote Debug

Derek Molloy 2015-01-08 | Important note: There is currently a problem with Debian Wheezy and cross-platform tools installation. A new version of this video is available at: youtube.com/watch?v=T9yFyWsyyGk

Also see: exploringbeaglebone.com/chapter7 for a description on how to fix the problem under Wheezy and how to install the entire toolchain under Jessie.

This video introduces C/C++ cross-compilation on the BeagleBone platform, and is applicable to any embedded Linux development. I show the steps that are necessary to set up a toolchain, the Eclipse CDT environment and use the Target Management RSE (Remote System Environment) plugin to communicate with the BeagleBone. Finally, I demonstrate how you can set up a cross-platform debugging environment within Eclipse, where you can use gdbserver on the ARM device and gdb-multiarch on the client device to establish a full debugging environment.

This video supports Chapter 7 in the book "Exploring BeagleBone" -- please see more at www.exploringbeaglebone.com

Analog Discovery - An Introduction with Practical Analog & Digital Examples (diode, flip-flop & i2c)

Derek Molloy 2014-01-12 | In this video I investigate the use of the Digilent Analog Discovery with Waveforms and look how it can be used for the analysis of analog and digital circuits. The Analog Discovery is a USB oscilloscope, waveform generator, digital pattern generator and logic analyzer. It is priced at $99 for US students and generally for $219. l demonstrate three different applications of the Discovery:
- Analog analysis of a rectifier diode.
- Using the digital pattern generator and logic analyzer to investigate the behavior of a JK flip-flop.
- Using the logic analyzer and its I2C interpreter to connect to the BeagleBone I2C bus and analyse how it behaves when we use the Linux i2c tools.

Further information on the videos on this channel can be found at the website http://www.derekmolloy.ie/ including update blogs, source code, text guides and structured instruction.

www.derekmolloy.ie

Beaglebone: Java Setup (JRE), Eclipse and Remote System Explorer (RSE)

Derek Molloy 2013-11-16 | This short video explains: how you can install the Java Runtime Environment (JRE) on the Beaglebone Black; how you can build Java applications using Eclipse and deploy them to the Beaglebone; and, finally how you can use the Remote System Explorer (RSE) plugin for Eclipse that streamlines the process. This video is for student of my EE402 module in Dublin City University who will be building client/server applications using the Beaglebone as one of the platforms.

Further information on the videos on this channel can be found at the website http://www.derekmolloy.ie/ including update blogs, source code, text guides and structured instruction.

www.derekmolloy.ie

Beaglebone: Getting Started - Windows USB Network Adapter Setup Tutorial

Derek Molloy 2013-11-16 | This video looks at getting started with the Beaglebone Black using the USB network adapter that allows you to use the BBB without having to install it within a network. So, the BBB can be connected to the desktop PC using only one USB cable, which provides power and Internet connectivity. This is a video for students that are taking my EE402 module in Dublin City University. A USB network adapter is much more straightforward than trying to custom configure routers/switches within a university infrastructure. The video also briefly deals with the date/time problem in a very basic way.

Further information on the videos on this channel can be found at the website http://www.derekmolloy.ie/ including update blogs, source code, text guides and structured instruction.
www.derekmolloy.ie

Installing Eclipse (Kepler) for Java and C++ (MinGW & CDT) under Windows 2013/2014

Derek Molloy 2013-10-12 | A quick guide for my students on installing Eclipse (Kepler) under Windows for programming in C++ and Java at the same time. The installation uses MinGW for the GNU C++ compiler and the Java Development Kit (JDK) for Java. CDT is used as the plugin to provide the C++ interface in Eclipse. This video is relevant in Oct 2013.

Further information on the videos on this channel can be found at the website http://www.derekmolloy.ie/ including update blogs, source code, text guides and structured instruction.

www.derekmolloy.ie

Beaglebone: Streaming Video from Embedded Linux & Custom Video Player

Derek Molloy 2013-07-19 | In this video I look at video streaming using the Beaglebone black using: RTP, UDP unicasting, and UDP multicasting, which allows one to many streaming. In all of these examples I used the VLC media player to display the video data. The final part of this video goes on to describe how you can build your own software implementation that can display the data using LibVLC and the Qt framework. The advantage of doing this is that you can add your own data processing and controlling functionality into the video display. You could even develop code for capturing multiple streams simultaneously and processing the data -- for example, for stereo imaging.

In this video I use a Logitech C920 and the Beaglebone Black. I would highly recommend both of these devices because of the processing power of the Beaglebone black and the high resolution capability of the C920. However, you should be able to adapt the code to any specific camera.

If you use this code or the content of the associated video in your research, please cite:

Molloy, D. [DerekMolloyDCU]. (2013, July, 19). Beaglebone: Streaming Video from Embedded Linux [Video file]. Retrieved from http://youtu.be/-6DBR8PSejw

Further information on the videos on this channel can be found at the website http://www.derekmolloy.ie/ including update blogs, source code, text guides and structured instruction.

http://derekmolloy.ie/beaglebone/beaglebone-video-capture-and-image-processing-on-embedded-linux-using-opencv/

Beaglebone: Introduction to GPIOs - Using Device Tree Overlays under Linux 3.8+

Derek Molloy 2013-06-12 | In this video I continue my series on the Beaglebone and Beaglebone Black by demonstrating how to use its GPIOs for both input and output applications. I wire simple input and output circuits that are attached to two GPIOs -- one that lights an LED and the other that receives a button input. This video will cover the Linux device tree for ARM embedded systems and explain how you can create custom Device Tree Overlays (DTOs) to configure the GPIOs for your applications at run time from within Linux userspace. I explain the use of internal and external pullup and pulldown resistors and I make available and describe a set of C++ code examples for reading and writing to the Beaglebone's GPIOs. I have also built a set of PDF tables that aggregate the information that you need and make it easier to configure GPIOs on your Beaglebone's P8 and P9 headers. The code for this video is available by typing:

git clone git://github.com/derekmolloy/boneDeviceTree.git

at the Linux shell prompt. Further information on the videos on this channel can be found at the website http://www.derekmolloy.ie/ including update blogs, source code, text guides and structured instruction.

If you use this video in your research, please cite:

Molloy, D. [DerekMolloyDCU]. (2012, May, 3). Beaglebone: GPIO Programming on ARM Embedded Linux [Video file]. Retrieved from http://www.youtube.com/watch?v=SaIpz0...

Please find more information on these videos at: http://www.derekmolloy.ie/

Beaglebone: Video Capture and Image Processing on Embedded Linux using OpenCV

Derek Molloy 2013-05-25 | In this video I look at how you can get started with video capture and image processing on the Beaglebone. It is an introductory video that should give people who are new to this topic a starting point to work from. I look at three different distinct challenges:
- How do you capture video from a USB webcam under Linux
- How do you capture image frames from a USB webcam under Linux
- How do you use OpenCV to capture and image process frames so that you can build computer vision applications under Linux on the Beaglebone.

In this video I use a Logitech C920 and the Beaglebone Black. I would highly recommend both of these devices because of the processing power of the Beaglebone black and the high resolution capability of the C920. However, you should be able to adapt the code to any specific camera.

If you use this code or the content of the associated video in your research, please cite:

Molloy, D. [DerekMolloyDCU]. (2013, May, 25). Beaglebone: Video Capture and Image Processing on Embedded Linux using OpenCV [Video file]. Retrieved from http://www.youtube.com/watch?v=8QouvYMfmQo

Further information on the videos on this channel can be found at the website http://www.derekmolloy.ie/ including update blogs, source code, text guides and structured instruction. More detail on this specific video is available at:

http://derekmolloy.ie/beaglebone/beaglebone-video-capture-and-image-processing-on-embedded-linux-using-opencv/

Custom Cables & Guide to Crimping Dupont PCB Interconnect Cables

Derek Molloy 2013-04-07 | This is a very quick video guide to working with custom PCB connectors. I recently had to make a custom connector for my Raspberry PI, which has a bank of male headers. I looked at a few different options and in the end I decided I would invest in a crimp tool to create my own custom cables. While the experiences are still fresh in my mind I decided I would make this video in case that it will be of benefit as an introductory guide to others who are trying to do the same sort of thing. The video will discuss regular ribbon cables, fixed length pre-crimped cables, and custom crimped cables. I will also give a guide to how to crimp 0.1" male and female PCB interconnect cables and describe what a proper crimp connector should look like. See: www.derekmolloy.ie

Digital Electronics: Overflow, Overflow Detection and Underflow

Derek Molloy 2013-04-02 | In this video I will look at the problems that can arise in unsigned and signed systems with overflow and underflow, which is where our system goes beyond its physical limitations. I will look at how you can detect that overflow is occurring in a digital system and how you can design a logic circuit to detect its occurrence. The video then describes underflow and finally, presents a few interesting questions with solutions.

This video is part of materials on modules taught by Derek Molloy, School of Electronic Engineering at Dublin City University, Ireland: http://www.eeng.dcu.ie/~molloyd/

Digital Electronics: The 2s Complement

Derek Molloy 2013-03-22 | The Two's Complement is a method of representing negative/signed binary numbers that is commonplace in digital electronics and is the basis for how signed integers are represented in embedded systems. This tutorial explains the need for the Two's Complement form and describes how you can perform operations such as additions/subtractions and multiplications using this form. It provides some numerical examples with solutions to allow you to test your understanding of the materials that are presented.

This video is part of materials on modules taught by Derek Molloy, School of Electronic
Engineering at Dublin City University, Ireland: http://www.eeng.dcu.ie/~molloyd/

Beaglebone: Example Qt Embedded Linux Application

Derek Molloy 2013-03-09 | This is the third video in a set of three on Qt application development on the Beaglebone or any other embedded Linux device. The first video introduces the LCD module that I used and the second video is where I set up a full toolchain for C++ Qt application development under embedded Linux (Qt for embedded devices). This toolchain allows us to cross compile Qt applications for the Beaglebone, deploy the applications directly to the beaglebone with a single click and even use remote debugging using gdbserver to diagnose any problems with our applications. The main use of this platform is for GUI application development when a LCD module, or external display is present.

In this the final video in this series I demonstrate an example application that uses an accelerometer and LED to act as output/input devices and I provide the full source code. I explain how the source code is structured and how the physical circuit was configured.

The source code is available at the Linux prompt by typing:
git clone git://github.com/derekmolloy/beagleboneQT.git

If you use this video in your research, please cite:

Molloy, D. [DerekMolloyDCU]. (2013, March, 6). Beaglebone: Qt Creator for C++ ARM Embedded Linux Development [Video file]. Retrieved from http://www.youtube.com/watch?v=kP7uvOu9hoQ

Please find more information on these videos at: http://www.derekmolloy.ie/

Beaglebone: Qt Creator for C++ ARM Embedded Linux Development

Derek Molloy 2013-03-06 | This is the second video in a set of three on Qt application development on the Beaglebone or any other embedded Linux device. The first video introduces the LCD module that I used and this video is where I set up a full toolchain for C++ Qt application development under embedded Linux (Qt for embedded devices). This toolchain allows us to cross compile Qt applications for the Beaglebone, deploy the applications directly to the beaglebone with a single click and even use remote debugging using gdbserver to diagnose any problems with our applications. The main use of this platform is for GUI application development when a LCD module, or external display is present.

In the final video I demonstrate an example application that uses an accelerometer and LED to act as output/input devices and I provide the full source code.

Thad Failor (via comments below) provides some information on how to deal with the requirement to execute . /usr/local/angtrom/arm/environment-setup in advance of starting QtCreator. The steps are:
- Open Qt Creator
- Open your project
- Click Projects under [Your Beaglebone Kit]
- Click Build
- Scroll down to the bottom and click details
- Click on Batch
- Edit Paste the contents of the ". /usr/local/angstrom/arm/environment-setup" removing any of the "export" commands.

If you use this video in your research, please cite:

Molloy, D. [DerekMolloyDCU]. (2013, March, 6). Beaglebone: Qt Creator for C++ ARM Embedded Linux Development [Video file]. Retrieved from http://www.youtube.com/watch?v=kP7uvOu9hoQ

Please find more information on these videos at: http://www.derekmolloy.ie/

Beaglebone: LCD Touchscreen GUI Applications for Embedded Linux

Derek Molloy 2013-03-06 | This is the first video in a set of three on Qt application development on the Beaglebone or any other embedded Linux device. This video introduces the LCD module that I used, reviews it and then discusses how you can install it and develop very basic onboard GTK GUI applications. This leads to the second video where I set up a full toolchain for Qt application development under embedded Linux (Qt for embedded devices) and then in the final video I demonstrate an example application that uses an accelerometer and LED to act as output/input devices and I provide the full source code.

If you use this video in your research, please cite:

Molloy, D. [DerekMolloyDCU]. (2013, March, 6). Beaglebone: Qt Creator for C++ ARM Embedded Linux Development [Video file]. Retrieved from http://www.youtube.com/watch?v=kP7uvOu9hoQ

Please find more information on these videos at: http://www.derekmolloy.ie/

Raspberry PI: XBMC Home Media Player - Adding IR Remote Control

Derek Molloy 2013-02-21 | In this video series I am going to explain how you can build a XBMC (xbmc.org) Media Player for a home television using the OpenELEC Linux distribution and deploy this on the Raspberry PI platform. This video demonstrates how we can add infra red (IR) remote control functionality to the setup using a cheap IR receiver that is connected directly to the GPIO pins of the Raspberry PI.The Raspberry PI is a very low cost and small single-board computer developed in the UK by the Raspberry Pi Foundation. It is a powerful device and additionally it has hardware accelerated support for MPG4 and MPG2 decoding, making it a perfect choice for a home media centre.

The three electronics parts used for this video are:
1. An IR Receiver the TSOP34838 (google that code with digikey, farnell, mouser etc.) For example - digikey part number 751-1386-5-ND ~1.41 ea.

2. A 100 ohm through hole resistor (any power dissipation) For example - digikey part number P100BACT-ND ~0.08 ea.

3. A 4.7uF electrolytic capacitor (any voltage) - please note the polarity on this component. The +ve lead (longer one) needs to be connected to the 3.3V line (red) and the -ve lead (shorter one) to the GND line (black). For example - digikey part number P5177-ND ~0.17 ea.

Ideally you need leads with a female header so that they can connect to the male header of the Raspberry PI. These are often referred to 0.1" as there is 1/10th of an inch between each pin. In metric they are referred to 2.54mm spacing leads.

The full lircd.conf file is available on my blog site at: http://derekmolloy.ie/raspberry-pi/

This video is not as education focused as other videos that I have presented; however, it does allow us to build a platform on which I can demonstrate how we can integrate electronics devices in the home; in fact, a smart television is the perfect point to act as an information hub for the built environment... and to do this, we may need to integrate sensor inputs from all over a house together and provide aggregated intelligent analysis of that information to the householder.

Raspberry PI: XBMC Home Media Player - Building the OpenELEC Linux Distribution

Derek Molloy 2013-02-21 | In this video series I am going to explain how you can build a XBMC (xbmc.org) Media Player for a home television using the OpenELEC Linux distribution and deploy this on the Raspberry PI platform. This video starts from the very first steps and is aimed to be an introductory guide for those who are not used to compiling and building software under Linux.

Warning - Please make sure you have at least 15GB free on your building system and be warned that the compile could take up to 10-12 hours (or more) depending on the performance of your machine and the speed of your download link.

The Raspberry PI is a very low cost and small single-board computer developed in the UK by the Raspberry Pi Foundation. It is a powerful device and additionally it has hardware accelerated support for MPG4 and MPG2 decoding, making it a perfect choice for a home media centre.

The second video in this series demonstrates how we can add infra red (IR) remote control functionality to the setup using a cheap IR receiver that is connected directly to the GPIO pins of the Raspberry PI.

This video is not as education focused as other videos that I have presented; however, it does allow us to build a platform on which I can demonstrate how we can integrate electronics devices in the home; in fact, a smart television is the perfect point to act as an information hub for the built environment... and to do this, we may need to integrate sensor inputs from all over a house together and provide aggregated intelligent analysis of that information to the householder.

Beaglebone: Driving Stepper Motors in Embedded Linux using the EasyDriver Board

Derek Molloy 2013-02-12 | This video examines how we can drive stepper motors using C++ within Embedded Linux using the open source hardware EasyDriver board. The video begins by describing stepper motors and the effects of micro-stepping. It then discusses the EasyDriver Board (V4.4) and all of the available inputs and outputs. The board uses the Allegro A3967 which allows for full, half-, quarter and one eight micro-stepping. The video then explains C++ code that uses the GPIOs on the Beagleboard to wrap the EasyDriver with a C++ class that is easy to use by creating an object of the class for each stepper motor that is connected.

The source code in this video is available through githhub:

git clone git://github.com/derekmolloy/beaglebone

Finally I show an example of my code running on the Mercury Motor (SM-42BYG011-25), which is a low cost stepper motor.

If you use this video in your research, please cite:

Molloy, D. [DerekMolloyDCU]. (2013, Feb, 12). Beaglebone: Driving Stepper Motors in Embedded Linux using the EasyDriver Board [Video file]. Retrieved from http://www.youtube.com/watch?v=gqrjtB2cmu8

Please find more information on these videos at: http://www.derekmolloy.ie/

Beaglebone: Adding USB Wi-Fi & Building a Linux Kernel

Derek Molloy 2012-06-22 | In this video I go through the steps required to build the Linux kernel for the Beaglebone and show the steps that are required to deploy the kernel to an existing distribution. I download the Ubuntu Arm minimal distribution and deploy it and the kernel together. I then show how we can get Wi-Fi working using two small USB Wifi adapters that are based on the Realtek RTL8192CU chipset. Both of these adapters are less than €10 ($13 USD) in price and can be bought directly from suppliers such as Amazon: The "Edimax EW-7811" and the "Duronic IR786" are the two devices that are tested in this video. Finally, I demonstrate how I would compile and deploy a custom driver using the 8192CU driver that is available from the Realtek website.

This video is based on the work of many helpful guides that are available online, such as:

http://embeddedgeeks.wordpress.com
http://wiki.debian.org/WiFi/HowToUse
http://www.cianmcgovern.com/getting-the-edimax-ew-7811un-working-on-linux
http://wikidevi.com/wiki/Edimax_EW-7811Un
And the README that is available with the RobertCNelson linux-dev release.

If you use this video in your research, please cite:

Molloy, D. [DerekMolloyDCU]. (2012, June, 22). Beaglebone: Adding USB Wi-Fi & Building a Linux Kernel [Video file]. Retrieved from http://www.youtube.com/watch?v=HJ9nUqYMjqs

Please find more information on these videos at: http://www.derekmolloy.ie/

Beaglebone: An I2C Tutorial - Interfacing to a BMA180 Accelerometer

Derek Molloy 2012-06-11 | In this video I continue my series on the beaglebone to discuss the I2C bus and how we can connect and program devices attached to the bus using C/C++. I explain the use of i2c-tools on embedded Linux and then show how we can interface to a digital accelerometer (Bosch BMA180) or any other I2C device. Finally, I show how we can use sysfs to build a C++ class that wraps the functionality of the digital accelerometer. Source code included! This video builds on the three previous videos: The introduction to the Beaglebone; Setting up a C/C++ Development Environment; and, Programming with GPIOs. So, I recommend that you view those videos first. This video is part of a series that I have developed in the School of Electronic Engineering at Dublin City University.

The NXP I2C Specification document is at:
http://www.nxp.com/documents/user_manual/UM10204.pdf

The source code in this video is available through githhub:
git clone git://github.com/derekmolloy/beaglebone

Please note that I have mixed up the words bit and byte a few times in this video -- apologies, I do know the difference(!) but I seem to have a problem when describing some points in this video.

If you use this video in your research, please cite:

Molloy, D. [DerekMolloyDCU]. (2012, June, 11). Beaglebone: An I2C Tutorial - Interfacing to a BMA180 Accelerometer [Video file]. Retrieved from http://www.youtube.com/watch?v=8C2zk6B-eLU

Please find more information on these videos at: http://www.derekmolloy.ie/

Beaglebone: GPIO Programming on ARM Embedded Linux

Derek Molloy 2012-05-03 | Note: This video was made before the Linux device tree was implemented on the beaglebone (beaglebone black uses Linux 3.8.11). I have a new video coming in a few days that explains how to do the same thing on the beaglebone black using device tree overlays.

In this video I extend my series on introducing the Beaglebone and developing applications using embedded Linux to demonstrate how we can build an application that uses its GPIOs (General Purpose Input/Outputs). The example demonstrates a simple LED output circuit and a simple pushbutton input circuit that we can connect to the Beaglebone GPIOs directly. I then go through the steps on how we can configure and access these GPIOs using Sysfs in embedded linux and then demonstrate how we can write a C/C++ program that works directly with these pins. Finally I demonstrate how we can use polling to wait for a GPIO input such as a button press or key press. This application is relevant to all flavours of embedded Linux.

The code that the final application is based on is available at: https://www.ridgerun.com/developer/wi...

The source code in this video is available through githhub: git clone git://github.com/derekmolloy/beaglebone

The 4,500 page document that I mention 15 minutes in is available for download from Texas Instruments' Website. It is called "AM335x ARM(r) Cortex(TM)-A8 Microprocessors(MPUs)". The version I have is "Literature Number: SPRUH73C" from Oct'11(revised Dec'11).

If you use this video in your research, please cite:

Molloy, D. [DerekMolloyDCU]. (2012, May, 3). Beaglebone: GPIO Programming on ARM Embedded Linux [Video file]. Retrieved from http://www.youtube.com/watch?v=SaIpz0...

Please find more information on these videos at: http://www.derekmolloy.ie/

Beaglebone: C/C++ Programming Introduction for ARM Embedded Linux Development using Eclipse CDT

Derek Molloy 2012-04-10 | A new version of this video is available (Jan, 2015) See: youtube.com/watch?v=T9yFyWsyyGk

This video introduces C and C++ programming on the Beaglebone platform, which is applicable to any embedded Linux development. I quickly introduce how we can program directly on the beaglebone using a terminal window and point out the limitations. I show the steps that are necessary to set up the Eclipse CDT environment and use the Target Management RSE (Remote System Environment) plugin to communicate with the Beaglebone. I then demonstrate how we can use Eclipse CDT IDE to cross-develop (using arm-linux-gnueabi) applications for the ARM architecture. To do this, I write a short program that flashes the user LEDs on the Beaglebone. Finally, I demonstrate how we can set up a cross-debug environment, where we use gdbserver on the arm device and gdb-multiarch on the client device to establish a full debug environment.

TangoBravo has pointed out that some paths have been changed in the current Angstrom image (June 2013). For instance, the path to the brightness properties has been changed in the latest version of Angstrom.
The old path: /sys/class/leds/beaglebone::usr3/brightness
...is now this: /sys/class/leds/beaglebone:green:usr3/brightness
So you have to make the change to get the LED to flash. Check your path to verify.

If you use this video in your research, please cite:

Molloy, D. [DerekMolloyDCU]. (2012, Apr, 10). Beaglebone: C/C++ Programming Introduction for ARM Embedded Linux Development using Eclipse CDT [Video file]. Retrieved from http://www.youtube.com/watch?v=vFv_-y...

One common problem that arises with this setup:

If bash reports "file not found" when executing an executable file that exists, the reason is that it doesn't recognise it as a binary file, and attempts to treat it as a script. The hypothetical script should start off with #!/path/to/interpreter and bash cannot find the (non-existent) interpreter so it returns "file not found". This could happen if for example you are running a 64-bit executable on 32-bit machine, or an x86 executable on an ARM target.

In Eclipse your executable should display in your source directory as "HelloWorld - [arm/le]" in the project explorer window. If it does *not* then there is a problem with your compiler setup and you need to watch the steps again. If it *does* then one likely problem is if that you are using an ARM Linux platform that uses "hard floats" and that you have compiled using my setup which uses "soft floats". Here are two possible solutions:

- Graemefisheratwork let me know that he has found that when using the ubuntu armhf distros, applications should be cross-compiled using arm-linux-gnueabihf- and not arm-linux-gnueabi-. This seems to have worked for him on the ubuntu 12.04 armhf build.

- I'm using "Linux omap 3.2.18-psp14 armv71" in this video that I built myself which has defaulted to soft floating point numbers. There are floating-point options in gcc that you have to set when using hardware floating point numbers -- you should add " -mfloat-abi=hard" to your compiler options.

Digital Electronics: The JK Flip-Flop

Derek Molloy 2012-03-31 | This video lecture/tutorial describes the JK Flip-Flop in detail. I begin by describing the general operation of a 7473 JK flip-flop, showing the toggle state that makes this flip-flop important for many applications. Then I show in detail how we can create a JK flip-flop using NAND gates, describing both edge-triggered and pulse-triggered configurations. I implement both types of circuit, using a pulse generator for the edge-triggered version and a master-slave JK flip-flop for the pulse-triggered implementation. Finally, I show how we can add asynchronous set and reset inputs for the master-slave configuration and implement a circuit to demonstrate that this works correctly. This video is part of a module on Digital & Analogue electronics that is taking place at Dublin City University, Ireland. http://www.eeng.dcu.ie/~molloyd/EE223/

Digital Electronics: Debouncing a Push Button Switch (SPST)

Derek Molloy 2012-03-11 | This video explains how we can debounce a SPST (Single Pole Single Throw) momentary push button switch. It describes the concept of hysteresis and the use of a Schmitt Trigger. The circuit uses a RC low-pass filter as the input to a 74HCT14 Hex Schmitt Trigger to achieve debouncing and it shows how we can implement and test this circuit using an oscilloscope. This is part 2 - in the previous video I explained how to debounce a SPDT slide switch using a SR latch. This video is part of a module on electronics that is running at the School of Electronic Engineering at Dublin City University, Ireland. http://ee223.eeng.dcu.ie/

Digital Electronics: Debouncing a Slider Switch (SPDT)

Derek Molloy 2012-03-07 | This video discusses what is switch bouncing and explaines how we can debounce a SPDT (single pole double throw) slide switch. It uses an SR latch to achieve debouncing and it shows how we can implement this circuit using 74LS00 NAND gates. It also examines the output of this circuit using an oscilloscope and demonstrates that the circuit is working effectively. This is part 1, in the next part I will explain how to debounce a SPST momentary push button switch using a RC circuit and a Schmitt trigger. This video is part of a module on digital electronics that is running at the School of Electronic Engineering at Dublin City University. http://www.eeng.dcu.ie/~molloyd/EE223/

The Beaglebone - Unboxing, Introduction Tutorial and First Example

Derek Molloy 2012-02-18 | See www.derekmolloy.ie for my blog and for updates to this video.

In this video I introduce the Beaglebone - a low-cost high-performance 720MHz ARM A8 device with 256MB of DDR2 Memory. It has full support for 10/100 Ethernet, USB client support, JTAG debug via USB. It has 64 GPIOs, 7 x 12-bit ADCs, and support for canbus and LCDs. The pin layout is like the arduino where you can place "capes" on the board. The Beaglebone boots using the MicroSD card into embedded Linux (Angstrom). In this video I will demonstrate the first steps with the board and I will discuss how you can use embedded Linux to send or receive values to the input/output pins and the 4 onboard LEDs. This is part of a module on Digital Electronics at the School of Electronic Engineering, Dublin City University, Ireland. www.eeng.dcu.ie/~molloyd/EE223/

Derek Molloy DCU Channel - Video Index

Derek Molloy 2011-07-13 | Welcome to the Derek Molloy DCU Channel. Further information related to these videos can be found on www.derekmolloy.ie and www.eeng.dcu.ie/~molloyd/EE223/

On the left is a categorised index of the digital electronics videos on this channel. When the index pauses on videos you should be able to press on the video to follow a link to view that video. Enjoy, Derek.

Digital Electronics: The Half Adder and Full Adder

Derek Molloy 2011-07-11 | This video is an introduction into Binary Addition. It discusses the concept of binary addition and it discusses how we can create a half adder and a full adder using logic gates (XOR, AND and OR). The video follows on to another video on 4-bit addition, which cascades full adders together to create the 4-bit adder circuit. This video is part of an introductory module on Digital Electronics that takes place at Dublin City University (DCU), Ireland. See: www.eeng.dcu.ie/~molloyd/EE223/

Digital Electronics: The 4-bit Adder (74HC283)

Derek Molloy 2011-07-11 | This video is an introduction into 4-bit Binary Addition. It discusses the concept of binary addition and extends on a previous video that demonstrates how to create a half adder and full adder. It shows how to cascade full adders together to create the 4-bit adder circuit and discusses the use of the 74HC283 4-bit full adder with fast carry. This video is part of an introductory module on Digital Electronics that takes place at Dublin City University (DCU), Ireland. See: www.eeng.dcu.ie/~molloyd/EE223/

AVR Programming - AVR Studio Tutorial Introduction

Derek Molloy 2011-06-09 | In this video I demonstrate how to write a small application using AVR Studio 4 and avr-gcc. It is an introduction for those new to the AVR platform. I am using the AVR Dragon as my program/debug tool and this tutorial demonstrates how to upload and debug code using this device.

AVR Programming - AVR Dragon Introduction

Derek Molloy 2011-06-09 | This tutorial introduces the AVR Dragon. It is a device that allows us to program and debug AVR ATmega Microcontrollers. I show how to setup and use the AVR Dragon, soldering a 40 pin ZIF socket to the board and show how to connect it to AVR Studio 5 beta 2. I write a sample application and program it on an ATmega328.

Arduino: Arduino LCD Tutorial II - A Reaction Timer

Derek Molloy 2011-05-31 | In this video I combine three previous videos and write some code to create an Arduino based Reaction Timer. The entire circuit is built on a breadboard using an ATmega328P on its own, which is combined with a Newhaven Display LCD Module that has an RGB backlight. I work through the code in some detail and explain how to write the code for the reaction timer. At the end of the video I provide links to the previous videos that show how to build the three individual circuits: Breadboard PSU, Arduino on a Breadboard and Arduino LCD Tutorial. This video is a part of a module on an introduction to Digital and Analogue Electronics at Dublin City Univeristy, Ireland: www.eeng.dcu.ie/~molloyd/EE223/

The code for this application is at:
docs.google.com/open?id=0B66t6qVNnmHSMXppejN1OWdlbnM
Please note it was developed on a 2011 version of the Arduino development environment, so changes to the libraries may introduce errors.

Arduino: Arduino on a Breadboard

Derek Molloy 2011-05-23 | This tutorial shows you how to build an Arduino on a breadboard. It describes the use of 16MHz and 20Mhz crystals for driving the Arduino and compares their use to the use of a resonator. A simple circuit is created that blinks an LED for 1000ms and 100ms. The Arduino is programmed on the breadboard using an Arduino shield's Reset, TX and RX pins. This video is part of an introductory module to Digital and Analogue Electronics that is running at Dublin City University, Ireland: http://www.eeng.dcu.ie/~molloyd/EE223/

Arduino: Arduino LCD Tutorial

Derek Molloy 2011-05-19 | This short video looks at the different options available for connecting an LCD character display to an Arduino. It uses a wide set of displays: The nuelectronics display shield, 20x4, 20x2,16x2 and 8x2 display modules. It shows the code that you need to create an example display and describes the use of the POT in the display. The modules used are the nuelectronics display shield, JHD 204, WH1602, CM200200 and a YJ 802A. This experiment is part of an introductory module to Digital and Analogue Electronics at Dublin City University, Ireland: http://ee223.eeng.dcu.ie/

Please note that the background wallpaper that is used in the logo image is from PJRC Electronic Projects, www.pjrc.com.

Arduino: RGB LED Tutorial (Pirhana RGB with LCD Display)

Derek Molloy 2011-05-15 | This short video demonstrates how to connect a common anode Pirhana RGB LED to an Arduino and to drive each of the red, green and blue channels individually using PWM (Pulse Width Modulation). A 4x20 LCD Module is connected to the Arduino and the red, green and blue channels are displayed on it. It could be use to create a "mood light". This experiment is a part of a module EE223, an introduction to digital electronics, at Dublin City University, Ireland. The notes can be found at: http://www.eeng.dcu.ie/~molloyd/EE223/

Digital Electronics: Optocoupler | Optoisolator - Driving a high-current CREE XLamp XR-C LED

Derek Molloy 2011-05-09 | In this video I introduce and explain the operation of optocouplers / optoisolators (617A) and describe how they can be used to drive independent circuits at the same or different voltage levels. I also demonstrate that we can connect a BC547 NPN Transistor to the optocoupler and use it to drive a larger current. In this case I use a CREE XRC White 57 (XRCWHT-L1) Lumen White LED. This tutorial/experiment is part of a series of experiments that introduces digital and analogue electronics in a module EE223 at Dublin City University, Ireland. The materials are at http://www.eeng.dcu.ie/~molloyd/EE223/

Experiments 1.2: Introductory Power Supply Circuit II (Mains PSUs)

Derek Molloy 2011-04-23 | This video continues from a previous video on setting up a simple battery power supply on a breadboard. This video uses a mains transformer 9V Power Supply Unit (PSU) that allows us to power circuits without the need of a battery. However, the supply is noisy and could lead to difficulties. A diode is added to protect the circuit from reverse connections. A switch is added to simplify usage. A PTC (Positive Temperature Coefficient) Transducer is added to protect the circuit from short connections and Capacitors are added to smooth the supply. We use the oscilloscope to examine the quality of the output supply.

Experiments 5.3: 8x8 LED Dot Matrix Display Tutorial (Red/Green Common Anode) using the Arduino

Derek Molloy 2011-04-20 | In this video a 2 Colour (red/green) 8x8 LED Dot Matrix Display circuit is developed that uses three 74HC595 ICs to drive the rows/columns and a darlington transistor array (UDN2981A) to source the current. An Arduino is used to provide the serial data and the source code is presented to show how this was achieved. The display is a common anode display and the experiment spends time examining the current constraints, explaining why we require transistor arrays to source or sink current. This experiment is a part of a module on an introduction to Digital Electronics at Dublin City University, which can be viewed at: www.eeng.dcu.ie/~molloyd/ee223/

Experiments 5.2: Arduino - Serial to Parallel Conversion (74HC164 & 74HC595)

Derek Molloy 2011-04-01 | This video looks at serial to parallel conversion in digital electronic circuits. In particular it shows how we can drive a sequence of LEDs using a single pin of the Arduino. Also, it discusses the difference between latched and unlatched serial to parallel converters. The particular ICs that are examined are the 74HC164 and the 74HC595 (latched), where the video demonstrates how to drive 8 LEDs using a single pin and 16 LEDs using two pins of serial data. This video is part of an introductory module on digital electronics. The associated content can be found at http://www.eeng.dcu.ie/~molloyd/EE223/

Experiments 4.4.3: Questions: BCD Counter - Change to Octal

Derek Molloy 2010-10-21 | This is the solution to the third question asked - how do you convert the BCD counter into an (binary coded) octal counter. See: www.eeng.dcu.ie/~molloyd/EE223/

Experiments 4.4.4: Assignment: BCD Counter 0-99 Assignment

Derek Molloy 2010-10-21 | ...

Experiments 3.2: Sequential Logic - D-Type and JK Flip-Flop

Derek Molloy 2010-10-20 | This video demonstrates the use of a D-Type and JK-Type Flip Flops. It contines on from the previous video on S-R/Gated S-R flip flops and shows how the D-Type flip-flop has a single input and the JK-Type flip-flop has a new toggle state, which inverts the current state of the flip-flop. This is one of the circuits in the EE223 Introduction to Digital and Analogue electronics module at Dublin City University. The associated materials are at: http://www.eeng.dcu.ie/~molloyd/EE223/

Experiments 2.1: Logic Gates - NOT gate using a single transistor

Derek Molloy 2010-10-19 | This video demonstrates the use of a single transistor to implement a NOT gate (inverter).
This is one of the first circuits in the EE223 Introduction to Digital and Analogue electronics module at Dublin City University.
The associated materials are at: http://www.eeng.dcu.ie/~molloyd/EE223/

Experiments 3.1: Sequential Logic - S-R Latch and a Gated S-R Latch

Derek Molloy 2010-10-18 | This video demonstrates two circuits: First - an S-R Latch that is created using two NOR gates. It can be set or reset using the two inputs on the left hand side and shows how a basic flip-flop works. Second - a gated S-R latch that adds an enable input to the circuit, which must be pressed before the state can be changed. This is one of the first circuits in the EE223 Introduction to Digital and Analogue electronics module at Dublin City University. The associated materials are at: http://www.eeng.dcu.ie/~molloyd/EE223/

Experiments 1.3: Power Supply - Simple Transistor Example

Derek Molloy 2010-10-18 | This video demonstrates the use of a simple transistor. In this module we really only treat the transistor as a 'switch' that is enabled (on) when the transistor is in saturation state and disabled (off) when the transistor is in cutoff state. The full details of this course are at www.eeng.dcu.ie/~molloyd/EE223

Experiments 4.4.2: Questions: BCD Counter - Up/Down Counting Enabled

Derek Molloy 2010-10-11 | This is the solution to the second question that was asked in the previous question - to build some mechanism that allowed for the counter to count up or down. This solution uses NAND gates to create the switching mechanism. The switch decides with pin should receive the clock signal and which pin should receive the high value. Note: this cicuit inverts the clock cycle. This is one of the experiments attached to the module at: www.eeng.dcu.ie/~molloyd/EE223/