News:

Exness ลงทะเบียนระบบใหม่ ใส่รหัสพาร์ทเนอร์ 73208
https://www.exness.com/boarding/sign-up/a/73208?lng=th
1. เลือกประเทศ ไทย
2. อีเมล์จริงของคุณ
3. รหัสผ่าน
* รหัสผ่านต้องมีความยาว 8-15 ตัว
* ใช้ทั้งอักษรตัวพิมพ์ใหญ่และตัวพิมพ์เล็ก
* ใช้ทั้งตัวเลขและตัวอักษรภาษาอังกฤษ
* ห้ามใช้อักขระพิเศษ (!@#$%^&*., และอื่นๆ)
4. ใส่รหัสพาร์ทเนอร์ 73208
---------------------------------------------------------

Main Menu

Recent posts

#1
วันแรงงาน (Labour Day) มีจุดเริ่มต้นมาจากการต่อสู้ของแรงงานในประเทศ สหรัฐอเมริกา ในช่วงปลายศตวรรษที่ 19

### จุดเริ่มต้นสำคัญ

เหตุการณ์หลักคือ
👉 Haymarket Affair
เกิดขึ้นที่เมือง ชิคาโก ในปี ค.ศ. 1886

ตอนนั้นแรงงานเรียกร้องให้ลดเวลาทำงานเหลือ **วันละ 8 ชั่วโมง**
(ก่อนหน้านั้นทำงานหนักถึง 10–16 ชั่วโมงต่อวัน)

### เหตุการณ์ที่เกิดขึ้น

* วันที่ 1 พฤษภาคม 1886 แรงงานทั่วอเมริกานัดหยุดงานครั้งใหญ่
* ต่อมาในวันที่ 4 พฤษภาคม มีการชุมนุมที่ Haymarket Square
* เกิดเหตุระเบิดและความรุนแรง ทำให้มีผู้เสียชีวิตทั้งตำรวจและประชาชน

### ผลลัพธ์

เหตุการณ์นี้กลายเป็นสัญลักษณ์ของการต่อสู้เพื่อสิทธิแรงงานทั่วโลก
และนำไปสู่การกำหนดให้

👉 วันที่ 1 พฤษภาคม เป็น
วันแรงงานสากล

### ในประเทศไทย

ประเทศไทยเริ่มจัด "วันแรงงานแห่งชาติ" อย่างเป็นทางการในปี พ.ศ. 2499
และกำหนดให้ **1 พฤษภาคมของทุกปี** เป็นวันหยุดแรงงาน

---

### สรุปสั้นๆ

* เริ่มจากการเรียกร้องสิทธิแรงงานในสหรัฐอเมริกา
* จุดสำคัญคือเหตุการณ์ Haymarket
* กลายเป็นวันสำคัญระดับโลกเพื่อยกย่องแรงงาน

--------------------------------------------
#2
กฎแบดมินตัน **15 แต้ม (3×15)** เป็น "กติกาใหม่" ที่เพิ่งถูกอนุมัติโดย Badminton World Federation (BWF) และจะเริ่มใช้ในระดับนานาชาติประมาณปี **2027** ([Thairath English][1])

## 🔥 สรุปกติกาใหม่ 15 แต้ม

* แข่งแบบ **ชนะ 2 ใน 3 เกม (Best of 3)**
* แต่ละเกมเล่นถึง **15 คะแนน** (แทน 21 เดิม) ([Fan Zone][2])
* ต้องชนะห่างอย่างน้อย **2 คะแนน**
* ถ้าสูสี เช่น 14–14 → ต้องเล่นต่อจนห่าง 2 แต้ม
* บางกรณีมีเพดานคะแนนสูงสุด (เช่น 20 หรือ 21 แล้วแต่รูปแบบทดลอง) ([The Bridge - Home of Indian Sports][3])

---

## ⚖️ เทียบกับกติกาเดิม

| กติกา           | เดิม    | ใหม่     |
| --------------- | ------- | -------- |
| จำนวนแต้มต่อเกม | 21      | 15       |
| รูปแบบ          | 3 เกม   | 3 เกม    |
| ความยาวเกม      | ยาวกว่า | สั้นลง   |
| ความเร็วเกม     | ปานกลาง | เร็วขึ้น |

---

## 🎯 ทำไมต้องเปลี่ยนเป็น 15 แต้ม

เหตุผลหลักของ BWF:

* ทำให้เกม **เร็วขึ้น ตื่นเต้นขึ้น** ([Fan Zone][2])
* ลดเวลาแข่งขัน (เหมาะกับถ่ายทอดสด)
* ลดความเหนื่อยและการบาดเจ็บของนักกีฬา ([BBC][4])
* ทำให้แต้มสูสี มีโอกาสพลิกเกมมากขึ้น

---

## 📌 ผลกระทบต่อการเล่น

* เกมจะ "ไว" มาก → พลาดนิดเดียวเสียเปรียบทันที
* นักกีฬาต้อง **เริ่มแรงตั้งแต่ต้นเกม**
* สายวางแผนยาว ๆ (Endurance) อาจเสียเปรียบ
* สายบุกเร็ว จะได้เปรียบมากขึ้น

---

## 🧠 สรุปง่าย ๆ

> จากเดิม "ค่อย ๆ เล่น 21 แต้ม"
> 👉 เปลี่ยนเป็น "บุกเร็ว ตัดสินไว 15 แต้ม"

---

ถ้าคุณเล่นจริง (เช่นตีสมัครเล่นหรือแข่ง) ผมแนะนำปรับสไตล์การเล่นให้เหมาะกับระบบใหม่นี้ได้ครับ เดี๋ยวผมช่วยวางกลยุทธ์แบบ 15 แต้มให้ได้ 👍

[1]: https://en.thairath.co.th/sport/worldsport/2928862?utm_source=chatgpt.com "Badminton to Adopt New Scoring System Fully Next Year ..."
[2]: https://badmintoneurope.com/w/new-scoring-system-3-x-15?utm_source=chatgpt.com "New scoring system - 3 x 15 - Fan Zone"
[3]: https://thebridge.in/badminton/explained-what-is-bwfs-newly-approved-3x15-points-system-in-badminton-56391?utm_source=chatgpt.com "Explained: What is BWF's newly approved 3x15 points system ..."
[4]: https://www.bbc.co.uk/sport/badminton/articles/cwyd4edznv2o?utm_source=chatgpt.com "Badminton votes to change scoring system from 2027 - BBC"
#3
การวัด "น้ำหนักตัวอย่างเดียว" บอกได้แค่ภาพรวม แต่ **ยังไม่พอที่จะบอกว่าสุขภาพดีหรือรูปร่างเหมาะสมหรือไม่** เพราะน้ำหนักไม่ได้แยกว่าเป็นไขมัน กล้ามเนื้อ หรือน้ำในร่างกาย

ถ้าจะประเมินว่า "เหมาะสมหรือไม่" ควรดูหลายค่าร่วมกัน 👇

---

## 1. ค่า BMI (ดัชนีมวลกาย)

ใช้ประเมินเบื้องต้นว่าอ้วนหรือผอม

สูตร:
[
BMI = \frac{น้ำหนัก(kg)}{ส่วนสูง(m)^2}
]

เกณฑ์ (คนเอเชีย):

* < 18.5 = ผอม
* 18.5 – 22.9 = ปกติ
* 23 – 24.9 = เริ่มท้วม
* ≥ 25 = อ้วน

👉 ข้อจำกัด: คนมีกล้ามเยอะ (เช่นออกกำลังกาย) อาจ BMI สูงแต่ไม่ได้อ้วนจริง

---

## 2. % ไขมันในร่างกาย (Body Fat %)

อันนี้สำคัญกว่าน้ำหนัก

* ผู้ชาย:

  * 10–20% = ดี
  * 20–25% = เริ่มสะสม
  * > 25% = ไขมันสูง

👉 ใช้วัดด้วย:

* เครื่องชั่งแบบ BIA (ที่บ้าน)
* เครื่อง InBody (ฟิตเนส/โรงพยาบาล)

---

## 3. รอบเอว (Waist Circumference)

บอกไขมันหน้าท้อง (อันตรายสุด)

* ผู้ชาย: ไม่ควรเกิน **90 ซม.**

👉 ถ้าเอวใหญ่ = เสี่ยงโรค เช่น เบาหวาน ความดัน

---

## 4. อัตราส่วนเอวต่อส่วนสูง (Waist-to-Height Ratio)

สูตร:
[
เอว ÷ ส่วนสูง
]

* ควร < 0.5 = ดี

---

## 5. มวลกล้ามเนื้อ (Muscle Mass)

สำคัญมากถ้าคุณ:

* ต้องการ "ลดพุง + สร้างกล้าม"

👉 น้ำหนักอาจไม่ลด แต่รูปร่างดีขึ้นได้

---

## สรุปแบบเข้าใจง่าย

* ❌ ดูแค่น้ำหนัก = ไม่พอ
* ✅ ควรดูร่วมกัน:

  * BMI
  * % ไขมัน
  * รอบเอว
  * กล้ามเนื้อ

แต่ถ้าคุณออกกำลังกายอยู่:

* ต้องดู **% ไขมัน + รอบเอว** เพิ่ม จะแม่นยำกว่า

----------------------------------------------
#4
การใช้ **MACD Divergence** เทรดจริง (Buy / Sell) เป็นเทคนิค "ดูแรงโมเมนตัมสวนกับราคา" ซึ่งช่วยหาจุด "กลับตัว" ได้ค่อนข้างดี ถ้าใช้ถูกวิธีจะแม่นมากกว่า MACD ปกติ

เปิดบัญชี Standard ได้ที่ https://www.exness.com/a/73208

ผมอธิบายแบบใช้ได้จริงเลย 👇

---

# 🔍 1. MACD Divergence คืออะไร (เข้าใจสั้นๆ)

คือการที่

* **ราคา (Price)** ไปทางหนึ่ง
* แต่ **MACD** ไปอีกทางหนึ่ง

👉 แปลว่า "แรงเริ่มหมด" มีโอกาสกลับตัว

---

# 📈 2. ประเภทที่ใช้เทรดจริง

## 🟢 (1) Bullish Divergence → ใช้เข้า BUY

เกิดตอน "ตลาดกำลังจะขึ้น"

### วิธีดู

* ราคาทำ **Low ใหม่ (ต่ำลง)**
* แต่ MACD ทำ **Low สูงขึ้น**

👉 ราคา: ลง ↓
👉 MACD: ขึ้น ↑

### แปลว่าอะไร

แรงขาย "อ่อนลง" → มีโอกาสกลับขึ้น

---

## 🔴 (2) Bearish Divergence → ใช้เข้า SELL

เกิดตอน "ตลาดกำลังจะลง"

### วิธีดู

* ราคาทำ **High ใหม่ (สูงขึ้น)**
* แต่ MACD ทำ **High ต่ำลง**

👉 ราคา: ขึ้น ↑
👉 MACD: ลง ↓

### แปลว่าอะไร

แรงซื้อ "อ่อนลง" → มีโอกาสกลับลง

---

# 🎯 3. วิธีเข้าเทรดจริง (สำคัญมาก)

## ✅ กลยุทธ์ BUY (Bullish Divergence)

### Step:

1. หา Divergence ให้เจอ
2. รอ "แท่งยืนยัน" (Bullish Candle)
3. เข้า Buy

### จุดเข้า (Entry)

* เข้าเมื่อแท่งเขียวปิด
* หรือ Break High แท่งก่อนหน้า

### Stop Loss

* ใต้ Low ล่าสุด

### Take Profit

* แนวต้าน
* หรือ RR = 1:2 ขึ้นไป

---

## ✅ กลยุทธ์ SELL (Bearish Divergence)

### Step:

1. หา Divergence
2. รอแท่งแดงยืนยัน
3. เข้า Sell

### จุดเข้า

* เข้าเมื่อแท่งแดงปิด
* หรือ Break Low

### Stop Loss

* เหนือ High ล่าสุด

### Take Profit

* แนวรับ
* หรือ RR 1:2

---

# ⚠️ 4. ข้อผิดพลาดที่คนส่วนใหญ่พลาด

❌ เข้าเลยทันทีที่เห็น Divergence
✔ ต้อง "รอแท่งยืนยัน"

❌ ใช้ในตลาด Sideway มั่วๆ
✔ ใช้ดีที่สุดตอน "ปลายเทรนด์"

❌ ไม่ดู Timeframe ใหญ่
✔ ควรดู H1 + H4 คู่กัน

---

# 🔥 5. เทคนิคระดับมืออาชีพ (ใช้แล้วแม่นขึ้นเยอะ)

### ✅ ใช้ร่วมกับ

* Support / Resistance
* Trendline
* Supply / Demand

👉 ถ้า Divergence เกิดตรง "แนวสำคัญ" = โอกาสชนะสูงมาก

---

### ✅ ใช้กับ Timeframe

* Scalping → M5 / M15
* ทำเงินจริง → **H1 (ดีที่สุดสำหรับคุณ)**
* Swing → H4

---

### ✅ ใช้กับคู่เงิน

* EURUSD (นิ่ง อ่านง่าย)
* GBPUSD (แรง แต่ต้อง SL กว้าง)

---

# 💡 6. ตัวอย่างสถานการณ์จริง

## BUY

* EURUSD ลงทำ Low ใหม่
* MACD ไม่ลงตาม
* เกิด Bullish Divergence
* มีแท่งเขียวกลับตัว

👉 เข้า Buy → กำไรจากการกลับตัว

---

## SELL

* GBPUSD ขึ้นทำ High ใหม่
* MACD เริ่มต่ำลง
* เกิด Bearish Divergence

👉 เข้า Sell → กินรอบลง

---

# 📊 7. สูตรลัด (จำง่ายมาก)

* ราคา ↓ แต่ MACD ↑ = BUY
* ราคา ↑ แต่ MACD ↓ = SELL

-------------------------------------
#5
แจกฟรี MACD Divergence Indicator (MQL5)

เปิดบัญชีมืออาชีพได้ที่ https://www.exness.com/a/73208

ไว้ดูกราฟ MT5 หาประกอบกับ EA ที่ได้เขียนมาใช้งานเทรด

//+------------------------------------------------------------------+
//| MACD Divergence Indicator (MQL5)                                |
//| Converted from MQL4 original                                    |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2026, junjao.com"
#property link      "http://www.exness.com/a/73208"

#property indicator_separate_window
#property indicator_buffers 5
#property indicator_plots  5
#property indicator_level1  0.0

//---- ไม่ใช้ #property indicator_label/type/color ที่นี่
//---- เพราะ MQL5 จะ warning "property already exists" เมื่อ type หรือ color ซ้ำกัน
//---- ตั้งค่าทั้งหมดใน OnInit() ด้วย PlotIndexSet แทน

#define arrowsDisplacement 0.0001

//---- Input parameters
input string separator1              = "*** MACD Settings ***";
input int    FastMAPeriod            = 12;
input int    SlowMAPeriod            = 26;
input int    SignalMAPeriod          = 9;
input string separator2              = "*** Indicator Settings ***";
input bool  drawIndicatorTrendLines = true;
input bool  drawPriceTrendLines    = true;
input bool  displayAlert            = true;

//---- Buffers
double MACDLineBuffer[];
double SignalLineBuffer[];
double HistogramBuffer[];
double bullishDivergence[];
double bearishDivergence[];

//---- Variables
double alpha  = 0;
double alpha_1 = 0;

static datetime lastAlertTime;
static string  indicatorName;

//---- Handles for iMA
int hFastMA;
int hSlowMA;

//+------------------------------------------------------------------+
//| Custom indicator initialization function                        |
//+------------------------------------------------------------------+
int OnInit()
  {
  IndicatorSetInteger(INDICATOR_DIGITS, _Digits + 1);

  //---- Bind buffers
  SetIndexBuffer(0, MACDLineBuffer,    INDICATOR_DATA);
  SetIndexBuffer(1, SignalLineBuffer,  INDICATOR_DATA);
  SetIndexBuffer(2, HistogramBuffer,  INDICATOR_DATA);
  SetIndexBuffer(3, bullishDivergence, INDICATOR_DATA);
  SetIndexBuffer(4, bearishDivergence, INDICATOR_DATA);

  //---- Plot 0: MACD Line (DodgerBlue)
  PlotIndexSetInteger(0, PLOT_DRAW_TYPE,  DRAW_LINE);
  PlotIndexSetInteger(0, PLOT_LINE_COLOR,  clrDodgerBlue);
  PlotIndexSetInteger(0, PLOT_LINE_WIDTH,  1);
  PlotIndexSetString (0, PLOT_LABEL,      "MACD Line");
  PlotIndexSetInteger(0, PLOT_DRAW_BEGIN,  SlowMAPeriod);

  //---- Plot 1: Signal Line (Red)
  PlotIndexSetInteger(1, PLOT_DRAW_TYPE,  DRAW_LINE);
  PlotIndexSetInteger(1, PLOT_LINE_COLOR,  clrRed);
  PlotIndexSetInteger(1, PLOT_LINE_WIDTH,  1);
  PlotIndexSetString (1, PLOT_LABEL,      "Signal Line");
  PlotIndexSetInteger(1, PLOT_DRAW_BEGIN,  SlowMAPeriod + SignalMAPeriod);

  //---- Plot 2: Histogram (Silver)
  PlotIndexSetInteger(2, PLOT_DRAW_TYPE,  DRAW_HISTOGRAM);
  PlotIndexSetInteger(2, PLOT_LINE_COLOR,  clrSilver);
  PlotIndexSetInteger(2, PLOT_LINE_WIDTH,  2);
  PlotIndexSetString (2, PLOT_LABEL,      "Histogram");
  PlotIndexSetInteger(2, PLOT_DRAW_BEGIN,  SlowMAPeriod + SignalMAPeriod);

  //---- Plot 3: Bullish Divergence arrow (Lime, arrow 233 = up)
  PlotIndexSetInteger(3, PLOT_DRAW_TYPE,  DRAW_ARROW);
  PlotIndexSetInteger(3, PLOT_ARROW,      233);
  PlotIndexSetInteger(3, PLOT_LINE_COLOR,  clrLime);
  PlotIndexSetString (3, PLOT_LABEL,      "Bullish Divergence");
  PlotIndexSetDouble (3, PLOT_EMPTY_VALUE, EMPTY_VALUE);

  //---- Plot 4: Bearish Divergence arrow (Red, arrow 234 = down)
  PlotIndexSetInteger(4, PLOT_DRAW_TYPE,  DRAW_ARROW);
  PlotIndexSetInteger(4, PLOT_ARROW,      234);
  PlotIndexSetInteger(4, PLOT_LINE_COLOR,  clrRed);
  PlotIndexSetString (4, PLOT_LABEL,      "Bearish Divergence");
  PlotIndexSetDouble (4, PLOT_EMPTY_VALUE, EMPTY_VALUE);

  //---- Indicator short name
  indicatorName = "MACD(" + IntegerToString(FastMAPeriod) + "," +
                  IntegerToString(SlowMAPeriod) + "," +
                  IntegerToString(SignalMAPeriod) + ")";
  IndicatorSetString(INDICATOR_SHORTNAME, indicatorName);

  //---- EMA smoothing factor
  alpha  = 2.0 / (SignalMAPeriod + 1.0);
  alpha_1 = 1.0 - alpha;

  //---- Create MA handles
  hFastMA = iMA(NULL, 0, FastMAPeriod, 0, MODE_EMA, PRICE_CLOSE);
  hSlowMA = iMA(NULL, 0, SlowMAPeriod, 0, MODE_EMA, PRICE_CLOSE);

  if(hFastMA == INVALID_HANDLE || hSlowMA == INVALID_HANDLE)
    {
      Print("Failed to create MA handles");
      return(INIT_FAILED);
    }

  return(INIT_SUCCEEDED);
  }

//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                      |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
  for(int i = ObjectsTotal(0, 0, -1) - 1; i >= 0; i--)
    {
      string label = ObjectName(0, i, 0, -1);
      if(StringSubstr(label, 0, 19) != "MACD_DivergenceLine")
        continue;
      ObjectDelete(0, label);
    }
  IndicatorRelease(hFastMA);
  IndicatorRelease(hSlowMA);
  }

