EMBEDDED 2015

Arduino Sketch ที่ทำงานเป็นเครื่องคำนวณอย่างง่าย (Simple Calculator) ครั้งที่ 1

วัตถุประสงค์

1) ความเข้าใจและฝึกทักษะในการเขียนโค้ดคำสั่งการทำงานของ arduino มากยิ่งขึ้น

2) ความเข้าใจกลไกการแปลงข้อมูลจาก infix เป็น postfix และสามารถนำมาประยุกต์ใช้งานได้

3) การใช้นำความรู้ด้านอัลกอริทึมในการเก็บข้อมูลแบบ stack มาประยุกต์

วัสดุ อุปกรณ์และเครื่องมือ (Materials and Equipment)

1) คอมพิวเตอร์ PC หรือ Notebook ที่มีโปรแกรม Arduino

2) บอร์ด Arduino UNO R3

3) สาย USB ใช้เชื่อมต่อระหว่าง Arduino กับ Notebook

Block diagram

หลักการทำงาน
จะรับข้อมูลชนิด char ผ่านทาง Arduino serial แล้วมาเก็บเป็น String ซึ่งข้อมูลที่รับมานั้นจะคือนิพจน์ที่เป็น infix เมื่อได้รับนิพจน์ที่เป็น infix มาเรียบร้อยแล้วก็จะเป็นกลไกการแปลงนิพจน์จาก infix เป็น postfix ที่ต้องนำ stack มาใช้ในการเก็บ Operator ตามลำดับการดำเนินการทางคอมพิวเตอร์ ดังนี้

Operator	Operator Precedence & Association
Operator	Precedence	Associativity
^	3	Right
%	2	Left
/	2	Left
*	2	Left
-	1	Left
+	1	Left

1. 1 ตารางเปรียบเทียบการดำเนินการของ Operator

Algorithm ในการแปลง infix เป็น postfix ได้ศึกษาแนวทางการดำเนินการมาจาก http://www.engineersgarage.com/contribution/expert/calculator-using-postfix-notification

โดยศึกษาจาก Flowchart มีดังนี้

1. อ่านค่าอินพุตที่ได้รับถ้าเป็น number ให้นำไปเก็บเป็น String (output)

2. อ่านค่าอินพุตถ้าเป็น operand ให้ทำดังนี้

2.1 นำ operand เก็บลงใน Stack ถ้า Stack Empty (ว่าง)

2.2 ถ้า Stack ไม่ว่างให้เปรียบเทียบค่า Precedence ของ operator ที่อินพุตกับ operator ใน Stack โดยเทียบค่าในตาราง

3. อ่านค่าอินพุตถ้าเป็นเครื่องหมายวงเล็บเปิด ‘(’ ก็ให้ทำการ pop Stack

4. อ่านค่าอินพุตถ้าเป็นเครื่องหมายวงเล็บปิด ‘)’ ก็ให้ทำการ pop Stack ออกไปเก็บที่ String (output) จนกว่าจะเจอเครื่องหมายวงเล็บเปิดใหม่แล้วทิ้งเครื่องหมายวงเล็บปิดไป

5. ถ้าอ่านค่าอินพุตหมดแล้วให้ตรวจใน Stack ว่าว่างหรือไม่ถ้าไม่ว่างให้ pop Stack ออกไปเก็บไว้ที่ String (output) จน Stack ว่างมีดังนี้

1. อ่านค่าอินพุตที่ได้รับถ้าเป็น number ให้นำไปเก็บเป็น String (output)

2. อ่านค่าอินพุตถ้าเป็น operand ให้ทำดังนี้

2.1 นำ operand เก็บลงใน Stack ถ้า Stack Empty (ว่าง)

