Main Menu
Menu

Show posts

This section allows you to view all posts made by this member. Note that you can only see posts made in areas you currently have access to.

Show posts Menu

Topics - JENG

#1

tel: O89-8I9-45O8
ธ.กรุงเทพ Mr.Somlak Mangnimit
เลข บช 368-050-8631



3. ZyXEL NBG-461N หมดประกัน ขาย 250.- รวมส่ง EMS




15.คีบย้ำหางปลา SN-28B ขาย 860.- รวมส่ง EMS




22.หัวแร้งแช่ Angel blue สภาพ 90% + LED คละสีตามรูป ราคา 150.- พร้อมส่ง ลงทะเบียน





23.LAMBDA NU SC-800 XP บอร์ดละ 590.- รวมส่ง สองบอร์ด 890.- รวมส่ง
http://www.smile-electronic.com/p/3


#2
เหล่ามิตรรักแฟนเพลง เงียบหายไปไหนกันหมดครับ หายหน้าหายตากันเลย  ;D
ว่าจะลงโปรเจค mutitask เรียกแขกซะหน่อย  ;D ;D ;D
ยังหาเวลาว่างๆไม่ได้เลย ยังคิดถึงมิตรรักแฟนเพลงทุกท่าน

#3
ลองเล่นกับเขาดูบ้าง  ;D

งบประมาณไม่เกิน 1000.- อยู่ที่ว่าจะเอาขยะอิเล็กทรอนิกส์มาใช้ได้มากแค่ไหน

กระผมเพิ่มเติมให้รองรับคำสั่ง M18 ปิด driver หลังเสร็จงานเพื่อไม่ให้ stepper motor ร้อนครับ
ส่วน drive ใช้ไฟสูงหน่อยคือราว 8.2volt 1amp สายเข้า motor ใช้เบอร์ 22awg เพื่อให้เขียนได้เร็ว
โดยไม่หลุด step เพราะการ drive เป็นแบบ microstep นุ่มนวล แต่แรงบิดก็จะต่ำเช่นกัน

https://www.youtube.com/v/axsdhdKHw9M




อุปกรณ์หลักๆ

Micro Servo Tower Pro SG90


Motor Drive Shield dual L293D for arduino


Arduino UNO R3


LM2596 Converter Buck Step Down


Adapter 12V 2A





download mini cnc firmware






download gctrl for win






download gcodesender






download g-code






download g-code






download g-code






download g-code






download g-code






download g-code

#4
#‎Arduino‬ ชุดแนะนำสำหรับมือใหม่
Electronics Component Packages พร้อมกล่อง 300.-
Arduino UNO R3 315.-
ฐานรองอะคริลิค 50.-
Arduino Common Parts Package 130.- **option เสริม**
ทั้งหมดซื้อได้จาก www.arduinoall.com

#8
-----------------------
NiCd/NiMH
-----------------------
voltage level: 1.2V/cell
allowable fast charge current: 1C - 2C
discharge voltage cut off level: 0.85V/cell(NiCd), 1.0V/cell(NiMH)


-----------------------
LiIo
-----------------------
voltage level: 3.6V/cell
max. charge voltage: 4.1V/cell
allowable fast charge current: 1C or less
min. discharge voltage cut off level: 2.5V/cell or higher


-----------------------
LiPo
-----------------------
voltage level: 3.7V/cell
max. charge voltage: 4.2V/cell
allowable fast charge current: 1C or less
min. discharge voltage cut off level: 3.0V/cell or higher


-----------------------
LiFe
-----------------------
voltage level: 3.3V/cell
max. charge voltage: 3.6V/cell
allowable fast charge current: 4C or less (e.g. A123M1)
min. discharge voltage cut off level: 2.0V/cell or higher


-----------------------
Pb (Lead-acid)
-----------------------
voltage level: 2.0V/cell
max. charge voltage: 2.4V/cell
allowable fast charge current: 0.4C or less
min. discharge voltage cut off level: 1.75V/cell or higher




***DISCHARGE RATE OR C-RATE***
http://bb-batteryasia.com/discharge-rate




http://www.youtube.com/v/_ROhH9EkhtU




http://www.youtube.com/v/A6mKd5_-abk
#9




แง่คิดดีๆ ....ถูก ผิด แล้วได้อะไร

คุณคิดว่าข้อใดถูก
8 x 3 = 23 หรือ
8 x 3 = 24 ?

คุณตอบข้อไหน ?

เรื่องจริงที่เกิดกับ "เอี้ยนหุยและขงจื้อ"

เรื่อง 8 x 3 = 23
เอี้ยนหุย กับ พ่อค้า ขายผ้า ในตลาด

พ่อค้าบอกว่า 8 x 3 = 23

เอี้ยนหุย รีบบอก พ่อค้าทันทีว่า 8 x 3 = 24

(พ่อค้าไม่รู้ว่า เอี้ยนหุยเป็นลูกศิษย์ขงจื้อ)

ทั้งคู่เถียงกันอยู่นาน ในสิ่งที่ตัวเองถูก สั่งสอนมา
สุดท้ายก็เดินทาง ไปหาขงจื้อ
ด้วยกันเพื่อให้ ขงจื้อ ตัดสิน

เอี้ยนหุย ก็บอก ต่อหน้า ขงจื้อว่า

ถ้า 8 x 3 = 23 ผมจะถอดยศ ถอดหมวกออก

แต่ถ้า 8 x 3 = 24 พ่อค้าคนนี้ต้องโดนตัดหัว

ขงจื้อได้ยินดังนั้น ก็ตัดสินว่า "8 x 3 = 23"

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

"เจ้าจงอย่าอยู่
ใต้ต้นไม้
และถ้าเจ้าจะ
คิดฆ่าใคร เจ้า จงคิดให้ดีเสียก่อน"

ระหว่างทางกลับมี ฝนตกหนัก
เอี้ยนหุย จึงรีบวิ่งเข้าไป หลบใต้ต้นไม้
พลันก็แว๊ปปขึ้นมาในหัวว่า อ.บอกไว้ว่า

"ห้ามอยู่ใต้ต้นไม้"

ก็รีบวิ่งออกมา จากต้นไม้

ทันใดนั้น ฟ้าก็ผ่าต้นไม้ ต้นนั้น !! เอี้ยนหุยตกใจมาก
แต่ก็รู้สึกขอบคุณ ขงจื้อมากที่เตือน
นึกในใจว่า ขงจื้อรู้ได้ยังไงว่า จะเกิดเรื่องนี้ ///

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

