Embedded distributed/parallel computing hardware for high school students

Transcription

1 Embedded distributed/parallel computing hardware for high school students Hannes Haljaste Institute of Computer Science University of Tartu Abstract This paper focuses on embedded distributed/parallel computing hardware, where microcontrollers are used as a central processing unit. It gives an overview of two controllers one with the best available performance at the time of writing and one for its ease of use to learn about. Different development environments are evaluated to be used for teaching distributed and parallel paradigms. Index Terms Embedded computing, distributed computing, parallel computing, Cortex-M7, Arduino, high school I. INTRODUCTION Building distributed/parallel computing hardware is expensive and therefore is usually not available for hobbyists and high school students. With more research and development going towards these fields, raising interest in younger people is essential. This paper tries to find the best solution to use in a way that could demonstrate distributed and parallel paradigms before university education in high schools and for hobbyists how might have an interest in the field. For this reason two different microcontrollers and their most likely development environments are evaluated to find the best and to develop prototype electronics and software for demonstration. II. HARDWARE For the embedded distributed/parallel computing hardware two different microcontrollers are considered - Microchip ATSAME70 and ATmega328P. Both of these devices have different features besides central processing unit which makes them very useful in different applications like sensor networks, robotics, self driving cars, aerospace etc. One of the most useful feature is that they can be configured to consume very low power based on the performance that is needed at the time. On a small battery these controllers can stay in sleep mode for years. This opens up a lot of possibilities where high performance computing is needed occasionally and/or where system s power consumption is limited. The ATSAME70 s central processing unit is based on the 32-bit Cortex-M7 core running at up to 300 MHz. It also features various hardware peripherals like the Advanced Encryption Standard (AES), True Random Number Generator (TRNG), Universal Serial Bus (USB), Serial Peripheral Interface (SPI), Two Wire Interface (TWI) also known as Inter-Integrated Circuit (I2C) and Universal Synchronous/Asynchronous Receiver/Transmitter (USART) among others. The second microcontroller has a 8-bit core and is running at up to 20 MHz. It also has ATSAME70 [4] ATmega328P [3] Core 32-bit 8-bit CPU design RISC RISC Core clock 300 MHz 20 MHz Floating point support Hardware Software Flash memory 2 MB 32 KB RAM 384 KB 2 KB Maximum power consumption 300 mw 20 mw Sleep mode power consumption 19 µw 4 µw Other DSP instructions - Peripherals AES SPI TRNG TWI Ethernet MAC USART USB SPI TWI USART TABLE I COMPARISON BETWEEN TWO MICROCONTROLLERS. Iterations ATSAME70 at 300 MHz ATmega328P at 16 MHz s s s s s s TABLE II PI CALCULATION RESULTS USING MONTE CARLO METHOD IN SECONDS. SPI, TWI and USART communication peripherals to transmit and receive data. Compared by the power consumption both of these microcontrollers consume about the same amount of power per 1 MHz. While in sleep mode they consumes couple of µw. On a small 100 mah battery ATmega328P can stay in sleep mode for about 14 years while not taking into consideration other factors. [3] [4] To compare actual performance of the two microcontrollers a simple calculation test was written. Table II shows the result of using Monte Carlo Method to calculate Pi for both microcontrollers. ATmega328P was clock at 16 MHz since this is directly supported by the Arduino and its millis() function to measure time. For ATSAME70 time measurement was implemented on the hardware timers since specific function to measure processor time was not available. Results show that ATSAME70 was about 77 times faster in executing the algorithm while the clock speed was only times faster. This is mostly thanks to hardware floating point unit and 32-bit core that helps speed up calculations. For ATSAME70 code was compiled with no optimizations.

