Paste: 1

Author: 1
Mode: factor
Date: Sun, 4 Feb 2024 11:21:52
Plain Text |
#include <ros/ros.h>
#include <geometry_msgs/Twist.h>
#include <serial/serial.h>
#include <thread>
#include <iostream>
#include <cmath>

#include <nav_msgs/Odometry.h>
#include <geometry_msgs/TransformStamped.h>
#include <tf2/LinearMath/Quaternion.h>
#include <tf2_geometry_msgs/tf2_geometry_msgs.h>
#include <tf/transform_broadcaster.h>

#include "mavlink2ros/ServoCtrl.h"
#include "FishCom/mavlink.h"
#include <mavlink2ros/Optlimit.h>//new
#include "mavlink2ros/FunctionCtrl.h"//new

#define SERVO_DUTY_CYCLE_MIN  499
#define SERVO_DUTY_CYCLE_MAX  2499
#define SERVO_DUTY_CYCLE_INIT  1500

class RobotController {
public:
    RobotController(const std::string& port, int baud_rate) : 
        serial_device(port, baud_rate, serial::Timeout::simpleTimeout(1000)),
        chassis_odom_pub_(nh.advertise<nav_msgs::Odometry>("odom", 50)),
        optlimit_pub(nh.advertise<mavlink2ros::Optlimit>("optlimit_info", 50)) 
    {
        if (!serial_device.isOpen()) {
            ROS_ERROR_STREAM("Failed to open serial port.");
        }

        cmd_ctrl_sub_ = nh.subscribe("cmd_vel", 100, &RobotController::cmdVelCallback, this);
        servo_ctrl_sub_ = nh.subscribe("servo_ctrl", 100, &RobotController::servoCtrlCallback, this);

        // 
        receive_thread = std::thread(&RobotController::receiveData, this);


        manage_timer = nh.createTimer(ros::Duration(1.0), &RobotController::sendManageInfoRegularly, this);
        control_timer = nh.createTimer(ros::Duration(0.01), &RobotController::sendCtrlInfoRegularly, this);
        servos_timer = nh.createTimer(ros::Duration(0.01), &RobotController::sendServosInfoRegularly, this);

        chassis_odom_pub_=nh.advertise<nav_msgs::Odometry>("odom",1);
        odom_.header.frame_id = "odom";
        odom_.child_frame_id = "base_link";
        odom_tf_.header.frame_id = "odom";
        odom_tf_.child_frame_id = "base_link";

        optlimit_pub = nh.advertise<mavlink2ros::Optlimit>("optlimit_info",1);//new
        optlimit_sub = nh.subscribe("optlimit_info", 100, &RobotController::optlimitCallback, this);//new
        // optlimit_msg.pattern = gpio_read_level;//initialize the message


        function_sub = nh.subscribe("function_id", 100, &RobotController::functionCtrlCallback, this);//new functionid
    }

    ~RobotController() {
        if (receive_thread.joinable()) {
            receive_thread.join();
        }
    }

    void runTask(){
        int functionid = function_id.functionid;
        if(functionid == 1)
        {
            upper_to_lower();
            clp_close();
            lower_to_upper();
            clp_open();
            printf("run\n");
        }
        if(functionid == 2)
        {
            servo_ctrl_r(4, 1.4);
            servo_ctrl_r(4,0.0);
        }
        if(functionid == 3)
        {
            upper_to_lower();
            servo_ctrl_r(2, 0.65);
            lower_to_upper();
        }
        if(functionid == 4)
        {
            upper_to_lower();
            servo_ctrl_r(2, 0.0);
            lower_to_upper();
        }
        if(functionid == 5)
        {
           servos_positions[5] = 1.65 * (SERVO_DUTY_CYCLE_MAX - SERVO_DUTY_CYCLE_MIN) / M_PI + SERVO_DUTY_CYCLE_MIN; 
        }
        if(functionid == 6)
        {
            servos_positions[5] = 1.45 * (SERVO_DUTY_CYCLE_MAX - SERVO_DUTY_CYCLE_MIN) / M_PI + SERVO_DUTY_CYCLE_MIN;
        }
        if(functionid == 7)
        {
            servos_positions[0] = 3.14 * (SERVO_DUTY_CYCLE_MAX - SERVO_DUTY_CYCLE_MIN) / M_PI + SERVO_DUTY_CYCLE_MIN;
        }//check id and give the diploma
        if(functionid == 8)

        {
            servos_positions[0] = 0 * (SERVO_DUTY_CYCLE_MAX - SERVO_DUTY_CYCLE_MIN) / M_PI + SERVO_DUTY_CYCLE_MIN;
        }//check id and give the diploma
    }