พอถึงห้องนอน เอี้ยนหุยคลำเจอคน 2 คนนอนอยู่
เขานึกใจในด้วย ความโมโหว่า

"อะไรกันเนี๊ยะ ข้าฯไป เรียนรู้วิชา กับ อ.ขงจื้อ
กลับมา ภรรยามีชู้เลยเหรอ"

ขณะที่กำลังจะเอามีดฟัน ก็นึกได้ว่า อ.เตือนไว้ว่า

"คิดจะฆ่าใคร ต้องคิดให้ดี"

เขาจึงจุดเทียนแล้ว ดูว่า 2 คนที่นอน อยู่นั้น เป็นใคร ?
สิ่งที่เขาเห็นนั้นคือ ภรรยาและน้องสาวของภรรยานอนอยู่ !!!!!!!!
เขานึกเลยว่าถ้าเขาไม่เชื่อคำของขงจื้อ ก็จะมีคนตาย 2 คน
ซึ่งเป็นภรรยาของเขาเอง และน้องสาว ของภรรยา!!

เอี้ยนหุย ไม่รีรอ ที่จะเดินทาง กลับไปถามขงจื้อ
ว่าท่านรู้ได้อย่างไร ว่าจะเกิดสิ่งต่างๆนี้

ขงจื้อจึงบอกว่า " ถ้าข้าตัดสินว่า 8 x 3 = 24 "

พ่อค้าคนนั้นต้อง ตาย ใช่ไหม ?

# จงใจสอนผิด เพื่อไม่ให้มีคน ล้มตาย

# แม้ไม่ใช่ คณิตศาสตร์ ที่ถูกต้อง

# แต่คุณธรรม ต่างหากที่ถูกต้อง

# เสียเกียรติ แต่ อย่าให้ผู้อื่น เสียชีวิต

# คนที่กำลังโกรธ ฉุนเฉียว มักจะ วู่วาม ทำอะไรโดย ไม่คิดหน้าคิดหลัง

..ทะเลาะกับลูกค้า ต่อให้ชนะ ก็แพ้อยู่ดี

..ทะเลาะกับคนเฒ่าคนแก่ ต่อให้ชนะ ก็แพ้อยู่ดี

..ทะเลาะกับครู หรืออาจารย์ ต่อให้ชนะ ก็แพ้อยู่ดี

..ทะเลาะกับเพื่อน ต่อให้ชนะ ก็แพ้อยู่ดี

..ทะเลาะกับภรรยา ต่อให้ชนะ ก็แพ้อยู่ดี

..ทะเลาะกับเจ้านาย (ที่เป็นเพื่อน) หรือผู้มีอำนาจ ต่อให้ชนะก็แพ้อยู่ดี

*****************

ดังนั้น รู้จักยอม และหยุด แล้วพูดว่า"ไม่เป็นไร" แล้วค่อยหาหนทาง แก้ไขต่อไปอย่าง มีสติ จะได้ไม่ต้อง เสียใจ ภายหลัง

Cr.
https://www.facebook.com/photo.php?fbid=741797352606335&set=a.396623310457076.1073741826.100003282316585&type=1
#11
Projects / PIC12F675 + DHT11
May 14, 2015, 02:06:19 PM





Source code
/*
PROGRAM : DHT11
AUTHOR : MR.SOMLAK MANGNIMIT
DATE : 13/05/2015
PIC12F675
*/


#include <htc.h>
__CONFIG(FOSC_INTRCIO & WDTE_OFF & PWRTE_OFF & MCLRE_OFF & CP_OFF & CPD_OFF);
//FOSC_INTRCIO
#define _XTAL_FREQ 4000000


#define delay_us(us)    __delay_us(us)
#define delay_ms(ms)    __delay_ms(ms)


#define SET_BIT(p, b)   (p|=1<<b)
#define CLR_BIT(p, b)   (p&=~(1<<b))
#define GET_BIT(p, b)   ((p&(1<<b))>>b)
#define TOG_BIT(p, b)   (p^=(1<<b))


volatile unsigned char DHT_H1, DHT_H2;
volatile unsigned char DHT_T1, DHT_T2;
volatile unsigned char DHT_SM;


struct bit_field
{
    unsigned char bit0:1;
    unsigned char bit1:1;
    unsigned char bit2:1;
    unsigned char bit3:1;
    unsigned char bit4:1;
    unsigned char bit5:1;
    unsigned char bit6:1;
    unsigned char bit7:1;
};


volatile union
{
    struct bit_field bit_of_data;
    unsigned char byte_of_data;
}status;


#define TOUT        status.bit_of_data.bit0
#define DHT_PIN 0
#define DHT_PIN_CHECK() GET_BIT(GPIO, DHT_PIN)


volatile unsigned char lcdbitmask;


#define LCD_CK_PIN 1
#define LCD_DT_PIN 2
#define LCD_EN_PIN 4


#define LCD_CK_LO()  CLR_BIT(GPIO, LCD_CK_PIN)
#define LCD_CK_HI()  SET_BIT(GPIO, LCD_CK_PIN)


#define LCD_DT_LO()  CLR_BIT(GPIO, LCD_DT_PIN)
#define LCD_DT_HI()  SET_BIT(GPIO, LCD_DT_PIN)


#define LCD_EN_LO()  CLR_BIT(GPIO, LCD_EN_PIN)
#define LCD_EN_HI()  SET_BIT(GPIO, LCD_EN_PIN)


//----------------------------------------------------------------------
void shiftOut(unsigned char byte_of_data)
//----------------------------------------------------------------------
{
    unsigned char i = 8;


    while(i--)
    {
        LCD_DT_LO();
        if(byte_of_data & 0x80) LCD_DT_HI();
        byte_of_data <<= 1;
        LCD_CK_LO();
        LCD_CK_HI();
    }
}


//----------------------------------------------------------------------
void lcdSendByte(unsigned char byte_of_data)
//----------------------------------------------------------------------
{
    unsigned char mask = 0;


    if(byte_of_data & 0x01) mask |= 0x01;
    if(byte_of_data & 0x02) mask |= 0x02;
    if(byte_of_data & 0x04) mask |= 0x04;
    if(byte_of_data & 0x08) mask |= 0x08;


    mask |= lcdbitmask;


    shiftOut(mask);
    LCD_EN_HI();
    LCD_EN_LO();
}


