Category: Developer

งานพัฒนาระบบ, เขียนโปรแกรม

  • Uploading Files into Database with ASP.NET MVC

    การ    upload  file มีหลายรูปแบบ ไม่ว่าจะเป็นการ upload file  แบบ copy ไว้บน server หรือจะเป็นการบันทึกลงในฐานข้อมูลเลยโดยตรง วันนี้จะขอนำเสนอในส่วนของการ upload   file  และบันทึกลงฐานข้อมูล     โดยใช้ ASP.NET MVC  ดังนี้

     

    กำหนดไฟล์ที่ต้องการ upload ให้มีรูปแบบดังนี้

          public class UploadModel

    {

    [Required]

    public HttpPostedFileBase File { get; set; }

    }

     

    ในส่วนของ    View

     

    <form id=”uploader” enctype=”multipart/form-data” method=”POST”>

    <a type=”submit” href=”#” onclick=”uploadConfirm();” class=”btn btn-info”><span class=”glyphicon glyphicon-save”></span>&nbsp;Upload</a>

    </form>

    ในส่วนของ java script (สำหรับเรียก Controller)

      function uploadConfirm() {

    $.ajax({

    type: ‘POST’,

    contentType: ‘application/json; charset=utf-8’,

    url: ‘@Url.Action(“CheckDataBeforeUpload”, “NoteUpload”)’,

    data: “{ ‘periodID’:’” + $(‘#selectedlistPeriods’).val() +

    “‘ ,’financeID’:’” + $(‘#selectedlistFinance’).val() +

    “‘ }”,

    success: function (resultSave) {

     

    },

    error: function (data) {

    alert(data);

    }

    });

    }

     

    ในส่วนของ Controller

    public async Task<ActionResult> UploadFile(UploadModel model, FormCollection form)

    {

     

    string fileName = Path.GetFileName(model.File.FileName); //แสดงชื่อไฟล์

    string strFileName = Path.GetFileNameWithoutExtension(fileName); //แสดงชื่อไฟล์

    string contentType = model.File.ContentType;  //แสดงนามสกุลไฟล์

     

    string FileExtension = fileName.Substring(fileName.LastIndexOf(‘.’) + 1).ToLower();

    using (Stream fs = model.File.InputStream) //

    {

    using (BinaryReader br = new BinaryReader(fs))

    {

    byte[] bytes = br.ReadBytes((Int32)fs.Length);

     

    //TO DO:  Code ในส่วนที่ต้องการ insert ข้อมูลลง Database

    }

    }

     

    return RedirectToAction(“Index”);

    }

     

    จากตัวอย่างข้างต้น จะเป็นการ upload file ลงฐานข้อมูลโดยตรงในส่วนของรูปแบบการพัฒนาแบบ MVC ผู้เขียนหวังว่าอาจจะเป็นอีกทางเลือกหนึ่งของผู้พัฒนา ในการนำไปพัฒนาโปรแกรมต่อไปนะคะ ^_^

    แหล่งอ้างอิง

    https://stackoverflow.com/questions/15106190/uploading-files-into-database-with-asp-net-mvc

    https://stackoverflow.com/questions/21677038/mvc-upload-file-with-model-second-parameter-posted-file-is-null/21677156

  • การบริหารโครงการโดยใช้เครื่องมือ Team Foundation Server (Phase 2 : การบันทึกความต้องการ)

    อ้างอิงจากบทความก่อนหน้าในหัวข้อ “เริ่มต้นกับการบริหารโครงการโดยใช้เครื่องมือ Team Foundation Server (Phase 1 : Overview)” 

    จากบทความดังกล่าว ผู้เขียนตั้งใจเกริ่นนำเพื่อให้ผู้อ่านเข้าใจเกี่ยวกับเครื่องมือ TFS เพื่อนำมาเป็นผู้ช่วยผู้จัดการโครงการ ในการบริหารโครงการมาแล้ว สำหรับใน Phase2 นี้ ผู้เขียนจะขออธิบายขั้นตอนและรายละเอียดของการบันทึกความต้องการ หรือที่เรียกว่า Backlog Items โดยใช้เครื่องมือ TFS

    ในกระบวนการ Software Process : SDLC ในขั้นตอน Planning หรือการวางแผน ผู้จัดการโครงการจะสามารถวางแผนได้ ก็ต่อเมื่อทราบรายละเอียดของความต้องการทั้งหมดหรือเกือบทั้งหมดของโครงการ ในที่นี่ขอเรียกว่า Backlog items  ดังนั้น TFS จะเป็นเครื่องมือที่ช่วยเก็บบันทึก รวบรวม Backlog items ต่างๆ ที่เก็บรวบรวมมา และสามารถตรวจสอบสถานะของแต่ละ Backlog items ว่าอยู่ในสถานะใด เช่น ยังไม่ดำเนินการ กำลังดำเนินการ หรือดำเนินการแล้วเสร็จ เป็นต้น

    อยากรู้รายละเอียดกันแล้วใช่ไม๊ค่ะ…มาติดตามกันเลยค่ะ

    ขั้นตอน 1 : การสร้าง Project Name

    ก่อนการบันทึก Backlog items แต่ละระบบก็จะมีชื่อของระบบ หรือโครงการ กันก่อน ดังนั้นจะต้องทำการ Add Project Name หรือชื่อโครงการ เข้าไปใน TFS กันก่อน ซึ่งผู้จัดการโครงการ 1 คน อาจจะต้องดูแลและรับผิดชอบ มากกว่า 1 โครงการ หรือ 1 Project ได้ ในที่นี้ขอยกตัวอย่าง FMIS Accounting Report นะค่ะ เป็นโครงการในการพัฒนาระบบสารสนเทศเพื่อรายงานงบแสดงฐานะการเงิน งบรายได้-ค่าใช้จ่าย และหมายเหตุประกอบงบการเงิน

    ขั้นตอน 2 : การบันทึกความต้องการ 

    ในขั้นตอนนี้ผู้จัดการโครงการ และทีมพัฒนา จะทำการรวบรวมความต้องการ หรือ Backlog items ด้วยวิธีการต่างๆ ได้แก่ การประชุม การสอบถามจากผู้มีส่วนได้ส่วนเสียหรือผู้ปฏิบัติงาน การศึกษาจากเอกสาร ฯลฯ เพื่อให้ได้มาซึ่ง Backlog Item เป็นข้อๆ และนำมาบันทึกใน Project Name ตามขั้นตอนดังนี้

    2.1 เลือก Project Name ที่ต้องการ

    2.2 เลือก WORK เลือก Backlog items และเลือก Backlog ดังรูปด้านล่าง

    2.3 ทำการ Add Backlog item โดย ระบุ Type = Product Backlog Item และ Title คือ ชื่อของความต้องการ หลังจากนั้น กดปุ่ม Add แสดงขั้นตอนดังรูปด้านล่าง

    2.4 เมื่อ Add แล้ว Backlog หรือความต้องการก็จะถูกบันทึกลงใน TFS โดยมีสถานะเริ่มต้น เป็น “New” ดังรูป

    2.5 ขั้นตอนข้างต้น เป็นการบันทึก Title ของ Backlog item เท่านั้น หากต้องการบันทึกรายละเอียดให้ Double click ที่รายการของ Backlog item ที่ต้องการ หน้าจอจะแสดง รายละเอียดของ Backlog item ดังกล่าว เพื่อให้ระบุรายละเอียดสำคัญ ๆ ดังรูป

    จากรูปด้านบน แต่ละส่วน มีรายละเอียด ดังนี้

    หมายเลข 1 : หมายถึง ประเภทเป็น Backlog item โดยมี No. ที่ running จาก TFS = 5796 ซึ่งส่วนนี้ไม่สามารถแก้ไขได้

    หมายเลข 2 : หมายถึง Title ที่ได้เพิ่มในข้อ 2.4

    หมายเลข 3 : หมายถึง Title เช่นเดียวกับ ข้อ 2 แต่สามารถแก้ไขได้ ในกรณีที่ต้องการเปลี่ยน Title

    หมายเลข 4 : หมายถึง คำอธิบายความต้องการนั้นๆ หรือที่มาของความต้องการ

    หมายเลข 5 : หมายถึง สิ่งที่ต้องการ หรือผลลัพธ์ที่จะได้รับจากความต้องการนั้น

    หมายเลข 6 : กรณีที่มีการเปลี่ยนแปลงแก้ไขรายละเอียด ให้กดปุ่ม save หรือ Save and close เพื่อบันทึกรายละเอียดที่เปลี่ยนแปลง

    ขั้นตอน 3 : การพิจารณา และคัดเลือกความต้องการ

    จากขั้นตอนที่ 2 เราจะได้ Backlog items เกือบทั้งหมดของระบบ (ที่กล่าวว่าเกือบทั้งหมด เนื่องจาก Backlog บางข้อ หรือความต้องการบางข้อ อาจจะมีเพิ่มขึ้นได้ระหว่างโครงการ ซึ่งสามารถบันทึกเพิ่มเข้าไปใน Project ได้) ในการจะเริ่มวางแผน ผู้จัดการโครงการ และเจ้าของระบบที่ต้องการให้พัฒนาระบบ จะมาวิเคราะห์ หรือพิจารณาคัดเลือก Backlog โดยให้เกณฑ์ต่างๆ สำหรับ Backlog items ที่ผ่านขั้นตอนการพิจารณา/คัดเลือกแล้ว ผู้จัดการโครงการจะดำเนินการจัดการ Backlog item แต่ละข้อ โดย

    Backlog ที่ไม่ผ่านการพิจารณา หรือไม่ต้องดำเนินการ ด้วยเหตุผลใดๆ เช่น ด้วยนโยบายของมหาวิทยาลัยไม่ต้องดำเนินการ เป็นต้น จะทำการกำหนด

    1) State = Done

    2) เลือก History

    3) ระบุรายละเอียด หรือ ระบุเงื่อนไขที่ไม่ผ่านการพิจารณา

    4) กดปุ่ม Save หรือ Save and close เพื่อบันทึกรายละเอียด

    รายละเอียด ดังรูป

     

    Backlog ที่ผ่านการพิจารณาให้ดำเนินการ จะทำการกำหนด State = Approved ดังรูป

    ผู้จัดการโครงการสามารถดูภาพรวมของ Backlog items ทั้งหมดของ Project ในอีกมุมมอง ดังรูป

    1) New : Backlog item ที่ยังไม่ผ่านการพิจารณา หรือถูกคัดเลือกเพื่อจัดทำโครงการ

    2) Approved : Backlog item ที่ถูกเลือกให้พัฒนา แต่ยังไม่เข้ากระบวนการพัฒนา

    3) Commited : Backlog item ที่ถูกเลือกให้พัฒนา และอยู่ระหว่างการพัฒนา

    4) Done : Backlog item ที่ไม่ผ่านการพิจารณาให้พัฒนา หรือ Backlog item ที่ดำเนินการเสร็จเรียบร้อยแล้ว

     

    หมายเหตุ : สำหรับ Backlog items ที่ผ่านการคัดเลือกเพื่อให้พัฒนา จะเข้าสู่กระบวนการวางแผนต่อไป ซึ่งจะได้อธิบายรายละเอียดขั้นตอนการวางแผนโครงการใน Phase ถัดไปค่ะ (รอติดตามกันต่อนะค่ะ…อย่าเพิ่งเบื่อ…)

     

    บทสรุป : การนำ TFS มาใช้ในการบันทึกความต้องการ หรือ Backlog items มีประโยชน์ อย่างไร?

    จากประสบการณ์ที่ผู้เขียนนำ TFS มาใช้ในการบันทึกความต้องการนั้น สามารถสรุปประโยชน์ หรือข้อดี ที่เกี่ยวกับการบริหารโครงการในขั้นตอนของการรวบรวมความต้องการ สามารถแยกเป็นข้อๆ ได้ดังนี้

    1. เป็นเครื่องมือบันทึก และเก็บรวบรวมความต้องการ ทำให้ทราบว่ามีความต้องการจำนวนกี่รายการ
    2. สามารถตรวจสอบสถานะของความต้องการ หรือ Backlog items ที่
      • ยังไม่ผ่านการพิจารณา/คัดเลือก
      • ผ่านการอนุมัติเพื่อให้ดำเนินการแต่ยังไม่ดำเนินการ กี่รายการ
      • ผ่านการอนุมัติ และอยู่ระหว่างการดำเนินการ กี่รายการ (จะกล่าวรายละเอียดใน Pase เกี่ยวกับการวางแผนต่อไป)
      • ดำเนินการแล้วเสร็จ กี่รายการ (จะกล่าวรายละเอียดใน Pase เกี่ยวกับการวางแผนต่อไป)
    3. ความต้องการที่รวบรวมมาไม่หาย หรือตกหล่นไประหว่างทาง หรือระหว่างการดำเนินโครงการ
    4. สามารถนำข้อมูลมาเพื่อจัดทำเป็น Requirement Check list ได้ต่อไปในอนาคต

     

    สุดท้าย ผู้เขียนหวังว่าบทความนี้จะเป็นประโยชน์ หรือเป็นทางเลือกให้กับผู้บริหารโครงการ หรือผู้พัฒนาระบบในการเลือกใช้เครื่องมือในการบริหารโครงการในส่วนการบันทึกข้อมูลความต้องการ หลังจากนี้ผู้เขียนจะทยอยแนะนำเครื่องมือ TFS ในการบริหารโครงการในขั้นตอนต่อๆ ไป ฝากติดตามด้วยนะค่ะ…ขอบคุณค่ะ

  • เริ่มต้นกับการบริหารโครงการโดยใช้เครื่องมือ Team Foundation Server (Phase 1 : Overview)

    บทความนี้เป็นลักษณะของการเล่าประสบการณ์ของการนำเครื่องมือ MS Team Foundation มาใช้เพื่อการบริหารโครงการ เพื่อให้ผู้อ่านหรือผู้สนใจได้เห็นภาพคร่าว ๆ หรือหากเป็นประโยชน์ก็สามารถนำไปใช้งานการทำงานได้จริง ^___^

    Team Foundation Server หรือ TFS เป็นเครื่องมือช่วยในกระบวนการของการพัฒนาระบบ ผลิตโดยบริษัทไมโครซอฟท์ ซึ่งประกอบด้วยเครื่องมือต่างๆ ที่ช่วยในการพัฒนาระบบในหลายๆ ส่วน ตั้งแต่ส่วนการบริหารโครงการ ส่วนการพัฒนาระบบ เป็นต้น แต่ในครั้งนี้จะกล่าวถึงการนำ TFS มาช่วยผู้จัดการโครงการในการบริหารโครงการ ตั้งแต่ขั้นตอนการมอบหมายงาน ตลอดจนการติดตามงาน ซึ่งผู้เขียนขอแบ่งออกเป็น Phase ย่อย ๆ เพื่อไม่ให้ผู้อ่านเบื่อกันไปซะก่อนนะค่ะ โดย Phase 1 นี้จะขอเกริ่นนำเพื่อให้ผู้อ่าน เห็นภาพรวมกันก่อน และใน Phase ถัดๆ ไปจะแนะนำขั้นตอนการใช้งานนะค่ะ

    เบื้องต้นให้ผู้อ่านคิดถึงกระบวนการการพัฒนาระบบสารสนเทศทั่วไป จะมีขั้นตอนต่างๆ ตามกระบวนการ SDLC ซึ่งจะมีขั้นตอนหลักๆ คือ

    Software Process : SDLC

    • Planning
    • Requirement Analysis
    • Designing the product architecture
    • Building or Developing the Product
    • Testing the Product
    • Deployment and Maintenance

    ในมุมองของผู้จัดการโครงการ ในการบริหารโครงการ TFS ก็สามารถนำมาเป็นเครื่องมือช่วยงานได้ตั้งแต่ขั้นตอนการเก็บความต้องการจากลูกค้า (Requirements) และนำมารวบรวมไว้ใน TFS หลังจากนั้นจะนำ Requirements ที่ได้เข้าสู่กระบวนการวางแผนต่อไป

    เริ่มต้นมาทำความเข้าใจคำที่ใช้ใน TFS กันก่อนนะค่ะ ซึ่งจะเทียบให้เห็นกับคำทั่วๆ ที่ใช้กันในการพัฒนาระบบ นะค่ะ

    • Backlog items หมายถึง ความต้องการ หรือ Requirements
    • Sprint หมายถึง รอบระยะของโครงการย่อย หรือ รอบระยะเวลาของการพัฒนาระบบซึ่งแบ่งย่อยเป็นรอบๆ
    • Task หมายถึง งานย่อยๆ ที่จะมอบหมายให้สมาชิกดำเนินการ

    อ่านครั้งแรก อาจจะยังไม่เข้าใจ ขออธิบายรายละเอียดเพิ่มเติมนะค่ะ กล่าวคือ

    1. ในขั้นตอนของการวางแผน หรือ Planning สำหรับการพัฒนาระบบสารสนเทศจะเริ่มต้นด้วยการเข้าไปเก็บ รวบรวมความต้องการ หรือ Requirements จากลูกค้า ซึ่ง Requirements นี้ใน TFS จะเรียกว่า Backlog item โดยผู้จัดการโครงการจะนำ Backlog ที่ได้จากการรวบรวม มาเก็บไว้ใน TFS เพื่อเข้าสู่กระบวนการคัดกรอง Backlog items อีกครั้ง
    2. การคัดกรอง Backlog items คือ การพิจารณา Backlog item ว่าจะให้ดำเนินการ หรือไม่ดำเนินการ ด้วยเหตุผลใด
    3. หลังจาก Backlog items ผ่านขั้นตอนการคัดกรอง ก็จะมี Backlog items ที่พิจารณาให้ดำเนินการ ผู้จัดการโครงการก็จะต้องนำ Backlog Items มาวางแผน โดยพิจารณาตามระยะเวลา ในกรณีที่มี Backlog items จำนวนมาก นั่นก็หมายถึงระบบก็จะมีขนาดใหญ่ไปด้วยเช่นกัน จำเป็นจะต้องมีการแบ่งโครงการเป็นโครงการย่อยๆ เพื่อป้องกันความเสี่ยงของการพัฒนาระบบไม่เสร็จตามแผนที่วางไว้ การแบ่งโครงการออกเป็นโครงการย่อยๆ ใน TFS เรียกว่า Sprint ใน Sprint จะต้องระบุวันที่เริ่มต้น และ วันที่สิ้นสุด ซึ่งก็คือระยะเวลาของโครงการนั่นเอง
    4. จากนั้นผู้จัดการโครงการจะต้องพิจารณาร่วมกับลูกค้าเพื่อเลือก Backlog items ที่จะทำให้แล้วเสร็จใน Sprint นั้นๆ ในการคัดเลือก ก็จะนำปัจจัยหลาย ๆ ปัจจัย มาพิจารณา ซึ่งได้แก่ Backlog item ที่เป็นฟังก์ชันหลัก หรือมีความสำคัญจำเป็นต้องทำก่อน ความเร่งด่วนของการใช้งาน เป็นตน ผลจากการคัดกรอง หรือคัดเลือก ผู้จัดการโครงการก็จะทราบว่าในแต่ละ Sprint มี Backlog items อะไรบ้างที่จะต้องดำเนินการ ซึ่งจะเข้าสู่กระบวนการวางแผนและมอบหมายงานต่อไป
    5. โดยในแต่ละ Backlog item ของแต่ละ Sprint นั้น ผู้จัดการโครงการ จะต้องดำเนินการกำหนด งานย่อยๆ ซึ่งเป็นงาน ตามขั้นตอน หรือกระบวนการที่จะทำให้ Backlog item อันนั้นสำเร็จนั่นเอง โดยงานย่อยดังกล่าวเรียกว่า Task ซึ่งผู้จัดการโครงการเอง จะทำการบันทึกงานย่อยๆ ดังกล่าวลงใน TFS เพื่อเข้าสู่ขั้นตอนการมอบหมาย Task ต่อไป

    ตัวอย่าง รูปภาพ เพื่อความชัดเจนมากยิ่งขึ้นนะค่ะ

     

    ในครั้งต่อไป จะมาอธิบายวิธีการใช้เครื่องมือ TFS เพื่อทำการบันทึกข้อมูล Backlog items และอธิบายขั้นตอนการคัดกรอง Backlog items กันนะค่ะ อย่าลืมติดตามอ่านกันต่อนะค่ะ

     

    ข้อมูลอ้างอิง

    Team Foundation Overview : https://msdn.microsoft.com/en-us/library/ms242904(VS.80).aspx

    Software Process

  • Raspberry Pi 3 [Automated Relay Controller]

    ตอนที่แล้วเราได้ทดลองทำการสั่งงานรีเลย์แบบ Manual ผ่านหน้าเว็บไปแล้ว

    ครั้งนี้เราลองสั่งให้รีเลย์ทำงานโดยผ่านการประมวลผลค่าที่ได้จากเซนเซอร์ เพื่อให้ก้าวไปอีกขั้นของ IoT

     

    โดยเราจะใช้เซนเซอร์ที่เคยได้นำเสนอไปก่อนหน้านี้แล้ว นั่นคือ DHT22 Temperature & Humidity Sensor (ต่อที่ PIN: 32 [GPIO 12])
    และรีเลย์ 4 Channel ซึ่งสามารถนำไปต่อกับอุปกรณ์เครื่องใช้ไฟฟ้าได้ ต่อ PIN เดิมจากตอนที่แล้ว

     

    ความต้องการเบื้องต้นคือ
    1. เมื่ออุณหภูมิต่ำกว่าหรือเท่ากับ 28 องศา ให้เปิดพัดลมระบายอากาศ 1 (ที่ต่ออยู่กับ Relay 1)
    2. เมื่ออุณหภูมิสูงกว่า 28 องศา ให้ปิดพัดลมระบายอากาศ 1 และเปิดพัดลมระบายอากาศ 2 (ต่ออยู่กับ Relay 2)
    3. เมื่อความชื้นต่ำกว่า 50% ให้เปิดเครื่องสร้างความชื้น (Humidifier) (ต่ออยู่กับ Relay 3)  โดยไม่ต้องสนใจอุณหภูมิ

    เริ่มเขียนโค้ดเพื่อทำการประมวลผลกันเลย (โค้ดบางส่วน ได้อธิบายไว้ในตัวอย่างบทความก่อนหน้านี้แล้ว)

     

    ทำการติดตั้ง Library Adafruit จากบทความก่อนหน้านี้ Raspberry Pi 3 [Temperature & Humidity Sensor]

    จากนั้นทำการเขียน python ด้วยคำสั่ง

    sudo nano automated_relay.py

    ด้วยโค้ดต่อไปนี้

     

    import os
    import time
    import datetime

    while True :
     temperature = os.popen(‘sudo /home/pi/sources/Adafruit_Python_DHT/examples/AdafruitDHT.py 2302 12 | cut -c 6-7’).read()
     humidity = os.popen(‘sudo /home/pi/sources/Adafruit_Python_DHT/examples/AdafruitDHT.py 2302 12 | cut -c 22-23’).read()
     now = datetime.datetime.now()

     print ”
     print ”
     print now.strftime(“%d-%m-%Y %H:%M:%S”)
     print ‘Temperature: ‘ + temperature + ‘Humidity: ‘ + humidity

     if int(temperature) <= 28:
      os.popen(‘sudo python /var/www/html/relay_off.py 2’).read()
      os.popen(‘sudo python /var/www/html/relay_on.py 1’).read()
      print ‘Temperature below 28C ==> Relay 1: ON. Relay 2: OFF’
     else:
      os.popen(‘sudo python /var/www/html/relay_off.py 1’).read()
      os.popen(‘sudo python /var/www/html/relay_on.py 2’).read()
      print ‘Temperature above 28C ==> Relay 1: OFF. Relay 2: ON’

     if int(humidity) < 50:
      os.popen(‘sudo python /var/www/html/relay_on.py 3’).read()
      print ‘Humidity below 50% ==> Relay 3: ON’
     else:
      os.popen(‘sudo python /var/www/html/relay_off.py 3’).read()
      print ‘Humidity above 50% ==> Relay 3: OFF’

     time.sleep(5)

     

     

    จากนั้นเซฟและทดลองรันด้วยคำสั่ง python automated_relay.py

    พบว่ารีเลย์ทำงานได้ตามต้องการและได้ผลดังรูปนี้

    จากรูปด้านบน เมื่ออุณหภูมิอยู่ที่ 24 องศา ความชื้น 48% จะทำการ ON Relay 1 และ OFF Relay 2 และ ON Relay 3
    จากนั้นทำการรอไป 5 วินาที จากนั้นจึงอ่านค่าใหม่ วนแบบนี้เรื่อยๆ
    และเมื่อความชื้นสูงกว่า 50% ก็จะทำการ OFF Relay 3 ขึ้นมา โดยไม่ได้สนใจอุณหภูมิ
    จากนั้นเมื่ออุณหภูมิสูงกว่า 28 องศา ก็จะทำการ OFF Relay 1 และ ON Relay 2 ตามโปรแกรมที่เราเขียนเอาไว้

     

    โปรแกรมด้านบนนี้ เป็นโปรแกรมอย่างง่าย ซึ่งอาจจะมีข้อบกพร่อง (bug) อยู่หลายประการ เช่นการ initial state ของ relay ตอนเริ่มต้น, การแสดงผลบนหน้าจอ เป็นต้น
    โดยท่านที่สนใจ สามารถนำไปปรับปรุงต่อได้ด้วยตัวเองครับ ผมต้องการเพียงเพื่อจะชี้ให้เห็นถึง concept การทำงานเท่านั้น

     

    การนำไปประยุกต์ใช้ ขึ้นอยู่กับความต้องการเป็นหลัก ซึ่งมีเซนเซอร์ให้เลือกใช้มากมาย เช่น

    • หากเราต้องการให้เปิดไฟเมื่อมีคนเดินผ่าน เราสามารถใช้ Passive Infrared Sensor (PIR) มาจับความเคลื่อนไหวและความร้อนของวัตถุ (จากรังสี Infrared ที่ปล่อยออกมา) และนำไป Trig Relay ได้ทันที
    • ระบบรดน้ำอัตโนมัติ เมื่ออุณหภูมิหรือความชื้นหรือเวลา ตรงกับเงื่อนไขที่เราตั้งไว้ ให้ Trig Relay ที่ต่อกับ Solinoid Valve (วาล์วน้ำไฟฟ้า ที่จะเปิดเมื่อมีไฟไหลผ่าน) เพื่อรดน้ำต้นไม้
    • ระบบระบายความร้อน หรือ HVAC ที่จะทำงานตามเงื่อนไขอุณหภูมิและความชื้น โดยสามารถโปรแกรมให้มีการเปรียบเทียบอุณหภูมิจากภายในและภายนอก ให้พัดลมระบายอากาศทำงานตามที่กำหนด
    • ฯลฯ

     

    จากบทความเรื่อง Raspberry PI ทั้งหมดที่เขียนมา จะเห็นว่าเป็นเรื่องเกี่ยวกับการเล่นกับอุปกรณ์ Input/output เท่านั้น ซึ่งแท้จริงๆแล้ว Raspberry PI นั้นมีความสามารถมากกว่านี้อีกเยอะ ซึ่งหากว่าท่านต้องการทำแค่ระบบ Automation หรือ IoT ในบ้านง่ายๆ ยังมี Solution อื่น ที่ประหยัดงบประมาณมากกว่านี้คือการเลือกใช้ Arduino Board ซึ่งจะเป็นการทำงานแบบ Microcontroller เข้ามาทำงานในส่วนประมวลผลง่ายๆ ไม่ซับซ้อน ที่สำคัญหรือราคาถูกกว่าครึ่ง (เฉพาะบอร์ด)

     

    ผิดพลาดประการใด ขออภัยมา ณ โอกาสนี้ครับ

    ขอบคุณครับ

     

     

     

     

     

     

  • Raspberry Pi 3 [Relay Control via Web Interface]

    ตอนนี้เราจะมาสร้างหน้าเว็บสำหรับดูสถานะและควบคุมรีเลย์อย่างง่ายๆ

     

    ก่อนอื่น ผมได้ทำการเปลี่ยน PIN ของ GPIO บน Raspberry Pi 3 เพื่อให้เป็นระเบียบมากขึ้นจากครั้งที่แล้ว
    โดยผมได้เลือกใช้ PIN: 12 (GPIO 18), PIN: 16 (GPIO 23), PIN: 18 (GPIO 24) และ PIN: 22 (GPIO 25) สำหรับสั่งงานรีเลย์ตัวที่ 1-4 ตามลำดับ ดังรูปด้านล่างนี้

     

    หลังจากการทดสอบการทำงานของรีเลย์ทุกตัว (ในบทความที่แล้ว) จากนั้นเราจึงเริ่มขึ้นตอนการติดตั้ง Apache Web Server, PHP และเขียนหน้าเว็บ ดังขั้นตอนต่อไปนี้ครับ

     

    ติดตั้ง Apache Web Server และ PHP ดังนี้

    ใช้คำสั่ง sudo apt-get install apache2 เพื่อติดต้ัง apache web server

    (หากขึ้นว่า Package apache2 is not available ให้ใช้คำสั่ง sudo nano /etc/apt/sources.list  จากนั้น uncomment บันทัดสุดท้าย เซฟไฟล์และใช้คำสั่ง sudo apt-get update เมื่อเรียบร้อยแล้วให้ลองใช้คำสั่งด้านบนอีกครั้ง)

    จากนั้นทดสอบเปิดเว็บด้วย

    http://localhost/ หรือ http://{RASPBERRY_IP}/

     

    จากนั้นติดตั้ง PHP5 Module สำหรับ Apache

    sudo apt-get install php libapache2-mod-php

     

    เมื่อเรียบร้อยแล้ว ให้ใช้คำสั่งต่อไปนี้

    cd /var/www/html

    เนื่องจากไฟล์ index.html จะมีเจ้าของเป็น root ทำให้ไม่สามารถแก้ไขหรือลบได้ ให้ใช้คำสั่งเปลี่ยน owner ดังนี้

    sudo chown pi: index.html

    จากนั้นทำการลบไฟล์ index.html เพราะเราไม่ใช้

    ใช้คำสั่ง sudo nano index.php เพื่อสร้างไฟล์และเขียนโค้ดต่อไปนี้ เพื่อทดสอบการทำงานของ php

    <?php phpinfo(); ?>

    และลองเปิดหน้าเว็บดู จะพบกับหน้านี้ ถือว่าติดตั้งเสร็จเรียบร้อยแล้ว

     

    จากนั้นเพิ่ม user ของ apache นั่นคือ www-data ให้สามารถใช้คำสั่ง sudo ได้ ด้วยวิธีการต่อไปนี้

    sudo nano /etc/sudoers

    จากนั้นเพิ่มบันทัดต่อไปนี้ลงไปท้ายสุด

    www-data ALL=(ALL) NOPASSWD: ALL

    และเพื่อความสะดวก ทุกท่านสามารถดาวน์โหลดไฟล์ที่ผมได้ทำเอาไว้แล้ว ==> relay_control_via_web.zip
    (สามารถแก้ไขรูปแบบการแสดงผลให้สวยงามขึ้นได้ในภายหลังได้ด้วยตัวท่านเอง) และทำการ copy file ไปไว้ที่ /var/www/html

     

    โดยหลักการทำงานคือ

    เมื่อมีการเปิดหน้าเว็บขึ้นมา จะเรียกไฟล์ index.html และจะทำการ post ajax firstcheck.php เพื่อทำการตรวจสอบสถานะของรีเลย์ (ซึ่งภายใน firstcheck.php จะเป็นการเรียกคำสั่ง python firstcheck.py และส่งค่ากลับเป็น json)

    เมื่อมีการสั่งงานรีเลย์ จะทำการ post ajax changestate.php โดยที่ไปเรียกคำสั่ง relay_off หรือ relay_on (มี parameter คือชุดของรีเลย์ ที่ได้ทำการเซฟค่า BCM GPIO ID เอาไว้ในไฟล์ .py ดังกล่าวแล้ว) เพื่อเป็นการสั่งให้รีเลย์ดังกล่าว ทำงาน

    (เพื่อความปลอดภัย ในกรณีที่ท่านต้องการแยกไฟล์ .py ออกจาก web root directory /var/www/html ท่านสามารถทำได้ โดยท่านจะต้องทำการแก้ไขไฟล์ .php ให้เรียก path ที่ถูกต้อง – และตรวจสอบ permission execute ของไฟล์สำหรับ user: www-data ด้วย)

     

    ทดสอบลองเปิดหน้าเว็บ
    (เว็บถูกพัฒนาขึ้นด้วย bootstrap ดังนั้น จะสามารถใช้งานผ่านหน้าจอมือถือได้ทันที เพียงเรียก http://RASPBERRY_IP/)

             
    ทดสอบการแสดงผลและการสั่งงานบน Google Chrome ทั้งบน iOS และ PC

     

    สำหรับตอนหน้า จะเป็นการสั่งงานรีเลย์ด้วยระบบอัตโนมัติตามค่าที่ได้จากเซนเซอร์ภายนอก ซึ่งจะเป็นการประยุกต์ใช้ทั้งส่วนการ Input จากเซนเซอร์และ Output ไปยังรีเลย์
    เช่น เมื่ออุณหภูมิถึง 30 องศา ให้เปิดพัดลมระบายอากาศ เป็นต้น

     

    ผิดพลาดประการใด ขออภัยมา ณ โอกาสนี้ครับ

    ขอบคุณครับ

  • Raspberry Pi 3 [Relay Control]

    จากตอนที่แล้ว เราได้ลองต่อเซนเซอร์ภายนอก ซึ่งเซนเซอร์จะเป็นประเภท Input เพื่อนำข้อมูลไปประมวลผลต่อตามที่เราต้องการ

    ยังมีอุปกรณ์บางตัวที่เราสามารถต่อเป็น Output จาก Raspberry Pi ได้ด้วย

    ซึ่งหนึ่งในนั้นจะเป็นอุปกรณ์หลักที่นำมาเชื่อมต่อกับอุปกรณ์อื่นๆ ได้อย่างหลากหลาย นั่นคือ รีเลย์ (Relay) – (ไม่ใช่ Delay นะครับ กรุณาอย่าสับสน)

     

    Relay คืออะไร

    Relay ถ้าให้พูดจากความเข้าใจคือ สวิตซ์ ประเภทหนึ่งครับ ที่จะทำงานตามกระแสไฟ นั่นคือ เมื่อมีกระแสไฟไปเหนี่ยวนำภายใน สวิตซ์ก็จะทำงาน (Energize)
    (พูดให้เข้าใจอีกครั้งหนึ่งคือ เหมือนสวิตซ์ตามผนังนี่แหละครับ แต่แทนที่จะเอามือไปกด เราก็ใช้กระแสไฟเข้าไปให้มันทำงานแทนนั่นเอง)
    และในบางครั้ง ในระบบไฟฟ้ากำลัง อาจจะเรียกอุปกรณ์นี้ว่า Magnetic Contactor ซึ่งเป็นหลักการทำงานแบบเดียวกันครับ

    (ขออภัย หากรูปจะไม่ถูกต้องตามหลักการเป๊ะๆ เพราะวาดจากความเข้าใจ)

    จากในรูปด้านบนนี้
    DC+, DC- คือ ไฟที่เราจะจ่ายให้ขดลวดแม่เหล็ก (ตาม spec ของ relay) เพื่อจะไปทำให้สวิตซ์ Relay ทำงาน
    โดยที่ขา
    C = Common ขาที่ต้องการให้กระแสไฟมารออยู่ หรือ กระแสไหลกลับ
    NC = Normal Close เมื่อไม่มีไฟจ่ายที่ขดลวดแม่เหล็ก ขา C และ NC จะเชื่อมต่อถึงกันอยู่
    NO = Normal Open จะทำงานเมื่อมีไฟจ่ายมาที่ขดลวดแม่เหล็ก จะทำให้ขา C และ NO นั้น เชื่อมถึงกัน และทำให้ขา C ขาดการเชื่อมกับ NC

    วิธีการอ่านสเปครีเลย์ (ตัวสี่เหลี่ยมสีน้ำเงินในรูปด้านบน)
    – 5VDC คือไฟที่เราจ่ายเพื่อให้รีเลย์ทำงาน (Energize)
    – 10A 250VAC คือ หน้าคอนแทคทนกระแสได้ 10A ที่ 250V AC
    – 15A 125VAC คือ หน้าคอนแทคทนกระแสได้ 15A ที่ 125V AC

     

    รีเลย์ที่จะเอามาใช้กับ Raspberry Pi ควรจะเป็นรีเลย์ที่ทำงานด้วยไฟ 5V เพราะจะได้ต่อ +5V และ GND ออกจากบอร์ดของ Raspberry Pi ได้เลย ซึ่งรีเลย์ก็จะมีด้วยกันสองแบบคือ Active Low และ Active High นั่นคือ…

    – Active Low รีเลย์จะทำงานเมื่อมีการจ่าย Logic Low เข้ามา (จ่าย GND เข้ามา)
    – Active High รีเลย์จะทำงานเมื่อมีการจ่าย Logic High เข้ามา (จ่าย +5V เข้ามา)

    รีเลย์บางรุ่นรองรับทั้งสองแบบ แต่จะมี Jumper ให้เซ็ตว่าต้องการทำงานในแบบไหน

     

    ** ถ้าหากไม่รู้จริงๆ ก็ลองเขียนโปรแกรมตามด้านล่าง เพื่อทดสอบได้ครับ ไม่พัง จ่ายผิด รีเลย์ก็แค่ไม่ทำงานครับ **

    ** รุ่นที่ผมนำเอามาใช้งาน จะเป็น Active Low นั่นคือจ่าย GND หรือ Logic 0 (เลขศูนย์) เพื่อให้รีเลย์ทำงาน **

     

    การเชื่อมต่อนั้นไม่ยากครับ

    GND ต่อกับ GND ของ Raspberry Pi
    VCC ต่อกับ +5V ของ Raspberry Pi
    IN1…4 ต่อกับ GPIO ขาที่ว่างอยู่ โดยดูจาก Pinout ของ Raspberry Pi ครับ

    โดยผมเลือกที่จะเชื่อมต่อขาของ Raspberry Pi ดังนี้

    ขาที่ [2] เพื่อจ่าย +5V ให้กับรีเลย์
    ขาที่ [6] เพื่อจ่าย GND
    ขาที่ [29] GPIO 5 เพื่อควบคุม Relay 1
    ขาที่ [31] GPIO 6 เพื่อควบคุม Relay 2
    ขาที่ [33] GPIO 13 เพื่อควบคุม Relay 3
    ขาที่ [37] GPIO 26 เพื่อควบคุม Relay 4

    ** ไม่จำเป็นต้องต่อให้ครบ ต่อเท่าที่ใช้ก็ได้ **
    ** ในตลาด มีรีเลย์หลายรุ่นทั้งแบบ 1 ตัว, 4 ตัว, 8 ตัว, 16 ตัว ให้เลือกใช้ตามความต้องการได้เลยครับ **

     

    เมื่อเชื่อมต่อเรียบร้อยแล้ว ก็ Power ON ตัว Raspberry Pi ขึ้นมาเลยครับ จากนั้นลองเขียน Python สั่งงานดู ตามด้านล่างนี้เลยครับ

    เปิด Terminal จากนั้นใช้คำสั่ง

    mkdir projects/relay

    cd projects/relay

    sudo nano test_cycle.py

    เราจะมาลองเขียนให้ on relay 1 ถึง 4 จากนั้นตามด้วย off relay 1 ถึง 4 เพื่อเป็นการทดสอบ Logic ว่ารีเลย์ทำงาน ดังนี้ครับ

    import RPi.GPIO as GPIO
    import time

    GPIO.setmode(GPIO.BCM)
    GPIO.setwarnings(False)

    pins = [5, 6, 13, 26] #เป็น array
    GPIO.setup(pins, GPIO.OUT, initial = GPIO.HIGH)

    time.sleep(1)

    for pin in pins :
     GPIO.output(pin,  GPIO.HIGH)
     print(“PIN: ” + str(pin) + ” is 1 (GPIO.HIGH)”)
     time.sleep(5)
     GPIO.output(pin,  GPIO.LOW)
            print(“PIN: ” + str(pin) + ” is 0 (GPIO.LOW)”)
            time.sleep(5)

    GPIO.cleanup()
    print “Cleaned up relays”

    อธิบายโค้ดคร่าวๆ ดังนี้

    GPIO.setmode(GPIO.BCM) #มีสองแบบคือ GPIO.BCM ใช้ GPIO ID และ GPIO.BOARD ใช้ PIN NUMBER

    GPIO.setwarnings(False) #เพื่อไม่ให้ show warning ของ relay เช่น สถานะเก่าค้างอยู่ เป็นต้น

    pins = [5, 6, 13, 26] #เป็น array ตาม setmode

    GPIO.setup(pins, GPIO.OUT, initial = GPIO.HIGH) #เซ็ตอัพ pins ให้เป็นการทำงานแบบ output (เนื่องจาก gpio สามารถเป็นได้ทั้ง input และ output) และ relay ที่เรามาต่อเป็น Active LOW ซึ่งทำงานเมื่อจ่าย GPIO.LOW หรือ Logic 0 จึงเซ็ตค่าเริ่มต้นเป็น HIGH เอาไว้ไม่ให้ทำงานตอน setup (สามารถใช้ 1 แทน GPIO.HIGH ได้)

    GPIO.output(pin,  GPIO.LOW) #คือการสั่งจ่าย GPIO.LOW หรือ Logic 0 ให้กับ pin ที่เราต้องการ เพื่อให้ทำงาน (Energize)

     

    จากนั้นทดลองรัน ด้วยคำสั่ง python cycle.py

        

    ในระหว่างการทำงาน จะเห็นว่าเมื่อมีการจ่าย GPIO.HIGH หรือ Logic 1 ให้กับรีเลย์ จะไม่เกิดการเปลี่ยนแปลงใดๆ
    และเมื่อจ่าย GPIO.LOW หรือ Logic 0 ให้กับรีเลย์ จะได้ยินเสียงรีเลย์ทำงาน และเห็นว่าไฟสถานะ LED ติดขึ้น

     

    เมื่อรีเลย์ทำงานแล้ว เราสามารถนำ Terminal ของ Relay ไปควบคุมอุปกรณ์ไฟฟ้าได้ (ตามพิกัดกระแสไฟสูงสุดของรีเลย์)
    ** การทำงานอุปกรณ์ไฟฟ้า (ถึงแม้จะเป็นไฟ 220V แรงต่ำ) ควรใช้ความระมัดระวัง **
    ** ควรทำการตัดกระแสไฟก่อนทุกครั้ง เพื่อความปลอดภัยของตัวท่านเอง **

     

    วิธีการตรวจสอบช่องต่อของรีเลย์
    สามารถดูได้จากสัญลักษณ์ ทำให้เรารู้ว่าขาไหนคือ COM, NC หรือ NO (รีเลย์แต่ละตัวจะมี 3 ขา ส่วนใหญ่จะวาง pattern เหมือนกัน เพราะฉะนั้น หาขาแค่ตัวเดียวก็พอครับ)
    หรือจะใช้มัลติมิเตอร์วัด เพื่อความมั่นใจ โดยใช้วิธีการดังนี้

    เพื่อความเข้าใจที่ตรงกัน ผมขอให้ขาที่ [1] คือขาด้านบน (ของรีเลย์แต่ละตัว) ขาที่ [2] คือ ขาตรงกลาง และขาที่ [3] คือขาด้านล่าง ตามในรูปครับ

    1.ใช้โหมดวัดความต้านทาน ลองดูว่าถ้าความต้านทานเป็น 0 (ปลายของโพรบแตะกัน) จะแสดงผลอย่างไร และถ้าไม่แตะกันจะเป็นอย่างไร ถือว่าเป็นการทดสอบสายในตัว
    (ในรูปนี้เป็นเพียงตัวอย่างเท่านั้น การแสดงผลของมิเตอร์แต่ละยี่ห้อ แต่ละรุ่น แตกต่างกัน ควรศึกษาและทำความเข้าใจในมิเตอร์ของท่าน)

     

    2.ทดสอบเอาปลายโพรบแตะขาที่ [2] [3] พบว่ามีความต้านทานเป็น 0 นั่นหมายถึงว่า สองช่องนี้ติดต่อกันได้ นั่นคือขา [2] และ [3] ทำงานแบบ NC

     

    3.ทำการ Energize Relay ตัวที่เราวัดขึ้นมา เพื่อหาขา COM และ NO จากในรูปด้านบนนี้ เห็นว่าขาที่เราเคยวัด [2] และ [3] กลายเป็น Open ไปแล้ว (นั่นคือ ขาทั้งสองไม่แตะกัน – ในรูปที่มัลติมิเตอร์ จะมีมีตัว M (Mega) ขึ้นมา นั่นคือความต้านทานเป็นล้านโอห์ม ซึ่งไม่สามารถวัดได้)

     

    4.Energize Relay ทิ้งเอาไว้แบบนั้น เปลี่ยนขาวัดเป็นขา [1] และ [2] ปรากฎว่าความต้านทานเป็น 0 นั่นคือ สองช่องนี้ ไฟสามารถเดินผ่านไปได้

     

    จะเห็นว่าขาที่ใช้ร่วมกันเมื่อรีเลย์ทำงานและไม่ทำงานนั่นคือขาที่ [2] ทำให้ขาที่ [2] คือขา COM นั่นเอง และขา [1] ก็คือขา NO และขา [3] ก็คือ NC ครับ
    เมื่อเราได้ขามาแล้ว ก็ขึ้นอยู่กับการนำไปประยุกต์ใช้งาน ซึ่งส่วนใหญ่จะทำการต่อขาแบบ COM กับ NO ครับ

     

    โดยจะมีเฉพาะเส้น L (Line) เท่านั้น ที่จะผ่านสวิตซ์รีเลย์ ส่วนสาย N (Neutral) สามารถต่อเข้าโหลดได้เลย ซึ่งโหลดอาจจะเป็นหลอดไฟ พัดลม หรือเครื่องใช้ไฟฟ้าอื่นๆ ในพิกัดกระแสที่รีเลย์รับได้

     

    ผิดพลาดประการใด ขออภัยมา ณ ที่นี้ครับ

    ป.ล. การสั่งงานแบบผ่าน command line ก็ไม่สะดวกนัก สำหรับตอนหน้า จะเป็นการสั่งงาน relay ผ่านทาง web interface และรีโมทเข้ามาผ่านทาง port 80 ได้ด้วยครับ

     

  • Raspberry Pi 3 [Temperature & Humidity Data Chart]

    จากตอนที่แล้ว เราได้เขียนคำสั่งเพื่อที่จะดึงค่าจากเซนเซอร์แล้ว

    ครั้งนี้จะเป็นการใช้วิธีดังค่าดังกล่าว มาเก็บไว้เป็นไฟล์ csv จากนั้นนำไปแสดงเป็นกราฟ โดยแสดงผลผ่าน Web Interface

    ด้วยวิธีดังต่อไปนี้ครับ

     

    สร้างที่เก็บไฟล์ด้วยคำสั่งต่อไปนี้

    mkdir –p /home/pi/projects/temp–and–humidity
    mkdir –p /home/pi/projects/temp–and–humidity/sensor–values
    cd /home/pi/projects/temp–and–humidity

    (หากใครไม่ต้องการสร้าง directory เพื่อเก็บข้อมูลตามตัวอย่างนี้ ให้แก้ไฟล์ temp_hud_csv_log.py ด้วยครับ)

    จากนั้นดาวน์โหลดสคริปด้วยคำสั่งนี้

    wget https://sysadmin.psu.ac.th/wp-content/uploads/2018/03/temp_hud_csv_log.txt
    mv temp_hud_csv_log.txt temp_hud_csv_log.py

    (เนื่องจาก sysadmin นี้ไม่รองรับการอัพโหลดไฟล์ .py จึงต้องอัพโหลดเป็น .txt ไปก่อน แล้วค่อยเอามา rename เอาเอง)

     

    ตรวจสอบและติดตั้ง dependencies ด้วยคำสั่งนี้ sudo easy_install apscheduler และรอจนเสร็จ

          

     

    โดยค่า default สคริปนี้จะถูกเซ็ตให้เป็นเซนเซอร์ AM2302 และใช้ GPIO 4 ซึ่งถ้าหากเราใช้เซนเซอร์และขาคนละขากัน ให้เข้าไปแก้ไฟล์ temp_hud_csv_log.py

    จากนั้นเริ่มต้นการทำงานด้วยคำสั่ง sudo python temp_hud_csv_log.py

    รอซัก 2-3 นาที เราจะเห็นว่ามีไฟล์เกิดขึ้นใน sub folder ชื่อ sensor-values

     

    ต่อไปเราจะทำการอ่านค่าใน csv files ไปแสดงผลเป็นกราฟด้วย NVD3 charts for d3.js ใช้งานร่วมกับ node.js JavaScript ซึ่งรวมเว็บเซอร์เวอร์ node.js Express เอาไว้ในตัว (ซึ่ง node.js ได้ถูกติดตั้งเป็น official ใน raspberry pi image os file ซึ่งสามารถเช็คเวอร์ชั่นได้จากคำสั่ง node –version)

     

    ทำการดาวน์โหลด html file ใส่ไว้ในโฟลเดอร์ย่อย public ด้วยคำสั่งต่อไปนี้

    mkdir –p /home/pi/projects/temp–and–humidity/public
    cd /home/pi/projects/temp–and–humidity/public
    wget https://sysadmin.psu.ac.th/wp-content/uploads/2018/03/index.txt
    mv index.txt index.html

    ท่านสามารถแก้ไขไฟล์ index.html ได้ ไม่ว่าจะเป็น Title, DateTime Format, สีตัวอักษร, สีพื้นหลัง และอื่นๆ ได้เลย

     

    จากนั้นติดตั้ง node.js script ด้วยคำสั่งต่อไปนี้

    cd /home/pi/projects/temp–and–humidity
    wget https://sysadmin.psu.ac.th/wp-content/uploads/2018/03/nodejs_webserver_soapws.txt
    mv nodejs_webserver_soapws.txt nodejs_webserver_soapws.js

     

    และทำการติดตั้ง dependencies ของ node.js ด้วยคำสั่งต่อไปนี้

    npm install express
    npm install body–parser
    npm install csv–parse@1.1.0
    npm install glob

    ** ถ้ามีปัญหาในการเรียก npm เช่น command not found. ให้ติดตั้งด้วยคำสั่ง sudo apt-get install npm ได้เลย **
     ** เป็นการติดตั้งใน home folder ของตัวเอง เพราะงั้นไม่ต้องใช้ sudo นำหน้า npm ครับ **
    ** csv-parse ผมใช้เป็นเวอร์ชั่น 1.1.0 เนื่องจากเวอร์ชั่นใหม่ ลองคอมไพล์แล้วไม่ผ่าน **

     

    เมื่อเรียบร้อยแล้วลอง start web server service ด้วยคำสั่ง sudo node nodejs–webserver–with–soap–services.js

    และลองเปิดเว็บด้วย http://[ไอพีของ Raspberry Pi]:9999/


    ** รูปนี้ผมเปิดจาก gui บน raspberry pi เลย จึงใช้ 127.0.0.1 **

     

    จากนั้นทำการแก้ไขให้รันสคริปอัตโนมัติเมื่อ boot ขึ้นมา

    ติดตั้ง forever เพื่อให้รัน background ด้วยคำสั่ง sudo npm –g install forever

    จากนั้นแก้ไขไฟล์ /etc/rc.local ด้วยคำสั่ง sudo nano /etc/rc.local และเพิ่มบันทัดเหล่านี้ลงไป

    cd /home/pi/projects/temp–and–humidity

    /usr/bin/sudo /usr/bin/python temp_hud_csv_log.py & /usr/bin/sudo /usr/local/bin/forever start nodejs_webserver_soapws.js

     

    เรียบร้อยครับ นอกนั้นจะเป็นการแก้ไข gui ซึ่งสามารถแก้เป็น html syntax ที่ไฟล์ index.html ได้เลย

    ในตัวอย่างด้านล่างนี้ ลองทิ้งไว้ 2-3 วัน (รวมเสาร์/อาทิตย์) จากนั้นเปิดกราฟดู จะเห็นว่าเป็นกราฟเริ่มมีข้อมูลเยอะแล้ว

    (ในตัวอย่าง เริ่มเก็บ 9 มีนาคม 13.54 น. – 12 มีนาคม 12.56 น.)

     

    เมื่อเอาเมาส์ไปชี้ที่กราฟ จะปรากฎค่านั้นๆ ด้วย

     

    และเมื่อลองเลือกช่วงวันดู จะปรากฎเป็นดังนี้


    วันที่ 10 มีนาคม ความชื้นจะลดลงในช่วงกลางวัน ตั้งแต่ประมาณ 7.15 น. เป็นต้นไป
    ซึ่งสวนทางกับอุณหภูมิที่เพิ่มขึ้นจาก 27.9 องศา ไปสูงสุดที่ประมาณ 32 องศา

    วันที่ 12 มีนาคม (วันทำงาน) พบว่าอุณหภูมิและความชื้นลดลงอย่างรวดเร็วเมื่อเปิดแอร์ ที่เวลาประมาณ 8.45 น.
    จากนั้นจะสวิงตามรอบการทำงานของคอมเพรสเซอร์แอร์ (แอร์ธรรมดา มิใช่ inverter แต่อย่างใด) ระหว่าง 22.4 – 25 องศา

     

    ผิดพลาดประการใดขออภัยมา ณ โอกาสนี้ครับ ขอบคุณครับ

     

     

  • Raspberry Pi 3 [Temperature & Humidity Sensor]

    สวัสดีและขออภัยที่ห่างหายไป เนื่องจากติดภารกิจทั้งงานราษฏร์และงานหลวงครับ

     

    ครั้งนี้จะเป็นการเริ่มต่อเซนเซอร์ภายนอก เซนเซอร์พื้นฐานที่มีในปัจจุบันก็จะเป็นเซนเซอร์เกี่ยวกับสภาพแวดล้อม ไม่ว่าจะเป็น เซนเซอร์อุณหภูมิ, เซนเซอร์ความชื้นในอากาศ, เซนเซอร์ความชื้นในดิน, เซนเซอร์น้ำ (ทำงานเมื่อมีน้ำมาสัมผัสเซนเซอร์ – ใช้ตรวจเช็คฝนตก), เซนเซอร์แสง (สวิตซ์), เซนเซอร์ความเข้มแสง, เซนเซอร์วัด pH, เซนเซอร์ UV, เซนเซอร์วัดฝุ่นละอองในอากาศ, เซนเซอร์วัดความชื้นในดิน, เซนเซอร์วัดแรงสั่นสะเทือน และเซนเซอร์อื่นๆ อีกมากมาย ซึ่งหลักการทำงานนั้นส่วนใหญ่จะเหมือนกันหมด คือการอ่านค่ามาจากเซนเซอร์ และนำค่านั้นมาแปรผลที่เราสามารถอ่านได้ง่าย

     

    บทความนี้จะเริ่มด้วยเซนเซอร์ที่ Basic ที่สุด เพื่อให้ทุกท่านพอจะได้เห็นหลักการทำงานและเป็นแนวทางในการเชื่อมต่อเซนเซอร์อ่นๆ ต่อไปครับ นั่นคือ เซนเซอร์วัดอุณหภูมิและความชื้น AM2302 (DHT22) นั่นเอง

    โดยจะมี Pinout ดังนี้ (จากซ้ายบน คือขาที่ 1)
    ขาที่ 1 คือ VCC รองรับ 3.6-6V
    ขาที่ 2 คือ Data
    ขาที่ 3 คือ NC (Normal Close)
    ขาที่ 4 คือ GND

    เราจะต้องทำการต่อ R (Resistor) ด้วย 4.7KOhm ระหว่างขา Data และ VCC ไว้เพื่อป้องกันการรับ/ส่ง ข้อมูลผิดพลาด

    ดังรูปนี้

    ซึ่งถ้าเกิดเราเอามาต่อกันภายนอก จะทำให้เกิดความไม่สวยงามแยะยุ่งยาก จึงขอแนะนำเป็นอุปกรณ์ที่ Built-In R ลงในบอร์ดเลย ดังตามที่กำลังจะนำเสนอให้ดูนี้

    จากนั้นเราทำการต่อสาย ซึ่งผมใช้ Jump Wire ตัวเมียทั้งสองฝั่ง เพื่อสะดวกในการต่อเข้ากับ GPIO ของ Raspberry Pi และเพื่ออนาคตสามารถปรับเปลี่ยนได้ง่าย

    ** เนื่องจากมีแค่ 3 เส้น จึงไม่ได้เน้นว่ามีแดงต้องเป็น +5V, สีดำต้องเป็น GND แค่เสียบให้ถูกทั้งต้นและปลาย ก็พอแล้วครับ **

     

    จากนั้นทำการเสียบเข้าบอร์ด โดยดูจาก Diagram และผมเลือกต่อเข้าช่อง GPIO 4 (ขาที่ 7 – สายสีแดง ในรูป)

    ทำการประกอบลง Enclosure (ไม่จำเป็น) เพื่อความเป็นระเบียบเรียบร้อยเท่าที่จะทำได้ จากนั้นทำการต่อสายและ Boot เครื่องครับ

     

    จากนั้นมาในส่วนของโปรแกรมกันครับ

    เริ่มทำการเขียน Python อย่างง่าย เพื่อที่จะดึงค่าอุณหภูมิและความชื้นมาแสดงบนหน้าจอ ดังนี้ครับ

     

    ทำการอัพเดทระบบด้วยคำสั่ง sudo apt-get update -y

     

    จากนั้นติดตั้ง dependency ที่ต้องใช้ด้วยคำสั่ง sudo apt–get install –y build–essential python–dev git

    (ถ้าใครติดตั้งมาก่อนในบทความก่อนหน้านี้ ก็ผ่านไปได้เลยครับ)

    จากนั้นทำการติดตั้ง Library จาก Adafruit (เพื่อที่เราจะได้ไม่ต้องเขียน GPIO Connection เอง ซึ่งยุ่งยาก) ด้วยคำสั่งต่อไปนี้ครับ

    mkdir –p /home/pi/sources
    cd /home/pi/sources
    git clone https://github.com/adafruit/Adafruit_Python_DHT.git
    cd Adafruit_Python_DHT
    sudo python setup.py install

          

    รอจนเสร็จเรียบร้อย

     

    จากนั้นทดลองเรียกค่าจากเซนเซอร์ด้วยคำสั่ง

    sudo /home/pi/sources/Adafruit_Python_DHT/examples/AdafruitDHT.py 2302 4

    โดย 2302 คือ ชนิดของเซนเซอร์และ 4 คือ GPIO ID (ดูจาก Pinout ของ Raspberry Pi และไม่ใช่เลขขานะครับ)
    ก็จะได้ค่ามาดังรูป

    ตามตัวอย่างด้านบนนี้ เป็นการใช้ Python Example ที่มีมากับ Library ที่เรา Clone มา
    อันที่จริงแล้วเราสามารถเขียน Python ให้สามารถเรียกค่าได้โดยง่ายเพียงไม่กี่บันทัด โดยผ่าน Python ดังนี้

    1. เข้า python interactive mode ด้วยคำสั่ง sudo python
    2. พิมพ์คำสั่งข้างล่างนี้ (ขึ้นบันทัดใหม่ด้วย Enter)

    import Adafruit_DHT
    humidity, temperature = Adafruit_DHT.read_retry(Adafruit_DHT.AM2302, 4)

    3. จากนั้นลองพิมพ์ temperature จะได้ค่าอุณหภูมิออกมา

    4. ลองพิมพ์ humidity จะได้ค่าความชื้นออกมา

    5. ออจาก python interactive mode ด้วยการกด Ctrl+D

     

    จะเป็นว่าการดึงค่ามาจากเซนเซอร์นั้น ไม่ได้ยากแต่อย่างใดเลย ครั้งหน้า จะเป็นการเก็บค่าอุณหภูมิและความชื้น นำไปแสดงบน Web Interface เป็นกราฟ เพื่อให้สามารถดูค่าและนำไปวิเคราะห์ได้ง่ายขึ้น ได้โปรดรอติดตามครับ

     

    ผิดพลาดประการใด ขออภัยมา ณ โอกาสนี้ครับ

     

     

     

  • GET STRING FROM ENUM

    เพื่อนๆนักพัฒนาหลายคนก็คงจะรู้จัก enum กันพอสมควรแล้วนะคะ วันนี้เรามาทำความรู้จักเจ้า Enum กันให้มากขึ้นกว่าเดิมกันดีกว่านะคะ ว่านอกจากเราจะดึงค่า Integer ที่เก็บค่าในตัวแปร หรือ Tostring() เป็นค่าstring ตามชื่อของตัวแปร Enum แล้ว เรายังสามารถ ดึงค่า  String  เป็นประโยคยาวๆได้โดยที่ไม่จำเป็นต้องเหมือนกับชื่อตัวแปรแล้วนะคะ เอาล่ะค่ะ เรามาเริ่มจากการทำความรู้จักเจ้าตัว Enum กันตั้งแต่เริ่มต้นเพื่อระลึกความจำกันก่อนละกันนะคะ ^^

    Enumeration จะมีชนิดเป็น integer type ซึ่ง เราสามารถกำหนดกลุ่มของข้อมูลได้ (User-defined)

    ในการสร้าง enumeration เราจะใช้ keyword คำว่า  enum  ดังนี้

    public enum Colors
    {
      White,
      Black,
      Red,
      Green,
      Blue
    }

    ในตัวอย่างนี้สร้าง enum ที่ชื่อว่า Colors โดยมีสมาชิกอยู่ 5 สมาชิกคือ White,Black,Red,Green,Blue

    โดยสมาชิกต่างๆของ enum ถ้าเราไม่ได้กำหนดค่าเริ่มต้นจะมีค่าเริ่มต้นจาก 0 ดังนี้

    white = 0

    Black =1

    Red =2

    Green=3

    Blue=4

    ในการเรียกใช้งาน enum

    Colors  c = Colors.Green; //สร้างตัวแปร c ขึ้นมาเพื่อเรียกใช้สมาชิกที่ชื่อ Green

    ตัวอย่าง enum

     

    using System;
    public enum Colors
    {
        White,
        Black,
        Red,
        Green,
        Blue
    }
    public class TestEnum
    {
        public static void Main()
        {
            Colors c = Colors.Blue;
            Console.WriteLine(c);
            Console.ReadLine();
        }
    }

    ผลลัพธ์จะแสดง Blue

    จากตัวอย่างนี้ถ้าต้องการให้แสดงเป็น integer type   เราก็เขียนได้ดังนี้

    Console.WriteLine((int)c);

    ผลลัพธ์จะได้ 4

    เราสามารถกำหนดค่าให้กับสมาชิกของ  enum ได้ดังนี้

     

    public enum Colors
    {
      Red = 10,
      Green =20,
      Blue=30
    }

    ตัวอย่าง

     

    using System;
    public enum Colors
    {
      Red = 10,
      Green =20,
      Blue=30
    }
    public class TestEnum
    {
        public static void Main()
        {
            Colors c = Colors.Green;
            Console.WriteLine((int)c);
            Console.ReadLine();
        }
    }

    ผลลัพธ์จะได้ 20
    นอกจากนี้สามารถเขียนรับค่า value มาจาก enum ได้อีกแบบคือ
    Colors c = (Colors)Enum.Parse(typeof(Colors), “Blue”, false);
    ตัวอย่าง

    using System;
    public enum Colors
    {
      Red = 10,
      Green =20,
      Blue=30
    }
    public class TestEnum
    {
        public static void Main()
        {
            Colors c = (Colors)Enum.Parse(typeof(Colors), “Blue”, false);
            Console.WriteLine((int)c);
            Console.ReadLine();
        }
    }

    ผลลัพธ์จะได้ 30

    กรณีที่เราจะใช้ tostring เข้ามาใช้ก็สามารถทำได้
    ตัวอย่าง

     

    using System;

    public enum Colors
    {
      Red = 10,
      Green =20,
      Blue=30
    }
    public class TestEnum
    {
        public static void Main()
        {
            string  c = Colors.Green.tostring();
            Console.WriteLine(c);
            Console.ReadLine();
        }
    }

    ผลลัพธ์จะได้ Green
    นอกจากเราจะสามารถ tostring ให้ได้ค่า string เหมือนกับชื่อ enum แล้วนั้น ผู้พัฒนาทราบหรือไม่คะ ว่า enum เราสามารถกำหนดคำอธิบายได้เป็นประโยค และสามารถดึงค่านั้นมาใช้ได้ หรือพูดง่ายๆว่าเราสามารถดึงค่า enum มาใช้ในรูปแบบประโยคได้ง่ายๆ ดังตัวอย่างค่ะ

    public enum Colors
    {[Description(“This is Red”)]  //เราต้องกำหนด Description attributes ว่าเราต้องการจะให้แสดงข้อความอย่างไร
      Red = 10,   Green =20,
      Blue=30
    }

    ส่วนนี้จะเป็น code ส่วนที่จะดึงข้อมูล Description ตามที่กำหนด ที enum

    public static string GetEnumDescription(Enum value)

    {   

    FieldInfo fi = value.GetType().GetField(value.ToString());    

    DescriptionAttribute[] attributes = (DescriptionAttribute[])fi.GetCustomAttributes(        typeof(DescriptionAttribute),        false);    

    if (attributes != null &&        attributes.Length > 0)       

    return attributes[0].Description;   

    else        return value.ToString();

    }

    ตัวอย่างการเรียกใช้

    var myEnumDescriptions = Colors.Red.GetDescription();

    ผลลัพธ์จะได้ This is Red

    ผู้เขียนหวังว่านี่คงจะเป็นอีกทางเลือกนึงของผู้พัฒนา ในการนำไปพัฒนาโปรแกรมต่อไปนะคะ ^_^

    แหล่งอ้างอิง
    https://stackoverflow.com/questions/2650080/how-to-get-c-sharp-enum-description-from-value
    http://yaritc.blogspot.com/2012/01/enum-struct-by-paedotnet.html