    void sendManageInfoRegularly(const ros::TimerEvent&) {
        sendManageInfo(1, 1, 1);
    }

    void sendCtrlInfoRegularly(const ros::TimerEvent&) {
        std::lock_guard<std::mutex> lock(twist_mutex); // 确保线程安全
        sendCtrlInfo(current_twist.linear.x, current_twist.linear.y, current_twist.angular.z);
    }

    void sendServosInfoRegularly(const ros::TimerEvent&){
        std::lock_guard<std::mutex> lock(servos_mutex); 
        sendServosInfo(servos_positions[0],servos_positions[1],servos_positions[2],servos_positions[3],
            servos_positions[4],servos_positions[5],servos_positions[6]);
    }

    void sendManageInfo(bool enable_chassis,bool enable_servos,bool reset_quaternion){
        mavlink_message_t *msg = (mavlink_message_t *)malloc(sizeof(mavlink_message_t));
        memset(msg, 0, sizeof(mavlink_message_t));

        uint16_t Txlen = 0;
        uint8_t *txbuf = (uint8_t *)malloc(MAVLINK_MSG_ID_CHS_MANAGE_INFO_LEN + 12);

        mavlink_msg_chs_manage_info_pack(
            CHS_SYSTEM_ID::CHS_ID_ORANGE,
            CHS_SYSTEM_ID::CHS_ID_ORANGE, 
            msg, enable_chassis, enable_servos, reset_quaternion);
        
        Txlen = mavlink_msg_to_send_buffer(txbuf, msg);

        serial_device.write(txbuf, Txlen);
        
        free(msg);
        free(txbuf);
    }

    void sendCtrlInfo(float vx, float vy, float vz){
        mavlink_message_t *msg = (mavlink_message_t *)malloc(sizeof(mavlink_message_t));
        memset(msg, 0, sizeof(mavlink_message_t));

        uint16_t Txlen = 0;
        uint8_t *txbuf = (uint8_t *)malloc(MAVLINK_MSG_ID_CHS_CTRL_INFO_LEN + 12);

        mavlink_msg_chs_ctrl_info_pack(
            CHS_SYSTEM_ID::CHS_ID_ORANGE,
            CHS_SYSTEM_ID::CHS_ID_ORANGE, 
            msg, 
            -vy, vx, vz);
        
        Txlen = mavlink_msg_to_send_buffer(txbuf, msg);

        serial_device.write(txbuf, Txlen);

        free(msg);
        free(txbuf);
    }

    void sendServosInfo(uint16_t servo1, uint16_t servo2, uint16_t servo3, 
                        uint16_t servo4, uint16_t servo5, uint16_t servo6, uint16_t servo7){
        mavlink_message_t *msg = (mavlink_message_t *)malloc(sizeof(mavlink_message_t));
        memset(msg, 0, sizeof(mavlink_message_t));

        uint16_t Txlen = 0;
        uint8_t *txbuf = (uint8_t *)malloc(MAVLINK_MSG_ID_CHS_SERVOS_INFO_LEN + 12);

        uint16_t servos[7] = {servo1, servo2, servo3, servo4, servo5, servo6, servo7};

        mavlink_msg_chs_servos_info_pack(
            CHS_SYSTEM_ID::CHS_ID_ORANGE,
            CHS_SYSTEM_ID::CHS_ID_ORANGE, 
            msg, 
            servos);
        
        Txlen = mavlink_msg_to_send_buffer(txbuf, msg);

        serial_device.write(txbuf, Txlen);

        free(msg);
        free(txbuf);
    }