//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double  &open[],
                const double  &high[],
                const double  &low[],
                const double  &close[],
                const long    &tick_volume[],
                const long    &volume[],
                const int      &spread[])
  {
  if(rates_total < SlowMAPeriod + SignalMAPeriod + 5)
      return(0);

  //---- Copy MA buffers
  double fastMA[], slowMA[];
  if(CopyBuffer(hFastMA, 0, 0, rates_total, fastMA) <= 0) return(prev_calculated);
  if(CopyBuffer(hSlowMA, 0, 0, rates_total, slowMA) <= 0) return(prev_calculated);

  //---- Use chronological order: index 0 = oldest bar
  ArraySetAsSeries(fastMA, false);
  ArraySetAsSeries(slowMA, false);
  ArraySetAsSeries(time,  false);
  ArraySetAsSeries(high,  false);
  ArraySetAsSeries(low,    false);

  int limit = (prev_calculated == 0) ? SlowMAPeriod : prev_calculated - 1;

  //---- Calculate MACD, Signal, Histogram
  for(int i = limit; i < rates_total; i++)
    {
      MACDLineBuffer = fastMA - slowMA;
      if(i == 0)
        SignalLineBuffer = MACDLineBuffer;
      else
        SignalLineBuffer = alpha * MACDLineBuffer + alpha_1 * SignalLineBuffer[i - 1];
      HistogramBuffer  = MACDLineBuffer - SignalLineBuffer;
      bullishDivergence = EMPTY_VALUE;
      bearishDivergence = EMPTY_VALUE;
    }

  //---- Detect divergences (skip last 2 unconfirmed bars)
  for(int i = limit; i < rates_total - 2; i++)
    {
      CatchBullishDivergence(i, time, low,  rates_total);
      CatchBearishDivergence(i, time, high, rates_total);
    }

  return(rates_total);
  }

