Reference Designs for Embedded Controls

Transcription

1 Reference Designs for Embedded Controls Chiu H. Choi University of North Florida, Abstract - A set of reference designs suitable for our student design projects was developed and tested. The purpose is to make them available for students to choose the ones suitable for integration into their projects with confidence. All the reference designs are available on our website. Some of those that are intended for embedded control applications are described in this paper. They are reference designs for DC motor driver, stepper motor driver, and GPS module. These reference designs were adopted into our embedded control projects before. Other reference designs were also developed but due to limited space are not included into this paper but the hyperlinks to them are provided. Some of the interesting projects and their evaluations are also described in this paper. Another aspect of this paper is the description of the structure of the reference designs and the various issues encountered. The information should be useful to those intend to develop reference designs for their own design courses. Index Terms reference designs, capstone design projects, embedded control projects, microcontroller applications. I. INTRODUCTION Several of our senior level courses require students to complete design projects. These courses include linear control systems, microcontroller applications, and capstone design courses. Many of the design projects are microcontroller-based with embedded control flavor. The microcontroller selected for our courses was the Freescale s MC9S12C32 microcontroller unit (MCU). The MCU is surfaced mounted on the Axiom s CSM-12C32 module. It is the module being integrated into the projects. The reasons for choosing the MC9S12C32 are that the MCU is simple enough for the students to learn its functions quickly and that it has sophisticated enough on-chip peripherals for solving a wide range of embedded control problems. The on-chip peripherals include general purpose input outputs, timer with input capture and output compare, pulse accumulator, universal asynchronous receiver/transmitter (UART), serial peripheral interface (SPI), pulse width modulator (PWM), and more. CodeWarrior Development Studio for HCS12 was the software development tool selected. It supports C, C++, absolute assembly, and relocatable assembly programming. Our students were taught how to use the MCU in our microcontroller applications courses ([1], [2], [3]). In the embedded control projects, actuators and sensors are widely used. Many students have high level concepts in block diagrams for integrating them but only a few of them know how to implement the individual blocks and their interfacing. Many times the circuits that they designed for individual blocks in the block diagram did not work and it took several iterations to get it to work. This wasted much time and that could lead to incomplete project at the end of the term. It is because of this issue that reference designs are proposed. The reference designs are intended to be proven solutions that the students can integrate into their projects with confidence. There are reference designs in the market, e.g., Freescale University Program and the Arduino community [7]. However, they do not match all our needs. We give careful considerations to what information to be provided in our reference designs. On one hand, a complete solution is preferred by the students but that will encourage straight copying without any student input. That is not pedagogically desirable. On the other hand, a meager reference design solution will not be helpful either. A balance should be sought. We propose a structure for what information to be included in the reference designs and show a few examples. In these examples, sufficient hardware interfacing, software, and other information are provided so that students with some additional effort will be able to integrate them into their projects. The rest of this paper is organized as follows: the reference designs mentioned above are described in the next section. In particular the reference designs are DC Motor driver, stepper motor driver, and GPS module. Section III covers some of the embedded control projects that contained these designs. The reference designs development process and the issues encountered are discussed in Section IV. Concluding remarks are provided in Section V. II. STRUCTURE OF THE REFERENCE DESIGNS The structure of the reference designs consists of 1) description of the design, 2) hardware interfacing techniques, 3) circuit and wiring diagrams, 4) code snippets in C language, and 5) ordering information with hyperlinks. The materials prepared for the reference designs are structured in such manner that extra work is required of the students in order to use them in their projects. This prevents the students from reproducing them without their own S2F-1

