Categories
บทความ

SSD1963 + SQI Flash Driver สำหรับ MPLAB Harmony

SSD1963 และ SQI Flash Driver สำหรับ MPLAB Harmony version 1.08

SSD1963 Driver ให้แตกไฟล์ไปไว้ที่โฟลเดอร์ v1_08\framework\driver\gfx\controller แล้วต้องไปเพิ่ม driver ใน harmony config เพิ่มเติม
SQI Flash driver สามารถเพิ่มเข้าไปในโปรเจคแล้วเรียกใช้งานได้เลย ทดสอบกับ SST26VF032B และ SST26VF064B

Download:
SSD1963 driver
SQI Flash driver

Categories
บทความ

เขียนโปรแกรม LED กระพริบด้วย MPLAB Harmony Framework

MPLAB Harmony Framework เป็น Framework หรือ Library สำหรับเขียนโปรแกรมบน Microcontroller 32-bit ของ Microchip รองรับ PIC32MZ, PIC32MX ตัว Framework มี Library ให้ใช้งานหลากหลาย อาทิเช่น USB, TCP/IP stack, Graphics, Wifi, Audio decoder เป็นต้น ข้อดีของ Harmony คือการรวม Library หลายๆตัวไว้ในโปรเจคเดียวกัน สามารถทำได้ง่ายดายและสะดวก หากใครเคยใช้ Microchip Library for Application หรือ MLA การรวม Library ต่างๆไว้ในโปรเจคเดียวกันทำได้ลำบากมาก ผู้ใช้ต้องเพิ่มไฟล์ที่ต้องใช้เข้าไปในโปรเจคเอง ต้องเขียนไฟล์ config สำหรับ Library แต่ละตัวเอง และการทำงานของแต่ละ Library ก็ต้องมีการรอการทำงานกัน ไม่ได้เขียนเป็น state machine แบบ Harmony ข้อดีอีกอย่างของ Harmony คือมี Help ที่ค่อนข้างละเอียดหากสงสัยหรือไม่เข้าใจอะไรสามารถค้นหาในไฟล์ Help ของ Harmony ได้ ผมเคยทดลองใช้งาน STM32CubeF4 ซึ่งการใช้งานก็จะคล้ายๆ Harmony แต่ STM32CubeF4 มี Help ที่ไม่ค่อยละเอียดเท่าไหร่ หากสงสัยในฟังก์ชั่นอะไรในไฟล์ Help ก็ยังมีให้อ่านไม่ค่อยละเอียดครับ

กล่าวถึงข้อดีของ MPLAB Harmony Framework ไปแล้ว ต่อไปขอกล่าวถึงข้อเสียของ Harmony ที่ผมเคยเจอ และถามหลายๆคนแล้วก็ถือว่าเป็นข้อเสียหลักของ Harmony เลยก็คือ การเขียนโปรแกรมแบบ State machine ซึ่งหากใครเคยเขียนโปรแกรมบน Microcontroller ของ Microchip มาแล้วทั้ง PIC16, PIC18, PIC24, PIC32 โดยใช้ภาษาซี หรือ Library แบบเดิม แล้วมาเขียนบน Harmony จะงงเอามากๆ ครั้งแรกที่ผมลองไล่ดูโปรแกรมตัวอย่างของ Harmony ผมไล่ไม่ถูกเลยจริงๆว่าจะเริ่มยังไง จะเขียนตรงไหน จะแก้ไขโปรแกรมตรงไหน ยิ่งถ้าใครไม่ถนัดเรื่อง Structure, Union, Pointer, Function pointer ยิ่งจะงงไปกันใหญ่ เพราะ Harmony ใช้การเขียนโปรแกรมแบบนี้เยอะมาก

วันนี้ผมเลยจะมาเขียนบทความเริ่มต้นการเขียนโปรแกรม LED กระพริบด้วย MPLAB Harmony Framework เอามาให้คนที่สนใจจะเขียนโปรแกรมด้วย Harmony ได้เรียนรู้และศึกษาครับ

มาเริ่มกันที่โปรแกรมที่ต้องดาวน์โหลดมาใช้ในการเขียนโปรแแกรมด้วย Harmony ก็จะมีโปรแกรม MPLAB X IDE, MPLAB XC32 เป็น C Compiler และ MPLAB Harmony Framework ในบทความนี้จะใช้ Harmony เวอร์ชั่น 2.02.00b ซึ่งเป็นเวอร์ชั่นเบต้า โปรแกรมทั้งหมดสามารถดาวน์โหลดได้ฟรีบนเว็บไซต์ของ Microchip ครับ