//+------------------------------------------------------------------+
//| Returns true if bar[shift] is a MACD trough                      |
//+------------------------------------------------------------------+
bool IsIndicatorTrough(int shift, int total)
  {
  if(shift < 2 || shift >= total - 1) return(false);
  return(MACDLineBuffer[shift] <= MACDLineBuffer[shift - 1] &&
          MACDLineBuffer[shift] <  MACDLineBuffer[shift - 2] &&
          MACDLineBuffer[shift] <  MACDLineBuffer[shift + 1]);
  }

//+------------------------------------------------------------------+
//| Returns true if bar[shift] is a MACD peak                        |
//+------------------------------------------------------------------+
bool IsIndicatorPeak(int shift, int total)
  {
  if(shift < 2 || shift >= total - 1) return(false);
  return(MACDLineBuffer[shift] >= MACDLineBuffer[shift - 1] &&
          MACDLineBuffer[shift] >  MACDLineBuffer[shift - 2] &&
          MACDLineBuffer[shift] >  MACDLineBuffer[shift + 1]);
  }

//+------------------------------------------------------------------+
//| Find the previous MACD trough before shift                      |
//+------------------------------------------------------------------+
int GetIndicatorLastTrough(int shift, int total)
  {
  for(int i = shift - 5; i >= 2; i--)
    {
      if(SignalLineBuffer <= SignalLineBuffer[i - 1] &&
        SignalLineBuffer <= SignalLineBuffer[i - 2] &&
        SignalLineBuffer <= SignalLineBuffer[i + 1] &&
        SignalLineBuffer <= SignalLineBuffer[i + 2])
        {
        for(int j = i; j >= 2; j--)
          {
            if(MACDLineBuffer[j] <= MACDLineBuffer[j - 1] &&
              MACDLineBuffer[j] <  MACDLineBuffer[j - 2] &&
              MACDLineBuffer[j] <= MACDLineBuffer[j + 1] &&
              MACDLineBuffer[j] <  MACDLineBuffer[j + 2])
              return(j);
          }
        }
    }
  return(-1);
  }