//----------------------------------------------------------------------
void lcdWriteByte(unsigned char byte_of_data)
//----------------------------------------------------------------------
{
    lcdSendByte(byte_of_data >> 4);
    lcdSendByte(byte_of_data & 0x0f);
}


//----------------------------------------------------------------------
void lcdWriteCommand(unsigned char byte_of_data)
//----------------------------------------------------------------------
{
    lcdWriteByte(byte_of_data);
    delay_ms(5);
}


//----------------------------------------------------------------------
void lcdWriteData(unsigned char byte_of_data)
//----------------------------------------------------------------------
{
    lcdbitmask |= 0x10;             //RS
    lcdWriteByte(byte_of_data);
    lcdbitmask ^= 0x10;             //RS
}


//----------------------------------------------------------------------
const unsigned char rowOffSet[] = {0x00, 0x40, 0x14, 0x54};
void lcdSetCursor(unsigned char col, unsigned char row)
//----------------------------------------------------------------------
{
    if(row > 4) row = 4-1;
    lcdWriteCommand(0x80|(col + rowOffSet[row]));
}


//----------------------------------------------------------------------
void lcdPrint(char * pointer)
//----------------------------------------------------------------------
{
    while(* pointer)
    {
        lcdWriteData(* pointer++);
    }
}


//----------------------------------------------------------------------
void lcdInitial(void)
//----------------------------------------------------------------------
{
    unsigned char i = 3;


    lcdbitmask = 0;
    shiftOut(0);
    LCD_EN_LO();


    delay_ms(50);


    while(i--)
    {
        lcdSendByte(0x33);
        delay_ms(5);
    }


    lcdSendByte(0x22);
    lcdWriteCommand(0x28);
    lcdWriteCommand(0x08);
    lcdWriteCommand(0x0C);
    lcdWriteCommand(0x01);
}


//----------------------------------------------------------------------
void interrupt isr(void)
//----------------------------------------------------------------------
{
    if(TMR1IF)
    {
        TOUT = 1;
        TMR1ON = 0;
        TMR1IF = 0;
    }
}


//----------------------------------------------------------------------
void DHT_PIN_LOW(void)
//----------------------------------------------------------------------
{
    CLR_BIT(TRISIO, DHT_PIN);
    CLR_BIT(GPIO, DHT_PIN);
}


//----------------------------------------------------------------------
void DHT_PIN_FLOAT(void)
//----------------------------------------------------------------------
{
    SET_BIT(TRISIO, DHT_PIN);
}


//----------------------------------------------------------------------
void dhtStartSignal(void)
//----------------------------------------------------------------------
{
    DHT_PIN_LOW();
    delay_ms(18);
    DHT_PIN_FLOAT();
    delay_us(40);
}


//----------------------------------------------------------------------
unsigned char dhtResponse(void)
//----------------------------------------------------------------------
{
    TOUT = 0;
    TMR1 = 0;
    TMR1ON = 1;
    while(!DHT_PIN_CHECK() && !TOUT);
    if(TOUT) return 0;


    TMR1 = 0;
    while(DHT_PIN_CHECK() && !TOUT);
    if(TOUT) return 0;
    else
    {
        TMR1ON = 0;
        return 1;
    }
}


//----------------------------------------------------------------------
unsigned char dhtReadByte(void)
//----------------------------------------------------------------------
{
    unsigned char byte_of_data;
    unsigned char counter;


    byte_of_data = 0;


    for(counter = 0; counter < 8; counter++)
    {
        TOUT = 0;
        TMR1 = 0;
        TMR1ON = 1;
        while(!DHT_PIN_CHECK() && !TOUT);
        if(TOUT) return 0;


        TOUT = 0;
        TMR1 = 0;
        TMR1ON = 1;
        while(DHT_PIN_CHECK()  && !TOUT);
        if(TOUT) return 0;
        else
        {
            TMR1ON = 0;
            if(TMR1 > 40) byte_of_data |= 1<<(7-counter);
        }
    }


    return byte_of_data;
}


//----------------------------------------------------------------------
void setup(void)
//----------------------------------------------------------------------
{
    GPIO   = 0x00;
    TRISIO = 0x00;
    CMCON  = 0x07;      //Disable comparator
    ANSEL  = 0x00;


    GIE = 1;            //Global interrupt enable
    PEIE = 1;           //Peripheral interrupt enable


    TMR1IE = 1;         //Timer 1 interrupt enable
    T1CON = 0;          //Prescaler 1:1 and timer 1 off
    TMR1IF = 0;         //Clear timer 1 interrupt flag
    TMR1 = 0;


    lcdInitial();
}


//----------------------------------------------------------------------
void main(void)
//----------------------------------------------------------------------
{
    setup();


    for(;;)
    {
        delay_ms(1000);


        dhtStartSignal();


        if(dhtResponse())
        {
            DHT_H1 = dhtReadByte();
            DHT_H2 = dhtReadByte();
            DHT_T1 = dhtReadByte();
            DHT_T2 = dhtReadByte();
            DHT_SM = dhtReadByte();


            if(DHT_SM == (DHT_H1 + DHT_H2 + DHT_T1 + DHT_T2))
            {
                lcdSetCursor(0, 0);
                lcdPrint("###  DHT-11  ###");
               
                lcdSetCursor(0, 1);
                lcdPrint("T: ");
                lcdWriteData(DHT_T1/10 + '0');
                lcdWriteData(DHT_T1%10 + '0');
                lcdWriteData(223);
                lcdPrint("C  ");


                lcdPrint("H: ");
                lcdWriteData(DHT_H1/10 + '0');
                lcdWriteData(DHT_H1%10 + '0');
                lcdPrint(" %");
            }
            else
            {
                lcdSetCursor(0, 0);
                lcdPrint("Checksum Error! ");
                lcdSetCursor(0, 1);
                lcdPrint("Trying Again ...");
            }
        }
        else
        {


            lcdSetCursor(0, 0);
            lcdPrint("No response     ");
            lcdSetCursor(0, 1);
            lcdPrint("from the sensor ");
        }
    }
}

