Syntax

Built-in Functions

Structures

Built-in Variables

SetChannelData

Publishes the latest status data to a channel. This function is used for communication between live trading bots, allowing the current bot's status data to be broadcast to a channel for other live trading bots to subscribe to and retrieve.


    
    
    
SetChannelData(data)

Examples

Channel Broadcaster Example - Publishing BTC Market Price Data


    javascript
    
    
function main() {
    var updateId = 0
    var robotId = _G()  // Get current live bot ID

    while(true) {
        // Get real-time market price
        var ticker = exchange.GetTicker("BTC_USDT")
        if (!ticker) {
            Sleep(5000)
            continue
        }

        // Construct current channel state data
        var channelState = {
            robotId: robotId,
            updateId: ++updateId,
            timestamp: Date.now(),
            symbol: "BTC_USDT",
            lastPrice: ticker.Last,
            volume: ticker.Volume,
            high: ticker.High,
            low: ticker.Low
        }

        // Publish the latest state on the channel (overwrites the old state)
        SetChannelData(channelState)

        // Display current channel state
        LogStatus("Channel Broadcaster [Bot ID: " + robotId + "]\n" +
                  "Update ID: #" + channelState.updateId + "\n" +
                  "Time: " + _D(channelState.timestamp) + "\n" +
                  "Symbol: " + channelState.symbol + "\n" +
                  "Last Price: $" + channelState.lastPrice.toFixed(2) + "\n" +
                  "Volume: " + channelState.volume.toFixed(4) + "\n" +
                  "High: $" + channelState.high.toFixed(2) + "\n" +
                  "Low: $" + channelState.low.toFixed(2))

        Sleep(60000)  // Update channel state once per minute
    }
}


    python
    
    
def main():
    updateId = 0
    robotId = _G()  # Get current live bot ID

    while True:
        # Get real-time market price
        ticker = exchange.GetTicker("BTC_USDT")
        if not ticker:
            Sleep(5000)
            continue

        # Construct current channel state data
        channelState = {
            "robotId": robotId,
            "updateId": updateId + 1,
            "timestamp": time.time() * 1000,
            "symbol": "BTC_USDT",
            "lastPrice": ticker["Last"],
            "volume": ticker["Volume"],
            "high": ticker["High"],
            "low": ticker["Low"]
        }
        updateId += 1

        # Publish the latest state on the channel (overwrites the old state)
        SetChannelData(channelState)

        # Display current channel state
        LogStatus("Channel Broadcaster [Bot ID: {}]\n".format(robotId) +
                  "Update ID: #{}\n".format(channelState["updateId"]) +
                  "Time: {}\n".format(_D(channelState["timestamp"])) +
                  "Symbol: {}\n".format(channelState["symbol"]) +
                  "Last Price: ${:.2f}\n".format(channelState["lastPrice"]) +
                  "Volume: {:.4f}\n".format(channelState["volume"]) +
                  "High: ${:.2f}\n".format(channelState["high"]) +
                  "Low: ${:.2f}".format(channelState["low"]))

        Sleep(60000)  # Update channel state once per minute


    rust
    
    
fn main() {
    let mut updateId = 0;
    let robotId = _G!();  // Get current live bot ID

    loop {
        // Get real-time market price
        let ticker = match exchange.GetTicker("BTC_USDT") {
            Ok(t) => t,
            Err(_) => {
                Sleep(5000);
                continue;
            }
        };

        // Construct current channel state data
        // Rust's SetChannelData only accepts a string argument, so use format! to build the JSON text
        updateId += 1;
        let timestamp = Unix() * 1000;
        let channelState = format!(
            r#"{{"robotId": {}, "updateId": {}, "timestamp": {}, "symbol": "BTC_USDT", "lastPrice": {}, "volume": {}, "high": {}, "low": {}}}"#,
            robotId, updateId, timestamp, ticker.Last, ticker.Volume, ticker.High, ticker.Low
        );

        // Publish the latest state on the channel (overwrites the old state)
        SetChannelData(&channelState);

        // Display current channel state
        LogStatus!(format!(
            "Channel Broadcaster [Bot ID: {}]\nUpdate ID: #{}\nTime: {}\nSymbol: BTC_USDT\nLast Price: ${:.2}\nVolume: {:.4}\nHigh: ${:.2}\nLow: ${:.2}",
            robotId, updateId, _D(timestamp), ticker.Last, ticker.Volume, ticker.High, ticker.Low
        ));

        Sleep(60000);  // Update channel state once per minute
    }
}