2 III. COMMUNICATION [3] [4] While building multi-microcontroller distributed system for high performance computing there aren t available any communication standards that directly support it like on some high end CPUs. For example Intel has developed its own point-to-point interconnect called QuickPath. Microprocessors can exchange data at speeds up to 19.2 GB/s [7]. For high performance computing ARM has developed CoreLink that allows connecting up to 32 multi-core processor on a same bus with bandwidth exceeding 1 TB/s [8]. Most of the microcontrollers support various communication interfaces that allow data to be passed between different devices. The speed how fast data can be transmitted and received is mostly determined by the clock sources supported by the devices or the protocol used. Less powerful microcontrollers which have slower clocks have their communication speeds limited. For example ATmega328P has its maximum communication speed limited for SPI by half the main clock source giving the maximum transfer rate up to 10 Mbits/s. On the other hand ATSAME70 can theoretically run SPI at 150 Mbits/s. This section will give a better overview of the communication protocols available while designing distributed/parallel embedded system. One of the most versatile communication interfaces would be bit-banging. This means that microcontroller manipulates communication lines in software and can create any protocol to transit data. Since all this must be done in software, it makes it very complicated, hard to implement and consumes valuable resource needed to perform computations. A better option would be using one of the communication interfaces implemented into the microcontroller that does most of the trivial signaling while the central processing unit can perform its own tasks. One of those communication interfaces is an Inter-Integrated Circuit (I2C). It uses two lines - clock (SCL) and data (SDA) line. The protocol was created by Philips Semiconductor (currently NXP Semiconductor) and is wildly used by most of the microcontroller manufacturers. It has fixed clock speeds of 100 khz and 400 khz on most devices while higher clock speeds are only supported by some higher end devices going up to 5 MHz. I2C can support at least 7-bit address space, allowing up to 127 devices to be connected together on the same bus. The more advanced microcontroller can support up to 10-bit address space supporting up to 1023 devices on a single bus. Because of its design, I2C bus is recommended to be used only on a single printed circuit board (PCB). Its slow communication speed limits what algorithms can be efficiently run on such a distributed/parallel system. [6] While I2C is half duplex the Serial Peripheral Interface (SPI) can communicate in full duplex mode. It uses three lines for data transfer, clock (SCLK), master in slave out (MISO) and master out slave in (MOSI), and one additional chip select (CS) line for each slave device. SPI can be used in multi-master mode but this requires additional signaling lines to make sure that no collisions happen on the bus. At the same time I2C is multi-master by design. Requirement for chip select line for each slave limits the amount of microcontrollers that can be implemented on the same bus since the pin count is physically limited by the package used for the microcontroller. SPI speed is usually the fastest that microcontrollers support. On ATSAME70 SPI can run at a clock rate up to 150 MHz, while ATmega328P can support speeds up to 10 MHz. Next very popular communication interface is Universal Synchronous/Asynchronous Receiver/Transmitter (USART). As a standalone interface, it allows only point to point communication. To support multi-master or master-slave communication additional hardware must be used. One of those is RS485 which allows multiple devices with USART to be connected to the same bus. For communication USART uses two lines, one for transmitting (TXD) and one for receiving (RXD) data while RS485 uses two lines in half duplex mode and four lines in full duplex mode. Since RS485 is not directly supported, nor is communication protocol available then the user must program this part in software. Some of the more advanced communication protocols are only available on more advanced microcontrollers. One of such protocols is Ethernet, which is supported by microcontrollers only on the MAC level like it is on ATSAME70. The additional integrated circuit is required to transmit and receive electrical signals. With a lot of research and advancement going on in the field of Internet of Thing (IoT) there is available SPI to Ethernet converters which can be used with the ATmega328P. While ATSAME70 can reach 100 Mbits/s the ATmega328P is limited by its SPI speed which is 10 Mbits/s. Ethernet uses IPv4, which can practically support unlimited amount of devices on the same local network. Additionally Ethernet also needs switches to allow communication between different devices. The biggest problem with Ethernet is its power consumption. It usually is around 100 ma to 500 ma for five devices. This is way over the maximum what microcontrollers use. The biggest power consumer is magnetics that protects them from overvoltage and noise. If the distributed/parallel system is designed and implemented on a single PCB then magnetics can be replaced by using only capacitors to reduce power consumption [2]. This requires special PCB design and testing. Although there is an IEEE Work group maintaining backplane Ethernet standard IEEE 802.3ap, devices that support this standard are not widely commercially available. Other communication standards that can be found on some devices is controller area network (CAN) that is mostly used in car industry. Although it is slow it is very robust. One option is also to build wireless distributed/parallel computing network. Recently different manufacturers have come out with some low energy wireless network modules all based on IEEE technical standard. It supports IPv6 and its network is self healing so losing some of the nodes does not make it inoperable. Based on the microcontroller capabilities and performance, ATSAME70 seems like a clear choice but for the high school student and hobbyist others factors are also very important. The most important is that the concepts are easy to understand

3 and that the code development isn t frustrating and hard to understand. IV. SOFTWARE DEVELOPMENT There are a lot of software development tools available. Finding the right one for a particular task may be hard and confusing. For ATSAME70 and ATmega328P there is integrated development environment (IDE) developed by the microcontroller manufacturer itself called Atmel studio (Atmel was acquired by Microchip). Microchip also develops a hardware abstraction layer called Advanced Software Framework (ASF) for both microcontrollers to make developing firmware for the devices easier. For ATmega328P there is also support by Arduino, who has developed its own IDE and hardware abstraction layer. Next two examples demonstrate their difference. i f ( p m c i s p e r i p h c l k e n a b l e d ( ID PIOD ) == 0) p m c e n a b l e p e r i p h c l k ( ID PIOD ) ; p i o s e t i n p u t ( PIOD, PIO PD11, 0 ) ; i n t v a l u e = p i o g e t ( PIOD, 0, PIO PD11 ) ; Listing 1. Advanced software framework code example. Setting pin as an input and reading its value. pinmode (3 INPUT ) ; i n t v a l u e = d i g i t a l R e a d ( 3 ) Listing 2. Arduino code example. Setting pin as an input and reading its value where 3 is pin number. A. Atmel studio and advanced software framework Atmel studio is built on Microsoft Visual Studio and supports some of its features. The most important feature is that Microchip directly develops the environment and starting a project in this is very easy and does not require more advanced knowledge about hardware design, compilers and linkers to set it up. Using the advanced software framework (ASF) is not very straight forward and requires knowledge about registers, individual bits and how to use them correctly. ASF makes code writing easier and better to understand, but does not replace the actual deep knowledge needed to program microcontrollers. Atmel Studio and ASF include many example projects and demos to help developers develop software. B. Arduino ATmega328P is supported microcontroller by Arduino open source hardware initiative, which makes programming very easy and straight forward with a huge amount of examples and wide community support. Arduino has put more focus on making software writing easy and straight forward for simple projects. All of its hardware designs are open source which makes creating electric circuits and PCB designs very simple and does not require deep knowledge about the actual microcontroller. For PCB designing and breadboard design Arduino does not support any specific design environment. Eagle PCB has been the one that open source community mostly uses. By focusing on the software side, Arduino has created a hardware abstraction layer which completely hides registers Fig. 1. Fritzing breadboard design view. and individual bits from the user making programming very easy to learn by high school students, hobbyists and beginners. Because of its simplicity and quick development cycle some of the companies have used Arduino to bring their products to the market. V. FRITZING Fritzing is another open source hardware initiative that makes hardware design and software writing easy for hobbyist and beginners. Its focus is more on developing hardware schematics, breadboard layouts and PCB designs. For a small project, it is a viable tool to use although it can t currently really compete with tool that are developed by professional companies and offer free version of their product for hobbyist like Eagle PCB or long developed KiCad by the community. Fritzing features four different views (breadboard, schematic, PCB and code) which are connected in the background. Making changes in the schematic view will be shown in the breadboard and PCB view which makes designing electronic circuits quite easy. Fritzing already includes most of the Arduino hardware, but it also allows adding new components like ATSAME70 to build electronics. VI. PROTOTYPE DESIGN Some Estonian schools offer optional courses in electronics, programming and robotics. These courses are very short compared to the courses offered in universities. The most important thing is to teach student about parallel and distributed paradigms. This can best achieved by making hardware and software design as simple as possible. The development environment must be simple to use and software writing must be easy to understand. For this reason Arduino was chosen as a platform from which to develop hardware and software demonstrations. As a demonstration a schematic and PCB was designed in Fritzing to show how to build multi-microcontroller distributed system and perform parallel computations. Printed circuit board (PCB) features two ATmega328P microcontrollers, each