Hex
:1000000014C02EC02DC02CC02BC02AC029C028C0AF
:1000100027C0D6C025C024C023C022C021C020C014
:100020001FC01EC01DC00040145411241FBECFE5C8
:10003000D4E0DEBFCDBF10E0A0E6B0E0E8EEF4E033
:1000400002C005900D92A63CB107D9F720E0A6ECBE
:10005000B0E001C01D92AE3CB207E1F735D142C21B
:10006000CFCFA09AA898089598E0949888230CF48C
:10007000949AC09A25E02A95F1F70000C098880F5D
:10008000915099F7979A85E08A95F1F70000979833
:100090000895CF9380FD02C090E001C090E181FD02
:1000A000906282FD906483FD9068C091C600C92B68
:1000B0008C2FDADF88E08C27D7DF8C2FD5DFCF912C
:1000C0000895CF93C82F82958F70E3DF8C2F8F70A8
:1000D000E0DFCF910895F5DF8FE19EE40197F1F71E
:1000E00000C0000008959091C60092609093C600F1
:1000F000E8DF9091C60082E089278093C6000895CA
:10010000653008F063E0E62FF0E0EA5DFF4FE49130
:100110008E0F8068E0DF0895CF93DF93EC01888134
:10012000882329F02196DFDF89918111FCCFDF91AF
:10013000CF9108959091C60091609093C60081116F
:1001400006C09091C60081E089278093C600809107
:10015000C6008ADF08951092C6008C9A8F9AB89ACA
:1001600080E082DF2FEF80E792E0215080409040D6
:10017000E1F700C0000083E38CDF8FE19EE401978C
:10018000F1F700C0000083E384DF8FE19EE4019774
:10019000F1F700C0000083E37CDF8FE19EE401976C
:1001A000F1F700C0000082E274DF88E294DF88E0AB
:1001B00092DF8CE090DF81E08EDF81E0BBDF08958D
:1001C0001F920F920FB60F9211248F938091CD0042
:1001D00081608093CD0013BE8F910F900FBE0F9062
:1001E0001F9018953EDF2FEF80EE90E02150804069
:1001F0009040E1F700C00000A09825ED2A95F1F7A6
:10020000000008958091CD008E7F8093CD0012BEB6
:1002100082E083BF989904C08091CD0080FFFACF1F
:100220009091CD00892F817090FD0EC012BE989BD9
:1002300004C09091CD0090FFFACF9091CD0090FD39
:1002400004C013BE81E0089580E0089527E030E007
:1002500060E072E041E050E08091CD008E7F8093BD
:10026000CD0012BE73BF989904C08091CD0080FF6D
:10027000FACF9091CD00892F817090FD1BC012BEE6
:10028000989B04C09091CD0090FFFACF9091CD0043
:1002900090FD13C013BE82B7813540F0CA01022E13
:1002A00002C0880F991F0A94E2F7682B2150310988
:1002B00098F602C080E00895862F08954CDF89B734
:1002C000816089BF78940895F9DF0F2EF8E78F2EAB
:1002D000F0E09F2EF02D0F2EFDEC3F2EF02D0F2E77
:1002E000F9E7AF2EF0E0BF2EF02D0F2EF7E6CF2E60
:1002F000F0E0DF2EF02D0F2EF8E6EF2EF0E0FF2ECF
:10030000F02D0AE710E00F2EFFED2F2EF02DCDE798
:10031000D0E00F2EFEE76F2EF0E07F2EF02D0F2E97
:10032000FFE74F2EF0E05F2EF02D2FEF89E698E1EA
:10033000215080409040E1F700C00000EFEFF9E667
:1003400028E1E150F0402040E1F700C000004ADF22
:1003500059DF81110CC060E0D3DE82E890E0DCDE82
:1003600061E080E0CDDE83E990E0D6DEDECF6EDFB7
:100370008093C8006BDF8093CB0068DF8093CC0054
:1003800065DF8093C70062DF8093CA002091CA00B6
:100390006091C8008091CB005091CC004091C70083
:1003A00030E090E0860F911D850F911D840F911D07
:1003B00099272817390709F07CC08091CC00839DCC
:1003C000812D1124869586958695805DF401808324
:1003D0008091CC00839D912D1124969596959695AC
:1003E000990F292F220F220F920F891B805DF50193
:1003F00080838091C800839D812D112486958695E8
:100400008695805DF60180838091C800839D912D43
:100410001124969596959695990F292F220F220FC4
:10042000920F891B805DF7018083F8012082809103
:10043000CC0090E09C01220F331F220F331F220FAC
:10044000331F820F931F9C0120563F4FADECBCEC35
:100450003DD096958795969587958093CC00809111
:10046000CC00839D812D1124869586958695805D8F
:1004700088838091CC00839D912D1124969596952B
:100480009695990F292F220F220F920F891B805DBD
:10049000F3018083F201208260E080E031DE81E7B9
:1004A00090E03ADE61E080E02BDE80E690E034DE32
:1004B0003CCF60E080E024DE84EA90E02DDE61E065
:1004C00080E01EDE85EB90E027DE2FCFA29FB001FB
:1004D000B39FC001A39F01D0B29F700D811D112455
:0804E000911D0895F894FFCF6F
:1004E80048756D693A202030302025524820202058
:1004F8000054656D703A2020303020432030302081
:1005080046004E6F20726573706F6E7365202020F1
:1005180020200066726F6D207468652073656E73A5
:100528006F722000436865636B73756D2045727246
:100538006F72212000547279696E67204167616982
:060548006E202E2E2E0095
:00000001FF
#12


เรื่องทำเมนูตั้งค่าบน lcd สำหรับมือใหม่อาจดูเป็นเรื่องยุ่งยาก วันนี้ผมมีแนวคิดการทำ
ที่น่าจะพอเป็นแนวทางสำหรับมือใหม่ได้





จากผังเมนู ผมจะแบ่งออกเป็นชั้นๆ โดยมี menu layer counter เป็นตัวบอกว่ากำลังอยุ่ layer ใด
อันนี้ใช้ในกรณีที่ต้องการย้อนกลับไปยังเมนูต้นทางทีละชั้นเพื่อกลับไปตั้งค่าโดยใช้ปุ่ม return
หรืออะไรก็ได้แล้วแต่เราจะกำหนด และเอาไปเป็นเงื่อนไขในการแสดงผลและตั้งค่าได้


ส่วนใน menu หลักก็จะมี menu counter เป็นตัวบอกอีกเช่นกัน ส่วนอีกชั้นจะเป็น menu ย่อย
หรือ sub เมนู โดย layer count, menu count, sub menu count ทั้งสามตัว ใช้เป็นเงื่อนไข
ทั้งการแสดงผลและการตั้งค่าทั้งหมด


