Lbus MCP2004 Can`t write to ibus

Hi I have a problem, I fight with him already a few days and without results, move on to things Arduino → MCP2004 takes my data every push of a button on the radio or steering wheel shows up in the Serial monitor, but when you try to send nothing happens, the car behaves how would not receive data from arduino-> mcp

The following diagram Sketch and how I connected.

#include <SoftwareSerial.h>

SoftwareSerial IBusSerial(10,11); // RX, TX for IBus

//Lbus = Ibus from Car
//Vss = Ground
//Vbb = +12V

// Pins we use for MCP2004
const int faultPin = 13; //FAULT
const int cspin = 8;  //CS

boolean read_byte = false;
byte readbuffer[256];

int i;
int buffer_index = 0;
int buffer_max = 256; // 64 default
int cksum;
long lastrx;
long lasttx;

boolean byteSTATE = false;
int EventID = 0; // Event number (for case select)

void setup(){
    // initialize buffer array to 0's
    memset(readbuffer, 0, sizeof(readbuffer));
    
    // Open serial communications to host (PC) and wait for port to open:
    Serial.begin(9600, SERIAL_8E1);
    Serial.println("IBus Debugging begins");
    
    // set the data rate for the SoftwareSerial port
    IBusSerial.begin(9600);
    
    // Set high to enable TX on MCP2004
    pinMode(cspin, OUTPUT);
    digitalWrite(cspin, HIGH);

    pinMode(faultPin, OUTPUT);
    digitalWrite(faultPin, HIGH);
    
    lastrx = millis();
    lasttx = millis();
}

void loop(){
    // Somehow I think I'm having to slow this down to accurately read messages. 
    // Trying to just add a delay x number of microseconds to see how it does.
    delayMicroseconds(3000);
    
    // Check Serial (PC) to see if we need to send something. 
    if (Serial.available()){
        Serial.println("Got Input");
        handleMessage(Serial.read());
    }
    lasttx = millis();

  
    // Do timeout of buffer after not receiving anything for 10ms
    if ((millis() - lastrx) > 15) {
        memset(readbuffer, 0, sizeof(readbuffer));
        buffer_index = 0;
        read_byte = false;
        buffer_max = 64;
        lastrx = millis();
        return;
    }

    
    // If there's something to be read, read it.
    if (IBusSerial.available()) {
        readbuffer[buffer_index] = IBusSerial.read();
        read_byte = true;
    }
  
    // If this is byte 2, then set buffer_max to it's value.
    // Also set cksum to xor of byte 1 and byte 2.
    if (read_byte){
        if (buffer_index == 1){
            buffer_max = readbuffer[buffer_index] + 2;
            cksum = readbuffer[0] ^ readbuffer[1];
        } else if ((buffer_index > 1 ) && (buffer_index < buffer_max)){
            cksum = cksum ^ readbuffer[buffer_index];
        }
    }

    // Reset buffer_index when it is buffer_max - 1.
    if (buffer_index == (buffer_max - 1)) {
       if ((readbuffer[0] == 0x68) || (readbuffer[2] == 0x68)){
            if (cksum == 0) {
              //  Serial.print("Good message: ");
              //  Serial.print(millis());
              //  Serial.print(": ");
                for (i = 0; i < buffer_max; i++){
                   Serial.print(readbuffer[i],HEX);
              //     Serial.print(" ");
              
                }
            }else {
                Serial.print("Invalid message. cksum: ");
                Serial.println(cksum, HEX);
                for (i = 0; i < buffer_max; i++){
                    Serial.print(readbuffer[i], HEX);
                    Serial.print(" ");
                }
            }
            Serial.println();
      }

        // Empty the buffer
        memset(readbuffer, 0, sizeof(readbuffer));
        buffer_index = 0;
        read_byte = false;
        lastrx = millis();
    }
    
    // Increment index if we put something into the buffer
    if (read_byte == true){
        read_byte = false;
        buffer_index++;
        lastrx = millis();
    }
}

void handleMessage(byte messageType){
   byte volup[6] = {0x50,0x04,0x68,0x32,0x11,0x1F}; // Steering wheel Volume Up
   //char volume_up[]="\x50\x04\x68\x32\x11\x1F";
    byte voldown[6] = { 0x50 , 0x04 , 0x68 , 0x32, 0x10 , 0x1E }; // Steering wheel Volume Down
    //50 4 68 32 11 1F
    //50 4 68 32 10 1E 
    byte pressmode[6] = { 0xF0, 0x4, 0x68, 0x48, 0x23, 0xF7 };
    byte releasemode[6] = { 0xF0, 0x4, 0x68, 0x48, 0xA3, 0x77 };
    //MENU  68 4 3B 46 1 10 
    ////68 4 3B 46 C 1D
    byte ibussucks[22] = {
        0x68, 0x12, 0x3B, 0x23, 0x62, 0x10, 0x49, 0x42, 0x55,
        0x53, 0x53, 0x55, 0x43, 0x4b, 0x53, 0x20, 0x20, 0x20,
        0x20, 0x20, 0x20, 0x40
    };

    
    
    // OP Was setting faultPin HIGH to write?
 //    digitalWrite(13, HIGH);
// Serial.println(messageType);
    switch (messageType){
        case 0x70: // p for vol up
            Serial.println("Sending vol up.");
            sendMessage(volup);
            break;
        case 0x6E: // n for vol down
            Serial.println("Sending vol down.");
            sendMessage(voldown);
            break;
        case 0x42: // B for IBus Sucks
            Serial.println("Sending IBus Sucks.");
            sendMessage(ibussucks);
            break;
        case 0x6D: // m for mode
            Serial.println("Sending Mode.");
            sendMessage(pressmode);
            delay(150);
            sendMessage(releasemode);
            break;
    }
    
    // Again, OP was resetting the faultPin
   //digitalWrite(13, LOW);
}

void sendMessage(byte message_data[]){

    byte message_cksum = gen_cksum(message_data);
    for (int i=0; i <= sizeof(message_data) - 1; i++){
      IBusSerial.write(message_data[i]);
   } 
   IBusSerial.write(message_cksum);
   digitalWrite(13, LOW);
}

byte gen_cksum(const byte message[]){
    byte cksum = 0x00;
    for (int i = 1; i <= message[0]; i++){
        cksum = cksum ^ message[i];
    }
    return cksum;
}