การติดตั้ง Plugin MPLAB Harmony Configurator
ในกรณีที่ใช้ Harmony เวอร์ชั่นเบต้า เราต้องติดตั้ง Plugin เองโดยเข้าไปที่เมนู Tools -> Plugins

แล้วเลือกที่ Tab Downloaded คลิกที่ปุ่ม Add Plugins… แล้ว Browse ไปหาไฟล์ D:\microchip\harmony\v2_02_00b\utilities\mhc\com-microchip-mplab-modules-mhc.nbm เสร็จแล้วก็คลิกที่ปุ่ม Open

หลังจากนั้นก็คลิกที่ปุ่ม Install

ต่อไปก็ให้คลิกที่ยอมรับ License agreement แล้วคลิกที่ปุ่ม Install แล้วก็รอจนกว่าการติดตั้งจะเสร็จ หลังจากนั้นก็ให้ Restart MPLAB X IDE เพื่อให้การติดตั้ง Plugin สมบูรณ์ก็เป็นอันว่าติดตั้งสำเร็จแล้วครับ

หลังจากที่ติดตั้ง Plugin MPLAB Harmony Configurator เสร็จแล้ว ก็มาเริ่มสร้างโปรเจคสำหรับเขียนโปรแกรมด้วย Harmony กัน โดยเริ่มจากเข้าไปเมนู File -> New Project…

แล้วเลือกที่ Microchip Embedded และ 32-bit MPLAB Harmony Project เสร็จแล้วให้คลิกที่ปุ่ม Next

ขั้นตอนต่อไปจะเป็นการตั้งค่าตำแหน่ง Directory ของ MPLAB Harmony Framework โดยคลิก Browse ไปหา Path ของ Harmony ที่ทำการติดตั้งไว้ แล้วก็ตั้งชื่อโปรเจค เลือก MCU ที่จะใช้แล้วคลิกที่ปุ่ม Finish

หลังจากที่คลิกปุ่ม Finish แล้ว โปรแกรม Harmony Configurator ก็จะแสดงขึ้นมา ในตัวอย่างนี้ยังไม่ใช้ BSP หรือ Board Support Package โดยเราจะตั้งค่าต่างๆเอง โดยเริ่มจากการตั้งค่า Clock ให้กับ MCU ให้ตั้งค่า POSC ให้ตรงกับ Hardware ที่ใช้ เลือก POSCMOD เป็น EC ตั้งค่า UPLLFSEL ให้ตรงกับความถี่ที่ใช้ เลือก PLLICLK เป็น POSC แล้วคลิกที่ปุ่ม Auto-Calculate หลังจากนั้นจะมีหน้าต่างให้ใส่ความถี่ของ MCU ก็ป้อนความถี่ที่ MCU สามารถทำงานได้คือ 200MHz แล้วคลิกที่ปุ่ม Apply หลังจากนั้นโปรแกรมจะทำการคำนวณค่าต่างๆของ PLL ให้เองครับ

ต่อไปก็คือเป็นการตั้งค่า Configuration bit ของ MCU โดยคลิกที่ Tab Options -> Device & Project Configuration เลือก PIC32MZ1024EFE100 Device configuration แล้วก็เข้าไปตั้งค่าต่างๆให้ตรงกับ Hardware ที่ใช้ เช่นหากต่อ ICD3 กับ PGEx2 ก็ให้ตั้งค่า ICE/ICD Comm Channel Select ให้เป็น ICS_PGx2

ต่อไปก็ไปตั้งค่า System timer เพื่อใช้งาน System delay โดยเข้าไปที่ Tab Options -> Harmony Framework Configuration -> System Service -> Timer แล้วทำเครื่องหมายที่ Use Timer System Service

ขั้นตอนต่อไปคือการตั้งค่า Port ของ MCU ให้คลิกที่ Tab Pin Settings บนบอร์ดที่ใช้งาน LED จะต่อกับขา RD11 ให้เข้าไปตั้งค่า RD11 ให้เป็น Output และ LAT = Low ดังรูปด้านล่าง

เมื่อตั้งค่าต่างๆเสร็จเรียบร้อยแล้ว ให้คลิกที่ปุ่ม Generate Code เพื่อให้ MHC สร้างไฟล์ Source code เข้าไปในโปรเจค

หลังจาก Generate code เสร็จแล้ว ในหน้าต่าง Project จะมีโฟล์เดอร์และไฟล์ต่างๆเพิ่มเข้า ไฟล์ที่เราต้องเขียนโปรแกรมเพิ่มเข้าไปจะอยู่ที่ไฟล์ app.c และ app.h โดยที่ Enum สำหรับกำหนด statement ของโปรแกรมและตัวแปล Global จะประกาศไว้ที่ไฟล์ app.h ส่วนไฟล์ app.c ก็จะเป็นไฟล์ที่ใช้เขียนโปรแกรมเพิ่มเติมครับ

มาเริ่มเขียนโปรแกรมไฟกระพริบโดยใช้ MPLAB Harmony Framework กันเลย โดยเริ่มจากการเปิดไฟล์ app.h ขึ้นมา แล้วเพิ่ม statement ของโปรแกรมเข้าไปดังนี้
โดย Statement ที่เพิ่มเข้ามาจะเป็น APP_STATE_TOGGLE_LED และ APP_STATE_WAIT_DELAY

typedef enum
{
	 /* Application's state machine's initial state. */
	 APP_STATE_INIT=0,
	 APP_STATE_TOGGLE_LED,
	 APP_STATE_WAIT_DELAY,

	 /* TODO: Define states used by the application state machine. */

} APP_STATES;

ในส่วนของ Structure สำหรับประกาศตัวแปลแบบ Global ให้เพิ่มตัวแปล SYS_TMR_HANDLE tmrHandle; เข้าไป

typedef struct
{
	/* The application's current state */
	APP_STATES state;
	SYS_TMR_HANDLE tmrHandle;
} APP_DATA;

หลังจากนั้นให้เปิดไฟล์ app.c ขึ้นมา แล้วแก้ไขและเพิ่ม Source code ในฟังก์ชั่น APP_Tasks() ดังนี้

void APP_Tasks ( void )
{

    /* Check the application's current state. */
    switch ( appData.state )
    {
        /* Application's initial state. */
        case APP_STATE_INIT:
        {
            appData.state = APP_STATE_TOGGLE_LED;
            break;
        }

        case APP_STATE_TOGGLE_LED:
        {
            SYS_PORTS_PinToggle(PORTS_ID_0, PORT_CHANNEL_D, PORTS_BIT_POS_11);
            appData.tmrHandle = SYS_TMR_DelayMS(500);
            appData.state = APP_STATE_WAIT_DELAY;
            break;
        }
        
        case APP_STATE_WAIT_DELAY:
        {
            if(SYS_TMR_DelayStatusGet(appData.tmrHandle) == true)
            {
                appData.state = APP_STATE_TOGGLE_LED;
            }
            break;
        }
        
        /* The default state should never be executed. */
        default:
        {
            /* TODO: Handle error in application's state machine. */
            break;
        }
    }
}

การทำงานของโปรแกรมที่ Harmony สร้างขึ้นมาจะเริ่มต้นที่ไฟล์ main.c โดยเริ่มที่ SYS_Initialize ( NULL ); ฟังก์ชั่นนี้จะเป็นการ Initialize ระบบต่างๆของ Harmony รวมถึงฟังก์ชั่น APP_Initialize(); ที่เราสามารถเขียนเพิ่มได้ว่าจะให้มีการ Initialize อะไรบ้าง หลังจาก Initialize เสร็จแล้ว MCU ก็จะเข้าไปทำงานในฟังก์ชั่น SYS_Tasks ( ); ในฟังก์ชั่นนี้ก็จะเรียกฟังก์ชั่น APP_Tasks(); ที่เราเขียนโปรแกรมเพิ่มเข้าไปอีกทีหนึ่ง

  • การทำงานของโปรแกรมในฟังก์ชั่น APP_Tasks(); จะเริ่มที่ State APP_STATE_INIT ใน state นี้ไม่ได้มีการเขียนโปรแกรมอะไรเพิ่มเข้าไป มีเพียวแค่เปลี่ยน state การทำงานไปเป็น APP_STATE_TOGGLE_LED
  • ในส่วนของ state APP_STATE_TOGGLE_LED จะสั่งให้ LED Toggle ด้วยฟังก์ชั่น SYS_PORTS_PinToggle(PORTS_ID_0, PORT_CHANNEL_D, PORTS_BIT_POS_11); Parameter ที่ส่งไปก็มี PORTS_ID_0 คือ ID ของพอร์ทบน MCU มีแค่ ID เดียวคือ 0, PORT_CHANNEL_D คือพอร์ท D, PORTS_BIT_POS_11 คือตำแหน่งบิทที่ 11 หรือ RD11 ที่ต่ออยู่กับ LED นั่นเอง ฟังก์ชั่นอื่นๆที่เกี่ยวของกับ I/O Port สามารถอ่านดูรายละเอียดเพิ่มเติมในไฟล์ Help ของ Harmony ครับ หลังจากที่สั่งให้ LED Toogle แล้ว ต่อไปก็คือการเริ่มต้นหน่วงเวลาโดยใช้ฟังก์ชั่น appData.tmrHandle = SYS_TMR_DelayMS(500); ตัวแปล appData.tmrHandle จะเป็นตัวเก็บ Handle จากฟังก์ชั่น SYS_TMR_DelayMS(500); เอาไว้ เพื่อตรวจสอบว่าการหน่วงเวลาครบแล้วหรือยัง เสร็จแล้ว MCU ก็จะเปลี่ยน state ไปเป็น APP_STATE_WAIT_DELAY
  • ที่ state APP_STATE_WAIT_DELAY MCU จะตรวจสอบว่าการหน่วงเวลาจาก state ก่อนหน้านี้ครบเวลาแล้วหรือยังโดยใช้ฟังก์ชั่น if(SYS_TMR_DelayStatusGet(appData.tmrHandle) == true) หากหน่วงเวลาจนครบแล้ว จะ Return ค่ากลับมาเป็น 1 แต่ถ้ายังไม่ครบเวลาก็จะส่งค่ากลับมาเป็น 0 หลังจากหน่วงเวลาครบแล้ว MCU ก็จะเปลี่ยน state เป็น APP_STATE_TOGGLE_LED เพื่อ Toggle LED อีกครั้ง การทำงานของโปรแกรมก็จะวนลูปอย่างนี้ไปตลอดเวลาครับ

จากตัวอย่างการเขียนโปรแกรมโดยใช้ State machine จะเห็นว่าเราไม่ต้องรอให้หน่วงเวลาจนครบเวลาแล้วค่อยไปทำงานอย่างอื่น การหน่วงเวลาเราสามารถตรวจสอบได้ว่าครบเวลาแล้วหรือยัง หากยังไม่ครบเราก็สามารถไปทำงานอื่นๆได้ โดยไม่ต้องเสียเวลาไปกับการหน่วงเวลาครับ

Categories
บทความ

การใช้งาน STM32CubeMX STM32CubeF4 ร่วมกับ SW4STM32

STM32CubeMX เป็นตัว generate code สำหรับสร้าง source code เพื่อใช้งานร่วมกับ Library STM32CubeF4 ซึ่งเป็น Library สำหรับช้วยให้เขียนโปรแกรมควบคุม MCU ได้ง่ายขึ้น ซึ่งจะคล้ายๆ MPLAB Harmony framework ของ Microchip

ในบทความนี้จะแสดงตัวอย่างการใช้งาน STM32CubeMX สร้าง code ขึ้นมาและนำไปใช้ร่วมกับ SW4STM32 หรือ System Workbench for STM32 ซึ่งเป็น Free IDE และ Compiler สำหรับ STM32 โดยตัว IDE จะสร้างมาจาก Eclipse ซึ่งจะคล้ายๆกับ MPLAB X ของ Microchip เวลาใช้งานก็ค่อนข้างสะดวกเพราะมี Auto complete ให้ เวลาเราเรียก structure ต่างๆ ส่วน Compiler ก็เป็น GCC สำหรับ STM32

ดาวน์โหลดไฟล์ต่างๆสำหรับติดตั้งบนคอมพิวเตอร์ (ต้องสมัครสมาชิกก่อนถึงจะดาวน์โหลดได้)
STM32CubeMX
STM32CubeF4
SW4STM32
JAVA Runtime Environment

หลังจากที่ดาวน์โหลดไฟล์ต่างๆที่ต้องใช้เสร็จแล้ว ก็ให้ติดตั้งไฟล์ทั้งหมดลงบนคอมพิวเตอร์ แล้วเปิดโปรแกรม STM32CubeMX ขึ้นมา คลิกที่ File->New Project เลือกเบอร์ Microcontroller ที่จะใช้ในโปรเจคแล้วคลิก OK

หลังจากนั้นให้ตั้งชื่อโปรเจค ตั้งค่าตำแหน่งโฟลเดอร์ของโปรเจคและตำแหน่งโฟลเดอร์ของ STM32CubeF4 ตัวอย่างดังรูป ให้ uncheck ตรงช่อง Generate Under Root ออกด้วย

ขั้นตอนต่อไปคือการเปิดใช้งาน RCC เพื่อเปิดใช้งาน Crystal oscillator โดยบอร์ดที่ใช้ในตัวอย่างจะใช้ Crystal 8MHz แล้วเลือก PF10 เป็น GPIO_Output

ต่อไปก็เป็นการตั้งค่า Clock ให้กับ MCU โดยเลือก Input frequency = 8MHz, PLL Source Mux = HSE, System Clock Mux = PLLCLK และตั้งค่า HCLK = 160MHz แล้วกด Enter

ต่อไปให้คลิกที่ Tab Configuration เลือก GPIO เพื่อตั้งค่า GPIO output level = high เป็นค่าเริ่มต้น

หลังจากตั้งค่าต่างๆแล้ว ให้คลิกที่เมนู Project -> Generate Code เพื่อทำการสร้าง Code เพื่อนำไปใช้ร่วมกับ SW4STM32 ต่อไป

หลังจาก Generate code แล้ว ให้เปิดโปรแกรม System Workbench for STM32 ขึ้นมา แล้วตั้งค่า Workspace ให้ตรงกับ Directory ที่เรา Generate code ออกมา

หลังจากตั้งค่า Workspace แล้ว ให้ Import project ที่สร้างจาก STM32CubeMX เข้ามาใน Workspace โดยคลิกที่เมนู File -> Import เลือก General -> Existing Project into Workspace

เลือก Root directory ให้ตรงกับ Directory ที่ใช้ STM32CubeMX สร้าง Code ขึ้นมา แล้วเลือก Project ชื่อ led_blink ตามรูป

เมื่อ Import project เข้ามาใน workspace แล้ว ให้ทดสอบ Debug ดูโดยการคลิกที่เมนู Run -> Debug แล้วโปรแกรมจะให้เราตั้งค่าบอร์ดสำหรับ Debug (หากยังไม่ได้กำหนด) ให้ตั้งค่า MCU และ Debugger ให้ตรงกับที่เราใช้งานแล้วกด OK

หากทำทุกอย่างถูกต้องแล้ว โปรแกรมก็จะ compile source code และเริ่ม Debug ให้กด Resume หรือ F8 เพื่อให้ MCU รันไปตามปกติ ทดสอบให้ LED กระพริบโดยเพิ่ม Code เข้าไปในฟังก์ชั่น main ดังนี้ แล้วลอง Debug ดูก็จะเห็น LED บนพอร์ท PF10 กระพริบ

/* Infinite loop */
/* USER CODE BEGIN WHILE */
while (1)
{
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */

    HAL_GPIO_TogglePin(GPIOF, GPIO_PIN_10);
    HAL_Delay(100);
}
/* USER CODE END 3 */

 

Categories
บทความ

การใช้งาน Windows 10 IoT Core บน Raspberry Pi 2

บอร์ด Raspberry Pi สามารถติดตั้ง OS ได้หลากหลาย ไม่ว่าจะเป็น linux, android รวมถึง OS ตัวล่าสุดที่ทาง Microsoft ได้พัฒนาให้รองรับกับบอร์ด Raspberry Pi ก็คือ Windows 10 IoT Core ซึ่งเป็น OS สำหรับงาน Embedded ที่เป็น Windows ในบทความนี้จะอธิบายขั้นตอนการติดตั้ง Windows 10 IoT Core บน Micro SD Card และติดตั้ง Visual studio 2015 Community Edition เพื่อพัฒนาโปรแกรมสำหรับบอร์ด Raspberry Pi โดย windows ที่ใช้สำหรับพัฒนาโปรแกรมต้องเป็น windows 10 และเปิดใช้งาน Developer mode ก่อนครับ

มาเริ่มกันที่การติดตั้ง Visual studio 2015 Community Edition กันก่อนนะครับ ให้ดาวน์โหลดไฟล์ติดตั้งที่ http://go.microsoft.com/fwlink/?LinkID=534599 หลังจากที่ดาวน์โหลดไฟล์สำหรับติดตั้งมาแล้ว ให้เริ่มการติดตั้งได้เลยครับ ในการติดตั้งให้เลือกแบบ custom แล้วทำเครื่องหมายที่ Universal Windows App Development Tools เพื่อให้ Visual studio รองรับการเขียนโปรแกรมสำหรับ Raspberry Pi ครับ
raspberry-pi-windows-10-iot-1
หลังจากติดตั้ง Visual studio เสร็จแล้วให้เปิดโปรแกรมขึ้นมา เพื่อที่จะติดตั้ง Windows IoT Core Project Template โดยคลิกที่เมนู Tools -> Extensions and Updates
raspberry-pi-windows-10-iot-2
ที่หน้าต่าง Extensions and Updates ให้เลือกที่ Online -> Visual Studio Gallery ในช่องค้นหาให้ใส่คำค้นหาว่า IoT แล้วเลือก Windows IoT Core Project Templates และติดตั้ง template ดังกล่าว
raspberry-pi-windows-10-iot-3
หลังจากที่ติดตั้ง Windows IoT Core Template แล้ว ขั้นตอนต่อไปคือการเปิดใช้งาน Developer Mode โดยให้คลิกที่ปุ่ม Windows -> Settings แล้วคลิกที่ Update and Security
raspberry-pi-windows-10-iot-5
เลือกที่ For developers แล้วเลือกที่ Developer mode
raspberry-pi-windows-10-iot-6
หลังจากติดตั้ง Visual studio และเปิดใช้งาน Developer mode เสร็จแล้ว ขั้นตอนต่อไปก็คือการติดตั้ง Windows 10 IoT Core ลงบน Micro SD Card เพื่อนำไป Boot บนบอร์ด Raspberry Pi โดยให้ดาวน์โหลดโปรแกรม Windows 10 IoT Core Tools มาติดตั้งก่อน ให้เลือกที่ไฟล์ Download RTM Release for Raspberry Pi 2 เมื่อติดตั้งเสร็จแล้วให้เปิดโปรแกรม WindowsIoTImageHelper ขึ้นมา ในช่อง Select the SD Card ให้เลือก SD Card ที่เราจะใช้ ในช่อง Select the Image (.ffu) ให้ browse ไปหาไฟล์ C:\Program Files (x86)\Microsoft IoT\FFU\RaspberryPi2\flash.ffu เสร็จแล้วคลิกที่ปุ่ม Flash แล้วรอจนกว่าจะเสร็จ SD card ที่ใช้ต้องมีขนาด 8GB Class 10 ขึ้นไป .นบทความนี้ใช้ SD card ขนาด 32GB class 10
raspberry-pi-windows-10-iot-4
หลังจากที่ติดตั้ง Windows 10 IoT Core ลงบน SD Card เสร็จแล้ว ให้นำ SD card ดังกล่าวไป Boot บนบอร์ด Raspberry Pi 2 เพื่อทดสอบว่าสามารถทำงานได้ตามปกติหรือไม่ ในการ boot ครั้งแรกจะใช้เวลานานสักหน่อย และหน้าจะจะค้างเป็นสีดำนานพอสมควร เราต้องรอจนกว่าจะ boot เสร็จครับ

Jpeg
Raspberry Pi 2 + Windows 10 IoT

เมื่อทดสอบการทำงานของ WIndows 10 IoT กับบอร์ด Raspberry Pi แล้ว ต่อไปก็ทดสอบรันโปรแกรมตัวอย่าง โดยโปรแกรมตัวอย่างสามารถดาวน์โหลดได้ที่ https://github.com/ms-iot/samples ขั้นตอนการรันโปรแกรมตัวอย่างเริ่มโดยเปิดโปรแกรม WindowsIoTCoreWatcher ขึ้นมา แล้วเสียบสาย LAN และจ่ายไฟเลี้ยงให้กับบอร์ด Raspberry Pi เพิ่มเริ่มการทำงานของ Windows 10 IoT หลังจาก Boot เสร็จที่หน้าต่างโปรแกรม Windows10IoTCoreWatcher จะแสดง IP address และชื่อของบอร์ดที่เชื่อมต่อในเครือข่าย เราจะใช้ชื่อของบอร์ดนี้ไปใช้ในการเชื่อมต่อระหว่าง Visual studio และ Raspberry Pi ต่อไปครับ
raspberry-pi-windows-10-iot-9
กลับไปที่หน้าต่างโปรแกรม Visual studio 2015 ให้เปิดโปรแกรมตัวอย่างขึ้นมา โดยคลิกที่เมนู File -> Open -> Project/Solution แล้ว browse ไปหาไฟล์ในโปรแกรมตัวอย่าง ในบทความนี้จะใช้โปรแกรมตัวอย่างชื่อ Blinky คือไฟล์ samples-develop\Blinky\Cpp\BlinkyCpp.sln
raspberry-pi-windows-10-iot-10
เมื่อเปิดโปรแกรมตัวอย่างขึ้นมาแล้วให้คลิกขวาที่ Project เลือก Properties ที่หน้าต่าง Properties เลือก Configuration Properties และ Debugging ด้านขวามือตรงช่อง Machine Name ให้ใส่ชื่อของบอร์ด Raspberry Pi ที่รัน Windows 10 ในตัวอย่างนี้คือ minwinpc และในช่อง Require Authentication ให้ใส่เป็น No เสร็จแล้วคลิก OK
raspberry-pi-windows-10-iot-12
ในช่อง Solution Configuration ให้เลือกเป็น Debug หรือ Release ก็ได้ ในช่อง Solution Platform ให้เลือกเป็น ARM แล้วเลือกเป็น Remote Machine เสร็จแล้วคลิกที่ปุ่ม Remote Machine สีเขียนดังรูปด้านล่าง หากไม่มีอะไรผิดพลาดโปรแกรมตัวอย่างก็จะส่งไปรันที่บอร์ด Raspberry Pi ถ้าต่อจอภาพกับ Raspberry Pi ที่หน้าจอก็จะแสดง LED กระพริบตามรูปครับ
raspberry-pi-windows-10-iot-15
raspberry-pi-windows-10-iot-13

Jpeg
WIndows 10 IoT Blinky

เพิ่มเติมเกี่ยวกับ Windows 10 IoT Core
Default user password สำหรับ Login เข้าไปยัง Windows 10 IoT บน Raspberry Pi คือ User = Administrator และ Password = p@ssw0rd เราสามารถเข้าไปแก้ไขรหัสผ่านได้ทาง SSH โดยใช้คำสั่ง net user Administrator [new password]
และการเข้าถึงบอร์ดสามารถเข้าได้สามทางคือ Web browser โดยพิมพ์ IP address ของบอร์ดและพอร์ทคือ 8080 ทาง SSH ผ่านโปรแกรม putty และผ่านทาง FIle sharing
raspberry-pi-windows-10-iot-16
raspberry-pi-windows-10-iot-17

Categories
บทความ

การใช้งาน UDP multicast สำหรับ ESP8266 ด้วย Arduino IDE

ก่อนอื่นต้องขออธิบายคำศัพท์ที่เกี่ยวข้องก่อนดังนี้ครับ UDP ย่อมาจาก User Datagram Protocol เป็นโปรโตคอลที่อยู่บน IP อีกทีหนึ่ง การรับส่งข้อมูลต่างๆจะขึ้นอยู่กับผู้ใช้งานว่าจะรับส่งอะไรบ้าง คล้ายๆกับการรับส่งข้อมูลผ่าน UART หรือ RS232 ไม่มีการตรวจสอบว่าข้อมูลที่ส่งไปนั้นถึงผู้รับหรือไม่ โดยผู้ใช้งานต้องเขียนโปรแกรมตรวจสอบความถูกต้องเอง ข้อดีของโปรโตคอล UDP คือใช้งานง่าย เขียนรับส่งข้อมูลโดยผู้ใช้เป็นคนกำหนดเอง
คำศัพท์ต่อไปก็คือ Unicast, Multicast, Broadcast Unicast คือการรับส่งข้อมูลระหว่าง IP ต่อ IP หรือเรียกว่าเครื่องต่อเครื่อง ส่วน Multicast เป็นการรับส่งข้อมูลเป็นกลุ่ม โดยจะกำหนดกลุ่มของ IP สำหรับ Multicast เอาไว้ ส่วน Broadcast เป็นการส่งข้อมูลไปยังทุกๆ IP ในเครือข่าย อุปกรณ์ที่เชื่อมต่อในเครือข่ายทั้งหมดจะได้รับข้อมูลที่ตัวส่ง ส่งออกมา

Jpeg
ESP8266 UDP Multicast

ในบทความนี้จะนำบอร์ด nodemcu 2 บอร์ด มาเขียนโปรแกรมเพื่อรอรับข้อมูลทาง UDP โดยจะรอรับข้อมูลบน IP address ที่เป็น IP สำหรับ Multicast คือ 239.0.0.57 แล้วส่ง IP address ของบอร์ดไปให้กับโปรแกรมบนคอมพิวเตอร์ โดยโปรแกรมบนคอมพิวเตอร์ที่ใช้สำหรับการรับส่งข้อมูลคือโปรแกรม Packet Sender มีทั้งแบบติดตั้งลงเครื่องและแบบ Portable ครับ

ด้านล่างเป็น Source code ที่ใช้เป็นตัวรับส่ง UDP Multicast เขียนบน Arduino IDE

// UDP multicast with ESP8266 by Jirawat Kongkaen
// www.micro.in.th
// 2015-09-22
// hardware use nodemcu v0.9

#include <ESP8266WiFi.h>
#include <WiFiUdp.h>

// เปลี่ยน SSID และ password ให้ตรงกับ Access point
char ssid[] = "**********";
char pass[] = "**********";

char packetBuffer[255];
char replyBuffer[255];

// พอร์ทและ IP address สำหรับ UDP multicast
unsigned int localPort = 5555;
byte ipMulti[] = { 239,0,0,57 };

WiFiUDP Udp;

void setup() {
  Serial.begin(115200);
  Serial.println();
  Serial.println();

  Serial.print("Connecting to ");
  Serial.println(ssid);
  WiFi.begin(ssid, pass);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");

  Serial.println("WiFi connected");
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());

  Serial.println("Starting UDP");
  Udp.beginMulticast(WiFi.localIP(), ipMulti, localPort);
  Serial.print("Local port: ");
  Serial.println(Udp.localPort());

  pinMode(BUILTIN_LED, OUTPUT);
}

void loop() {
  // ตรวจสอบว่ามี packet UDP เข้ามาหรือยัง
  int packetSize = Udp.parsePacket();
  if (packetSize)
  {
    Serial.print("Received packet of size ");
    Serial.println(packetSize);
    Serial.print("From ");
    IPAddress remoteIp = Udp.remoteIP();
    Serial.print(remoteIp);
    Serial.print(", port ");
    Serial.println(Udp.remotePort());

    // อ่านข้อมูลจาก packet UDP แล้วเก็บไว้ที่ buffer
    int len = Udp.read(packetBuffer, 255);
    if (len > 0) packetBuffer[len] = 0;
    Serial.println("Contents:");
    Serial.println(packetBuffer);

    if(packetBuffer[0] == 'i' && packetBuffer[1] == 'p' && packetBuffer[2] == '?')
    {
      // ส่ง IP ของบอร์ด ESP8266 กลับไปยังคอมพิวเตอร์
      Udp.beginPacket(Udp.remoteIP(), Udp.remotePort());
      IPAddress ip = WiFi.localIP();
      sprintf(replyBuffer, "%d.%d.%d.%d\0", ip[0], ip[1], ip[2], ip[3]);
      Udp.write(replyBuffer);
      Udp.endPacket();
    }
  }
  
  blinkLed();
}

// LED กระพริบโดยไม่ใช้ delay
void blinkLed(void)
{
  static unsigned long previousMillis = 0;
  unsigned long currentMillis = millis();
  
  if(currentMillis - previousMillis >= 500)
  {
    previousMillis = currentMillis;
    if(digitalRead(BUILTIN_LED))
    {
      digitalWrite(BUILTIN_LED, LOW);
    }
    else
    {
      digitalWrite(BUILTIN_LED, HIGH);
    }
  }
}

รูปจาก Serial port monitor และโปรแกรม Packet Sender ที่ใช้สำหรับรับส่งข้อมูล UDP multicast
esp8266-udp-multicast-1
esp8266-udp-multicast-2 esp8266-udp-multicast-3