ส่วนการแสดงผลบน CLCD อาจจะเจอปัญหายุ่งยากคือการคุม Cursor เพื่อแสดงผลในจุดที่ต้องการ
ทำให้เสียเวลา ให้ใช้การเขียนลงบน array buffer แทน จากนั้นสราง task ขึ้นมาเพื่อ update เอา
ค่าจาก buffer เขียนลง lcd ในคราวเดียวจะทำให้สะดวกมากขึ่นในการเขียนโปรแกรมครับ


ตัวอย่างโปรแกรมเดี๋ยวเอามาลงให้ครับ ขอเวลาเรียบเรียงก่อน ยังมีอะไรต้องเพิ่มเติมอีกเยอะ
ใครมีวิธีดีกว่านี้มาแชร์กันบ้างนะครับ ... ^^

https://www.youtube.com/v/xigmvEofMd0
#13
Projects / นาฬิกาแบบไทยๆ
February 17, 2015, 01:38:46 PM
หากถูกใจช่วยกด like เป็นกำลังใจกันด้วยคับ จะทำ project ง่ายๆมาฝากอีก

ปล.หากมีข้อสงสัยรายละเอียด source code กรุณาถามโดย pm. มานะคับ ถามในกระทุ้ผมขอสงวนสิทธิ์ไม่ตอบนะคับ




/*
Program : numthai rtc clock
Author  : Mr.Somlak Mangnimit
Date    : 16/02/2015
*/

#include <Wire.h>
#define ds1337_id 0x68
#define Seconds  0
#define Minutes  1
#define Hour     2
#define Dow      3
#define Date     4
#define Month    5
#define Year     6
unsigned char rtc_data[7];

#define max7219clkPin 10
#define max7219csPin  9
#define max7219dinPin 8

unsigned char numthai[]=
{
  0x00, 0x7C, 0x82, 0x82, 0x82, 0x82, 0x7C, 0x00,       //0
  0x00, 0x0C, 0x92, 0x92, 0x8A, 0x42, 0x3C, 0x00,       //1
  0x7F, 0x80, 0x9C, 0x92, 0x84, 0x82, 0x7C, 0x00,       //2
  0x7C, 0xA2, 0x46, 0x08, 0x06, 0x82, 0x7C, 0x00,       //3
  0x78, 0x84, 0x82, 0xB2, 0xD2, 0x82, 0x01, 0x00,       //4
  0x78, 0x84, 0x86, 0xB5, 0xD2, 0x82, 0x01, 0x00,       //5
  0x01, 0x42, 0xA4, 0xC2, 0x82, 0x82, 0x7C, 0x00,       //6
  0x7C, 0xA2, 0x4C, 0x02, 0xFC, 0x41, 0x3E, 0x00,       //7
  0x78, 0x84, 0x84, 0x64, 0x84, 0xB2, 0x71, 0x00,       //8
  0x78, 0xC4, 0xA4, 0x4E, 0x12, 0x26, 0x49, 0x00,       //9
 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,       //blank //10
  0x00, 0x00, 0x00, 0x6C, 0x6C, 0x00, 0x00, 0x00,       //colon //11
};

//------------------------------------------------------------
void maxWriteByte(unsigned char data)
//------------------------------------------------------------
{
  unsigned char i = 8;
 
  while(i--)
  {
    if(data & 0x80)digitalWrite(max7219dinPin,HIGH);
    else digitalWrite(max7219dinPin,LOW);
    digitalWrite(max7219clkPin,HIGH);
    digitalWrite(max7219clkPin,LOW);
    data <<= 1;
  }
}

//------------------------------------------------------------
void maxWriteNop(unsigned char cnt)
//------------------------------------------------------------
{
  while(cnt--)
  {
    maxWriteByte(0);
    maxWriteByte(0);
  }
}

//------------------------------------------------------------
void maxWriteOp(unsigned char addr, unsigned char data)
//------------------------------------------------------------
{
  maxWriteByte(addr);
  maxWriteByte(data);
}

//------------------------------------------------------------
void maxWrite(unsigned char dev, unsigned char addr, unsigned char data)
//------------------------------------------------------------
{
  digitalWrite(max7219csPin,LOW);
 
  switch(dev)
  {
    case 1:
    maxWriteNop(4);
    maxWriteOp(addr,data);
    break;
   
    case 2:
    maxWriteNop(3);
    maxWriteOp(addr,data);
    maxWriteNop(1);
    break;
   
    case 3:
    maxWriteNop(2);
    maxWriteOp(addr,data);
    maxWriteNop(2);
    break;
   
    case 4:
    maxWriteNop(1);
    maxWriteOp(addr,data);
    maxWriteNop(3);
    break;
   
    case 5:
    maxWriteOp(addr,data);
    maxWriteNop(4);
    break;
  }
 
  digitalWrite(max7219csPin,HIGH);
}

//------------------------------------------------------------
void writeDigit(unsigned char digit, unsigned int num)
//------------------------------------------------------------
{
  num *= 8;
  for(int i=0; i<8; i++)maxWrite(digit,i+1,numthai[num+i]);
}

//------------------------------------------------------------
void initial_max7219(void)
//------------------------------------------------------------
{
  maxWrite(1,0x09, 0x00); //decode: BCD
  maxWrite(2,0x09, 0x00); //decode: BCD
  maxWrite(3,0x09, 0x00); //decode: BCD
  maxWrite(4,0x09, 0x00); //decode: BCD
  maxWrite(5,0x09, 0x00); //decode: BCD
 
  maxWrite(1,0x0a, 0x03); //Brightness
  maxWrite(2,0x0a, 0x03); //Brightness
  maxWrite(3,0x0a, 0x03); //Brightness
  maxWrite(4,0x0a, 0x03); //Brightness
  maxWrite(5,0x0a, 0x03); //Brightness
 
  maxWrite(1,0x0b, 0x07); //
  maxWrite(2,0x0b, 0x07); //
  maxWrite(3,0x0b, 0x07); //
  maxWrite(4,0x0b, 0x07); //
  maxWrite(5,0x0b, 0x07); //
 
  maxWrite(1,0x0c, 0x01); //
  maxWrite(2,0x0c, 0x01); //
  maxWrite(3,0x0c, 0x01); //
  maxWrite(4,0x0c, 0x01); //
  maxWrite(5,0x0c, 0x01); //
 
  maxWrite(1,0x0f, 0x00); //
  maxWrite(2,0x0f, 0x00); //
  maxWrite(3,0x0f, 0x00); //
  maxWrite(4,0x0f, 0x00); //
  maxWrite(5,0x0f, 0x00); //
}