//+------------------------------------------------------------------+
//| Find the previous MACD peak before shift                        |
//+------------------------------------------------------------------+
int GetIndicatorLastPeak(int shift, int total)
  {
  for(int i = shift - 5; i >= 2; i--)
    {
      if(SignalLineBuffer >= SignalLineBuffer[i - 1] &&
        SignalLineBuffer >= SignalLineBuffer[i - 2] &&
        SignalLineBuffer >= SignalLineBuffer[i + 1] &&
        SignalLineBuffer >= SignalLineBuffer[i + 2])
        {
        for(int j = i; j >= 2; j--)
          {
            if(MACDLineBuffer[j] >= MACDLineBuffer[j - 1] &&
              MACDLineBuffer[j] >  MACDLineBuffer[j - 2] &&
              MACDLineBuffer[j] >= MACDLineBuffer[j + 1] &&
              MACDLineBuffer[j] >  MACDLineBuffer[j + 2])
              return(j);
          }
        }
    }
  return(-1);
  }

//+------------------------------------------------------------------+
//| Detect and mark bullish divergence at bar[shift]                |
//+------------------------------------------------------------------+
void CatchBullishDivergence(int shift,
                            const datetime &time[],
                            const double  &low[],
                            int            total)
  {
  if(!IsIndicatorTrough(shift, total)) return;

  int currentTrough = shift;
  int lastTrough    = GetIndicatorLastTrough(shift, total);
  if(lastTrough == -1) return;

  //---- Classical: MACD higher low + price lower low
  if(MACDLineBuffer[currentTrough] > MACDLineBuffer[lastTrough] &&
      low[currentTrough] < low[lastTrough])
    {
      bullishDivergence[currentTrough] = MACDLineBuffer[currentTrough] - arrowsDisplacement;
      if(drawPriceTrendLines)
        DrawPriceTrendLine(time[currentTrough], time[lastTrough],
                            low[currentTrough],  low[lastTrough], clrLime, STYLE_SOLID);
      if(drawIndicatorTrendLines)
        DrawIndicatorTrendLine(time[currentTrough], time[lastTrough],
                                MACDLineBuffer[currentTrough], MACDLineBuffer[lastTrough],
                                clrLime, STYLE_SOLID);
      if(displayAlert)
        DisplayAlert("Classical bullish divergence on: ", shift, time);
    }

  //---- Reverse: MACD lower low + price higher low
  if(MACDLineBuffer[currentTrough] < MACDLineBuffer[lastTrough] &&
      low[currentTrough] > low[lastTrough])
    {
      bullishDivergence[currentTrough] = MACDLineBuffer[currentTrough] - arrowsDisplacement;
      if(drawPriceTrendLines)
        DrawPriceTrendLine(time[currentTrough], time[lastTrough],
                            low[currentTrough],  low[lastTrough], clrLime, STYLE_DOT);
      if(drawIndicatorTrendLines)
        DrawIndicatorTrendLine(time[currentTrough], time[lastTrough],
                                MACDLineBuffer[currentTrough], MACDLineBuffer[lastTrough],
                                clrLime, STYLE_DOT);
      if(displayAlert)
        DisplayAlert("Reverse bullish divergence on: ", shift, time);
    }
  }

//+------------------------------------------------------------------+
//| Detect and mark bearish divergence at bar[shift]                |
//+------------------------------------------------------------------+
void CatchBearishDivergence(int shift,
                            const datetime &time[],
                            const double  &high[],
                            int            total)
  {
  if(!IsIndicatorPeak(shift, total)) return;

  int currentPeak = shift;
  int lastPeak    = GetIndicatorLastPeak(shift, total);
  if(lastPeak == -1) return;

  //---- Classical: MACD lower high + price higher high
  if(MACDLineBuffer[currentPeak] < MACDLineBuffer[lastPeak] &&
      high[currentPeak] > high[lastPeak])
    {
      bearishDivergence[currentPeak] = MACDLineBuffer[currentPeak] + arrowsDisplacement;
      if(drawPriceTrendLines)
        DrawPriceTrendLine(time[currentPeak], time[lastPeak],
                            high[currentPeak], high[lastPeak], clrRed, STYLE_SOLID);
      if(drawIndicatorTrendLines)
        DrawIndicatorTrendLine(time[currentPeak], time[lastPeak],
                                MACDLineBuffer[currentPeak], MACDLineBuffer[lastPeak],
                                clrRed, STYLE_SOLID);
      if(displayAlert)
        DisplayAlert("Classical bearish divergence on: ", shift, time);
    }

  //---- Reverse: MACD higher high + price lower high
  if(MACDLineBuffer[currentPeak] > MACDLineBuffer[lastPeak] &&
      high[currentPeak] < high[lastPeak])
    {
      bearishDivergence[currentPeak] = MACDLineBuffer[currentPeak] + arrowsDisplacement;
      if(drawPriceTrendLines)
        DrawPriceTrendLine(time[currentPeak], time[lastPeak],
                            high[currentPeak], high[lastPeak], clrRed, STYLE_DOT);
      if(drawIndicatorTrendLines)
        DrawIndicatorTrendLine(time[currentPeak], time[lastPeak],
                                MACDLineBuffer[currentPeak], MACDLineBuffer[lastPeak],
                                clrRed, STYLE_DOT);
      if(displayAlert)
        DisplayAlert("Reverse bearish divergence on: ", shift, time);
    }
  }

//+------------------------------------------------------------------+
//| Alert only on the 2 most recent bars                            |
//+------------------------------------------------------------------+
void DisplayAlert(string message, int shift, const datetime &time[])
  {
  int fromEnd = ArraySize(time) - 1 - shift;
  if(fromEnd <= 2 && time[shift] != lastAlertTime)
    {
      lastAlertTime = time[shift];
      Alert(message, _Symbol, " , ", _Period, " minutes chart");
    }
  }

//+------------------------------------------------------------------+
//| Draw trend line on price chart (main window)                    |
//+------------------------------------------------------------------+
void DrawPriceTrendLine(datetime x1, datetime x2,
                        double y1,  double y2,
                        color lineColor, ENUM_LINE_STYLE style)
  {
  string label = "MACD_DivergenceLine.0# " + IntegerToString((long)x1);
  ObjectDelete(0, label);
  ObjectCreate(0, label, OBJ_TREND, 0, x1, y1, x2, y2);
  ObjectSetInteger(0, label, OBJPROP_RAY_RIGHT, false);
  ObjectSetInteger(0, label, OBJPROP_COLOR,    lineColor);
  ObjectSetInteger(0, label, OBJPROP_STYLE,    style);
  }

//+------------------------------------------------------------------+
//| Draw trend line on indicator sub-window                          |
//+------------------------------------------------------------------+
void DrawIndicatorTrendLine(datetime x1, datetime x2,
                            double y1,  double y2,
                            color lineColor, ENUM_LINE_STYLE style)
  {
  int indicatorWindow = ChartWindowFind(0, indicatorName);
  if(indicatorWindow < 0) return;

  string label = "MACD_DivergenceLine.0$# " + IntegerToString((long)x1);
  ObjectDelete(0, label);
  ObjectCreate(0, label, OBJ_TREND, indicatorWindow, x1, y1, x2, y2);
  ObjectSetInteger(0, label, OBJPROP_RAY_RIGHT, false);
  ObjectSetInteger(0, label, OBJPROP_COLOR,    lineColor);
  ObjectSetInteger(0, label, OBJPROP_STYLE,    style);
  }
//+------------------------------------------------------------------+

#6
**MACD Histogram** คือส่วนหนึ่งของอินดิเคเตอร์ MACD (Moving Average Convergence Divergence) ที่ใช้วัด "แรงของแนวโน้ม" และ "โมเมนตัม" ในตลาด เช่น Forex, หุ้น หรือคริปโต

เปิดบัญชีมืออาชีพ ได้ที่ https://www.exness.com/a/73208

---

## 🔍 MACD Histogram คืออะไร (เข้าใจง่าย)

MACD Histogram = **ส่วนต่างระหว่าง MACD Line กับ Signal Line**

แปลว่า:

* ถ้า Histogram สูง → แรงซื้อเริ่มมากขึ้น
* ถ้า Histogram ต่ำ → แรงขายเริ่มมากขึ้น

📊 ลักษณะ:

* เป็นแท่งขึ้น-ลง (คล้ายกราฟแท่ง)
* อยู่เหนือ/ใต้เส้นศูนย์ (0)

---

## 🧠 โครงสร้างของ MACD

MACD มี 3 ส่วน:

1. MACD Line (เส้นหลัก)
2. Signal Line (เส้นสัญญาณ)
3. Histogram (แท่ง)

---

## 📈 วิธีใช้งาน MACD Histogram

### 1. ดูแรงของเทรนด์ (Momentum)

* แท่งยาวขึ้น → เทรนด์ "แรงขึ้น"
* แท่งสั้นลง → เทรนด์ "เริ่มอ่อน"

👉 ใช้ดูว่า "ควรถือต่อ หรือเตรียมออก"

---

### 2. ใช้หา "จุดกลับตัว"

สังเกต:

* Histogram เริ่ม "ลดลง" ทั้งที่ราคายังขึ้น → มีโอกาสกลับตัวลง
* Histogram เริ่ม "เพิ่มขึ้น" ทั้งที่ราคายังลง → มีโอกาสกลับตัวขึ้น

📌 เรียกว่า **Divergence**

---

### 3. ใช้สัญญาณ Buy / Sell

#### 🟢 Buy

* Histogram จาก "ติดลบ → กลายเป็นบวก"
* หรือแท่งเริ่มสูงขึ้นต่อเนื่อง

#### 🔴 Sell

* Histogram จาก "บวก → กลายเป็นลบ"
* หรือแท่งเริ่มต่ำลงต่อเนื่อง

---

### 4. ใช้ร่วมกับเส้น 0 (Zero Line)

* เหนือ 0 → แนวโน้มขาขึ้น
* ต่ำกว่า 0 → แนวโน้มขาลง

---

## ⚠️ ข้อควรระวัง

* MACD เป็น **lagging indicator** (ช้า)
* ไม่ควรใช้เดี่ยว ๆ ควรใช้ร่วมกับ:

  * Trend (EMA / Price Action)
  * Support / Resistance
  * Timeframe ใหญ่ (เช่น H1, H4)

---

## 💡 ตัวอย่างใช้จริง (สาย Forex)

เช่น EURUSD TF H1:

* Histogram เริ่มจากลบ → บวก

* ราคาอยู่เหนือ EMA 50
  👉 เข้า Buy ได้

* Histogram เริ่มสั้นลงตอนกำไร
  👉 เตรียม Take Profit

---

## 🔧 สำหรับสาย EA (MQL4/MQL5)

ค่าที่ใช้:

* MACD Main
* Signal
* Histogram = Main - Signal

ใน MQL4:

```mql4
double macd = iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_MAIN,0);
double signal = iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_SIGNAL,0);
double histo = macd - signal;
```

---

## 🔥 สรุปสั้น ๆ

* Histogram = วัด "แรงตลาด"
* ใช้ดู "เข้า-ออก" และ "แรงเทรนด์"
* ดีมากสำหรับจับ "จังหวะเริ่มต้นของเทรนด์"

-------------------------------------
#7
Exness การสมัครเป็นลูกค้าใหม่ เริ่มวันที่ 23-4-2569 ทำอย่างไร

เปิดบัญชี Standard หรือ มืออาชีพ ได้ที่ https://www.exness.com/a/73208

แนะนำให้ใช้ PC (Personal Computer) ถ้าใช้ (มือถือส่วนใหญ่ ไม่เห็นในระบบ Partner ผมจะแนะนำหรือช่วยเหลือคุณไม่ได้) ในการสมัครลูกค้าใหม่

เปิด Google Chrome หรือ Microsoft Edge พิมพ์ https://www.exness.com/a/73208

Exness การยืนยันบัญชีของคุณ

เข้าสู่ระบบพื้นที่ส่วนบุคคลของ Exness แล้วคลิกลงทะเบียนให้เสร็จสมบูรณ์บนแบนเนอร์ด้านบนเพื่อเริ่มต้น

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

เพื่อให้การยืนยันเสร็จสมบูรณ์ โปรด

1.ยืนยันอีเมลของคุณ
ระบุอีเมลของคุณและขอรหัสยืนยัน ระบบจะส่งรหัส 6 หลักไปยังอีเมลที่คุณป้อน กรอกรหัสเพื่อดำเนินการต่อ
2.ยืนยันหมายเลขโทรศัพท์ของคุณ
ป้อนหมายเลขโทรศัพท์แล้วเลือกรับรหัสผ่าน SMS หรือรับสายโทรศัพท์ กรอกรหัส 6 หลักเพื่อดำเนินการต่อ
3.กรอกข้อมูลทางการเงินของคุณ
ตอบคำถามเกี่ยวกับแหล่งที่มาของรายได้ ธุรกิจ และประสบการณ์การเทรดเพื่อดำเนินการต่อ
4.กรอกข้อมูลส่วนบุคคลของคุณ
ระบุรายละเอียดของคุณที่ตรงกับข้อมูลในเอกสารยืนยัน รวมถึงชื่อและนามสกุล วันเดือนปีเกิด ที่อยู่ และเพศ
5.ยืนยันตัวตนและที่อยู่ของคุณ
หากจำเป็น ให้เลือกประเทศที่ออกเอกสารและประเภทเอกสารของเอกสารยืนยันตัวตน จากนั้นอัปโหลดตามข้อกำหนดของเอกสารที่ตรวจสอบแล้ว จากนั้น อัปโหลดเอกสารยืนยันที่อยู่ตามข้อกำหนดเดียวกัน

เมื่อส่งเอกสารเหล่านี้แล้ว การยืนยันอาจใช้เวลาไม่เกิน 24 ชั่วโมง หากเอกสารถูกปฏิเสธ คุณสามารถเริ่มใหม่จากขั้นตอนยืนยันตัวตนได้ คุณสามารถตรวจสอบสถานะการยืนยันปัจจุบันได้ตลอดเวลาด้วยการเข้าสู่ระบบพื้นที่ส่วนบุคคลของพาร์ทเนอร์ แล้วดูแถบโปรไฟล์ในการตั้งค่า

ติดต่อสอบถามในการสมัครได้ที่
Line : junjaocom
#8
อธิบาย Trailing Stop pips และ Trailing Step pips mql4 กับ mql5 ต่างกันหรือไม่ ใช้งานอย่างไร

สรุปสั้น ๆ ก่อน:
**Trailing Stop (pips)** และ **Trailing Step (pips)** ใน MetaTrader 4 (MQL4) กับ MetaTrader 5 (MQL5)
👉 "แนวคิดเหมือนกัน 100%"
👉 แต่ "วิธีเขียนโค้ด + โครงสร้างคำสั่งต่างกัน"

---

# 🔹 1. Trailing Stop (pips) คืออะไร

คือระยะห่าง (เป็น pips) ระหว่าง **ราคาปัจจุบัน** กับ **Stop Loss (SL)**

### หลักการ

* ถ้าราคา "วิ่งไปทางกำไร"
* SL จะ "เลื่อนตาม" เพื่อ lock กำไร

### ตัวอย่าง

* Buy EURUSD ที่ 1.1000
* ตั้ง Trailing Stop = 50 pips

👉 เมื่อราคาขึ้นไป 1.1050
→ SL จะถูกเลื่อนมาเป็น 1.1000 (breakeven)

👉 ถ้าขึ้นต่อ 1.1100
→ SL จะเลื่อนเป็น 1.1050

---

# 🔹 2. Trailing Step (pips) คืออะไร

คือ "ระยะที่ต้องขยับเพิ่มก่อนจะเลื่อน SL อีกครั้ง"

### ถ้าไม่มี Step

→ SL จะขยับ "ทุก tick" (ถี่มาก)

### ถ้ามี Step

→ SL จะขยับ "เป็นช่วง ๆ"

### ตัวอย่าง

* Trailing Stop = 50 pips
* Trailing Step = 10 pips

👉 ราคาไป 50 pips → เริ่ม trailing
👉 ราคาไปเพิ่มอีก 10 pips → SL ขยับ
👉 ไปอีก 10 pips → ขยับอีก

📌 ช่วยลด:

* การ Modify Order ถี่เกินไป
* ปัญหา broker reject

---

# 🔹 3. MQL4 vs MQL5 ต่างกันตรงไหน

## ✅ แนวคิด (Logic)

✔ เหมือนกัน
✔ ใช้ trailing ตามราคาเหมือนกัน

---

## ⚠️ โครงสร้างคำสั่ง (ต่างกัน)

### 🔸 MQL4 (MT4)

* ใช้ Order แบบ "Ticket"
* ฟังก์ชันหลัก:

```mql4
OrderModify()
OrderSelect()
```

👉 ต้อง loop ทุก order

---

### 🔸 MQL5 (MT5)

* ใช้ Position / Deal / Order แยกกัน
* ฟังก์ชันหลัก:

```mql5
PositionSelect()
PositionGetDouble()
trade.PositionModify()
```

👉 ใช้ Class เช่น:

```mql5
CTrade trade;
```

---

# 🔹 4. ตัวอย่างใช้งาน MQL4

```mql4
extern int TrailingStop = 50;
extern int TrailingStep = 10;

void TrailOrder()
{
   for(int i=0; i<OrdersTotal(); i++)
   {
      if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
      {
         if(OrderType() == OP_BUY)
         {
            double newSL = Bid - TrailingStop * Point;
           
            if(Bid - OrderOpenPrice() > TrailingStop * Point)
            {
               if(OrderStopLoss() < newSL - TrailingStep * Point)
               {
                  OrderModify(OrderTicket(), OrderOpenPrice(), newSL, OrderTakeProfit(), 0);
               }
            }
         }
      }
   }
}
```

---

# 🔹 5. ตัวอย่างใช้งาน MQL5

```mql5
#include <Trade/Trade.mqh>
CTrade trade;

input int TrailingStop = 50;
input int TrailingStep = 10;

void TrailPosition()
{
   if(PositionSelect(_Symbol))
   {
      double price = SymbolInfoDouble(_Symbol, SYMBOL_BID);
      double open  = PositionGetDouble(POSITION_PRICE_OPEN);
      double sl    = PositionGetDouble(POSITION_SL);

      double newSL = price - TrailingStop * _Point;

      if(price - open > TrailingStop * _Point)
      {
         if(sl < newSL - TrailingStep * _Point)
         {
            trade.PositionModify(_Symbol, newSL, PositionGetDouble(POSITION_TP));
         }
      }
   }
}
```

---

# 🔥 6. สรุปความต่างแบบเข้าใจง่าย

| เรื่อง       | MQL4        | MQL5           |
| ------------ | ----------- | -------------- |
| โครงสร้าง    | Order       | Position       |
| ฟังก์ชัน     | OrderModify | PositionModify |
| ความยาก      | ง่ายกว่า    | ซับซ้อนกว่า    |
| ความยืดหยุ่น | น้อยกว่า    | สูงกว่า        |

---

# 🔥 7. เทคนิคมือโปร (สำคัญมาก)

👉 Trailing Stop ที่ดี = ไม่ใช่แค่ตัวเลข

แนะนำสำหรับ TF H1:

* EURUSD

  * Trailing Stop: 30–80 pips
  * Step: 5–15 pips

👉 ถ้า Step เล็กเกิน
= โดนปิดเร็ว (noise)

👉 ถ้า Step ใหญ่เกิน
= ล็อกกำไรช้า

---

# 🔥 8. Insight สำหรับสาย EA Forex

ถ้าคุณทำ EA จริงจัง (เหมาะกับคุณมาก):

👉 ใช้ **Trailing แบบ Hybrid**

* เริ่ม trailing เมื่อกำไร ≥ X
* ใช้ ATR แทน pips (ฉลาดกว่า)

👉 หรือ:

* BreakEven + Trailing
* Partial Close + Trailing

--------------------------------------------------
#9
**Snowball Trading (การเทรดแบบสโนว์บอล)** ในตลาด Forex คือกลยุทธ์ที่ "เอากำไรไปทบเพิ่มขนาดล็อต" เพื่อให้พอร์ตโตแบบทวีคูณ เหมือนก้อนหิมะที่กลิ้งแล้วใหญ่ขึ้นเรื่อย ๆ

เปิดบัญชีมืออาชีพ ได้ที่ https://www.exness.com/a/73208

---

## 🔹 หลักการของ Snowball

แนวคิดง่าย ๆ คือ
👉 เริ่มจากล็อตเล็ก → ได้กำไร → เอากำไรไปเพิ่มขนาดการเทรด → กำไรมากขึ้น → โตเร็วขึ้น

เปรียบเทียบ:

* ปกติ: กำไรคงที่
* Snowball: กำไร "เร่งตัว"

---

## 🔸 ตัวอย่างเข้าใจง่าย

สมมติ:

* เงินเริ่มต้น: $1,000
* เทรดกำไรครั้งละ 10%

### แบบปกติ (ไม่ทบ)

* เทรดทุกครั้งใช้ล็อตเท่าเดิม
* กำไร = $100 ทุกครั้ง

### แบบ Snowball

* ครั้งที่ 1 → $1,100
* ครั้งที่ 2 → $1,210
* ครั้งที่ 3 → $1,331

👉 เงินจะโตแบบ "ดอกเบี้ยทบต้น"

---

## 🔹 วิธีใช้ Snowball ใน Forex

1. เริ่มล็อตเล็ก (ลดความเสี่ยง)
2. ตั้ง Risk ต่อไม้ เช่น 1–2%
3. เมื่อพอร์ตโต → เพิ่ม Lot ตามทุน
4. ไม่ถอนกำไร (หรือถอนบางส่วน)

---

## 🔸 จุดเด่น

* โตเร็วมาก (ถ้าชนะต่อเนื่อง)
* ใช้พลังของ "Compound"
* เหมาะกับระบบที่ Win rate สูง

---

## 🔻 ความเสี่ยง (สำคัญมาก)

นี่คือข้อเสียที่หลายคนพลาด:

* ❌ ถ้าแพ้ครั้งเดียวตอนล็อตใหญ่ → เสียหนัก
* ❌ Drawdown จะ "รุนแรงขึ้น"
* ❌ ต้องมีวินัยสูงมาก

👉 พูดตรง ๆ:
Snowball = "กำไรเร็ว + พังเร็ว" ถ้าไม่คุมความเสี่ยง

---

## 🔹 Snowball vs Martingale

ต่างกันชัดเจน:

| กลยุทธ์    | แนวคิด                   |
| ---------- | ------------------------ |
| Snowball   | เพิ่มล็อตเมื่อ "ได้กำไร" |
| Martingale | เพิ่มล็อตเมื่อ "ขาดทุน"  |

👉 Snowball ปลอดภัยกว่า Martingale มาก

---

## 🔸 ใช้กับ EA ได้ไหม?

ได้ และนิยมมาก เช่น:

* EA แบบ Trend Following
* EA ที่ Win rate > 60%
* EA ที่มี Risk Control ชัดเจน

---

## 🔥 สรุป

Snowball Trading คือ:

> "การใช้กำไรไปขยายพอร์ต เพื่อให้โตแบบทวีคูณ"

เหมาะกับ:

* คนมีระบบเทรดชัด
* คุมความเสี่ยงเป็น
* ไม่โลภเกินไป

----------------------------
#10
ผู้จัดการมรดก (Executor / Administrator) **มีสิทธิได้รับค่าตอบแทนได้** แต่ไม่ได้เป็นสิทธิอัตโนมัติทุกกรณี ขึ้นอยู่กับเงื่อนไขตามกฎหมายและพินัยกรรม โดยสรุปดังนี้:

---

## 🔹 1. ได้ค่าตอบแทน "ถ้ามีระบุไว้ในพินัยกรรม"

ถ้าเจ้ามรดกระบุไว้ชัดเจน เช่น

* ให้ค่าจัดการเป็นเงินก้อน
* หรือคิดเป็น % ของทรัพย์มรดก

👉 แบบนี้ ผู้จัดการมรดก "มีสิทธิได้รับตามที่ระบุ"

---

## 🔹 2. ถ้า "พินัยกรรมไม่ได้ระบุ"

ผู้จัดการมรดกสามารถ:

* ขอ "ค่าตอบแทนตามสมควร" จากศาลได้
* หรือให้ทายาทตกลงกันจ่ายให้

👉 ศาลจะพิจารณาจาก:

* ความยากง่ายของงาน
* มูลค่าทรัพย์มรดก
* ระยะเวลาในการจัดการ
* ภาระหน้าที่ที่ทำจริง

---

## 🔹 3. ค่าใช้จ่ายที่สามารถเบิกได้

แม้ไม่ได้ค่าตอบแทน ผู้จัดการมรดกสามารถเบิก "ค่าใช้จ่ายจริง" ได้ เช่น:

* ค่าทนาย
* ค่าเดินทาง
* ค่าธรรมเนียมศาล
* ค่าเอกสารต่าง ๆ

👉 ต้องมีหลักฐาน และเป็นค่าใช้จ่ายที่เกี่ยวกับการจัดการมรดกจริง

---

## 🔹 4. ถ้าเป็นทายาทเอง

* ถ้าเป็น "ทายาท + ผู้จัดการมรดก"
  👉 ยังมีสิทธิได้รับมรดกตามส่วนปกติ
  แต่ **ค่าตอบแทนพิเศษ** ต้องมีเหตุผลหรือมีการกำหนด

---

## 🔹 5. ข้อควรระวัง

* ห้ามเอาทรัพย์มรดกไปใช้ส่วนตัว
* ต้องทำบัญชีรายรับ-รายจ่ายชัดเจน
* หากทำผิด อาจถูกฟ้องหรือถอดถอนจากศาลได้

---

## ✅ สรุป

* ได้ค่าตอบแทน ✔️ (ถ้ามีพินัยกรรมกำหนด หรือศาลอนุญาต)
* เบิกค่าใช้จ่ายได้ ✔️
* ไม่ใช่ว่าทุกคนจะได้ "เงินเดือน" โดยอัตโนมัติ

------------------------------------