3. อ่านค่าอินพุตถ้าเป็นเครื่องหมายวงเล็บเปิด ‘(’ ก็ให้ทำการ pop Stack

5. ถ้าอ่านค่าอินพุตหมดแล้วให้ตรวจใน Stack ว่าว่างหรือไม่ถ้าไม่ว่างให้ pop Stack ออกไปเก็บไว้ที่ String (output) จน Stack ว่าง

Step การแปลง Infix เป็น Postfix
Token	Action	Output String	opStack
1	Add to string(output)	1
5	Add to string(output)	15
-	Push to Stack	15	-
(	Push to Stack	15	- (
(	Push to Stack	15	- ( (
1	Add to string(output)	15 1	- ( (
0	Add to string(output)	15 10	- ( (
-	Push to Stack	15 10	- ( ( -
5	Add to string(output)	15 10 5	- ( ( -
)	Pop Stack to string(output)	15 10 5 -	- ( (
)	Pop Stack	15 10 5 -	- (
-	Push to Stack	15 10 5 -	- ( -
3	Add to string(output)	15 10 5 - 3	- ( -
)	Pop Stack to string(output)	15 10 5 - 3 -	- (
)	Pop Stack	15 10 5 - 3 -	-
=	Pop Stack to string(output)	15 10 5 - 3 - -

เมื่อนำค่าที่รับมาแปลงเป็น postfix เรียบร้อย แล้ว เราก็จะนำ postfix ที่ได้ไปคำนวณค่าทางคณิตศาสตร์ โดยเราจะใช้ Stack ในการเก็บค่าของตัวเลข (Number) ที่ได้จากการวน loop ตาม index ของ postfix ที่ได้รับมา แต่ถ้าวนไปแล้วไปเจอ Operator ก็จะทำการ Pop Number ที่อยู่ใน Stack ออกมาจำนวนสองค่า เพื่อนำมาดำเนินการตาม Operator ที่พบ เมื่อคำนวณเสร็จแล้วก็จะเก็บค่าคำตอบนั้นลงไปใน Stack เพื่อนำไปคำนวณต่อไป เมื่อคำนวณเสร็จเรียบร้อยแล้วก็จะส่งคำตอบออกจากฟังก์ชัน และนำไปแสดงผลที่หน้าจอ

จากPostfix 15 10 5 - 3 - -

Step การคำนวณ Postfix
Token	Action	String	Stack
1	Add to string(number)	1
5	Add to string(number)	15
	Push string(number) to Stack	15	15
	Clear string		15
1	Add to string(number)	1	15
0	Add to string(number)	10	15
	Push string(number) to Stack	10	15 10
	Clear string		15 10
5	Add to string(number)	5	15 10
	Push string(number) to Stack	5	15 10 5
	Clear string		15 10 5
-	Pop two times form stack and calculate (10-5)		15
-	Push answer to stack		15 5
3	Add to string(number)	3	15 5
	Push string(number) to Stack	3	15 5 3
	Clear string		15 5 3
-	Pop two times form stack and calculate (5-3)		15
-	Push answer to stack		15 2
-	Pop two times form stack and calculate (15-2)
-	Push answer to stack		13
	Return pop stack (=13)

Code for calculator

#include <StackArray.h>
void setup() {
  Serial.begin(9600);
}
char input; //ใช้เก็บค่า character ที่รับเข้ามาจาก จากแป้นพิมพ์
int Size = 0; //ขนาดตัวอักษรของโจทย์ที่รับเข้ามา
int Ans = 0;  //ใช้เก็บคำตอบ จากโจทย์ที่รับเข้ามา
String S_input = "", postfix = "";  //S_input เป็น โจทย์ที่รับเข้ามาจากผู้ใช้ และpostfixใช้เก็บค่าตอบแปลงโจทย์เป็น postfix
void loop() {
  if (Serial.available() > 0)
  {
    input = Serial.read();
    // check your problem
    if (input == 61 || CheckNum(input) || CheckOp(input) || input == '(' || input == ')' ) //เช็คว่ามีส่วนประกอบของ = หรือตัวเลข หรือ เครื่องหมายทางคณิตศาสตร์ หรือเครื่องหมายวงเล็บหรือไม่
    {
      if (Size <= 25 ) //ขนาดโจทย์กำหนดให้ไม่เกิน 25ตัวอักษร
      {
        S_input = S_input + input; //บวก character ที่รับเข้ามา เพื่อสร้างเป็นโจทย์เก็บใน S_input
        Size++;
      }
    }
    if (input == 61) //เมื่อเจอเครื่องหมาย=
    {
      postfix = toPostfix(S_input);   //นำโจทย์ปกติส่งไปยังฟังก์ชัน toPostfix เพื่อแปลงเป็น postfix เก็บไว้ในตัวแปรชื่อ postfix ซึ่งเป็น String
      Ans = calulatePost(postfix);  //ส่งpostfixไปคำนวณคำตอบยังฟังก์ชัน calulatePost และเก็บข้อมูลไว้ในตัวแปร Ans ซึ่งเป็น integer
      Serial.println(S_input + " " + Ans); //แสดงโจทย์และคำตอบออกทางmonitor
      //resetข้อมูลใหม่
      S_input = "";
      postfix = "";
      Size = 0;
      Ans = 0;
    }
  }
}
int precedence(char op) //ฟังก์ชันบอกลำดับความสำคัญในการคำนวณของเครื่องหมายทางคณิตศาสตร์ รีเทิร์นออกไปเป็น integer ยิ่งค่ามากยิ่งมีความสำคัญมาก
{
  switch (op) {
    case '+':
    case '-':
      return 1;
    case '*':
    case '/':
    case '%':  //เครื่องหมายmodulo หรือการหารเอาเศษ
      return 2;
    case '^': //เครื่องหมายยกกำลัง
      return 3;
    default:
      return 0;
  }
}
String toPostfix(String infix) //ฟังก์ชันการแปลงโจทย์ไปเป็น postfix โดยรับโจทย์มาเป็น String และรีเทิร์นออกไปเป็นString
{
   String postfix = ""; //ใช้เก็บโจทย์ที่ถูกแปลงเป็น Stringแล้ว และรอการ return ออก
  char temp; //เป็นตัวแปรที่ใช้ไล่ไปในแต่ละตัวของinfix หรือโจทย์ที่รับมา
  StackArray <char> opStack; //operator stack ใช้เก็บเครื่องหมายในการคำนวณและเครื่องหมายวงเล็บ

for (int i = 0; i < infix.length(); i++) //ไล่เช็คข้อมูลไปทีละตัวในโจทย์ที่ให้มา
  { temp = infix.charAt(i); //ไล่เก็บค่าที่ละตัว
    if (CheckNum(temp)) //เป็นตัวเลข0-9?
    {
      postfix += temp;//เพิ่มตัวเลขนั้นเข้าไปยังข้อความpostfix
    }
    else if (temp == ')' ) //เป็นเครื่องหมายวงเล็บปิดหรือไม่?
    { postfix += " "; //เพิ่มเว้นช่องว่างไปในpostfix
      while (!opStack.isEmpty ()) //วนลูปจนกว่าstack ที่ชื่อ opStack จะEmpty
      {
        char ch = opStack.pop(); //popเครื่องหมายออกมาจากstack ที่ชื่อ opStack ใส่ในch
        //จะนำเครื่องหมายออกมาจากstackให้หมด หรือจนกว่าจะเจอเครื่องหมายวงเล็บเปิด
        if (ch == '(') //เจอเครื่องหมายวงเล็บเปิดจะbreakการวนลูป
        {
          break;
        } else {  //เพิ่มchต่อท้ายข้อความpostfix และเว้นช่องว่างต่อท้าย
          postfix = postfix + ch + " ";
        }
      }
    }
    else if (temp == '(' )//ถ้าเป็นเครื่องหมายวงเล็บเปิด ให้เก็บใส่ลงไปในstack ที่ชื่อ opStack
    {
      opStack.push(temp);
    }
    else if (CheckOp(temp) )// ถ้าเป็นกรณีที่เจอเครื่องหมาย
    { postfix += " "; //เพิ่มช่องว่างต่อท้ายข้อความpostfix
      if (!opStack.isEmpty ()) //stack ที่ชื่อ opStackมีข้อมูลอยู่ใช่หรือไม่?
      { char A = opStack.pop(); //popเครื่องหมายออกมาจากstack อีกครั้งเพื่อนำมาเช็ค
        if (CheckOp(A) )// เช็คว่า A เป็นเครื่องหมายการคำนวณใช่หรือไม่
        {
          //กรณีที่เครื่องหมายtemp มีลำดับความสำคัญมากกว่า เครื่องหมายA จะทำการเก็บข้อมูลที่popออกมาเข้าไปใหม่ซึ่งก็คือ A และข้อมูลเครื่องหมายใหม่ที่ยังไม่มีการเก็บซึ่งก็คือ temp ไว้ใน stack
          if (precedence(temp) > precedence(A))
          { opStack.push(A);
            opStack.push(temp);
          }
          //กรณีที่เครื่องหมายtemp มีลำดับความสำคัญน้อยกว่า เครื่องหมายA จะต้องpopเครื่องหมายออกจาก stack จนกว่าจะเจอเครื่องหมายที่มีลำดับความสำคัญเท่ากัน(ดึงข้อมูลที่เท่ากันตัวแรกสุดออกมาด้วย) หรือจนกว่าจะเจอเครื่องหมายวงเล็บเปิด
          else if (precedence(temp) < precedence(A))
          { postfix = postfix + A + " "; //ใส่เครื่องหมาย A ต่อท้ายข้อความpostfix  และตามด้วยช่องว่าง
            while (!opStack.isEmpty ()) //วนลูปจนกว่าstackจะไม่มีข้อมูลเก็บอยู่
            { char B = opStack.pop(); //popเครื่องหมายออกมาจาก stack และเก็บไว้ใน character B
              //เช็คเครื่องหมาย B ที่popออกมาใหม่กับเครื่องหมาย temp ที่สนใจอยู่ ว่า Bมีลำดับความสำคัญมากกว่า tempหรือไม่ ถ้าใช่จะใส่เครื่องหมาย B ต่อท้ายข้อความpostfix  และตามด้วยช่องว่าง
              if (precedence(B) > precedence(temp))
              {
                postfix = postfix + B + " ";
              }
              //ถ้า B ที่ popออกมามีลำดับที่เท่ากับเครื่องหมาย temp และต้องไม่เป็นเครื่องหมายวงเล็บเปิด จะทำการเพิ่มเครื่องหมาย B ต่อท้ายข้อความpostfix  และตามด้วยช่องว่าง และทำการ break ออกจากการวนลูป
              else if (B != '(') {
                postfix = postfix + B + " ";
                break;
              }
            }
            //หลังจากการวนลูปออกมาจะทำการใส่เครื่องหมายtemp
            opStack.push(temp) ;
          }
          //กรณีที่เครื่องหมาย temp มีลำดับความสำคัญที่เท่ากับ เครื่องหมาย A
          else {
            postfix = postfix + A + " "; //ใส่เครื่องหมาย A ต่อท้ายข้อความpostfix  และตามด้วยช่องว่าง
            while (!opStack.isEmpty ())//วนลูปจนกว่าopStackจะว่าง ไม่มีข้อมูล
            { char T = opStack.pop(); //popเครื่องหมายออกมาจากopStack
              //เช็คว่าเครื่องหมายtemp เท่ากับเครื่องหมาย Tที่พึ่งpopออกมาหรือไม่ ถ้าเท่าจะทำการใส่ค่า Tต่อท้ายpostfixและตามด้วยช่องว่างเพื่อเว้นวรรค ถ้าไม่ใช่จะออกจากลูปทันทีโดยคำสั่ง break
              if (precedence(temp) == precedence(T))
              { postfix = postfix + T + " ";
              }
              else {
                break;
              }
            }
            //เมื่อออกจากลูปจะเก็บเครื่องtempใน stack ที่ชื่อ opStack
            opStack.push(temp);
          }
        } else {  //กรณีที่เป็นเครื่องหมายวงเล็บเปิด จะทำการเก็บข้อมูลที่popออกมาเข้าไปใหม่ซึ่งก็คือ A และข้อมูลเครื่องหมายใหม่ที่ยังไม่มีการเก็บซึ่งก็คือ temp ไว้ใน stack
          opStack.push(A);
          opStack.push(temp);
        }
      }else { //กรณี stack ว่างไม่มีข้อมูลจะใส่เครื่องหมาย temp ลงไปใน stack
        opStack.push(temp);
      }
    }
    //ถ้า temp เป็นเครื่องหมายเท่ากับ จะทำการpopข้อมูลออกทั้งหมดในstack ที่ชื่อ opStack
    else if (temp == '=')
    { postfix += " ";
      while (!opStack.isEmpty ()) //วนลูปดึงเครื่องหมายออกจาก stack โดยเพิ่มเครื่องหมายไปยังข้อความ postfix popเครื่องหมายจนกว่าจะหมดstack
      { char A = opStack.pop();
        postfix = postfix + A + " ";
      }
    }
    //กรณีเป็นช่องว่าง ไม่ต้องทำอะไร
    else if (temp == ' ') {}
    else {
      Serial.print(temp);
    }
  }
  return postfix; //return ข้อความของโจทย์ที่ได้แปลงเป็น postfixแล้ว
}
//ฟังก์ชันสำหรับการคำนวณ postfix โดยจะreturn ค่าออกไปเป็น integer
int calulatePost(String postfix)
{
  StackArray <int> stack; //สร้างstack มาเพื่อเก็บข้อมูลเลขชนิด integer
  int space = 0; //ใช้นับช่องว่าง
  String num = ""; //เก็บข้อความเกี่ยวกับตัวเลข สำหรับเลขหลายหลัก เพื่อรอครบทุกหลักก่อนค่อยนำเก็บใส่stack
  //keep to stack
  for (int i = 0; i < postfix.length(); i++)
  {
    if (CheckNum(postfix[i]) && space == 0 ) //เช็คว่าเป็นตัวเลขหรือไม่ และต้องยังไม่มีเว้นวรรคมาคั่น(space == 0)
    {
      num += postfix[i]; //นำเลขนั้นเพิ่มต่อท้ายไปยังข้อความที่ใช้เก็บตัวเลข
    }
    else if (postfix[i] == ' ' && i < (postfix.length() - 1)) //เช็คว่าเป็นช่องว่างหรือไม่ และต้องเป็นตำแหน่งก่อนตัวสุดท้าย
    {
      space++; //เมื่อเจอช่องว่างค่าของspaceจะถูกบวกเพิ่มขึ้นทีละ1
      if (postfix[i + 1] != ' ' && num != "") //เช็คว่าตัวถัดไปต้องไม่ใช่ช่องว่างและต้องมีตัวเลขถูกเก็บไว้ในสตริง num เราถึงจะทำการpushเลขใส่ลงไปในstack
      {
        stack.push(num.toInt());
        //resetค่าให้space = 0 และเคลียข้อความของ num
        space = 0;
        num = "";
      }
      else if (postfix[i + 1] != ' ' && num == "") //เช็คว่าตัวถัดไปต้องไม่ใช่ช่องว่างและไม่มีตัวเลขใดถูกเก็บไว้ในสตริงnum เป็นกรณีที่เจอเครื่องหมายติดกัน เราจึงไม่เก็บค่าใส่ใน stack เพราะไม่ได้เป็นตัวเลข
      {
        //resetค่าให้space = 0 และเคลียข้อความของ num
        space = 0;
        num = "";
      }
    }
    //ถ้าเป็นช่องว่างสุดท้ายก่อนจบโจทย์ไม่ต้องทำอะไร
    else if (postfix[i] == ' ' && i == (postfix.length() - 1)) {}
    //กรณีเป็นเครื่องหมายจะทำการpop เลขออกมาจากstackจำนวนสองค่า โดยค่าแรกที่popออกมาจะใส่ใน int right และค่าที่popมาตัวที่สองจะใส่ใน int left
    else {
      space = 0;
      num = "";
      int right = stack.pop();
      int left = stack.pop();
      //ตรวจสอบว่าpostfix[i] เป็นเครื่องหมายชนิดใดและคำนวณตามคำสั่งของเครื่องหมายนั้น แล้วเก็บค่าใส่ stack
      switch (postfix[i])
      {
        case '+': stack.push(left + right); break;
        case '-':  stack.push(left - right); break;
        case '*':  stack.push(left * right); break;
        case '/':  stack.push(left / right); break;
        case '%':  stack.push(left % right); break;//คำนวณการหารเอาเศษ
        case '^':  stack.push(powInt(left, right));  break; //คำนวณเลขยกกำลัง
        default: break;
      }
    }
  }
  return stack.pop(); //return ค่าโดยการ popค่าออกมาจาก stack
}
//ฟังก์ชันการคำนวณเลขยกกำลัง โดยรีเทิร์นออกไปเป็น integer รับเลขมาสองตัวเป็น integer โดยleft เป็นเลขฐาน และrightเป็นค่าของเลขยกกำลัง
int powInt(int left , int right) {
  int product = 1;
  while (right--) {
    product *= left;
  }
  return product;
}
//ฟังก์ชันเช็คว่าcharacterตัวนั้นเป็นเครื่องหมายที่ใช้ในการคำนวณทางคณิตศาสตร์หรือไม่(บวก ลบ คูณ หาร ยกกำลัง หารเอาเศษ) โดยรีเทิร์นเป็น Boolean
boolean CheckOp(char input)
{
  return input == '*' || input == '/' || input == '+' || input == '-' || input == '^' || input == '%' ;
}
//ฟังก์ชันเช็คว่าcharacterตัวนั้นเป็น ตัวเลขตั้งแต่ 0-9หรือไม่ โดยรีเทิร์น เป็น Boolean
boolean CheckNum(char input)
{
  return input >= 48 && input <= 57 ;
}

สาธิตการทำงาน

ส่งข้อความที่เป็นนิพจน์ (10-3/2+5)*2= ผ่านทาง Arduino serial monitor (รูปซ้าย) ส่งไปคำนวณและนำกลับมาแสดงคำตอบ (รูปขวา)

ส่งข้อความที่เป็นนิพจน์ ((100+1)*50)/100= ผ่านทาง Arduino serial monitor (รูปซ้าย) ส่งไปคำนวณและนำกลับมาแสดงคำตอบ (รูปขวา) โดยยังสามารถมองเห็นผลลัพธ์ที่ได้จากการส่งข้อความไปก่อนหน้านี้ด้วย

ส่งข้อความที่เป็นนิพจน์ 15-((10-5)-3)= ผ่านทาง Arduino serial monitor (รูปซ้าย) ส่งไปคำนวณและนำกลับมาแสดงคำตอบ (รูปขวา) โดยยังสามารถมองเห็นผลลัพธ์ที่ได้จากการส่งข้อความไปก่อนหน้านี้ด้วย

ส่งข้อความที่เป็นนิพจน์ (10^2+2^10)%(100^2)= ผ่านทาง Arduino serial monitor (รูปซ้าย) ส่งไปคำนวณและนำกลับมาแสดงคำตอบ (รูปขวา) โดยยังสามารถมองเห็นผลลัพธ์ที่ได้จากการส่งข้อความไปก่อนหน้านี้ด้วย

ส่งข้อความที่เป็นนิพจน์ 2^3-5*2^2-3*2+10= ผ่านทาง Arduino serial monitor (รูปซ้าย) ส่งไปคำนวณและนำกลับมาแสดงคำตอบ (รูปขวา) โดยยังสามารถมองเห็นผลลัพธ์ที่ได้จากการส่งข้อความไปก่อนหน้านี้ด้วย

วิดีโอสาธิตการทดลอง : https://www.youtube.com/watch?v=6PO4MGXeEQk&feature=youtu.be

วันศุกร์ที่ 4 กันยายน พ.ศ. 2558

Arduino Sketch ที่ทำงานเป็นเครื่องคำนวณอย่างง่าย (Simple Calculator)