//------------------------------------------------------------
void rtc_read()
//------------------------------------------------------------
{
  Wire.beginTransmission(ds1337_id);
  Wire.write((byte)0x00);
  Wire.endTransmission();
  Wire.requestFrom(ds1337_id, 7);
  for(int i=0; i<7; i++)rtc_data[i] = Wire.read();
}

//------------------------------------------------------------
void rtc_write()
//------------------------------------------------------------
{
  Wire.beginTransmission(ds1337_id);
  Wire.write((byte)0x00);
  for(int i=0; i<7; i++)Wire.write(rtc_data[i]);
  Wire.endTransmission();
}

//------------------------------------------------------------
void print_digit(unsigned char bin1, unsigned char bin2)
//------------------------------------------------------------
{
  writeDigit(1,bin1>>4);
  writeDigit(2,bin1&0x0f);
  writeDigit(4,bin2>>4);
  writeDigit(5,bin2&0x0f);
}

//------------------------------------------------------------
void setup()
//------------------------------------------------------------
{
  pinMode(max7219clkPin,OUTPUT);
  pinMode(max7219csPin,OUTPUT);
  pinMode(max7219dinPin,OUTPUT);
  delay(50);
  Wire.begin();
  initial_max7219();
 
  rtc_data[Hour]    = 0x23;
  rtc_data[Minutes] = 0x59;
  rtc_data[Seconds] = 0x00;
  rtc_write();
}

//------------------------------------------------------------
void loop()
//------------------------------------------------------------
{
  rtc_read();
  print_digit(rtc_data[Hour], rtc_data[Minutes]);
  if(rtc_data[Seconds]&0x01)writeDigit(3,10);
  else writeDigit(3,11);
  delay(50);
}
#14
Projects / 4 digit code lock (mcs-51)
November 10, 2014, 12:38:38 PM
project สมัยวัยละอ่อน

หากถูกใจช่วยกด like เป็นกำลังใจกันด้วยคับ จะทำ project ง่ายๆมาฝากอีก ;D
ปล.หากมีข้อสงสัยรายละเอียด source code กรุณาถามโดย pm. มานะคับ ถามในกระทุ้ผมขอสงวนสิทธิ์ไม่ตอบนะคับ :) 

source code

ว่างๆ เลยเอา 7 segment serial มา upgrade ใช้ AT89LP4052 @18.432Mhz
จี๊ดมาก มี Ram 256 Byte เอามาเป็น fifo-buffer แบบเวอร์ๆมากถึง 160 byte
การแสดงผลออกมาเนียนกว่าใช้ AT89C2051 มาก เลยเอามาลองทำ code lock
แบบ 7 segment ดู.. ก็แปลกไปอีกแบบ เพราะผมเคยเห็นแต่ CLCD...

http://www.youtube.com/v/62-IsaNNCuE

การทำงาน
หน้าจอปรกกติ สามารถป้อน password 4 หลักได้ทันที
ถ้า password ถูกต้องจะแสดง pass กระพริบ 3 ครั้ง
ถ้า password ผิด จะแสดง err
ในระหว่างการป้อน password ถ้าต้องการลบให้กด * แล้วป้อนใหม่ได้

การเปลี่ยน password
กด # จะแสดง P-[xxxx]ใส่ password เดิม ถ้า password ผิด จะแสดง err
ถ้า password ถูกต้องจะแสดง n-[xxxx] ใส่ password ใหม่
ถ้า password ผิด จะแสดง err ถ้า password ถูกต้องจะแสดง A-[xxxx]
ยืนยัน password ใหม่อีกครั้ง ถ้า password ใหม่ถูกต้องจะแสดง pass
ลองไปต่อยอดกันดูครับ... :)
#15
Projects / Clock + Calendar + Temp (mcs-51)
November 10, 2014, 12:11:23 PM
project สมัยวัยละอ่อน

หากถูกใจช่วยกด like เป็นกำลังใจกันด้วยคับ จะทำ project ง่ายๆมาฝากอีก ;D
ปล.หากมีข้อสงสัยรายละเอียด source code กรุณาถามโดย pm. มานะคับ ถามในกระทุ้ผมขอสงวนสิทธิ์ไม่ตอบนะคับ :) 

Source Code (Keil C)

ด้นเขียนจนเสร็จ...

http://www.youtube.com/v/BrWxfUtzF2A

#16
Projects / Countdown Timer (PIC12F675)
November 09, 2014, 05:02:04 PM

ตั้งเวลาได้ 1-59 วิ หลังจากนั้นจะปัดเป็นนาที โดยสูงสุดที่ 99นาที เมืออยู่ในหน่วยของนาที ขณะนับตัวเลขจะกระพริบ
สามารถปรับตั้งเวลาขณะนับได้ เมื่อนับจนเป็น 0 จะมี alarm ดังประมาณ 30วิแล้วหยุดเอง หรือถ้าต้องการยกเลิก ให้กดปุ่มใดๆก็ได้

หากถูกใจช่วยกด like เป็นกำลังใจกันด้วยคับ จะทำ project ง่ายๆมาฝากอีก ;D

ปล.หากมีข้อสงสัยรายละเอียด source code กรุณาถามโดย pm. มานะคับ ถามในกระทุ้ผมขอสงวนสิทธิ์ไม่ตอบนะคับ :)

Download Source

http://www.youtube.com/v/QRpnMfxstIo

#17
Projects / MCS51 Countdown Timer 99นาที
October 15, 2014, 09:33:21 PM

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

จำได้ว่าเคยทำเป็นโครงงานของเด็ก ม.ปลาย หรือ ปวช นี่แหละสองปีที่แล้วโน่น

code เป้นแบบ state machine ไม่มีการใช้ interrupt ใดๆทั้งสิ้น เพราะโจทย์ไม่ได้ซับซ้อนเป็น
งานง่ายๆ รับค่า switch สั่ง แสดงผลโดยการ scan ซึ่งงานนี้ใช้ MCS51 อย่าง AT89C2051 เหลือๆ

switch มีสามปุ่ม
1.Set
2.Up และ Start
3.Down และ Stop

การทำงานหัวใจหลักๆก็ AT89C2051 นี่แหละคับตัวเดียวเลย ;D

งานหยาบๆนิดนึงแต่มองง่ายประกอบง่าย








วิดีโอตอนทดสอบ

http://www.youtube.com/v/JYf3wl9bEAA


file pcb คับ eagle 5.6.0

https://drive.google.com/file/d/0B77_GeSXdC6rX24zdmY4Q1FycFE/view?usp=sharing



code ไม่สั้นไม่ยาวเขียนไว้นานแล้วอาจยังไม่เนี๊ยบไม่เนียนไม่ถูกหลักไม่ได้กรองไม่ได้สมบูรณ์แบบ
ตอนนั้นเพิ่งเข้าวงการกำลังหัดเดินด้วยภาษา C แต่ก็พอถูๆไถๆไปได้ ;D

/*
Program        :CountDown 4Digit
Date              :2/02/2012
Author           :Mr.Somlak Mangnimit
Compiler        :Keil 4.5
Device           :AT89C2051 @12MHz
*/


#include <at892051.h>


#define SegmentPort P1
#define SwitchSET P3_1
#define SwitchINC P3_0
#define SwitchDEC P3_2
#define Speaker P3_3


#define CommonDigit1 P1_0
#define CommonDigit2 P3_7
#define CommonDigit3 P3_5
#define CommonDigit4 P3_4


volatile bit
BlinkFlag,Alarm;


volatile unsigned char
DigitSEL,Debounce,SwitchSTATE,
BlinkPOS,BlinkCNT,
CounterMODE,CounterVAL,
SEC,MIN,Num1,Num2,Num3,Num4,
AlarmCNT
;


unsigned char code SegTAB[] = {
//-0----1----2----3----4----5----6----7----8----9----[----]----t--neg-blank
//0x80,0xf3,0x49,0x61,0x33,0x25,0x05,0xf1,0x01,0x21,0x8d,0xe1,0x0f,0x7f,0xff
0x81,0xe7,0x49,0x45,0x27,0x15,0x11,0xc7,0x01,0x05,0x39,0xff
};


//===============//
// Wait tick 5ms //
//===============//
void WaitTick(void){
while(TF0==0);
TF0 = 0;
TH0 = 0xec;
TL0 = 0x78;
BlinkCNT++;
if(BlinkCNT==50){
BlinkFlag = ~BlinkFlag;
BlinkCNT = 0x00;
}
}


//================//
// scan 7 segment //
//================//
void Scan(void){
WaitTick();
CommonDigit1 = 1;
CommonDigit2 = 1;
CommonDigit3 = 1;
CommonDigit4 = 1;
DigitSEL++;
if(BlinkPOS==5&&BlinkFlag==1){return;}


switch(DigitSEL){
case 1:
SegmentPort = SegTAB[Num1]|1;
if(BlinkPOS==1){
CommonDigit1 = BlinkFlag;
break;
}
CommonDigit1 = 0;
break;


case 2:
SegmentPort = SegTAB[Num2]|1;
if(BlinkPOS==2){
CommonDigit2 = BlinkFlag;
break;
}
CommonDigit2 = 0;
break;


case 3:
SegmentPort = SegTAB[Num3]|1;
if(BlinkPOS==3){
CommonDigit3 = BlinkFlag;
break;
}
CommonDigit3 = 0;
break;


default:
DigitSEL = 0x00;
SegmentPort = SegTAB[Num4]|1;
if(BlinkPOS==4){
CommonDigit4 = BlinkFlag;
break;
}
CommonDigit4 = 0;
break;
}
}


//=================//
// Sound Generator //
//=================//
void BeepDelay(int val){
while(--val);
}


void SoundDelay(int val){
unsigned long x = val*100;
while(--x);
}


void Beep(void){
int Duration;
for(Duration=0;Duration<60;Duration++){
Speaker = 0;
BeepDelay(40);
Speaker = 1;
BeepDelay(40);
}
Speaker = 1;
}


void Sound(void){
unsigned char x;
for(x=0;x<4;x++){
Beep();
SoundDelay(20);
}
}


//=========//
// Initial //
//=========//
void Setup(void){
P1 = 0xff;
P3 = 0xff;
BlinkPOS = 0;
SwitchSTATE = 0;
Num1 = 0;
Num2 = 0;
Num3 = 0;
Num4 = 0;


TMOD = 0x21;
TR0 = 0;
TH0 = 0x78;
TL0 = 0xec;
TR0 = 1;
TF0 = 0;
}


//==============//
// main program //
//==============//
void main(void){
Setup();


while(1){
Scan();
Debounce++;


//-------------------------------------------------------------
// SwitchSTATE 0
//-------------------------------------------------------------
if(!SwitchSTATE&&(!SwitchSET||!SwitchINC||!SwitchDEC)){
SwitchSTATE = 1;
Debounce = 0;
}


//-------------------------------------------------------------
// SwitchSTATE 1
//-------------------------------------------------------------
if(SwitchSTATE==1&&Debounce==10){


//-------------------------------------------------
// SwitchSET
//-------------------------------------------------
if(!SwitchSET){
BlinkPOS++;
if(BlinkPOS<3){
BlinkPOS = 3;
Num3 = Num1;
Num4 = Num2;
Num1 = 11;
Num2 = 10;
}


if(BlinkPOS>4){
BlinkPOS = 0;
Num1 = Num3;
Num2 = Num4;
Num3 = 0;
Num4 = 0;
MIN = Num1<<4|Num2;
SEC = 0x60;
CounterVAL = 0;
}


CounterMODE = 0;
SwitchSTATE = 2;
continue;
}


//-------------------------------------------------
// SwitchINC Mode 0
//-------------------------------------------------
if(!SwitchINC&&!CounterMODE){
switch(BlinkPOS){
case 0:
if(!MIN&&SEC==0x60)break;
CounterMODE = 1; //Start
break;


case 3:
Num3++;
if(Num3>9){Num3=0;}
break;


case 4:
Num4++;
if(Num4>9){Num4=0;}
break;
}
SwitchSTATE = 2;
continue;
}


//-------------------------------------------------
// SwitchDEC Mode 0
//-------------------------------------------------
if(!SwitchDEC&&!CounterMODE){
switch(BlinkPOS){


case 3:
Num3--;
if(Num3==255){Num3=9;}
break;


case 4:
Num4--;
if(Num4==255){Num4=9;}
break;
}
SwitchSTATE = 2;
continue;
}


//-------------------------------------------------
// SwitchDEC Mode 1
//-------------------------------------------------
if(!SwitchDEC&&CounterMODE){
CounterMODE = 0;
}
}


//-------------------------------------------------------------
// SwitchSTATE 2
//-------------------------------------------------------------
if(SwitchSET&&SwitchINC&&SwitchDEC){
SwitchSTATE = 0;
}


//-------------------------------------------------------------
// Timer
//-------------------------------------------------------------
if(CounterMODE){
CounterVAL++;
if(CounterVAL==200){
CounterVAL = 0;
SEC--;
if((SEC&0x0f)==0x0f)SEC-=6;
if(!SEC&&!MIN){
Alarm = 1;
AlarmCNT = 0;
CounterMODE = 0;
}


if(!SEC){
SEC = 0x60;
Num3 = 0;
Num4 = 0;
continue;
}


if(MIN){
if(SEC==0x59){
MIN--;
if((MIN&0x0f)==0x0f)MIN-=6;
}
}


Num1 = MIN>>4;
Num2 = MIN&0x0f;
Num3 = SEC>>4;
Num4 = SEC&0x0f;
}
}


//-------------------------------------------------------------
// Timer
//-------------------------------------------------------------
if(Alarm&&!CounterMODE){
AlarmCNT++;
if(AlarmCNT==100){
AlarmCNT = 0;
CommonDigit1 = 1;
CommonDigit2 = 1;
CommonDigit3 = 1;
CommonDigit4 = 1;
Sound();
if(!SwitchSET||!SwitchINC||!SwitchDEC){
Alarm = 0;
AlarmCNT = 0;
}
}
}
}
}


ถ้าชอบใจก็ช่วยกันกด like ใต้รูป avata ของผม เพื่อเป็นกำลังใจกันเยอะๆนะคับ จะทำโปรเจคง่ายๆมาฝากกันเรื่อยๆ :-*

#18
รายละเอียดคงต้องรอช่วงว่างคับ ช่วงนี้เล่นเอามันส์ งานหลักยังรออีกหลายงาน วันนี้ลงทุนซื้อ smart phone ใหม่
เพื่อเอามาเล่นโดยเฉพาะ ;D เริ่มติดใจ เพราะคิดว่าต่อยอดงานที่ทำอยู่ได้อีกเยอะแยะ เพิ่งได้เล่นครั้งแรกรู้สึกว่ามันง่าย
ประกอบกับข้อมูลและตัวอย่างค่อนข้างเยอะ เลยไม่ต้องดำน้ำเอง


อันแรกเล่นกับ bluetooth
http://www.youtube.com/v/KYKyv0edsvc








BlueControl.APK
Download


Arduino source code
int LED = 13;
String readString;

void setup()
{
  Serial.begin(9600);
  pinMode(LED, OUTPUT);
}

void loop()
{
  while(Serial.available())
  {
    delay(3);
    char c = Serial.read();
    readString += c;
  }
 
  if(readString.length() > 0)
  {
    Serial.println(readString);
    if(readString == "on")
    {
      digitalWrite(LED, HIGH);
    }
    if(readString == "off")
    {
      digitalWrite(LED, LOW);
    }
    readString = "";
  }
}
#19
ทดสอบระยะส่ง nRF24L01+ (PA) ครั้งที่สอง
ขออนุญาตท่านผู้นำนะคับ น่าจะมีประโยชน์กับคนที่อยากลองควบคุมอะไรบางอย่างจากระยะไกลแบบไร้สาย

ธงก้อนโฟมดุ๊กดิ๊ก


ธงก้อนโฟมดุ๊กดิ๊กต่อกับ servo


พร้อมแว้ว .... ^^


ถ้าเป็นตัวไม่มี PA ระยะแค่นี้ก็เดี้ยงแล้ว


มันไกลจุงเบย ยังคุม servo ได้ปรกติ แต่เกือบมองไม่เห็นแล้ว เลยเลิก


ภาครับ



// http://www.bajdi.com
// Nrf24L01 connected to Arduino Uno
// Nrf24L01 connection details http://arduino-info.wikispaces.com/Nrf24L01-2.4GHz-HowTo
// Receives analog value from transmitter and maps it to a PWM range (0-255) to dim a led


#include <SPI.h>
#include <Servo.h>
#include <Mirf.h>
#include <nRF24L01.h>
#include <MirfHardwareSpiDriver.h>

int rate;
int val;


Servo myservo;  // create servo object to control a servo

void setup(){
 
  Mirf.cePin = 9;             //ce pin on Mega 2560, REMOVE THIS LINE IF YOU ARE USING AN UNO
  Mirf.csnPin = 10;            //csn pin on Mega 2560, REMOVE THIS LINE IF YOU ARE USING AN UNO
  myservo.attach(6);  // attaches the servo on pin 9 to the servo object
  Mirf.spi = &MirfHardwareSpi;
  Mirf.init();
  Mirf.setRADDR((byte *)"serv1");
  Mirf.payload = sizeof(rate);
  Mirf.config();
}

void loop(){

  while(!Mirf.dataReady()){
  }
  Mirf.getData((byte *) &rate);
  val = map(rate, 0, 1023, 0, 179);
  myservo.write(val);
  delay(10);
}


ภาคส่ง

// http://www.bajdi.com
// Nrf24L01 connected to Mega 2560
// Nrf24L01 connection details http://arduino-info.wikispaces.com/Nrf24L01-2.4GHz-HowTo
// Transmit analog value from pin A0 to the receiver

#include <SPI.h>
#include <Mirf.h>
#include <nRF24L01.h>
#include <MirfHardwareSpiDriver.h>

int rate;

void setup(){

  Serial.begin(9600);
  Mirf.cePin = 9;             //ce pin on Mega 2560, REMOVE THIS LINE IF YOU ARE USING AN UNO
  Mirf.csnPin = 10;            //csn pin on Mega 2560, REMOVE THIS LINE IF YOU ARE USING AN UNO
  Mirf.spi = &MirfHardwareSpi;
  Mirf.init();
  Mirf.setRADDR((byte *)"clie1");
  Mirf.payload = sizeof(rate);
  Mirf.config();
}

void loop(){
  rate = analogRead(A0);

  Mirf.setTADDR((byte *)"serv1");

  Mirf.send((byte *) &rate);

  while(Mirf.isSending()){
  }
}


สรุป

ระยะที่ module ทำได้จริงๆอาจได้ถึง 500 เมตรหรือไกลกว่านั้น ผมยังอึ้งๆอยู่แบบว่าราคากับคุณภาพมัน...ที่เหลืออธิบายด้วยภาพ
รายละเอียดต่างๆหาอ่านเพิ่มเติมได้จาก internet คับ
#20

ขาย raspberry pi + อุปกรณ์   (**ปิดการขายครับ**)


โทร O89-8I9-45O8 หรือ Email j e n g m o d (at) g m a i l . c o m