    void cmdVelCallback(const geometry_msgs::Twist::ConstPtr& msg) {
        current_twist = *msg;
    }

    void servoCtrlCallback(const mavlink2ros::ServoCtrl::ConstPtr& msg) {
        std::lock_guard<std::mutex> lock(servos_mutex);//这里使用了互斥锁(mutex),目的是确保在多线程环境中对servos_positions的访问是安全的。锁定在函数的生命周期内,以防止其他线程同时修改servos_positions。
        int servo_id = msg->servo_id;
        if (servo_id >= 0 && servo_id < 7) {
            double servo_angle = msg->servo_angle;
            servos_positions[servo_id] = static_cast<int>(servo_angle * (SERVO_DUTY_CYCLE_MAX - SERVO_DUTY_CYCLE_MIN) / M_PI) + SERVO_DUTY_CYCLE_MIN;//将上一步计算的结果强制转换为整数。这可能导致小数部分被截断,因为舵机位置通常以整数值表示。
            ROS_INFO("updated! Servo ID: %d, New Position: %d", servo_id, servos_positions[servo_id]);
        }

        std::stringstream ss;
        ss << "Current Servo Positions: ";
        for(int i = 0; i < 7; i++) {
         
            ss << servos_positions[i] << " ";
        }
        ROS_INFO_STREAM(ss.str());
    }

    void optlimitCallback(const mavlink2ros::Optlimit::ConstPtr& msg){
        int optlimit_position = msg->pattern;
        if(optlimit_position == 1)
        {
            // sendServosInfo(servos_positions[0], servos_positions[1], servos_positions[2], servos_positions[3], servos_positions[4], 1400, servos_positions[6]);
            servos_positions[5] = 1499;//need to check
        } 
    }

    void upper_to_lower()
    {
        servos_positions[1] = 1.3 * (SERVO_DUTY_CYCLE_MAX - SERVO_DUTY_CYCLE_MIN) / M_PI + SERVO_DUTY_CYCLE_MIN;
        ros::Duration(1).sleep();         
        servos_positions[0] = 2.8 * (SERVO_DUTY_CYCLE_MAX - SERVO_DUTY_CYCLE_MIN) / M_PI + SERVO_DUTY_CYCLE_MIN;
        ros::Duration(1).sleep();
        servos_positions[1] = 2.75 * (SERVO_DUTY_CYCLE_MAX - SERVO_DUTY_CYCLE_MIN) / M_PI + SERVO_DUTY_CYCLE_MIN;
        ros::Duration(1).sleep();
        servos_positions[0] = 2.5 * (SERVO_DUTY_CYCLE_MAX - SERVO_DUTY_CYCLE_MIN) / M_PI + SERVO_DUTY_CYCLE_MIN;
        ros::Duration(1).sleep();
    }
    void lower_to_upper()
    {
        servos_positions[0] = 2.8 * (SERVO_DUTY_CYCLE_MAX - SERVO_DUTY_CYCLE_MIN) / M_PI + SERVO_DUTY_CYCLE_MIN;
        ros::Duration(1).sleep();         
        servos_positions[1] = 1.3 * (SERVO_DUTY_CYCLE_MAX - SERVO_DUTY_CYCLE_MIN) / M_PI + SERVO_DUTY_CYCLE_MIN;
        ros::Duration(1).sleep();
        servos_positions[0] = 3.1 * (SERVO_DUTY_CYCLE_MAX - SERVO_DUTY_CYCLE_MIN) / M_PI + SERVO_DUTY_CYCLE_MIN;
        ros::Duration(1).sleep();
        servos_positions[1] = 0.55 * (SERVO_DUTY_CYCLE_MAX - SERVO_DUTY_CYCLE_MIN) / M_PI + SERVO_DUTY_CYCLE_MIN;
        ros::Duration(1).sleep();
    }
    void clp_open()
    {
        servos_positions[2] = 0.0 * (SERVO_DUTY_CYCLE_MAX - SERVO_DUTY_CYCLE_MIN) / M_PI + SERVO_DUTY_CYCLE_MIN;
        ros::Duration(0.8).sleep(); 
    }
    void clp_close()
    {
        servos_positions[2] = 0.65 * (SERVO_DUTY_CYCLE_MAX - SERVO_DUTY_CYCLE_MIN) / M_PI + SERVO_DUTY_CYCLE_MIN;
        ros::Duration(0.8).sleep(); 
    }
    void servo_ctrl_r(int servo_Id, int servo_Angle)
    {
        servos_positions[servo_Id] = servo_Angle * (SERVO_DUTY_CYCLE_MAX - SERVO_DUTY_CYCLE_MIN) / M_PI + SERVO_DUTY_CYCLE_MIN;
        ros::Duration(0.8).sleep();  
    }
    void functionCtrlCallback(const mavlink2ros::FunctionCtrl::ConstPtr& msg)
    {
        function_id = *msg;
        std::thread taskThread(runTask);
        taskThread.detach();
    }//new   


