1. 3/23/2015 Richard Kuo Assistant Professor
NuMicro GPIO
3/23/2015
Richard Kuo
Assistant Professor

2. Outline 4.NuMicro_GPIO.ppt Homework : LED Cube 3x3x3
GPIO Interface Introduction
Lab. LED control (smpl_GPIO_LED1, smpl_GPIO_RGBled)
Lab. Buzzer control (smpl_GPIO_Buzzer)
Lab. Sensor input (smpl_GPIO_PIR)
Lab. 7-segment Display (smpl_7seg)
Lab. Keypad scanning (smpl_Keypad)
Lab. Step Motor control (smpl_GPIO_StepMotor)
Lab. GPIO Interrupt (smpl_GPIO_IRQ)
Homework : LED Cube 3x3x3
Homework : Electronic Safe

3. Peripherals To use GPIO to access the following components/modules
LEDs
Buzzer IR
PIR
Relays
Step Motor
Keypad

4. GPIO I/O Modes Input only with high impedance Push-Pull Output
Set GPIOx_PMD (PMDn[1:0]) to 00b the GPIOx port [n] pin is in Input mode and the I/O pin is in tri-state (high impedance) without output drive capability
Push-Pull Output
Open-Drain
Quasi bi-direction

5. StdDriver/GPIO_OutputInput
Set I/O Mode
GPIO_SetMode(PA, BIT12, GPIO_PMD_OUTPUT);
GPIO_SetMode(PB, BIT1, GPIO_PMD_INPUT);
I/O groups :
M051 = P0, P1, P2, P3, P4
Nano102 = PA, PB, PC, PD, PE, PF
NUC140 = GPA, GPB, GPC, GPD, GPE
port no = BIT0~15
I/O modes
GPIO_PMD_INPUT : input only mode
GPIO_PMD_OUTPUT : push-pull output mode
GPIO_PMD_OPENDRAIN : open-drain output mode
GPIO_PMD_QUASI : quai bi-direction mode
Output value : PA12 = 0;
Read Input : if (PA12 !=0) { }

6. LED schematic (Nu-LB-NUC140)

7. LED
PC12
GPIO_SetMode(PC, BIT12, GPIO_PMD_OUTPUT);

8. smpl_GPIO_LED1 Initialize Clocks & Pins Output Mode int main(void) {
SYS_Init();
GPIO_SetMode(PC, BIT12, GPIO_PMD_OUTPUT);
while(1) {
PC12 =0; // turn on LED
CLK_SysTickDelay(100000); // Delay
PC12 =1; // turn off LED }
Initialize Clocks & Pins
Output Mode

9. PIR (Passive InfraRed) sensor

10. PIR (Passive InfraRed) schemiatc

11. PIR (Passive InfraRed) application circuit
5~9V Battery

12. smpl_GPIO_PIR display Detection message Passive Infrared Detector
detecting human body

13. smpl_GPIO_PIR Input Mode
int main(void) { SYS_Init(); GPIO_SetMode(PA, BIT0, GPIO_PMD_INPUT); while(1) { if (PA0==1) printf("PIR detected!\n"); else printf("PIR no detection!\n"); }
Input Mode

14. Reflective Optical Sensor : TCRT5000
Application Circuit
Picture
220
IR Diode keep emitting Infrared light
IR Transistor receive the reflective Infrared light
Top View

15. Buzzer schematic (Nu-LB-NUC140)
0 ohm

16. smpl_GPIO_Buzzer
void Init_Buzzer(void) { GPIO_SetMode(PB, BIT11, GPIO_PMD_OUTPUT); PB11=1; // turn off Buzzer } void Buzz(int number) int i; for (i=0; i<number; i++) { PB11 =0; // turn on Buzzer CLK_SysTickDelay(100000); // Delay PB11 =1; // turn off Buzzer

17. 7-segment display

18. 7seg. LED schematics (Nu-LB-NUC140)
Drive Low will turn on 7-seg. LED

19. Seven_Segment.c #include <stdio.h> #include "NUC100Series.h"
#include "GPIO.h"
#include "SYS.h"
#include "Seven_Segment.h"
#define SEG_N0 0x82
#define SEG_N1 0xEE
#define SEG_N2 0x07
#define SEG_N3 0x46
#define SEG_N4 0x6A
#define SEG_N5 0x52
#define SEG_N6 0x12
#define SEG_N7 0xE6
#define SEG_N8 0x02
#define SEG_N9 0x62
#define SEG_N10 0x22
#define SEG_N11 0x1A
#define SEG_N12 0x93
#define SEG_N13 0x0E
#define SEG_N14 0x13
#define SEG_N15 0x33
unsigned char SEG_BUF[16]={SEG_N0, SEG_N1, SEG_N2, SEG_N3, SEG_N4, SEG_N5, SEG_N6, SEG_N7, SEG_N8, SEG_N9, SEG_N10, SEG_N11, SEG_N12, SEG_N13, SEG_N14, SEG_N15};
void OpenSevenSegment(void) {
GPIO_SetMode(PC, BIT4, GPIO_PMD_OUTPUT);
GPIO_SetMode(PC, BIT5, GPIO_PMD_OUTPUT);
GPIO_SetMode(PC, BIT6, GPIO_PMD_OUTPUT);
GPIO_SetMode(PC, BIT7, GPIO_PMD_OUTPUT);
PC4=0; PC5=0; PC6=0; PC7=0;
GPIO_SetMode(PE, BIT0, GPIO_PMD_OUTPUT);
GPIO_SetMode(PE, BIT1, GPIO_PMD_OUTPUT);
GPIO_SetMode(PE, BIT2, GPIO_PMD_OUTPUT);
GPIO_SetMode(PE, BIT3, GPIO_PMD_OUTPUT);
GPIO_SetMode(PE, BIT4, GPIO_PMD_OUTPUT);
GPIO_SetMode(PE, BIT5, GPIO_PMD_OUTPUT);
GPIO_SetMode(PE, BIT6, GPIO_PMD_OUTPUT);
GPIO_SetMode(PE, BIT7, GPIO_PMD_OUTPUT);
PE0=0; PE1=0; PE2=0; PE3=0;
PE4=0; PE5=0; PE6=0; PE7=0; }

20. Seven_Segment.c switch(i) {
void ShowSevenSegment(unsigned char no, unsigned char number) {
unsigned char temp,i;
temp=SEG_BUF[number];
for(i=0;i<8;i++) {
if((temp&0x01)==0x01)
switch(i) {
case 0: PE0=1; break;
case 1: PE1=1; break;
case 2: PE2=1; break;
case 3: PE3=1; break;
case 4: PE4=1; break;
case 5: PE5=1; break;
case 6: PE6=1; break;
case 7: PE7=1; break; }
else
switch(i) {
case 0: PE0=0; break;
case 1: PE1=0; break;
case 2: PE2=0; break;
case 3: PE3=0; break;
case 4: PE4=0; break;
case 5: PE5=0; break;
case 6: PE6=0; break;
case 7: PE7=0; break; }
temp=temp>>1;
switch(no) {
case 0: PC4=1; break;
case 1: PC5=1; break;
case 2: PC6=1; break;
case 3: PC7=1; break;

21. Seven_Segment.c void CloseSevenSegment(void) { PC4=0; PC5=0; PC6=0;}

22. 4x4 Keypad

23. 3x3 Keypad schematic (Nu-LB-NUC140)

24. Keypad GPIO setting GPIO pin mode : Input
GPIO_SetMode(PA, BIT0, GPIO_PMD_QUASI);
Key press will connect output pin to input pin
Quasi output 1 : pin is floating
Quasi output 0 : pin drive to Low
Keypad scanning
Set input pins PA3,4,5 to 1
Set output pins to 0 one at a time PA0,1,2
PA3=1; PA4=1; PA5=1;
PA0=1; PA1=1; PA2=0;
if (PA3==0) return 1;
if (PA4==0) return 4;
if (PA5==0) return 7;

25. Scankey.c void OpenKeyPad(void) {
GPIO_SetMode(PA, BIT0, GPIO_PMD_QUASI);
GPIO_SetMode(PA, BIT1, GPIO_PMD_QUASI);
GPIO_SetMode(PA, BIT2, GPIO_PMD_QUASI);
GPIO_SetMode(PA, BIT3, GPIO_PMD_QUASI);
GPIO_SetMode(PA, BIT4, GPIO_PMD_QUASI);
GPIO_SetMode(PA, BIT5, GPIO_PMD_QUASI); }
uint8_t ScanKey(void) {
PA0=1; PA1=1; PA2=0; PA3=1; PA4=1; PA5=1;
if (PA3==0) return 1;
if (PA4==0) return 4;
if (PA5==0) return 7;
PA0=1; PA1=0; PA2=1; PA3=1; PA4=1; PA5=1;
if (PA3==0) return 2;
if (PA4==0) return 5;
if (PA5==0) return 8;
PA0=0; PA1=1; PA2=1; PA3=1; PA4=1; PA5=1;
if (PA3==0) return 3;
if (PA4==0) return 6;
if (PA5==0) return 9;
return 0; }

26. smpl_7seg_Keypad Scankey.c : function calls for scanning keypad 3x3
7-segment display number = 5
Press middle key
of 3x3 keypad
Scankey.c : function calls for scanning keypad 3x3

27. smpl_GPIO_Keypad Vcc/Gnd Press key
Using GPIO outputs to control relays
GPIOs control 4-port Relay

28. smpl_GPIO_Keypad Press key1 Press key2 Press key3 Press key4
Relay #1 off
Relay #2 off
Relay #3 off
Relay #4 off
Vcc = 3.3V, GPIO output hi (base)  Relay Control pin = low (collector)

29. Smpl_GPIO_Keypad int main(void) { uint32_t i =0; SYS_Init();
OpenKeyPad();
Init_GPIO();
while(1)
i=ScanKey();
switch(i) {
case 1 : PB0=1; break;
case 2 : PB1=1; break;
case 3 : PB2=1; break;
case 4 : PB3=1; break;
default: PB0=0; PB1=0; PB2=0; PB3=0; break; }

30. 8x8 LED Matrix
N1588
MAX7219

31. MAX7219.c // // MAX7219 Driver : drive 8x8 LEDs
#include <stdio.h>
#include "NUC100Series.h"
#include "SYS.h"
#include "GPIO.h"
// Define GPA2,1,0 as CLK, CS, DIN pins
#define CLK_HI PA2=1
#define CLK_LO PA2=0
#define CS_HI PA1=1
#define CS_LO PA1=0
#define DIN_HI PA0=1
#define DIN_LO PA0=0
void Init_GPIO(void) {
GPIO_SetMode(PA, BIT0, GPIO_PMD_OUTPUT);
GPIO_SetMode(PA, BIT1, GPIO_PMD_OUTPUT);
GPIO_SetMode(PA, BIT2, GPIO_PMD_OUTPUT);
PA0=0; PA1=0; PA2=0; }
void WriteData_MAX7219(uint8_t DATA)
uint8_t i;
CS_LO;
for(i=8;i>=1;i--) {
CLK_LO;
if (DATA&0x80) DIN_HI;
else DIN_LO;
DATA=DATA<<1;
CLK_HI;
CLK_SysTickDelay(10);

32. MAX7219.c void write_MAX7219(uint8_t address,uint8_t dat) { CS_LO;
WriteData_MAX7219(address);
WriteData_MAX7219(dat);
CS_HI; }
void Init_MAX7219(void)
write_MAX7219(0x09, 0x00);
write_MAX7219(0x0a, 0x03);
write_MAX7219(0x0b, 0x07);
write_MAX7219(0x0c, 0x01);
write_MAX7219(0x0f, 0x00);

33. smpl_GPIO_LED8x8 int main(void) { uint8_t i,j; SYS_Init();
Init_GPIO();
Init_MAX7219();
while(1) {
for(j=0;j<38;j++) {
for(i=1;i<9;i++)
write_MAX7219(i, Font8x8[j][i-1]);
CLK_SysTickDelay(100000); }

34. GPIO Interrupt pin circuit
MCU

35. GPIO Interrupt pin setting
GPIO pin mode : Input
GPIO_SetMode(PB, BIT12, GPIO_PMD_INPUT);
GPIO pin chip internal Pull-up
GPIO_ENABLE_PULL_UP(PB, BIT12);
GPIO interrupt trigger type : rising/falling
GPIO_EnableInt(PB, 12, GPIO_INT_FALLING);
GPIO Interrupts : two groups = ABC or DEF
NVIC_EnableIRQ(GPABC_IRQn); // ABC group share 1 interrupt to CPU
NVIC_EnableIRQ(GPDEF_IRQn); // DEF group share 1 interrupt to CPU
GPIO pin debouncing
Debounce Clock Source = IRC10K or HCLK
GPIO_SET_DEBOUNCE_TIME(GPIO_DBCLKSRC_IRC10K, GPIO_DBCLKSEL_64);
GPIO_ENABLE_DEBOUNCE(PB, BIT12);

36. Initialize GPIO interrupt pins
// KEY1 to PB12, KEY2 to PB13, KEY3 to PB14
void Init_KEY(void) {
GPIO_SetMode(PB, (BIT12 | BIT13 | BIT14), GPIO_PMD_INPUT);
GPIO_ENABLE_PULL_UP(PB, (BIT12 | BIT13 | BIT14));
GPIO_EnableInt(PB, 12, GPIO_INT_FALLING);
GPIO_EnableInt(PB, 13, GPIO_INT_FALLING);
GPIO_EnableInt(PB, 14, GPIO_INT_FALLING);
NVIC_EnableIRQ(GPABC_IRQn);
GPIO_SET_DEBOUNCE_TIME(GPIO_DBCLKSRC_IRC10K, GPIO_DBCLKSEL_64);
GPIO_ENABLE_DEBOUNCE(PB, (BIT12 | BIT13 | BIT14)); }

37. GABC_IRQHandler volatile uint8_t KEY1_Flag = 0;
void GPABC_IRQHandler(void) {
if (PB->ISRC & BIT12) { // check if PB12 interrupt occurred
PB->ISRC |= BIT12; // clear PB12 interrupt status
KEY1_Flag=1; // set a flag for PB12(KEY1)
} else if (PB->ISRC & BIT13) { // check if PB13 interrupt occurred
PB->ISRC |= BIT13; // clear PB13 interrupt status
KEY2_Flag=1; // set a flag for PB13(KEY2)
} else if (PB->ISRC & BIT14) { // check if PB14 interrupt occurred
PB->ISRC |= BIT14; // clear PB14 interrupt status
KEY3_Flag=1; // set a flag for PB14(KEY3)
} else { // else it is unexpected interrupts
PB->ISRC = PB->ISRC; // clear all GPB pins }

38. smpl_GPIO_IRQ int32_t main() { SYS_Init(); Init_KEY();
printf("Testing KEY1/2/3 IRQ generation:\n");
while(1) {
if (KEY1_Flag) {
printf("KEY1/PB12 Interrupt!\n");
KEY1_Flag=0; }
if (KEY2_Flag) {
printf("KEY2/PB13 Interrupt!\n"); KEY2_Flag=0; }
if (KEY3_Flag) {
printf("KEY3/PB14 Interrupt!\n");
KEY3_Flag=0; } }

39. Stepping Motor Operation principle of stepper motor

40. Step Motor Driving Methods
Four phase Step Motor :
4 phases are A, /A, B, /B
Diving Method as left
Wave Drive: single phase full step
Full Step Drive : two phase full step
Half Stepping : one/two phase half step
Microstepping

41. 5V Step Motor 28YBJ-48
步進電機 28YBJ-48
ULN2003 驅動IC

42. smpl_GPIO_Stepmotor 5V Step Motor Driver IC : TI ULN2003A Connections
Motor A+ connected to INA of ULN2003A, controlled by NUC140 GPA3
Motor A- connected to INB of ULN2003A, controlled by NUC140 GPA2
Motor B+ connected to INC of ULN2003A, controlled by NUC140 GPA1
Motor B- connected to IND of ULN2003A, controlled by NUC140 GPA0
unsigned char CCW[8]={0x08,0x0c,0x04,0x06,0x02,0x03,0x01,0x09}; //counter-clockwise sequence
unsigned char CW[8] ={0x09,0x01,0x03,0x02,0x06,0x04,0x0c,0x08}; //clockwise sequence

43. Stepping Control Port Step InA 1 InB InC InD Port Step InA 1 InB InC
Clockwise : 0x09,0x01,0x03,0x02,0x06,0x04,0x0c,0x08
Counter clockwise : 0x08,0x0c,0x04,0x06,0x02,0x03,0x01,0x09
Port
Step
InA 1
InB
InC
InD
Port
Step
InA 1
InB
InC
InD

44. smpl_GPIO_Stepmotor

45. Project : LED Cube 3x3x3
Ex.Video :

46. LED Cube 3x3x3 schematic 1 1 1 2 2 2 3 3 3 PD0 PD1 PD2 PD3 PD4 PD5 PD6
PA0
PA1
PA2

47. Project : LED Cube 8x8x8
Ex. Video:

48. Project : Electronic Safe
Ex.Video : Samsung Door Lock

49. Electronic Safe : Functional Description
Project Objectives
To use Cortex-M0 learning board to control the electronic safe
To study/trace the PCB & circuit of Electronic Safe
To draw the flow chart & implement the firmware of MCU
Functional Description
Input six keycode by pressing 3x3 keypad
Buzz when each keycode pressed
Compared with passcode when six keycodes are entered
If passcode equal to entered keycode, buzz few times and output to (drive electronic magnet) open the door
SWInt button to change the passcode

50. print_LCD to clear code
Flow Chart
Start
Init_RGBLED
Init_Buzzer
InitLock
Init SWInt
Setup HCLK
i=0
OpenKeyPad
Initial LCD
Print 2 lines
while(1)
number=Scankey()
number!=0 Y N
i==4
print_LCD
RGBLED(BLUE)
Buzz(1)
print_LCD
RGBLED(GREEN)
Buzz(3)
OpenLock
Keycode ==
passcode Y N
RGBLED(RED)
Buzz(2)
CloseLock
print_LCD to clear code
i=0

51. Electronic Safe : Interface Circuit
Vcc
+6V (1.5V AA x4)
Gnd
Ground
GPB15
GPA11
2N2222

52. Electronic Safe : Interface Circuit
GPA12
+6V
GPA13
GPA14
GPA15
2N2222
Gnd

53. Important Notice !
This educational material are neither intended nor warranted for usage in systems or equipment, any malfunction or failure of which may cause loss of human life, bodily injury or severe property damage. Such applications are deemed, “Insecure Usage”.
Insecure usage includes, but is not limited to: equipment for surgical implementation, atomic energy control instruments, airplane or spaceship instruments, the control or operation of dynamic, brake or safety systems designed for vehicular use, traffic signal instruments, all types of safety devices, and other applications intended to support or sustain life.
All Insecure Usage shall be made at user’s own risk, and in the event that third parties lay claims to the author as a result of customer’s Insecure Usage, the user shall indemnify the damages and liabilities thus incurred by using this material.
Please note that all lecture and sample codes are subject to change without notice. All the trademarks of products and companies mentioned in this material belong to their respective owners.