demo/J1939test.ttcn

/* Copyright (c) 2000-2019 Ericsson Telecom AB
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v2.0
* which accompanies this distribution, and is available at
* https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html
*
* Contributors:
* Michael Josenhans
******************************************************************************/
//
//  File:               J1939test.ttcn
//  Description:        J1939 port type test
//


module J1939test {

import from SocketCAN_Types all;
import from SocketCAN_PortType all;
import from SocketCAN_Templates all;
import from J1939 all;

const float c_guard := 10.0

type enumerated SocketCAN_open_socket_type
{ 
  OPEN_CAN_RAW,
  OPEN_CAN_BCM,
  OPEN_CAN_ISOTP,
  OPEN_CAN_J1939
}

type enumerated e_Phase {
  e_open_socket, 
  e_testbody1, 
  e_testbody2,
  e_testbody3,
  e_testbody4,
  e_testbody5,
  e_testbody6,
  e_testbody7,
  e_testbodyEnd,
  e_close_socket,
  e_testcase_complete
}

type record SocketCAN_open_j1939_result{
  SocketCAN_ifr                    ifr,
  SocketCAN_socketid               socket_id} 

type record J1939_message  {
  e_Phase phase,
  SocketCAN_J1939_PDU j1939_pdu
}

const integer J1939_MAX_PDU_NUMBER := 256;  // for testing purposes

type record length (0 .. J1939_MAX_PDU_NUMBER) of SocketCAN_J1939_PDU SocketCAN_J1939_PDUs

// workarounds as (x .. enum2int(e_testcase_complete)) fails but:
// workarounds as (x .. enum2int(c_testcase_complete)) works
const e_Phase c_firstPhase        := e_open_socket
const e_Phase c_testcase_complete := e_testcase_complete

type record PhaseStartReq {
  e_Phase phase,
  integer phase_int
}
type record PhaseEndInd   {
  e_Phase phase, 
  integer phase_int
}

type port SyncMasterPort message {
  out PhaseStartReq
  in  PhaseEndInd
} with { extension "internal" }

type port SyncSlavePort message {
  in   PhaseStartReq
  out  PhaseEndInd
} with { extension "internal" }

type record of PTC PTCSet 


type component PTC {
  port SyncSlavePort                  pt_sync
  port SocketCAN_PT                   pt_socketCAN
  var  e_Phase                        v_phase := c_firstPhase
}

//component declarations
type component MTC{ 
  timer t_guard
  port  SyncMasterPort pt_sync
  var PTCSet         v_PTCSet := {}
}

altstep alt_awaitPhaseStartReq(in e_Phase p_phase) runs on PTC {
  var PhaseStartReq v_PhaseStartReq;
  [] pt_sync.receive (PhaseStartReq: {phase := p_phase, phase_int := ?}){
    log("PTC name: ", self)
    log("Waits for start of phase: ", p_phase)
  }
  // between v_phase and p_phase
  [] pt_sync.receive (PhaseStartReq: {phase := ?, phase_int := (enum2int(c_firstPhase) .. enum2int(v_phase))}) -> value v_PhaseStartReq 
  { 
    //v_phase := f_incPhase(v_phase)
    log("PTC name: ", self)
    log("Waits for start of phase: ", p_phase)
    log("Received completion of phase: ", p_phase)
    f_sendPhaseEndInd()
    repeat
  }
  [] pt_sync.receive (PhaseStartReq: {phase := ?, phase_int :=?}) -> value v_PhaseStartReq
  {log("Received unexpected message:", v_PhaseStartReq);setverdict(inconc)}
}

function f_startPhase (in e_Phase p_phase) runs on MTC {
  var integer v_i
  var integer v_amount := sizeof(v_PTCSet)
  var PhaseStartReq v_phaseStartReq := { phase := p_phase, phase_int := enum2int(p_phase)}

  for (v_i := 0; v_i < v_amount; v_i := v_i +1){
    log("MTC instance: ", self)
    pt_sync.send(v_phaseStartReq) to v_PTCSet[v_i]
  }
}

function f_incPTCPhase(in e_Phase p_currentPhase) runs on PTC return e_Phase {
  var e_Phase v_nextPhase
  log("PTC: ", self)
  log("PTC instance: ", self)
  log("Current PTC phase: ", p_currentPhase)
  int2enum( enum2int(p_currentPhase)+1, v_nextPhase)
  log("Next PTC phase:", v_nextPhase)
  return v_nextPhase
}

function f_sendPhaseEndInd() runs on PTC{
  // just to allow matching with integer ranges on the reception side, as it is not poosible to do so with enums
  var PhaseEndInd v_PhaseEndInd := {phase := v_phase, phase_int := enum2int(v_phase)}
  pt_sync.send(v_PhaseEndInd)
  log("PTC: PhaseEndInd to MTC with content: ", v_PhaseEndInd, self)
  v_phase := f_incPTCPhase(v_phase)
}

function f_addSyncSlaveSet (in PTC p_slave,
  inout PTCSet p_set) {
  p_set[sizeof(p_set)] := p_slave
  return
}

function f_incMTCPhase(in e_Phase p_currentPhase) runs on MTC return e_Phase {
  var e_Phase v_nextPhase
  log("MTC: ", self)
  log("Current phase: ", p_currentPhase)
  int2enum( enum2int(p_currentPhase)+1, v_nextPhase)
  log("Next phase:", v_nextPhase)
  return v_nextPhase
}

function f_awaitEndPhase(in e_Phase p_phase) runs on MTC {
  var integer v_amount:= sizeof(v_PTCSet);
  var integer v_i
  t_guard.start(c_guard)
  var PhaseEndInd v_PhaseEndInd

  for(v_i := 0; v_i < v_amount; v_i := v_i +1) {
    alt {
      [] pt_sync.receive (PhaseEndInd: {phase :=p_phase, phase_int := ?}){}
      // value between p_phase +1  and e_testcase_complete:
      [] pt_sync.receive (PhaseEndInd: {phase :=?, phase_int :=  (enum2int(p_phase) .. (enum2int(c_testcase_complete)))}){}
      [] t_guard.timeout {
        log("Timeout in MTC phase:", p_phase)
        setverdict(inconc)
      }
      [] pt_sync.receive (?)  -> value v_PhaseEndInd {
        log("Unexpected phase recieved: ", v_PhaseEndInd)
        log("Expected phase range: ", p_phase)
        log(" to ", c_testcase_complete)
        setverdict(inconc)        
      }
      [] any port.receive{
        log("Expected phase:", p_phase)
        setverdict(inconc)
      }
    } 
  }
  t_guard.stop
}

function f_open_socket(in SocketCAN_socket p_socket) 
runs on PTC 
return SocketCAN_socket_result {

  var SocketCAN_socket_result v_result  
  timer t_guard
  t_guard.start(c_guard)

  pt_socketCAN.send(p_socket)  

  // receive response
  alt {
    [] pt_socketCAN.receive(
      a_SocketCAN_socket_result(a_result(SocketCAN_SUCCESS))) -> value v_result
    {log("SocketCan:Socket opened: ", v_result.id)}
    [] pt_socketCAN.receive(a_SocketCAN_socket_result(a_result(SocketCAN_ERROR)))
    {log("Received Opening Socket failed"); setverdict(fail)}
    [] t_guard.timeout {
      log("timeout!")
      setverdict(fail)}
    [] t_guard.timeout {
      log("timeout!")
      setverdict(fail)}
  }
  t_guard.stop
  return v_result
}

function f_ioctl_get_if_index(in SocketCAN_socketid p_socket_id) 
runs on PTC 
return SocketCAN_ioctl_result {
  var SocketCAN_ioctl_result v_result   
  timer t_guard
  t_guard.start(c_guard)

  pt_socketCAN.send(SocketCAN_ioctl:{id:= p_socket_id, ifu := omit});
  // receive response
  alt {
    [] pt_socketCAN.receive(a_SocketCAN_ioctl_result(a_result(SocketCAN_SUCCESS))) -> value v_result
    {log("Retrieved interface index", v_result.ifr.if_index)}
    [] pt_socketCAN.receive(a_SocketCAN_ioctl_result(a_result(SocketCAN_ERROR)))
    {log("Retrieving interface index failed", p_socket_id); setverdict(fail)}       
    [] t_guard.timeout {
      log("timeout!")
      setverdict(fail)
    }
  } 
  return v_result
}

function f_connect(in SocketCAN_socketid p_socket_id,
  in SocketCAN_if_index p_if_index, 
  in J1939_NAME p_j1939_name_destination,
  in J1939_PGN  p_j1939_pgn_destination,
  in J1939_ADDR  p_j1939_pgn_addr)
runs on PTC 
return SocketCAN_connect_result {  
  var SocketCAN_connect_result v_result                   
  timer t_guard
  t_guard.start(c_guard)

  pt_socketCAN.send(SocketCAN_Types.SocketCAN_connect:{id:= p_socket_id, 
      connectu := {j1939 := {if_index:= p_if_index, 
          j1939_destination:= {
            name := p_j1939_name_destination /* or J1939_NO_NAME */,
            pgn  := p_j1939_pgn_destination /* or J1939_NO_PGN */, 
            addr := p_j1939_pgn_addr        /* or J1939_NO_ADDR */}}}});
  // SocketCAN_connect receive response
  alt {
    [] pt_socketCAN.receive(a_SocketCAN_connect_result(a_result(SocketCAN_SUCCESS))) -> value v_result
    {log("Connecting socket", p_socket_id)}
    [] pt_socketCAN.receive(a_SocketCAN_connect_result(a_result(SocketCAN_ERROR))) 
    {log("Connecting socket failed.", p_socket_id); setverdict(fail)}       
    [] t_guard.timeout {
      log("timeout!")
      setverdict(fail)}
  } 
  return v_result
}

function f_bind(
  in SocketCAN_socketid p_socket_id,
  in SocketCAN_if_index p_if_index, 
  in J1939_NAME         p_j1939_name_source,
  in J1939_PGN          p_j1939_pgn_source,
  in J1939_ADDR         p_j1939_addr_source) 
runs on PTC 
return SocketCAN_bind_result {
  var SocketCAN_bind_result v_result
  timer t_guard
  t_guard.start(c_guard)

  log("p_socket_id", p_socket_id)
  log("p_if_index", p_if_index)
  log("p_j1939_name_source", p_j1939_name_source)
  log("p_j1939_pgn_source", p_j1939_pgn_source)
  log("p_j1939_addr_source", p_j1939_addr_source)


  pt_socketCAN.send(SocketCAN_bind:{id:= p_socket_id, 
      bindu := {j1939 := {if_index:= p_if_index, 
          j1939_source:= 
          {name :=  p_j1939_name_source /* or J1939_NO_NAME */,
            pgn :=  p_j1939_pgn_source  /* or J1939_NO_PGN */, 
            addr := p_j1939_addr_source /* or J1939_NO_ADDR or J1939_IDLE_ADDR */ }}}});
  alt {
    [] pt_socketCAN.receive(a_SocketCAN_bind_result(a_result(SocketCAN_SUCCESS))) -> value v_result
    {log("Binding socket", p_socket_id)}
    [] pt_socketCAN.receive(a_SocketCAN_bind_result(a_result(SocketCAN_ERROR))) {}
    [] t_guard.timeout {
      log("timeout!")
      setverdict(fail)
    }
  }  
  return v_result
}

function f_j1939_send_data_to(
  in SocketCAN_socketid   p_socket_id, 
  in SocketCAN_if_index   p_if_index,
  in J1939_hdr            p_j1939_destination,
  in SocketCAN_J1939_PDU  p_pdu)
runs on PTC
return SocketCAN_j1939_send_data_to_result { 
  var SocketCAN_j1939_send_data_to_result v_result

  timer t_guard
  t_guard.start(c_guard)

  pt_socketCAN.send(SocketCAN_j1939_send_data_to:{
      id                := p_socket_id,
      if_index          := p_if_index,
      j1939_destination := p_j1939_destination,
      pdu               := p_pdu});

  alt {
    [] pt_socketCAN.receive(a_SocketCAN_j1939_send_data_to_result(a_result(SocketCAN_SUCCESS))) -> value v_result
    {log("Sending j1939_send_data_to", p_socket_id)}
    [] pt_socketCAN.receive(a_SocketCAN_j1939_send_data_to_result(a_result(SocketCAN_ERROR))) 
    {log("Sending j1939_send_data_to failed", p_socket_id); setverdict(fail)}       
    [] t_guard.timeout {
      log("timeout!")
      setverdict(fail)
    }
  }
  return v_result
}

function f_receive_j1939_message_data(
  in SocketCAN_socketid        p_socket_id, 
  template J1939_PGN           p_pgn_expected,
  template J1939_ADDR          p_addr_expected,
  template J1939_NAME          p_name_expected,
  template SocketCAN_J1939_PDU p_pdu_expected
)
runs on PTC { 
  var SocketCAN_receive_j1939_message v_result

  timer t_guard
  t_guard.start(c_guard)

  // receive frame or timeout
  alt {

    [] pt_socketCAN.receive(a_SocketCAN_receive_j1939_message(
        p_socket_id,
        ?,
        p_pgn_expected,
        p_addr_expected,
        p_name_expected,
        p_pdu_expected))-> value v_result
    {log("SocketCan:Expected frame received", v_result)}
    [] pt_socketCAN.receive(SocketCAN_receive_j1939_message:?) -> value v_result
    {log("SocketCan:Unexpected j1939 message received!", v_result)
      setverdict(fail)}
    [] t_guard.timeout {
      log("timeout!")
      setverdict(fail)}
  }
}

function f_receive_no_data_but_timeout(in SocketCAN_socketid p_socket_id, in float p_timeout_period)
runs on PTC { 
  var SocketCAN_receive_j1939_message v_result

  timer t_guard
  t_guard.start(p_timeout_period)

  // receive j1939 message or timeout
  alt {
    [] pt_socketCAN.receive(a_SocketCAN_receive_j1939_message(
        p_socket_id,
        ?,
        ?,
        ?,
        ?,
      ?)) -> value v_result {
      log("SocketCan:Unexpected j1939 message received!", v_result)
      setverdict(fail)
    }
    [] t_guard.timeout {
      log("Expected timeout!")}
  }
}

function f_j1939_send_data(in SocketCAN_socketid p_socket_id, 
  in SocketCAN_J1939_PDU              p_pdu) 
runs on PTC 
return SocketCAN_j1939_send_data_result { 

  var SocketCAN_j1939_send_data_result v_result

  timer t_guard
  t_guard.start(c_guard)
  log("SocketCAN_j1939_send_data_to:{id}:", p_socket_id)
  log("SocketCAN_j1939_send_data_to:{pdu}:", p_pdu)

  pt_socketCAN.send(SocketCAN_j1939_send_data:{
      id:= p_socket_id, 
      pdu:=p_pdu});
  alt {
    [] pt_socketCAN.receive(a_SocketCAN_j1939_send_data_result(a_result(SocketCAN_SUCCESS))) -> value v_result
    {log("Writing data on J1939 socket: ", p_socket_id)}
    [] pt_socketCAN.receive(a_SocketCAN_j1939_send_data_result(a_result(SocketCAN_ERROR))) 
    {log("Writing data on J1939 socket failed", p_socket_id); 
      setverdict(fail)}       
    [] t_guard.timeout {
      log("timeout!")
      setverdict(fail)}
  }
  return v_result
}

function f_receive_j1939_data(
  in SocketCAN_socketid p_socket_id,
  template SocketCAN_ifr      p_ifr,
  template J1939_PGN          p_peer_pgn,
  template J1939_ADDR         p_peer_addr,
  template J1939_NAME         p_peer_name,
  template SocketCAN_J1939_PDU p_j1939_pdu__expected)
runs on PTC { 
  var SocketCAN_receive_j1939_message v_result

  timer t_guard
  t_guard.start(c_guard)

  // receive frame or timeout
  alt {
    [] pt_socketCAN.receive(a_SocketCAN_receive_j1939_message(
        p_socket_id,
        p_ifr,
        p_peer_pgn,
        p_peer_addr,
        p_peer_name,
        p_j1939_pdu__expected)) -> value v_result
    {log("SocketCan:Expected frame received", v_result)}
    [] pt_socketCAN.receive(SocketCAN_receive_j1939_message:?) -> value v_result
    {log("SocketCan:Unexpected frame received!", v_result)
      setverdict(fail)}
    [] t_guard.timeout {
      log("timeout!")
      setverdict(fail)}
  }
}


function f_setsockopt(in SocketCAN_socketid p_socket_id,
  in SocketCAN_setsockopt_commandu p_command)
runs on PTC 
return SocketCAN_setsockopt_result{
  var SocketCAN_setsockopt_result v_result

  timer t_guard
  t_guard.start(c_guard)

  pt_socketCAN.send(SocketCAN_Types.SocketCAN_setsockopt:{id:= p_socket_id, command := p_command});
  alt {
    [] pt_socketCAN.receive(a_SocketCAN_setsockopt_result(a_result(SocketCAN_SUCCESS))) -> value v_result
    {log("Writing data", p_socket_id)}
    [] pt_socketCAN.receive(a_SocketCAN_setsockopt_result(a_result(SocketCAN_ERROR))) 
    {log("Writing data failed", p_socket_id); setverdict(fail)}       
    [] t_guard.timeout {
      log("timeout!")
      setverdict(fail)
    }
  }
  return v_result
}

function f_close_socket (in SocketCAN_socketid p_socket_id) 
runs on PTC {
  pt_socketCAN.send(SocketCAN_close:{id:= p_socket_id});
}

function f_open_j1939()
runs on PTC 
return SocketCAN_open_j1939_result {
  var SocketCAN_socketid v_socket_id
  v_socket_id := f_open_socket({domain:=PF_CAN, ptype := SOCK_DGRAM, protocol:= CAN_J1939}).id
  var SocketCAN_ifr v_ifr
  v_ifr := f_ioctl_get_if_index(v_socket_id).ifr

  var SocketCAN_open_j1939_result v_result
  v_result := {ifr := v_ifr, socket_id := v_socket_id}

  return v_result
}

function f_ptc_J1939SendInitiator(
  in e_Phase             p_phase,
  in J1939_Priority      p_send_prio,
  in J1939_ADDR          p_j1939_addr_source,
  in J1939_PGN           p_j1939_pgn_destination,
  in J1939_ADDR          p_j1939_addr_destination,
  in SocketCAN_J1939_PDU p_pdu_send) runs on PTC {
  map(self:pt_socketCAN, system:pt_socketCAN)
  var SocketCAN_socketid v_socket_id
  var SocketCAN_ifr v_ifr

  alt_awaitPhaseStartReq(e_open_socket)
  var SocketCAN_open_j1939_result res
  res := f_open_j1939()
  v_socket_id := res.socket_id
  v_ifr := res.ifr
  var SocketCAN_bind_result v_bind_result
  v_bind_result := f_bind(v_socket_id,
    v_ifr.if_index, 
    J1939_NO_NAME /* p_j1939_name_source */, 
    J1939_NO_PGN  /* p_j1939_pgn_source */,
    p_j1939_addr_source)
  var SocketCAN_setsockopt_result            v_setsockopt_result
  v_setsockopt_result := f_setsockopt(v_socket_id, {j1939_prio:=p_send_prio})
  v_setsockopt_result := f_setsockopt(v_socket_id, {j1939_prio:=p_send_prio})
  f_sendPhaseEndInd()

  alt_awaitPhaseStartReq(p_phase)
  var SocketCAN_j1939_send_data_to_result send_data_to_result
  var J1939_hdr v_j1939_destination := {
    //name := p_j1939_name_source, 
    pgn := p_j1939_pgn_destination, 
    addr:= p_j1939_addr_destination}

  send_data_to_result := f_j1939_send_data_to(
    v_socket_id, 
    v_ifr.if_index,
    v_j1939_destination,
    p_pdu_send)
  f_sendPhaseEndInd()

  alt_awaitPhaseStartReq(e_close_socket)
  f_close_socket (v_socket_id)
  unmap(self:pt_socketCAN, system:pt_socketCAN)
  setverdict(pass)
  f_sendPhaseEndInd()
}


function f_ptc_J1939SendInitiatorWithConnect(
  in e_Phase p_phase,
  in J1939_ADDR p_j1939_addr_source,
  in J1939_PGN  p_j1939_pgn_destination,
  in J1939_ADDR p_j1939_addr_destination,
  in SocketCAN_J1939_PDU p_pdu_send) runs on PTC {
  map(self:pt_socketCAN, system:pt_socketCAN)
  var SocketCAN_socketid v_socket_id
  var SocketCAN_ifr v_ifr

  alt_awaitPhaseStartReq(e_open_socket)
  var SocketCAN_open_j1939_result res
  res := f_open_j1939()
  v_socket_id := res.socket_id
  v_ifr := res.ifr
  var SocketCAN_bind_result v_bind_result
  v_bind_result := f_bind(v_socket_id,
    v_ifr.if_index, 
    J1939_NO_NAME /* p_j1939_name_source */, 
    J1939_NO_PGN  /* p_j1939_pgn_source */,
    p_j1939_addr_source)
  var SocketCAN_connect_result v_connect_result
  v_connect_result := f_connect(
    v_socket_id, 
    v_ifr.if_index, 
    J1939_NO_NAME,
    p_j1939_pgn_destination,
    p_j1939_addr_destination)
  f_sendPhaseEndInd()

  alt_awaitPhaseStartReq(p_phase)
  var SocketCAN_j1939_send_data_result send_data_result

  send_data_result := f_j1939_send_data(
    v_socket_id, 
    p_pdu_send)
  f_sendPhaseEndInd()

  alt_awaitPhaseStartReq(e_close_socket)
  f_close_socket (v_socket_id)
  unmap(self:pt_socketCAN, system:pt_socketCAN)
  setverdict(pass)
  f_sendPhaseEndInd()
}

function f_ptc_J1939FrameReceiver(
  in e_Phase p_phase,
  in J1939_ADDR               p_j1939_addr_source,
  template J1939_PGN          p_peer_pgn,
  template J1939_ADDR         p_peer_addr,
  template J1939_NAME         p_peer_name, 
  template SocketCAN_J1939_PDU p_j1939_pdu_expected) runs on PTC {
  map(self:pt_socketCAN, system:pt_socketCAN)
  var SocketCAN_socketid v_socket_id
  var SocketCAN_ifr v_ifr

  alt_awaitPhaseStartReq(e_open_socket)
  var SocketCAN_open_j1939_result res
  res := f_open_j1939()
  v_socket_id := res.socket_id
  v_ifr := res.ifr
  var SocketCAN_bind_result v_bind_result
  v_bind_result := f_bind(v_socket_id,
    v_ifr.if_index, 
    J1939_NO_NAME,
    J1939_NO_PGN,
    p_j1939_addr_source)
  f_sendPhaseEndInd()

  alt_awaitPhaseStartReq(p_phase)
  f_receive_j1939_data(
    v_socket_id, 
    v_ifr,
    p_peer_pgn,
    p_peer_addr,
    p_peer_name,
    p_j1939_pdu_expected)
  f_sendPhaseEndInd()

  alt_awaitPhaseStartReq(e_close_socket)
  f_close_socket (v_socket_id)
  unmap(self:pt_socketCAN, system:pt_socketCAN)  
  setverdict(pass)
  f_sendPhaseEndInd()
}

function f_ptc_J1939SendInitiatorDynamic(in e_Phase p_phase,
  in J1939_NAME p_j1939_name_source,  
  in J1939_NAME p_j1939_name_destination,
  in J1939_PGN  p_j1939_pgn_destination,
  in J1939_ADDR p_j1939_addr_destination,
  in SocketCAN_J1939_PDU p_pdu_send) runs on PTC {
  map(self:pt_socketCAN, system:pt_socketCAN)
  var SocketCAN_socketid v_socket_id
  var SocketCAN_ifr v_ifr

  alt_awaitPhaseStartReq(e_open_socket)
  var SocketCAN_open_j1939_result res
  res := f_open_j1939()
  v_socket_id := res.socket_id
  v_ifr := res.ifr
  var SocketCAN_bind_result v_bind_result
  v_bind_result := f_bind(v_socket_id,
    v_ifr.if_index, 
    p_j1939_name_source, 
    J1939_NO_PGN  /* p_j1939_pgn_source */,
    J1939_IDLE_ADDR /* p_j1939_addr_source */)
  //  var SocketCAN_connect_result v_connect_result
  //  v_connect_result := f_connect(v_socket_id, 
  //    v_ifr.if_index, 
  //    p_j1939_name_destination,
  //    p_j1939_pgn_destination,
  //    p_j1939_pgn_addr)
  var SocketCAN_setsockopt_result            v_setsockopt_result
  const SocketCAN_setsockopt_commandu c_commandu_activate_broadcast := {j1939_broadcast := Enable} 

  // configure filters:
  v_setsockopt_result := f_setsockopt(v_socket_id, c_commandu_activate_broadcast)
  // configure filters:
  const J1939_filter c_j1939_filter0 := {
    name_filter:= omit,
    addr_filter:= omit,
    pgn_filter :={
      pgn :=J1939_PGN_ADDRESS_CLAIMED,
      pgn_mask := J1939_PGN_PDU1_MAX}};

  const J1939_filter c_j1939_filter1 := {
    name_filter:= omit,
    addr_filter:= omit,
    pgn_filter :={
      pgn      := J1939_PGN_REQUEST, //J1939_PGN_ADDRESS_REQUEST
      pgn_mask := J1939_PGN_PDU1_MAX}};

  const J1939_filter c_j1939_filter2 := {    
    name_filter:= omit,
    addr_filter:= omit,
    pgn_filter :={
      pgn      := J1939_PGN_ADDRESS_COMMANDED,
      pgn_mask := J1939_PGN_MAX}};

  const SocketCAN_setsockopt_commandu c_commandu_activate_j1939_filters := 
  {j1939_filter:={c_j1939_filter0, c_j1939_filter1, c_j1939_filter2}}

  v_setsockopt_result := f_setsockopt(v_socket_id, c_commandu_activate_j1939_filters)
  f_sendPhaseEndInd()

  alt_awaitPhaseStartReq(p_phase)
  var SocketCAN_j1939_send_data_to_result send_data_to_result
  var J1939_hdr v_j1939_destination := {
    name := omit, 
    pgn := J1939_PGN_ADDRESS_CLAIMED, 
    addr:= J1939_NO_ADDR}

  send_data_to_result := f_j1939_send_data_to(
    v_socket_id, 
    v_ifr.if_index,
    v_j1939_destination,
    p_j1939_name_source /*p_pdu_send*/)

  //  var SocketCAN_j1939_send_data_result send_data_result
  //  send_data_result := f_j1939_send_data(v_socket_id,
  //    p_pdu_send)
  f_sendPhaseEndInd()

  alt_awaitPhaseStartReq(e_close_socket)
  f_close_socket (v_socket_id)
  unmap(self:pt_socketCAN, system:pt_socketCAN)
  setverdict(pass)
  f_sendPhaseEndInd()
}

function f_ptc_J1939FrameReceiverDynamic(in e_Phase p_phase,
  in J1939_NAME p_j1939_name_source,
  in J1939_PGN  p_j1939_pgn_source,
  in J1939_ADDR p_j1939_addr_source, 
  template J1939_PGN          p_peer_pgn,
  template J1939_ADDR         p_peer_addr,
  template J1939_NAME         p_peer_name, 
  template SocketCAN_J1939_PDU p_j1939_pdu_expected) runs on PTC {
  map(self:pt_socketCAN, system:pt_socketCAN)
  var SocketCAN_socketid v_socket_id
  var SocketCAN_ifr v_ifr

  alt_awaitPhaseStartReq(e_open_socket)
  var SocketCAN_open_j1939_result res
  res := f_open_j1939()
  v_socket_id := res.socket_id
  v_ifr := res.ifr
  var SocketCAN_bind_result v_bind_result
  v_bind_result := f_bind(v_socket_id,
    v_ifr.if_index, 
    p_j1939_name_source,
    p_j1939_pgn_source,
    p_j1939_addr_source)

  f_sendPhaseEndInd()

  alt_awaitPhaseStartReq(p_phase)
  f_receive_j1939_data(
    v_socket_id, 
    v_ifr,
    p_peer_pgn,
    p_peer_addr,
    p_peer_name,
    p_j1939_pdu_expected)
  f_sendPhaseEndInd()

  alt_awaitPhaseStartReq(e_close_socket)
  f_close_socket (v_socket_id)
  unmap(self:pt_socketCAN, system:pt_socketCAN)  
  setverdict(pass)
  f_sendPhaseEndInd()
}

function f_ptc_J1939FrameSequenceReceiver(
  in e_Phase p_sequence_expected_phase,
  in J1939_NAME p_j1939_name_source,
  template J1939_PGN          p_peer_pgn,
  template J1939_ADDR         p_peer_addr,
  template J1939_NAME         p_peer_name, 
  template SocketCAN_J1939_PDUs p_pdu_sequence_expected, 
  in e_Phase p_no_further_frames_expected_phase, 
  in float p_timeout_period) runs on PTC {
  map(self:pt_socketCAN, system:pt_socketCAN)
  var SocketCAN_socketid v_socket_id
  var SocketCAN_ifr v_ifr

  alt_awaitPhaseStartReq(e_open_socket)
  var SocketCAN_open_j1939_result res
  res := f_open_j1939()
  v_socket_id := res.socket_id
  v_ifr := res.ifr
  var SocketCAN_bind_result v_bind_result
  v_bind_result := f_bind(v_socket_id,
    v_ifr.if_index, 
    p_j1939_name_source, 
    J1939_NO_PGN  /* p_j1939_pgn_source */,
    J1939_NO_ADDR /*p_j1939_addr_source */)
  f_sendPhaseEndInd()

  alt_awaitPhaseStartReq(p_sequence_expected_phase)
  var integer v_i
  for( v_i := 0; v_i < lengthof(p_pdu_sequence_expected); v_i := v_i +1) { 
    f_receive_j1939_data(
      v_socket_id, 
      v_ifr,
      p_peer_pgn,
      p_peer_addr,
      p_peer_name,
      p_pdu_sequence_expected[v_i])
  }
  f_sendPhaseEndInd()

  alt_awaitPhaseStartReq(p_no_further_frames_expected_phase)
  f_receive_no_data_but_timeout(v_socket_id, p_timeout_period)
  f_sendPhaseEndInd()

  alt_awaitPhaseStartReq(e_close_socket)
  f_close_socket (v_socket_id)
  unmap(self:pt_socketCAN, system:pt_socketCAN)  
  setverdict(pass)
  f_sendPhaseEndInd()
}

function f_j1939_address_claim(in e_Phase p_phase, 
  in   J1939_NAME p_j1939_name_source) runs on PTC {
  map(self:pt_socketCAN, system:pt_socketCAN)
  var SocketCAN_socketid v_socket_id
  var SocketCAN_ifr v_ifr

  alt_awaitPhaseStartReq(e_open_socket)
  var SocketCAN_open_j1939_result res
  res := f_open_j1939()
  v_socket_id := res.socket_id
  v_ifr := res.ifr
  var SocketCAN_bind_result v_bind_result
  v_bind_result := f_bind(v_socket_id, 
    v_ifr.if_index, 
    p_j1939_name_source,
    J1939_NO_PGN,
    '80'O)//J1939_IDLE_ADDR)
  f_sendPhaseEndInd()

  var SocketCAN_setsockopt_result            v_setsockopt_result

  v_setsockopt_result := f_setsockopt(v_socket_id, {j1939_broadcast:=Enable})

  // configure filters:
  const J1939_filter c_j1939_filter0 := {
    name_filter:= omit,
    addr_filter:= omit,
    pgn_filter :={
      pgn :=J1939_PGN_ADDRESS_CLAIMED,
      pgn_mask := J1939_PGN_PDU1_MAX}};

  const J1939_filter c_j1939_filter1 := {
    name_filter:= omit,
    addr_filter:= omit,
    pgn_filter :={
      pgn      := J1939_PGN_REQUEST, //J1939_PGN_ADDRESS_REQUEST
      pgn_mask := J1939_PGN_PDU1_MAX}};

  const J1939_filter c_j1939_filter2 := {
    name_filter:= omit,
    addr_filter:= omit,
    pgn_filter :={
      pgn      := J1939_PGN_ADDRESS_COMMANDED,
      pgn_mask := J1939_PGN_MAX}};

  const SocketCAN_setsockopt_commandu c_commandu_activate_j1939_filters := 
  {j1939_filter:={c_j1939_filter0, c_j1939_filter1, c_j1939_filter2}}

  v_setsockopt_result := f_setsockopt(v_socket_id, c_commandu_activate_j1939_filters)

  alt_awaitPhaseStartReq(p_phase)

  var SocketCAN_j1939_send_data_to_result send_data_to_result
  var J1939_hdr v_j1939_destination := {
    name := omit, 
    pgn := J1939_PGN_ADDRESS_CLAIMED, 
    addr:= J1939_NO_ADDR}

  var J1939_NAME v_j1939_name_source_reverse := 
  p_j1939_name_source[7]& p_j1939_name_source[6]& p_j1939_name_source[5]&
  p_j1939_name_source[4]& p_j1939_name_source[3]& p_j1939_name_source[2]& 
  p_j1939_name_source[1]& p_j1939_name_source[0]
  
  send_data_to_result := f_j1939_send_data_to(
    v_socket_id, 
    v_ifr.if_index,
    v_j1939_destination,
    v_j1939_name_source_reverse /*p_pdu_send*/)

  f_sendPhaseEndInd()

  alt_awaitPhaseStartReq(e_close_socket)
  f_close_socket (v_socket_id)
  unmap(self:pt_socketCAN, system:pt_socketCAN)
  setverdict(pass)
  f_sendPhaseEndInd()
}

function f_j1939_address_claim2(in e_Phase p_phase, 
  in   J1939_NAME          p_j1939_name_source, 
  in   SocketCAN_J1939_PDU p_pdu_send) runs on PTC {
  map(self:pt_socketCAN, system:pt_socketCAN)
  var SocketCAN_socketid v_socket_id
  var SocketCAN_ifr v_ifr

  alt_awaitPhaseStartReq(e_open_socket)
  var SocketCAN_open_j1939_result res
  res := f_open_j1939()
  v_socket_id := res.socket_id
  v_ifr := res.ifr
  var SocketCAN_bind_result v_bind_result
  v_bind_result := f_bind(v_socket_id, 
    v_ifr.if_index, 
    p_j1939_name_source,
    J1939_NO_PGN,
    J1939_IDLE_ADDR)
  f_sendPhaseEndInd()

  var SocketCAN_setsockopt_result            v_setsockopt_result

  v_setsockopt_result := f_setsockopt(v_socket_id, {j1939_broadcast:=Enable})

  // configure filters:
  const J1939_filter c_j1939_filter0 := {
    name_filter:= omit,
    addr_filter:= omit,
    pgn_filter :={
      pgn :=J1939_PGN_ADDRESS_CLAIMED,
      pgn_mask := J1939_PGN_PDU1_MAX}};

  const J1939_filter c_j1939_filter1 := {
    name_filter:= omit,
    addr_filter:= omit,
    pgn_filter :={
      pgn      := J1939_PGN_REQUEST, //J1939_PGN_ADDRESS_REQUEST
      pgn_mask := J1939_PGN_PDU1_MAX}};

  const J1939_filter c_j1939_filter2 := {
    name_filter:= omit,
    addr_filter:= omit,
    pgn_filter :={
      pgn      := J1939_PGN_ADDRESS_COMMANDED,
      pgn_mask := J1939_PGN_MAX}};

  const SocketCAN_setsockopt_commandu c_commandu_activate_j1939_filters := 
  {j1939_filter:={c_j1939_filter0, c_j1939_filter1, c_j1939_filter2}}

  v_setsockopt_result := f_setsockopt(v_socket_id, c_commandu_activate_j1939_filters)

  alt_awaitPhaseStartReq(p_phase)

  var SocketCAN_j1939_send_data_to_result send_data_to_result
  var J1939_hdr v_j1939_destination := {
    name := omit, 
    pgn := J1939_PGN_REQUEST, 
    addr:= J1939_NO_ADDR}
  
  send_data_to_result := f_j1939_send_data_to(
    v_socket_id, 
    v_ifr.if_index,
    v_j1939_destination,
    p_pdu_send)

  f_sendPhaseEndInd()

  alt_awaitPhaseStartReq(e_close_socket)
  f_close_socket (v_socket_id)
  unmap(self:pt_socketCAN, system:pt_socketCAN)
  setverdict(pass)
  f_sendPhaseEndInd()
}

// control
// {
//    execute(tc_can_raw0())
// }
}