    void receiveData() {
        while (ros::ok()) {
            if (serial_device.available()) {
                mavlink_message_t *msg = (mavlink_message_t *)malloc(sizeof(mavlink_message_t));
                memset(msg, 0, sizeof(mavlink_message_t));

                mavlink_status_t status;
                uint8_t rxbuf[512];
                size_t RxLen = serial_device.read(rxbuf, sizeof(rxbuf));

                mavlink_chs_odom_info_t odom_info;
                mavlink_chs_ctrl_info_t ctrl_info;
                mavlink_chs_motor_info_t motor_info;
                mavlink_chs_servos_info_t servos_info;
                mavlink_chs_manage_info_t manage_info;
                mavlink_chs_remoter_info_t remoter_info;
                mavlink_chs_gpio_read_t gpio_read;


                for (size_t i = 0; i < RxLen; ++i) {
                    ROS_DEBUG_STREAM("Byte " << i << ": 0x" << std::hex << static_cast<int>(rxbuf[i]));
                    if (mavlink_parse_char(MAVLINK_COMM_0, rxbuf[i], msg, &status)) {
                        ROS_DEBUG_STREAM(" " << i << " 个包,解包成功:" << "Message ID: " << msg->msgid);
                        switch (msg->msgid) {
                            case MAVLINK_MSG_ID_CHS_ODOM_INFO: {
                                mavlink_msg_chs_odom_info_decode(msg, &odom_info);
                                ROS_DEBUG_STREAM("received odom info! vx: " << odom_info.vx << ", vy: " << odom_info.vy << ", vz: " << odom_info.vw);
                                std::stringstream ss;
                                ss << "quaternion: ";
                                for (int i = 0; i < 4; i++) ss << odom_info.quaternion[i] << " ";
                                ROS_DEBUG_STREAM(ss.str());

                                std::swap(odom_info.vx,odom_info.vy);
                                odom_info.vy = -odom_info.vy;
                                

                                current_time = ros::Time::now();
                                double dt = (current_time - last_time).toSec();

                                double delta_x = (odom_info.vx * cos(th) - odom_info.vy * sin(th)) * dt;
                                double delta_y = (odom_info.vx * sin(th) + odom_info.vy * cos(th)) * dt;
                                double delta_th = odom_info.vw * dt;

                                x += delta_x;
                                y += delta_y;
                                th += delta_th;

                                odom_.header.stamp = current_time;
                                odom_.twist.twist.linear.x = odom_info.vx;
                                odom_.twist.twist.linear.y = odom_info.vy;
                                odom_.twist.twist.angular.z = odom_info.vw;

                                geometry_msgs::Quaternion odom_quat = tf::createQuaternionMsgFromYaw(th);
                                odom_.pose.pose.position.x = x;
                                odom_.pose.pose.position.y = y;
                                odom_.pose.pose.position.z = 0.0;
                                odom_.pose.pose.orientation = odom_quat;

                                chassis_odom_pub_.publish(odom_);
                                

                                odom_tf_.header.stamp = current_time;
                                odom_tf_.transform.translation.x = x;
                                odom_tf_.transform.translation.y = y;
                                odom_tf_.transform.translation.z = 0.0;
                                odom_tf_.transform.rotation = odom_quat;
                                tf_broadcaster_.sendTransform(odom_tf_);

                                last_time = current_time;
                                break;
                            }
                            case MAVLINK_MSG_ID_CHS_REMOTER_INFO: {
                                mavlink_msg_chs_remoter_info_decode(msg, &remoter_info);
                                ROS_DEBUG_STREAM("received remoter_info: switch_message: " << remoter_info.switch_messgae <<
                                    ", channel_0: " << remoter_info.channel_0 << ", channel_1: " << remoter_info.channel_1 <<
                                    ", channel_2: " << remoter_info.channel_2 << ", channel_3: " << remoter_info.channel_3 <<
                                    ", wheel: " << remoter_info.wheel);
                                int switch_messgae_1 = remoter_info.switch_messgae;
                                if(switch_messgae_1%2 != 0)
                                {
                                    uint8_t switch_messgae_2 = remoter_info.switch_messgae;  // 二进制表示为 10001110

                                        // 读取第0位
                                    //uint8_t zerothBit =  & 0x01;

                                        // 读取第1和第2位
                                    uint8_t firstTwoBits = ( switch_messgae_2>> 1) & 0x03;

                                        // 读取第3和第4位
                                    uint8_t nextTwoBits = (switch_messgae_2 >> 3) & 0x03;
                                    int channel_0_p = remoter_info.channel_0;
                                    int channel_1_p = remoter_info.channel_1;
                                    int channel_2_p = remoter_info.channel_2;
                                    int channel_3_p = remoter_info.channel_3;
                                    //start to check
                                    //判断GPS,ATTI,ATTI的状态并作出反应
                                    switch (nextTwoBits) {
                                        case 0b00:
                                            clp_open();
                                            printf("%s\n", "clp_open");
                                            break;
                                        case 0b01:
                                            printf("%s\n", "nothing");
                                            break;
                                        case 0x02:
                                            clp_close();
                                            printf("%s\n", "clp_close");
                                            break;
                                        default:
                                            sprintf("%s\n", "fuck");
                                    }
                                    if(channel_0_p >= 100)
                                    {
                                        sendCtrlInfo(0, 1.0, 0); 
                                    }
                                    if(channel_0_p <= -100)
                                    {
                                        sendCtrlInfo(0, -1.0, 0);
                                    }
                                    if(channel_1_p >= 100)//需要实验是否是这个方向
                                    {
                                        sendCtrlInfo(1.0, 0, 0); 
                                    }
                                    if(channel_1_p <= -100)
                                    {
                                        sendCtrlInfo(-1.0, 0, 0);
                                    }
                                    if(channel_3_p >= 100)//需要实验是否是这个方向
                                    {
                                        sendCtrlInfo(0, 0, 1/M_PI); 
                                    }
                                    if(channel_3_p <= -100)
                                    {
                                        sendCtrlInfo(0, 0, -1/M_PI);
                                    }
                                    if(channel_2_p >= 100)//需要实验是否是这个方向
                                    {
                                        upper_to_lower(); 
                                        printf("%s\n", "down");
                                    }
                                    if(channel_2_p <= -100)
                                    {
                                        lower_to_upper();
                                        printf("%s\n", "up");
                                    }

                                }
                                


                    
                                break;
                            }
                            case MAVLINK_MSG_ID_CHS_GPIO_READ:{
                                mavlink_msg_chs_gpio_read_decode(msg, &gpio_read);
                                optlimit_msg.pattern = gpio_read.level;
                                // printf("%d\n",optlimit_msg.pattern);
                                optlimit_pub.publish(optlimit_msg);//new 
                                break;
                            }
            
                        }
                    }
                }

                free(msg);
            }
            usleep(1000);
        }
    }

private:
    ros::NodeHandle nh;
    serial::Serial serial_device;
    std::thread receive_thread;
    geometry_msgs::Twist current_twist; 