c++

Cross-platform sending example - Simulate an external platform (such as TradingView) sending data to an FMZ live bot


    javascript
    
    
// This example demonstrates how to use HttpQuery to send an HTTP POST request, simulating an external platform sending data to an FMZ live bot
// In a real scenario, external platforms (such as TradingView's Webhook alert URL, third-party trading systems, etc.) directly call the FMZ API endpoint

function main() {
    let uuid = "6BC42A119B5DBFA2188A8279DA3B5C30"
    let robotId = 123456  // Target live bot ID (the live bot used to receive data)
    let baseUrl = "https://www.fmz.com"

    while (true) {
        // Prepare the data to send (can be JSON, text, or other formats)
        let sendData = {
            "action": "buy",
            "symbol": "BTC_USDT",
            "price": 50000,
            "timestamp": Date.now()
        }

        // Construct the HTTP POST request
        let options = {
            method: "POST",
            body: JSON.stringify(sendData)  // body can be a JSON string, plain text, etc.
        }
        let url = `${baseUrl}/api/v1?method=pub&robot=${robotId}&channel=${uuid}`

        // Send the data
        let ret = HttpQuery(url, options)
        Log("Simulated external platform sending data, result:", ret)

        Sleep(10000)  // Send once every 10 seconds
    }
}


    python
    
    
# This example demonstrates how to use HttpQuery to send an HTTP POST request, simulating an external platform sending data to an FMZ live bot
# In a real scenario, external platforms (such as TradingView's Webhook alert URL, third-party trading systems, etc.) directly call the FMZ API endpoint

import json

def main():
    uuid = "6BC42A119B5DBFA2188A8279DA3B5C30"
    robotId = 123456  # Target live bot ID (the live bot used to receive data)
    baseUrl = "https://www.fmz.com"

    while True:
        # Prepare the data to send (can be JSON, text, or other formats)
        sendData = {
            "action": "buy",
            "symbol": "BTC_USDT",
            "price": 50000,
            "timestamp": time.time() * 1000
        }

        # Construct the HTTP POST request
        options = {
            "method": "POST",
            "body": json.dumps(sendData)  # body can be a JSON string, plain text, etc.
        }
        url = "{}/api/v1?method=pub&robot={}&channel={}".format(baseUrl, robotId, uuid)

        # Send the data
        ret = HttpQuery(url, options)
        Log("Simulated external platform sending data, result:", ret)

        Sleep(10000)  # Send once every 10 seconds


    rust
    
    
// This example demonstrates how to use HttpQuery to send an HTTP POST request, simulating an external platform sending data to an FMZ live bot
// In a real scenario, external platforms (such as TradingView's Webhook alert URL, third-party trading systems, etc.) directly call the FMZ API endpoint

fn main() {
    let uuid = "6BC42A119B5DBFA2188A8279DA3B5C30";
    let robotId = 123456;  // Target live bot ID (the live bot used to receive data)
    let baseUrl = "https://www.fmz.com";

    loop {
        // Prepare the data to send (can be JSON, text, or other formats)
        let sendData = format!(
            r#"{{"action": "buy", "symbol": "BTC_USDT", "price": 50000, "timestamp": {}}}"#,
            Unix() * 1000
        );

        // Construct the HTTP POST request; {:?} escapes body into a valid JSON string value
        let options = format!(r#"{{"method": "POST", "body": {:?}}}"#, sendData);
        let url = format!("{}/api/v1?method=pub&robot={}&channel={}", baseUrl, robotId, uuid);

        // Send the data
        let ret: String = HttpQuery(&url, options.as_str());
        Log!("Simulated external platform sending data, result:", ret);

        Sleep(10000);  // Send once every 10 seconds
    }
}

c++

Returns

Type	Description
null	This function has no return value.

Arguments

Name	Type	Required	Description
data	object / array / string / number / bool / null	Yes	The data to be published to the channel. It can be any data structure that supports `JSON` serialization, and is typically an object containing the live trading bot's status information.