4 Fig. 4. Prototype electronics for high schools. Fig. 2. Fritzing schematic design view with a part of the prototype embedded parallel computing hardware. of these controllers have its own USART to USB converters to program and debug the software. Also SPI interface is available to burn the bootloader on the chip. The board also includes a reset button for each microcontroller and other necessary components for it to work. Both microcontrollers have been connected together using I2C bus such that data can be passed between the two microcontrollers. Current hardware design has some limitations that should be eliminated in the next version. These additional features would allow users to better understand how software works and extend the possibilities what can be done. One of the most useful features on official Arduino boards is pin headers. They allow connecting different external devices to the microcontroller. All unused pins should be connected to a additional header. Also there should be one header for I2C bus so that multiple boards could be connected together to allow extending parallel/distributed system. For visual feedback at least one light emitting diode (LED) should be added per microcontroller. Current design features FTDI chips to communicate over USB. These chips are expensive and for this reason more cost effective solution should be considered. While designing hardware there were also shortcoming in the software. Fritzing seems to be a perfect tool to use, but it suffers from the fact that it is open source and developed by the community. As such, it lacks some basic features that most paid and long developed tools have. From the PCB development side, Fritzing lacks the ability to draw wires in a 90 and 45 angle which is the most basic feature in other PCB design tools. Also the PCB view rendering is slow and makes routing time consuming and annoying. A support for GPU should be added to help render graphics. One new view that might be very helpful to add is circuit simulators like the Falstad circuit simulator. This would help students measure different values of resistors, see LED s blinking and design more complex circuits all in one environment. VII. U SE CASE IN HIGH SCHOOLS Fig. 3. Fritzing PCB design view with a prototype embedded parallel computing hardware. In electronics and programming courses Fritzing can be used as a tool to help students to better understand how different levels in hardware and software design are intertwined. As a first step students can use schematic view to

5 Iterations Single core Dual core s s s s s s TABLE III PI CALCULATION RESULTS USING MONTE CARLO METHOD WITH SINGLE AND DUAL MICROCONTROLLER SETUP. build desired electronic circuits. After that they can build breadboard designs which would help them build it in the real world and test if their design work. As a third step they can create their own PCB designs after which they have been given a good understanding how the actual hardware development takes place. After hardware is designed they can program the Arduino microcontrollers in the same environment without the need to download or to get familiar with another tool. All this can take place through multiple courses and include a way to introduce the topics of distributed and parallel computing early on. For example, students could learn about simple algorithms like Pi calculation using Monte Carlo method and build a distributed system to do it faster. VIII. COMPUTATION RESULTS Built hardware was used to perform Monte Carlo Pi calculations (Listing 3) with one and two microcontrollers. Two microcontrollers were in master-slave configuration where master received commands from computer and then divided the work load between the two microcontrollers. The results are shown in TABLE III. It can be seen that using two microcontrollers cut the computation time in half. This was expected since the work load is divided equally and the communication between the microcontrollers is utilized only at the beginning and at the end. void m o n t e C a r l o P i ( unsigned long i t e r a t i o n s, unsigned long Mx, unsigned long Nx ) unsigned long M = 0 ; unsigned long N = 0 ; f o r ( ; i t e r a t i o n s!= 0 ; i t e r a t i o n s ) double x = random ( 0, 65536) / ; double y = random ( 0, 65536) / ; i f ( ( x x + y y ) < 1) ++M; e l s e ++N; Mx = M; Nx = N; To improve the performance of the demonstration source code, it can be written without using floating point math which should more than double the actual performance. The other idea would be using assembly language. It is hardware specific and requires a lot of experience to write efficient code. Usually it does not pay off while using microcontrollers where hardware cost is low. Using assembly could reduce cost when high performance computing centers are used where costs are much higher. IX. CONCLUSION The paper describes possible solutions to build an embedded distributed/parallel computing hardware. Comparison between two different microcontrollers, different communication interfaces and overview about available development environments were given. After picking Fritzing for hardware development, a demonstration hardware was designed, possible uses for high school students were given and results using single and dual microcontroller setup to calculate Pi with Monte Carlo method were demonstrated. The results show that parallel/distributed paradigms can be demonstrated for high school students with simple examples and affordable hardware. Next step is to set up curriculum and see how well students would understand the concepts. Project website: REFERENCES [1] Liem Radita Tapaning Hesti. (2017). GEMM in Multicore Arduinos [Online]. fall/uploads/main/gemm.pdf [2] Texas Instrument. (2013). AN-1519 DP83848 PHYTER Transformerless Ethernet Operation [Online]. Available: [3] Microchip. (2016). ATmega328/P - Complete Datasheet [Online]. Available: [4] Microchip. (2016). SAM E70 Datasheet [Online] Available: [5] E.Vita. (2014) Arduino Nano-Rev3.2 [Online]. Available: [6] NXP. (2014). UM10204 I2C-bus specification and user manual [Online] Available: manual/um10204.pdf [7] Intel. (2009). An Introduction to the Intel QuickPath Interconnect [Online]. Available: [8] ARM. (2017, May 10). CoreLink CMN-600 Coherent Mesh Network [Online]. Available: double g e t P i ( unsigned long M, unsigned long N) return 4. 0 M / ( double ) (M + N ) ; Listing 3. Monte Carlo Pi source code.