    ros::Timer manage_timer;
    ros::Timer control_timer;
    ros::Timer servos_timer;

    std::mutex twist_mutex;
    std::mutex servos_mutex;
    ros::Subscriber cmd_ctrl_sub_;
    ros::Subscriber servo_ctrl_sub_;
    ros::Subscriber optlimit_sub;//new

    tf::TransformBroadcaster tf_broadcaster_;//! ros chassis odometry tf broadcaster
    ros::Publisher chassis_odom_pub_;//! ros odometry message publisher
    
    //self defined message
    geometry_msgs::TransformStamped odom_tf_;//! ros chassis odometry tf
    nav_msgs::Odometry odom_;//! ros odometry message

    mavlink2ros::Optlimit optlimit_msg;//define the message of optical limit
    ros::Publisher optlimit_pub;//new

    mavlink2ros::FunctionCtrl function_id;//newnew message
    ros::Subscriber function_sub;//newnew subscriber

    // mavlink2ros::FunctionCtrl function_ctrl;

    // int gpio_read_level;//new
    double x = 0.0;
    double y = 0.0;
    double th = 0.0;
    ros::Time current_time = ros::Time::now(), last_time = ros::Time::now();

    int servos_positions[7] = {2474, 849, 499, 
        SERVO_DUTY_CYCLE_INIT, 499, SERVO_DUTY_CYCLE_INIT, SERVO_DUTY_CYCLE_INIT};
}; 

