Как вызвать метод из статической функции?

   struct sigaction sa;
   struct itimerval timer;
   memset(&sa, 0, sizeof(sa));
   sa.sa_handler = &StartTimer;
   sigaction(SIGALRM, &sa, NULL);
   timer.it_value.tv_sec = 0;
   timer.it_value.tv_usec = 25000;
   timer.it_interval.tv_sec = 0;
   timer.it_interval.tv_usec = 25000;
   setitimer(ITIMER_REAL, &timer, NULL);

void SerialPort::ReadBegin()
{
 
   
     m_serial_port.async_read_some(boost::asio::buffer(m_read_buffer,sizeof(m_read_buffer)),boost::bind(&SerialPort::ReadComplete, this,
            boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred));
 
    std::cout<<"read begin  " << std::endl;
}
 
void SerialPort::ReadComplete(const boost::system::error_code& error,size_t bytes_transferred)  //const boost::system::error_code &ec, size_t bytesTransferred
{
  
    std::cout<<"reading port"<<std::endl;
    ReadBegin();
}

boost::bind(&SerialPort::ReadComplete, this, boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred);

boost::bind(&SerialPort::ReadComplete, this)();

boost::bind(&SerialPort::ReadComplete, this, boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred)();

boost::bind(&SerialPort::ReadComplete, this, boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred)(0, 0);

std::vector<unsigned char> m_read_buffer;

bool SerialPort::Open()
{
    std::string s="/dev/ttyUSB0";
    try
    {
            m_serial_port.open(s);
            std::cout<<"open port ok"<<std::endl;
            return true;
    }
    catch (const std::exception &m_error_code)
   {
 
    std::cout<<"Error open port"<<std::endl;
    return false;
   }
 
}

bool SerialPort::Initialize()
{
    try
    {
        m_serial_port.set_option(serial_port_base::baud_rate(m_baud_rate));
        m_serial_port.set_option(serial_port_base::character_size(m_data_bits));
        if (m_parity == g_Parity_None)  m_serial_port.set_option(serial_port_base::parity(serial_port_base::parity::none));
        if (m_parity == g_Parity_Odd)   m_serial_port.set_option(serial_port_base::parity(serial_port_base::parity::odd));
        if (m_parity == g_Parity_Even)  m_serial_port.set_option(serial_port_base::parity(serial_port_base::parity::even));
        if (m_stop_bits == g_StopBits_1)   m_serial_port.set_option(serial_port_base::stop_bits(serial_port_base::stop_bits::one));
        if (m_stop_bits == g_StopBits_1_5) m_serial_port.set_option(serial_port_base::stop_bits(serial_port_base::stop_bits::onepointfive));
        if (m_stop_bits == g_StopBits_2)   m_serial_port.set_option(serial_port_base::stop_bits(serial_port_base::stop_bits::two));
        if (m_flow_control == g_Handshaking_Off)       m_serial_port.set_option(serial_port_base::flow_control(serial_port_base::flow_control::none));
        if (m_flow_control == g_Handshaking_Hardware)  m_serial_port.set_option(serial_port_base::flow_control(serial_port_base::flow_control::hardware));
        if (m_flow_control == g_Handshaking_Software)  m_serial_port.set_option(serial_port_base::flow_control(serial_port_base::flow_control::software));
        std::cout<<"Setting port ok"<<std::endl;
        return true;
    }
    catch (const std::exception &m_error_code)
    {
        std::cout<<"Error setting port"<<std::endl;
        return false;
   }
}

m_data_bits(8),
   m_stop_bits(g_StopBits_1),
   m_parity(g_Parity_None),
   m_flow_control(g_Handshaking_Off),

boost::asio::io_service srv;
boost::asio::serial_port port(srv);
srv.run();

class SerialPort  
{
    public:
        
    protected:
 
    private:
   
   boost::asio::io_service      m_service;
   boost::asio::serial_port     m_serial_port;

SerialPort::SerialPort():
   m_initialized(false),
   m_busy(false),
   m_baud_rate(115200),
   answerTimeoutMs_(500),
   refCount_(0),
 
   m_data_bits(8),
   m_stop_bits(g_StopBits_1),
   m_parity(g_Parity_None),
   m_flow_control(g_Handshaking_Software),
   
   pThread_(0),
   verbose_(true),
   m_serial_port(m_service)

void SerialPort::Write(const unsigned char *buffer, size_t bufferLength)
{
 
    boost::asio::write(m_serial_port, boost::asio::buffer(buffer, bufferLength));
   //m_serial_port.write_some(boost::asio::buffer(buffer, bufferLength));
 
 
  
}

void SerialPortLinux::Init()
{
        m_saio.sa_handler = signal_handler_IO;
        sigemptyset (&m_saio.sa_mask);
        m_saio.sa_flags = 0;
        m_saio.sa_restorer = NULL;
        sigaction(SIGIO,&m_saio,NULL);
        /*
          разрешаем процессу получать SIGIO
        */
        fcntl(m_fd, F_SETOWN, getpid());
 
        /*
          делаем файловый дескриптор асинхронным (страница руководства
          говорит, что только O_APPEND и O_NONBLOCK будут работать
          с F_SETFL...)
        */
        fcntl(m_fd, F_SETFL, FASYNC);
 
        tcgetattr(m_fd,&m_oldtio); /* save current port settings */
 
        /*
          устанавливаем новые установки порта для обработки канонического ввода
        */
        m_newtio.c_cflag = BAUDRATE | CS8 | CLOCAL | CREAD; //| CRTSCTS
        m_newtio.c_iflag = IGNPAR | ICRNL;
        m_newtio.c_oflag = 0;
       //m_newtio.c_lflag = ICANON;
        m_newtio.c_cc[VMIN]=0;
        m_newtio.c_cc[VTIME]=1;
        tcflush(m_fd, TCIFLUSH);
        tcsetattr(m_fd,TCSANOW,&m_newtio);
        printf("Init potr.\n");
 
}

 int m_fd;
        struct termios m_oldtio,m_newtio;
        struct sigaction m_saio;

void signal_handler_IO(int status)
{
//  int res = read(m_fd,m_rx_buf,255);
  printf("received SIGIO signal.\n");
  boost::bind(&SerialPortLinux::Read, SerialPortLinux())();
}

read(m_fd, m_rx_buf, 255)

void SerialPortLinux::Read()
{
 
    printf( "Start read.\n");
    
    int rd_static = read(m_fd, m_rx_buf, 255);
    if (rd_static>0)
    {
 
        printf( "%s \n", m_rx_buf);
 
    } else if(rd_static == 0)printf("No read data \n");
    else printf("Error read data \n");
}

SerialPortLinux::SerialPortLinux()
{
    adress = this;  
}

class SerialPortLinux
{
    public:
        SerialPortLinux();
        virtual ~SerialPortLinux();
        bool Open();
        void Close();
        void Init();
        void Write(char* buff);
        void Read();
 
    protected:
 
    private:
        int m_fd;
        struct termios m_oldtio,m_newtio;
        struct sigaction m_saio;           /* объявление действия сигнала (signal action) */
        char m_rx_buf[255];
        char* m_tx_buffer;
        bool m_flag_rx;
 
};
 
void signal_handler_IO(int status);
static SerialPortLinux* adress;

void signal_handler_IO(int status)
{
  printf("received SIGIO signal status = %d.\n", status);
 adress->Read();
}