2 thoughts. Three examples are given in this section to illustrate such structure. The code snippets in the reference designs are suitable for MC9S12C series of microcontrollers running at 8 MHz bus clock. The codes can be easily modified for other members of the MC9S12 family of 16-bit microcontrollers. The code snippets provided in the reference designs are intentionally condensed so that the students need to write their own additional codes in their applications. Students were encouraged to modify these code snippets and to integrate them into their main programs. Hardware interfacing to the Freescale 9S12C32 MCU The wiring diagram in Figure 1 below shows how to connect the Pololu motor driver carrier board to the CSM- 12C32 module, which pin-out diagram is also shown in the same figure. The motor direction control chart in Table II shows how to drive a motor in clockwise and counterclockwise directions and braking. TABLE II MOTOR DIRECTION CONTROL CHART FROM THE TB6612FNG DATASHEET A website was developed for hosting the reference designs for students to download. Further, the web versions of these designs are provided as hyperlinks in this paper. Example 1: DC motor driver This reference design shows students how to interface a DC motor to the MCU through an inexpensive DC motor driver. The materials developed for this reference design is found in the hyperlink and is repeated below. DC motors are usually driven by microcontrollers through motor drivers. There are many motor drivers in the market with a wide range of voltage and current specifications. The particular DC motor driver discussed in this section is Toshiba s TB6612FNG dual motor driver, which is very easy to use and is available in a carrier board. The motor driver can independently control two bidirectional DC motors. The operating voltage range is from 4.5 to 13.5 V. The peak current output is 3 A per channel with 1 A continuous. It is useful for driving lowpower motors. A picture of the motor driver is shown in Figure 1. Ordering information with web link for the datasheet of the motor driver is shown in Table I. Code snippets In the wiring diagram above, the PW0 pin of the microcontroller drives the PWMA pin of the motor driver. A C-function for initializing PW0 as a pulse width modulator (PWM) is shown as follows: Void init_pwm(void) { PWMPRCLK=0x06; //SET CLOCK A TO 125 Khz //PWMSCLA=0x06; // clock SA not used PWMCLK=0x00; // choose CLOCK A as the clock source for PWM channel 0 PWMCTL=0x00; // 8 bit pwm signal at channel 0 PWMPOL=0x01; // CHANNEL 0 IS ACTIVE HIGH PWMCAE=0x00; // channel 0 is left aligned PWMPER0=250; // PERIOD=250*ONE PERIOD OF CLK A=2ms PWMDTY0=200; // DUTY CYCLE SET TO 80% INITIALLY //PWMCNT0=0; PWME=0x01; // ENABLE CHANNEL 0 FIGURE 1 INTERFACING OF TOSHIBA TB6612FNG WITH CSM-12C32 MODULE. TABLE I TOSHIBA TB6612FNG ORDERING INFORMATION Vendor Part # Weblink Description Pololu Pololu TB6612FNG Corpora item #: m/catalog/product/71 Dual Motor tion Driver Carrier Unit Price $9.95 In the code the duty cycle is set to be 80%. To increase the speed, increase the duty cycle. To drive the motor moving in the clockwise direction, a C-function for that is shown as follows. Note that PT1 and PT2 are used as GPIO for driving AIN1 and AIN2 respectively. It is assume that PW0 is outputting the PWM signal. Void clockwise(void) { PTT_PTT2 = 0; To drive the motor moving in the counterclockwise direction, a C-function for that is shown as follows. It is assumed that PT1 and PT2 are used as GPIO for driving AIN1 and AIN2 respectively. Void counterclockwise(void) { PTT_PTT2 = 1; S2F-2

3 A C-function for braking is shown as follows. Void braking(void) { PTT_PTT2 = 1; To stop the motor abruptly, a C-function for that is shown as follows. Void stop(void) { PTT_PTT2 = 0; A few details of the code snippets above are intentionally left out for the students to figure out. This way will prevent the students from cut and paste without their own thinking. Example 2: Stepper motor driver This reference design shows students how to interface a stepper motor to the MCU through an inexpensive stepper motor driver. The materials developed for this reference design is described below and is shown in the hyperlink Stepper motors are used in printers, disk drives, and other devices where precise position control is required. Stepper motors do not turn continuously like DC motors. They move in steps such as 1.8 degrees or so. There are several types of stepper motors such as unipolar and bipolar. Electronic circuits driving these motors are different from those of DC motors. A common stepper motor driver is Allegro A3967. A module for this driver is available at Sparkfun Electronics. The module is labeled as EasyDriver v3 Stepper Motor Driver with part number ROB It is compatible with 5V TTL signals. This module is applicable to driving bipolar stepper motors. The EasyDriver requires a 7V to 30V supply to power a stepper motor and has an on board voltage regulator for driving the internal logic circuitry. The A3967 driver on the module is configured for 8-microstep mode with adjustable current control from 150mA/phase to 750mA/phase. The pin-out diagram of the stepper motor driver module is shown in Figure 2 (from the datasheet of EasyDriver). FIGURE 2 PIN-OUT OF TOSHIBA TB6612FNG EASYDRIVER MODULE. Ordering information with web link for the datasheet of the stepper motor driver is shown in Table III. Hardware interfacing to the Freescale 9S12C32 MCU The wiring diagram in Figure 3 shows how to connect the EasyDriver to the microcontroller and a bipolar stepper motor. GPIO pin PT0 is connected to the Direction pin. GPIO pin PT1 is connected to the Step pin. Other GPIO pins can be used instead of PT0 and PT1. A low-to-high transition on the STEP pin will microstep the motor. The EasyDriver is configured with 8 microsteps for one increment in stepper positioning. TABLE III ORDERING INFORMATION FOR ALLEGRO A3967 EASYDRIVER Part Vendor # Weblink Description Sparkfun Electronics ROB /commerce/product_info. php?products_id=8368 EasyDriver v3 Stepper Motor Driver Unit Price FIGURE 3 HARDWARE INTERFACE BETWEENT THE EASYDRIVER WITH CSM-12C32. The motor direction control chart in Table IV shows how to drive a stepper motor in clockwise direction. To drive it in the counterclockwise direction, simply reverse the sequence. TABLE IV STEPPER MOTOR DIRECTION CONTROL CHART step wire 1 wire 2 wire 3 wire 4 1 high low high low 2 low high high low 3 low high low high 4 high low low high Software development In the wiring diagram above, the PT0 pin of the microcontroller drives the Direction pin of the motor driver. The PT1 pin drives the STEP pin of the driver. A C-function for initializing PT0 and PT1 as general purpose output pins is shown as follows: Void init_pt01(void) { DDRT_DDRT0 = 1; DDRT_DDRT1 = 1; $15 S2F-3

4 To drive the stepper motor moving in the clockwise direction in one microstep, a C-function for that is shown as follows. When this function is executed 8 times, the stepper will have advanced one step. the TXD of the microcontroller goes straight to the RX0 of the GPS module terminal block. Void clockwise(void) { PTT_PTT0 = 0; Waitms(1); //hold at low level for 1 ms, can be long if necessary Waitms(10); //hold at high level for 10 ms, can be long if necessary //reset PT1 To drive the stepper motor moving in the counterclockwise direction in one microstep, a C-function for that is shown as follows. When this function is executed 8 times, the stepper will have advanced one step backward. Void counterclockwise(void) { PTT_PTT0 = 1; Waitms(1); Waitms(5); Example 3: Global positioning system module This reference design shows how to connect a GPS module to the CSM-12C32 module and provides several C functions for capturing the latitude, longitude, and UTC time information. There is other information such as the number of satellites that can be captured in the same way but is not covered. An easy-to-use GPS module is Vincotech 340- V23993-EVA1080A51GPS module, which consists of one GPS module and one GPS antenna on a coaxial cable. The on-board firmware supports bi-directional serial connection by using a full duplex UART interface of the GPS processor. The default configuration of this serial port is: 4800 baud, 8 data bits, no parity, 1 stop bit, no flow control. A level shifter is needed for passing the data to a PC through a serial COM port. A picture of the GPS module is shown in Figure 4. Ordering information with web link for the datasheet is shown in Table V. The materials developed for this reference design can be found in the hyperlink TABLE V VINCOTECH GPS MODULE ORDERING INFORMATION Vendor Part # Weblink Description Mouser 340-V EVA1080-A Evaluation kit for Electronics EVA1080-A Vincotech A1080-A GPS module Unit Price $130 Hardware interfacing to the CSM-12C32 module If the CSM-12C32 module is powered at 5 V, the wiring diagram is shown in Figure 4. If the CSM-12C32 module is powered at 3.3 V, the voltage divider can be removed and FIGURE 4 HARDWARE INTERFACING OF GPS MODULE TO CSM-12C32 MODULE. Software development The GPS module supports the NMEA interface. The description of the outputs coming from this interface and a summary of the commands that can be issued to this interface are discussed below. This will allow a programmer full control of the module. The outputs coming from the interface are in the form of NMEA sentences, which are in the NMEA 0183 Standard. These sentences were developed by the National Marine Electronics Association for digital data exchange among marine electronic products back in the early nineteen-eighties. Each sentence transmitted by a marine electronic product is in the form of $<vendor><message><parameters>*<checksum><cr><lf> The maximum length of a sentence is 80 characters. The combination of <vendor><message> is called address field. The vendor code for the Global Positioning System is GP. The Vincotech s GPS firmware for the GPS module supports six NMEA sentences. Each sentence can be individually turned off or on. Their default settings are shown as follows: $GPGGA (default: ON) $GPVTG (default: OFF) $GPRMC (default: ON) $GPGSA (default: ON) $GPGSV (default: ON, 0.2Hz) $GPGLL (default: OFF) Commands can be sent to the GPS module to turn an NMEA sentence on or off. The format of the command was described in the Vincotech s GPS firmware datasheet. For example, to disable the GGA message, the command is: $PSRF103,00,00,00,01*21 S2F-4

5 To enable the GGA message for a 1 Hz constant output with checksum enabled, the command is: $PSRF103,00,00,01,01*20 A C function for initializing the SCI of the 9S12C32 for communicating with the GPS module at 4,800 baud 8N1 format is shown as follows: void init_sci(void){ SCIBDH=0x00; // BR = Bus Clock/(16 * Baud Rate) SCIBDL=104; // Baud Rate set to 4800 SCICR1=0x04; //normal 8 bit mode, no parity SCICR2=0x0C; //enable tx and rx, disable interrupts To capture the latitude, longitude and UTC time from the GPS module, one can use the GPGGA sentence and the format of which is shown in Table VI below. TABLE VI GPGGA - GLOBAL POSITIONING SYSTEM FIX DATA SENTENCE FORMAT FROM THE VINCOTECH GPS USER S MANUAL Example $GPGGA, , ,N, ,E,1,04,2.5, 607.5,M,47.6,M,,*67 (1) $GPGGA Vendor and message identifier (2) Universal time coordinated (15h 21m s) (3) Latitude (48deg min) (4) N N North S South (5) Longitude (011deg min) (6) E E East W West (7) 1 Fix quality: 0 fix not valid or invalid, 1 GPS SPS mode, fix valid, 2 Differential GPS, SPS mode, fix valid (8) 04 Four satellites in use (min 00, max 12) (9) 2.5 Horizontal dilution of precision (10) MSL altitude (11) M Unit of antenna altitude: meters (12) 47.6 Geoidal separation (13) M Unit of geoidal separation: meters (14) <empty> Age of differential GPS data, null field when DGPS is not used (15) <empty> Differential reference station ID, null field when DGPS is not used (16) *67 Checksum A C function for capturing the latitude, longitude and UTC time from the GPS module is shown below. Every time this function is called, it will start the measurement and capture the information in global strings. The UTC time is stored in the global string UTC. The latitude is stored in the global string Latitude. The latitude direction (N or S) is stored in the global character Lat_direction. The longitude is stored in the global string Longitude. The longtitude direction (E or W) is stored in the global character Long_direction. void GPS_data(void){ int i; char GPGGA[80] = {0; char GPGGA_Off[25] = {"$PSRF103,00,00,00,01*24"; /*turn off GGA sentence*/ char GPRMC_Off[25] = {"$PSRF103,04,00,00,01*20"; /*turn off RMC */ char GPGSA_Off[25] = {"$PSRF103,02,00,00,01*26"; /*turn off GSA */ char GPSV_Off[25] = {"$PSRF103,03,00,00,01*27"; /*turn off GSV */ char GPGGA_On[25] = {"$PSRF103,00,00,01,01*25"; /*turn on GGA */ char end_sentence[3] = {0x0D,0x0A, 0x00; /*end of sentence <CR> <LF><NULL>*/ putstring(gpgga_off); // turn off GGA sentence putstring(gprmc_off); //turn off RMC sentence putstring(gpgsa_off); //turn off GSA sentence putstring(gpgsv_off); //turn off GSV sentence putstring(gpgga_on); // turn on GGA sentence getstring(gpgga,80); /*saves GPGGA statement*/ for (i=7; i<=16; i++) UTC[i-7]=GPGGA[i]; for (i=18; i<=26; i++) Latitude[i-18]=GPGGA[i]; Lat_direction=GPGGA[28]; for (i=30; i<=39; i++) Longitude[i-30]=GPGGA[i]; Long_direction=GPGGA[41]; char getchar(void) { while (!(SCISR1 & 0x20)); return SCIDRL; void getstring(char *stringptr, int string_length){ int i=0; stringptr[0]=getchar(); while((stringptr[i]!= 0x0D) && (i < string_length)){ i++; stringptr[i]=getchar(); void putchar(char a){ while(!(scisr1 & 0x80)); SCIDRL = a; S2F-5

6 void putstring(char *stringptr){ while((*stringptr!= 0x00)) putchar(*stringptr++); The functions getchar, getstring, putchar, and putstring are specific for the serial communication interface (UART) of the Freescale MC9S12C32 microcontrollers. Further, the components/modules of the reference designs should be easily available with good documentation, which will speed up the implementation of the designs. As electronics change rapidly, it is necessary that the reference designs be updated on a regular basis. III. A PROJECT THAT USED REFERENCE DESIGNS A project [4] selected from our senior level microcontroller applications course used the GPS module described above. As stated in the project report, The objectives of this project were to configure the MCU Project Board for use with the EVA1080-A-02 GPS module, to create, build, and debug five C-functions for getting the latitude, longitude, number of satellites, date, and time from the GPS module by using Code Warrior, and to flash the application into the microcontroller and display the parameters on a PC through the SCI. The objectives were achieved. Pictures of the project are shown in Figure 5 and Figure 6. FIGURE 6 A PICTURE OF THE GPS PROJECT. FIGURE 5 SCREEN CAPTURE OF GPS DATA DISPLAYED ON THE PC. In the conclusion of the project report, the students stated that The purpose of this project was not only to allow the student to be independently creative but to encourage the student to apply the many concepts learned in class and labs. Execution of the project prepared the student with a hands-on experience that will ready for future use. Overall it was a successfully executed project with the observed result matching expectations. The reference design materials were used in the project. Some other projects that used reference designs are in [5] and [6]. IV. REFERENCE DESIGNS DEVELOPMENT ISSUES The selection of which reference design to develop should be based on the particular applications covered in the courses. Embedded system projects are popular among our students. Therefore we develop reference design around that application. Cost of the reference designs is another factor. The cost should be within the budget of the students and the department. Reliability of the module is another factor to consider. The design should be able to sustain the abuses that inexperienced students inadvertently committed. V. CONCLUDING REMARKS A number of reference designs for embedded control projects were developed. They were used by students in their projects. The designs will reduce the burden on the students part in coming up with a complete solution from scratch. There are sufficient details in the reference designs as shown in the examples above to get the students started. Some other details are intentionally left out for the students to figure out so that they will have their share of work to do. The structure of the reference designs proposed appears to be adequate as indicated by the student projects. REFERENCES [1] Cady, F., Software and Hardware Engineering Assembly and C Programming for the Freescale HCS12 Microcontroller, 2nd ed., Oxford, [2] Choi, C.H., A Microcontroller Applications Course and Freescale s Microcontroller Student Learning Kit, Proceedings of the 2008 American Society for Engineering Education Annual Conference, June 2008, Pittsburg, PA. [3] MC9S12C128 Data Sheet, Rev. 1.16, Freescale Semiconductors, Oct [4] Nguyen, N., Class Project Report: Interfacing GPS Modules to MC9S12C32 Microcontrollers, Univ. of North Florida, July 30, [5] Lynch, J.M., and E. Larios, Class Project Report: Swinging Pendulum Acceleration Measurement, Univ. of North Florida, July 29, [6] Cooke, B., and N. Watt, Class Project Report: Hitachi HM55B Digital Compass, Univ. of North Florida, July 30, [7] Arduino website, June This work is supported by a grant provided by the Academic Affairs of the University of North Florida. S2F-6