int main(int argc, char** argv) {
    ros::init(argc, argv, "robot_controller");
    RobotController controller("/dev/robomaster", 115200);
    ros::spin();
    return 0;
}

Annotation: Cc cvv dump PayPal bank cashapp Venmo transfers and cloned card

Author: Albert Gonz
Mode: factor
Date: Sat, 3 Feb 2024 14:39:31
Plain Text |
                         CASH TEAM

 I'M OFFERING LEGIT HACKING SERVICES AND HACKING TOOLS, CC, CVV, PAYPAL, CASHAPP, WESTERN UNION, MONEYGRAM, FULLZ AS WELL AS ETHICAL HACKING LIKE ANY OTHER FORENSIC SCIENCE INVOLVES THE USE OF SOPHISTICATED SOFTWARE AVAILABLE AT YOUR DISPOSAL (USA) WITH OVER 16 YEARS OF EXPERIENCE  AND OVER 20,000 SUCCESSFUL TRANSACTIONS AND COUNTING ALSO INVOLVING BANK TO BANK WIRE TRANSFER, WESTERN UNION, PAYPAL, SKRILL, MONEYGRAM ETC. IF YOU ARE JUST SEEING THIS THEN YOU ARE ONE OF THE LUCKY FEW SO HIT ME UP ASAP.
I ALSO OFFER OTHER FINANCIAL, INVESTMENT AND HACKING RELATED SERVICES LIKE :

*BANK TO BANK WIRED TRANSFER WESTERN UNION PAYPAL ZELLE TRANSFERS  
*BLANK/CLONED CREDITCARDS TO YOUR DOORSTEPS 
*All CC CVV VBV DUMPS TRACKS FULLZ VISA MASTER AMEX GOLD
*CREDITCARD TOPUP (based on %)/CLEARING OUTSTANDING CREDITS
*CREDIT SCORE INCREASE
*REMOVE CRIMINAL RECORDS 
*TRACING PEOPLE'S BACKGROUND 
*HACK BANK ACCOUNTS 
*LOADING SPECIFIC BITCOIN WALLET AND CASHAPP
*DRIVERS LICENSE $600    
*REAL PASSPORT $950     
*SSN $600
*HACKING SOFTWARES ACTIVATION CODES AND LICENSE KEYS

CONTACT!!!!!!
Email: albertgonzalez0001@gmail.com 
Telegram: +1(202) 503-9187
Whatapp: : +1(202) 503-9187
Text : : +1(616) 202-1156


Cool Price
Western Union Transfer
Bank transfer
Paypal transfer
Cash App 
Skrill Transfer
Credit cards Load
Boa Transfer
Zelle Transfer
Venmo Transfer 
 
Transfer Charges
$€£ 250 - $€£ 3000 transfer
$€£ 300 - $€£ 4000 transfer
$€£ 400 - $€£ 5000 transfer
$€£ 500 - $£€ 6000 transfer
$€£ 650 - $£€ 7000 transfer
$€£ 700 - $£€ 8000 transfer

High balance       Charges
$10,000 Transfer = $1000
$15,000 Transfer = $1500
$20,000 Transfer = $2000
$30,000 Transfer = $3000
$50,000 Transfer = $5000
$70,000 Transfer = $7000
$90,500 Transfer = $9000



CLONED CARDS AND ATM CARDS ***
BEST WAY TO HAVE GOOD AMOUNT TO START A GOOD BUSINESS OR TO START LIVING A GOOD LIFE…..
Hack and take money directly from any ATM Machine Vault with the use of MY ATM Programmed Card which runs in automatic mode. Telegram:+1(202) 503 9187 for how to get it and its cost .

………. EXPLANATION OF HOW THESE CARD WORKS……….
You just slot in these card into any ATM Machine and it will automatically bring up a MENU of 1st VAULT $1,000, 2nd VAULT $5,000, RE-PROGRAMMED, EXIT, CANCEL. Just click on either of the VAULTS, and it will take you to another SUB-MENU of ALL, OTHERS, EXIT, CANCEL. Just click on others and type in the amount you wish to withdraw from the ATM and you have it cashed instantly… Done.
NOTE: DON’T EVER MAKE THE MISTAKE OF CLICKING THE “ALL” OPTION. BECAUSE IT WILL TAKE OUT ALL THE AMOUNT OF THE SELECTED VAULT. To get the card call
Some "special features" included are:
1. Your illegal ATM activity is undetectable and untraceable.
2. Card can be used anywhere in the world, on any model ATM machine.
3. $5,000 daily withdrawal possible. More, if you purchase a pricier card.
4. A secret mechanism or technique whichprevents ATM and CCTV cameras from recording your face. Hrmm. Maybe a can of spray paint or roll of duct tape to cover the camera lens is included? Or maybe a free Groucho Marx mask comes in the box???

 
ATM card 5000$€£ price 350$€£
ATM card 10000$€£ price 600$€£
ATM card 15000$€£ price 850$€£
ATM card 20000$€£ price 1500$€£
ATM card 25000$€£ price 2000$€£
ATM card 30000$€£ price 2550$€£
ATM card 35000$€£ price 3200$€£
ATM card 40000$€£ price 4350$€£
ATM card 50000$€£ price 5500$€£

RULES: No Long Talk!
= Please Read RULES & Respect Them.
= No Free Test, All Buyers who want to test my stuff can buy and test
= Bulk Order we have Special Prices, Contact For Info.
= We Have No Guarantee About Limit, We Are Not Selling Money, We Are Only Responsible For VALID.
= Instant Delivery
= Stuffs are sent to you after full payment for the order...
= We  Make REFUND or REPLACE WITHIN HOURS OF PURCHASE ONLY.
= Price Are Mention But Can Be UP Down.
= Service Rules Can Be Changed At Any Moment without Customer Notifications.
= Mobile Buyers Can Get Replace On road
= If you don't trust my service. Please do not contact me

LOADING PREPAID CARDS  GO2BANK/Revolut  Neo Money Card  AND LOTS MORE WORLDWIDE 

PREPAID card 5000$€£ price 300$€£
PREPAID card 10000$€£ price 600$€£
PREPAID card 15000$€£ price 850$€£
PREPAID card 20000$€£ price 1500$€£
PREPAID card 25000$€£ price 2000$€£
PREPAID card 30000$€£ price 2550$€£
PREPAID card 35000$€£ price 3200$€£
PREPAID card 40000$€£ price 4350$€£
PREPAID card 50000$€£ price 5500$€£



MAKE SURE TO KEEP YOUR TRANSACTION UNDERGROUND AND TAKE PRECAUTION DURING CASH-OUT.
USE DIFFERENT STORES FOR PICK-UP AND SEVERAL ID..
(THIS IS NOT A CHARITY ORG SO PLEASE COME WITH YOUR MONEY READY FOR SERIOUS BUSINESS

CONTACT!!!!!!
Email: albertgonzalez0001@gmail.com 
Telegram: +1(202) 503-9187
Whatapp: : +1(616) 202-1156
Text : : +1(616) 202-1156

New Annotation

Summary:
Author:
Mode:
Body: