vehicle networ is what connects the different parts together as a vehile.

the lower-level basic

A few basic concepts: TCP/UDP socket, CAN Bus, Ethernet, MCU register, Ip address, MAC address, Ethernet driver, network configure, how to code a ECU/MCU etc.

there are EE students working on this close to physical level implementation, on how to talk with register, MCU pins and controls, and some implementing the data traffic protocol in network. While both are isolated from top applications, since no matter where the data come from, either AV application or connected vehicle or media data, doesn’t make a difference.

architecture

typical vehicle network architecture

beyond the basic, network architecture brings a good vision to understand what makes a vehicle electronicly as a whole. and which is serving all apps with v2x, in-vehicle entertainment, AV.

I was thought ECU handling events the same as web server. while they are very different. each ECU is doing only one special task. e.g. ABS ECU only dealing with ABS events, there are no many ABS events happening simultaneously to seize the ECU computing resource; however, a web server have to deal with multiplex request simultaneously, either using thread pool or asynchronous event callbacks.

each ECU actually has an easy life, but the bus seems easily choked since around 100+ ECU nodes in the vehicle network. however again, typical vehicle network architecture is very matured products, without data-heavy applications arising, current CAN bus is great.

smart phone in wheels?

one day in future, every vehicle running on road is requesting some data from cloud seamlessly, the scenario is like billions of browsers send requests to Google server seamlessly, then the cloud may face same issues in today’s web server.

Service oriented architecture(SOA) is also rising in vehicle network architeture design, but what kind of services is better locally in vehicle, and which services in cloud ? as hardwares evolution, even the computing-heavy tasks, e.g. vision based detection, path planning in AV, suppose not be a burden for local ECUs. so these services make sense locally served.

except that, I only image future vehicle as a smart phone on wheels. so remote cloud server do connect to, e.g. talk to another vehicle, play online game during driving, check weather, find out a parking lot, resturant or similar, or the car company want to steal user data privately?

SOA is a good move to decouple ECU modules and make the network bus light, and it’s fun to try some vehicle network architecture open project or play with ROS simulator if hardware required. but in a business view, I don’t know a good story to attract investors, namely vehicle network sounds not that blinking amazing.

websocket projects recently reviewed: uWebSocket, which is used in Udacity self-driving car term2 projects. the other is libwebsocket, which is used in automotive message broker(amb).

gcc compiler options

gcc and make: a tutorial on how to compile, link and build c/c++ projects

-wall : print all warning messages 
-c : compile into object, by default the object has same name as the source file
-o : specify the output executable filename

headers(.h), static libs(.lib, .a) & shared libs(.dll, .so)

gcc by default, links to the shared libraries if available.

the compiler search “include-paths” for headers, which is specified via -L\ option or CPATH;

the linker search “library-paths” to link the program into an executable object, which is specified via -L\ or LIBRARY_PATH, in addition, need to specify the library name via -l

the system default “include-paths” can be found by “cpp -v”

gcc environment variables

PATH is used to search executable and run-time shared libs. (woo, this suppose to replace LD-LIBRARY-PATH)
CPATH is used to search “include-paths”, it’s searched after paths specified in -I<dir> options. C_INCLUDE_PATH & CPLUS_INCLUDE_PATH can be used to specify C & C++ headers
LIBRARY_PATH is used to search linking-time “library-paths”, it’s searched after paths specified in -L\ options. the standard directories is /usr/lib

Linux utils

1) readelf: read ELF

2) ldconfig : by default, read /etc/ls.so.conf, sets up the appropirate symbolic links in the dynamic link dir, and then write a cache to /etc/ld.so.cache, which then is used by other programs

3) ldd: to see recursive shared library dependencies

4) file: determine file type

5) nm: list symbol table of an object file, commonly-used to check if a particular func or variable is defined in an object file. “T” indicates it is defined; “U” means undefined, which should be resolved by the linker.

make & cmake

[gnu make] (https://www.gnu.org/software/make/manual/html_node/index.html#SEC_Contents)

there are many best practical, e.g. effective cmake

build libuv

it’s built based on GNU autotools

sh autogen.sh  
"libtoolize: AC_CONFIG_MACRO_DIR([m4]) conflicts with ACLOCAL_AMFLAGS=-I m4"

fixing-solution, then make all & make install, so here is libuv.so, add the directory to \$LIBRARY_PATH in ~/.bashrc

build uWebSockets

it’s built based on gnu make. the tests command has dependents on libuv. since already added libuv directory to \$LIBRARY_PATH, run through. if else, errors output:

cannot find -luv
collect2: error: ld returned 1 exit status
Makefile:xx recipe for targe 'tests' failed    
make: *** [tests] Error 1 

try to run ./testsBin, get another error:

error while loading shared libraries: libuWS.so: cannot open shared object file: No such file or directory 

that’s run-time error, since libuWS.so is not included in \$PATH or speically for building/testing purpose, define $LD_LIBRARY_PATH.

build libwebsockets

it’s built based on cmake. there is some dependent, but should go through well.

beyond the note

when 2-months ago, looking at amb project, which has websocket plugin module, then find uWebSocket lib, during reading this tiny lib, where libuv APIs are highly-used, and soon found out libuv is actually the event-loop in nodejs. Woo, somehow they are related.

build tools are highly used in each project, but prior experience is more done by luck.

product data managment

an interesting meeting with material research group, these guys have some IT needs, but does’nt reach there. e.g. there are plenty of material fatigue data, including metadata, tables, S-N plots, so how to organize/manage them? one solution is from MSC Material Center[http://www.mscsoftware.com/news/msc-software-reinvents-materials-lifecycle-management-materialcenter]

what triggered me is “data management” in general. In manufacturing industry, like automotive, many old style data used and storied in different departments, e.g. the material property data, load time history data for CAE department, the vehicle diagnostic logging data in vehcile control department, the vehicle dynamics records in vehicle test department. but neither are well-structured nor easy to track.

two fields so far: data dashboard, requires data visulization and data mining; product lifecycle management, it’s a product driven, and may also have data dashboard needs. currently as I see, most data analysis is in bussiness driven view, not in product itself. how to accelerate product iteration through better using history products data suppose to be a big thing.

on another side, industry data management is a little different than bussiness/market data. e.g. every year Ford releases a new F-150 truck, does it start out of new? no, the 2018 mois stly iterate by the 2017. so there is product data management, just managed through all component departments.

maybe the questions should ask is: 1 do we get the most value from these whole product level data? 2 how to make special data manageble at subsystem level? it needs more experience in the whole process, but bring some thoughts in next career: PLM software and data management in special domain, e.g. material datacenter product.

cloud CAE

since dashboard is so popluar to migrate the traditional software GUI to web/mobile app; and CAE solver can deployed in cloud, which is a better stronger reason to do user-side dashboard: with job submission, job status, and result plot/visulization sections.

but why is it necessary to migrate CAE solvers in cloud? why the manufacturing product companines would like to share their prodcuts data with cloud providers?

turn one step back, the most obvious reason is whenever internet is needed, e.g. communication among different end-users, cloud is good chonice; and for startup companies, who can’t afford to run jobs locally, have to migrate their calculation in cloud.

I am kind of curious who is using AWS? Netflix, BMW, Autodesk! I was so suprised at first, how BMW and Autodesk would like to use AWS? anyway Netflix is data-flow based company, the core business is client-server communication, which make sense to use AWS.

while BMW is using AWS for new business: connected service, all a sudden it makes sense. the car product business won’t be shared with AWS, but cloud is required as infrastructure for v2x connected service. that’s amazing.

AutoDesk say a different story in cloud, since they sell CAD softwares, few people want to buy and own an expensive software but choose to pay for the service, by all meaning, this is not a new business, but AWS offer a mature channel.

even though, cloud providers say they are cost-reducing, high-scalability, but I don’t think manufacturing companies will buy it due to security, instead they maintain their own clusters and share limited business in cloud.

so standing in manufacturing industry, it’s better to figure out new services, which require communications through cloud, than migrate CAE solvers to cloud. that’s my second point.

one concern yesterday: does each worker thread call loop() and run the whole active channels callback ?

suppose no. let’s track the process :

1
2
3
4
5
6

tcpServer.start() ->
	threadPool.start() ->
		new EventLoopThread(eventLoopThread::threadFunc, threadName)
		eventLoopThread->startLoop() ->
	   		thread.start() -> detail::startThread() -> 
	   		runInThread()::func_()

the real func_ during creating new eventLoopThread, is threadFunc(), in which call loop.loop().

first, this loop object is created inside this new eventLoopThread object, no issue that the loop.threadId_ is current threadID.

when multiple worker threads exist, what happens ?

suppose T1 is assigend to worker thread A, etc. when calling eventLoopThread A.loop(), epoll_wait() is first called and return number of active events, epoll_wait() is thread-safe, no worry.

then activeChannels:HandleEvents() is called. the real executor of this handleEvents is in the TcpConnection objects, namely: T1 or T2 or T3.

each TcpConnection object has its own loop-, and only the worker thread with the same loop- can execute the events. so even though threadA get the list of all active events, but only events in T1 conenction will be executed by threadA.

so we can see, in per (worker) thread per epoll, each (worker) epoll looks like only return the active channels/events in current worker thread’s eventLoop. There is no conflict among multiple worker threads, since each worker threas has its own eventLoop.

how about eventLoop in server/client

the eventLoopThread is kind of triggered inside Muduo, where is Tcp server/client eventLoop triggered ? from outsiders.

The several classes defined in Moduo: TcpServer, Acceptor, TcpConnection, EventLoop, epoller, channel, eventLoopThread, eventLoopThreadPool.

1) TcpServer construction

each TcpServer suppose have multi- tcp connections, the acceptor works as the main I/O thread, which listen the server-side I/O socket, and handle all client input connections at first, (later will assign the connection task to each worker thread from pool). so the input argument “loop” during TcpServer construction is the main I/O eventLoop.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

TcpServer::TcpServer(EventLoop* loop,
                     const InetAddress& listenAddr,
                     const string& nameArg,
                     Option option)
  : loop_(CHECK_NOTNULL(loop)),	                  ipPort_(listenAddr.toIpPort()),
    name_(nameArg),
    acceptor_(new Acceptor(loop, listenAddr, option == kReusePort)),
    threadPool_(new EventLoopThreadPool(loop, name_)),		    connectionCallback_(defaultConnectionCallback),
    messageCallback_(defaultMessageCallback),
    nextConnId_(1)
{
  acceptor_->setNewConnectionCallback(
      boost::bind(&TcpServer::newConnection, this, _1, _2));
}
``` 
one advantage of bind/callback is to import functors to different class domain. and server has always one I/O socket, but client-socket-fd suppose be a lot. 
## 2) TcpServer newConnection
Each new tcp connection, will assign a worker thread to execute the speical callback functor for this new connection, How to schedule thread in threadpool is implemented by round-robin, which are implemented as:
```c
ioLoop->runInLoop(boost::bind(&TcpConnection::connectEstablished, conn));  
EventLoopThreadPool::getNextLoop()

does each worker thread run EventLoop.loop(), which will call epoll_wait(), and execute all active channels? suppose no.

3) TcpConnection construction

each new client connection will reponse to a new socket fd, and a new channel. (channel is actually the container of socket fd); and the functors on this connection is also imported to channel callbacks. basically from outside, we only see channel objects, TcpConnection object is the inner class.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

TcpConnection::TcpConnection(EventLoop* loop,
                             const string& nameArg,
                             int sockfd,
                             const InetAddress& localAddr,
                             const InetAddress& peerAddr)
  : loop_(CHECK_NOTNULL(loop)),
    name_(nameArg),
    state_(kConnecting),
    reading_(true),
    socket_(new Socket(sockfd)),
    channel_(new Channel(loop, sockfd)),
    localAddr_(localAddr),
    peerAddr_(peerAddr),
    highWaterMark_(64*1024*1024)
{
  channel_->setReadCallback(
      boost::bind(&TcpConnection::handleRead, this, _1));
  channel_->setWriteCallback(
      boost::bind(&TcpConnection::handleWrite, this));
  channel_->setCloseCallback(
      boost::bind(&TcpConnection::handleClose, this));
  channel_->setErrorCallback(
      boost::bind(&TcpConnection::handleError, this));
  LOG_DEBUG << "TcpConnection::ctor[" <<  name_ << "] at " << this
            << " fd=" << sockfd;
  socket_->setKeepAlive(true);
}

so where are channel (read/write/error/close) handleEvent callbacks triggered? it is during the eventloop.loop, after epoller return the active events, based on the status of each revent, special handleEvent is called.

4) eventLoop construction

during constrution of eventLoop, a new poller is created based on this eventLoop itself, also a new wakeupfd and a new wakeupChannel. the purpose of wakeup fd/channel is to immediately wake up the work thread, rather than waiting till PollTime. and the wakeupfd bind handleRead, in which read one byte to make this wakeupfd I/O readable, which then is ready for I/O.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

EventLoop::EventLoop()
  : looping_(false),
    quit_(false),
    eventHandling_(false),
    callingPendingFunctors_(false),
    iteration_(0),
    threadId_(CurrentThread::tid()),
    poller_(Poller::newDefaultPoller(this)),
    timerQueue_(new TimerQueue(this)),
    wakeupFd_(createEventfd()),		
    wakeupChannel_(new Channel(this, wakeupFd_)),
    currentActiveChannel_(NULL)
{
  LOG_DEBUG << "EventLoop created " << this << " in thread " << threadId_;
  if (t_loopInThisThread)
  {
    LOG_FATAL << "Another EventLoop " << t_loopInThisThread
              << " exists in this thread " << threadId_;
  }
  else
  {
    t_loopInThisThread = this;
  }
  wakeupChannel_->setReadCallback(
      boost::bind(&EventLoop::handleRead, this));	    // we are always reading the wakeupfd
  wakeupChannel_->enableReading();
}

“activeChannels” suppose to be a class variable, which is shared by eventLoop objects, but it’s ok to keep a copy for each eventLoop object to avoid multi-thread competing. and suppose epoll_wait() is thread-safe, so later during construction of eventLoopThreadPool, multi eventLoopThreads won’t conflict with “active channels”

5) epoller construction

epoller object is created during eventloop construction. since the three interface of epoll instance are thread-safe, they look like global funcs.

epoll_create(), return an epfd referring to the new epoll instance, this epfd is used by all subsequent calsl to the epoll interface.

epoll_wait(), return all ready events on the epoll instance referred by epfd.

epoll_ctl(), traverse the red-black tree strucutre to return the existing fd, or add new fd to the tree.

6) channel construction

channel is the container of one fd, and is related to one eventLoop. channel is not responsible to create/delete fd, the real owner of each fd is TcpConnection or acceptor. Channel object works like a pipe to send fd from inner object TcpConnection to the eventLoop. the advantage here is eventLoop is independent from connections.

7) channel:update()

1
2
3
4

channel::update() -->
	loop->updateChannel() --> 
		poller->updateChannel() -->
			//poller maintain a channel list, call epoll_ctl to add/return/delete the requiring channel

8) one epoll + threadpool vs per thread per epoll

the first method, one global epoll listens all new connections, and send each connection callback to a new thread to execute. method 2, to listen the server I/O socket need to bind a unique epoll, in Moduo which is the acceptor epoll. then all client connection socket will be dealt with their own worker epoll.

Moduo: A C++ non-blocking network library for multi-threaded server in Linux.

C++ 11 features

a. functional, bind

in C++11, function declartion can be:

1
2
3
4
5
6
7
8
9

	return-type func(args)
//or
	auto func(args) -> return_type
//	the good part of "->" is to use "decltype" to decide the return type from future.
	std::function<return_type(arg1_type, arg2_type..)> ;
	[](type1, type2..){} ; //lambda func, anonymous func
	std::forward

std::bind() is used to assign existed variables to func parameters during compile-time, and unassigned parameters stand as placeholders, which then replace by real parameters during running-time, and return a new func. bind() can be used to bind static func, global func, class member func.

1
2
3
4
5
6
7
8
9
10

	   std::bind(global_func, 1.0, _2) ; 
	   std::bind(&class:memberfunc, classPointer[this], _1); 
``` 		
		
### b.  multi-threads synchronized primitives 
Q: what is condition variable ? 
	
A: used to block one or more threads, till been notified by another thread or overtime been wakeup. But if all threads are waiting, that's a problem, so at least for one thread, the condition variable should be true.

threadA.wait(condition_variable);
while(;;)
{
    threadB.do();    
}
threadB.notify();
threadA.do();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

	
Q: what is mutex?
	
A: it works like a lock, to block any other thread to access special part of memory, at any time, only one thread can own the mutex. in reality, to define mutexLock class will manage lock/unlock automatically due to the constructor/destructor of the object. 
### c.  rvalue reference, universal reference, std::forward 
	
Q: why need right-value reference ?
	
A: to use rvalue like lvalue, save object/variable copying, the detail is about move constructor. universal reference, means either rvalue reference or lvalue reference,  is to declare a variable /parameter with type T&& for some deduced type T
### d.  functional template, variadic arguments 
	
basically, it's to support any type, any number of parameters in function template. 
	
``` 
		template<typename… Args>  class  tuple{} //a template class
		template<typename T, typename… Args> void func(){} 	
	/* Args :: a template type parameter pack, a list of parameters
	   T ::  a normal template type parameter
  	*/ 
		func(T, args...) 
		/* (...) at right of func parameters is meta operator 
		used to unpack "args" into separate arguments  */

a simple thread / thread pool lib

take a look at: thread-pool

basically, a task queue to store all todo tasks; a thread pool, to store the worker threads, each of which takes one task from the task queue continuously till the queue empty.

racing condition happens when two threads try to take the same task simultaneously, so mutex. and all operators requrieing thread-safe should use mutex, e.g. enqueue/dequeue task
then callback functors, how each worker thread deal with the task at hand? to design function template with variadic arguments.

a simple Tcp network lib

take a look at: simpleNetwork

in server: socket() -> bind() -> listen() -> accept() –> send()/write()

in client: socket() -> connect() -> recv()/send()

a basic idea is that each connection, the server will create a new thread to handle it. But it consume server quickly.

I/O nonblocking/event-driven & multiplex

1
2
3
4
5
6
7
8
9
10
11

#include <poll.h>
 struct pollfd {
int fd; //file descriptor, non-negative
short events; //events to watch, set by user
short revents; //returned events, return from system kernel
  };
POLLIN | POLLPRI ; //event read
POLLOUT | POLLWRBAND ; //event write
POLLER ; //event error
POLLHUP ; //event hang up

the basic idea of multplex(Linux APIs: poll(), epoll()) is to use one single thread to listen many connections/socket/fd, once any socket is ready for I/O, the thread will execute the write/read callback.

epoll() on success, return the number of revents or 0; on error return -1

1
2
3
4
5
6
7
8
9

struct epoll_event {
	__u32 events ;
	union{
		void* ptr,  //if need to store a pointer 
		int fd,     // if need to store socket fd 
		__u32 u32, // to store general 32 bit number 
		__u64  u64  // to store general 64 bit number
	} data;
};

during this week studying: automotive message broker. It’s a framework to support in-vehicle network communication, based on which many vehicle applications can build up.

After jumped into the source code, soonly I found the dependent third-party libs, e.t. Qt, Glib, libwebsockets. None of these basis libs looks familiar, that’s really headache.

So had to jump to learn a little about these libs first. Qt is heavy, give up on reading source code, basically to know what’s used for; Glib has a core on eventloop, after review the concept: nonblocking event I/O; and few lighter projects are found, e.g. event.js in RocketEngine. so I was happy to read js source code, but after reading nothing really keep in my head due to don’t know where to use them, neither don’t understand why these implement is necessary.

maybe a bigger project with more details, so picked moduo, written by a Chinese. there is a book on this project, which started with multi-thread programming issues, no help. same problem, I am not familar with the application scenario, so can’t really catch the essential.

back to the question: how to effciently read source code?
1) I suppose, first to understand the application scenario
2) compile and run in debug to track the data flow for projects, which you can’t see the flow by once
3) if it’s a framework/foundmental libs, write demo

The company IT system is not developer-friendly, git, cmake, npm, python lib are missing. that’s maybe the reason I am becoming lazy, if tools at-hand, may give a try; if not, nothing really do. The company has itself gmake system, but the bottom code never been touched.

Then I compiled the demo libwebsocket, many failures bump out, during school time, I used a lot cmake, g++ with local headers, link to LD/_LIBRARY/_PATH, all out of practice for couple years.

Anyway, at this moment, I realize that coding is a system enginnering. first to be really familar with OS, then the basic libs, then think about to write applications.

For me, the first occupy with software is from (industry) application layer, lack of foundmental. now when to do sth, I feel hands are bounded, that push me to the root.

Rome is not built in one day, OMG.

pen source projects I scatched

To review how many open source projects I tried to study has been in my mind for a long time. I am always interested in new areas, new trends, and want to understand a little more, few contribution by now. One college friend, who worked at Intel China, first brought me to GTC 2008 at Beijing, where my eyes is opened first time, to know there is so many amazing works around the world.

1) HPC/FEA/CFD

after 2008, I was driven by computing mechanics more

HPCG: a benchmark work to test FLOPs, which I used as a class project at Buffalo

PETSC: a large sparse matrix solver, developed from Texas Austin, also met at Buffalo. the math is attracted me more and it is complex and a good learning material for C++

LibMesh: based on PETSC to do FEM. ran some demo and interested in math more

GPU-SPH: GPU implementd of SPH(CFD algorithm), during 2011, GPU is popular in applied mechanics.

PetIBM: immersed boundary method (CFD algorithm), used as a class project

OpenFEM, OpenFOAM etc. during that period, I collected many small/big open source CFD/FEA projects, but few study.

2) Game Engine

at 2011, Virtual Reality is attracting

CHAI3D: my friend show me a demo, but I didn’t go through

LiquidFun: google product

Box2D: for fun, like LiquidFun, where cmake, configure skills played

That time I also collected many other game engines from web, e.g. Unreal, skynet.. it’s so cool to be a game developer, but no time to deep in

3) Robot

at 2014, robot is hot

ROS: that’s my way to study the platform first, with a few study and no more

SLAM: the cool concept when to uderstand the core algorithm

OpenCV: used everywhere, read some docs, but not used independtely

Arduino: platform, when I joined the Detroit Hacking Night(DHN) meetup

RasiBerry: similar experience during DHN, later I tried to implement deep learning detection algorithm on a race car, not finished till now

RTOS: go through like 2-month ago, when I feel I need more understand at embedded system. simple to understand, but not sure how can I master in practice

4) Deep Learning

after 2016, DL is so popular, many frameworks, online courses, papers bursting, no way to keep calm.

TensorFlow: I thought it’s easy at first, but really didn’t go to the code, but implemented some examples

Caffe: the DL framework jumped in, first knew about Google protocol buffer, very confused at that time

ChatAI: I tried to add some fun in WeChat public platform

5) Vehicle

Buffalo Car simulator: at Buffalo lab, there was a physical car simulator, and code in OSG, cool project to learn C++

SimCar: later I had chance to know many open source/ commercial car simulators

AGL: at 2017, started to view AGL updates, try to keep in mind the new trends in vehicle software fields

GEVIVI: same time with AGL, interested in IVI as a sub-field

openXC, SmartDeviceLink: OEM level apps

6) Web & Mobile

at 2017, luckly transfered to a web project, have the chance to know AngularJS, Node.js and event driven, REST, AJAX, async, many new and exciting ideas here.

Hexo.io: a static blog engine

web crawler: looks like a hack skill

async event I/O lib: moduo, event.js

top github Rankers have js projects, looks very intersting

7) OS related

many little tools when playing with Linux, system level, apps. One big stuff is Linux Process Communication(IPC). I used share memory in one product but never had a chance to know the big picture of IPC, later want to know about Linux network, and see socket, signal… feel connected.

CMAKE:

QT:

Glib:

MKL: intel math kernal lib, cool in first impression

plugin-pattern in embedded software

the good is know diversity, the short I don’t have done any contribution to combine these experince

GBM

W3C automotive open web platform

Main page: Link

A clear web framework: 1) define the network communication APIs(based WebSocket protocol); 2) standarlize vehicle data; 3) define APIs to access vehicle data.

Vehicle Information Service Specification(VISS)

Object: to define WebSocket based APIs for a vehicle information service to enable client apps to get, set, subscribe, unsubscribe to vehicle signals, data attributes
Link

Vehicle Data

doc Link

Object: to define a standard Vehicle Data with might be available in a vehicle

1) VehicleInterface
2) VehicleCommonDataType
3) VehicleConfigurationInterface (identification, sizeConfiguration, fuelConfiguration, transmissionConfiguration, wheelConfiguration, steeringWheelConfiguration)
4) Running Status Interface(vehicleSpeed, wheelSpeed, engineSpeed, vehiclePowerMode, powertrain, acceleratorPedalPosition, throttlePosition, tripMeters, transmission, cruiseControlStatus, lightStatus, interiorLightStatus, horn, chime, fuel, engineOil, acceleration, engineeCoolant, steeringWheel, wheelTick, ignitionTime, gyro, brakeOperation, buttonEvent, drivingStatus, nightMode, startStopMode)
5) Maintenance Interfaces(odometer, transmissionOil, transmissionClutch, brakeMaintenance, washerFluid, malfuncitonIndicator, battery Status, Tire, trouble Code, diagnostic)
6) Personalization Interfaces ( languageConfiguration, unitsOfMeasures, mirror, driveMode, seatAdjustment, dashboardIllumination, vehicleSound )
7) DrivingSafety Interfaces ( antilockBrakingSystem, tractionControlSystem, electroniceStabilitySystem, topSpeedLimit, airbagStatus, door, childSafetyLock, seat)
8) Climate Interfaces (temperature, rainSensor, wiperStatus, defrost, sunroof, convertibleRoof, sideWindow, climateControl, atmosphericPressure)
9) Vision & Parking Interfaces( laneDepartureDetection, alarm, parkingBrake, parkingSensors)

Vehicle Information API Specification

Object: define a high level API for accessing vehicle signals, data attributes and communicate with in-vehicle data servers

doc Link

• VISClient Interface
  used to define any on-board, off-board clients
• VISClientOptions Interface
  used to define a connection to a vehicle signal server(speicifiable by protocal, host, port)
• VISSubscription Interface
  used as return value from subscribed() methods
• VSS Interface
  used as return value from getVSS(), which should be sufficent to fully traverse the VSS tree

Vehicle Information Access API

doc Link

Object: enable connectivity through in-vehicle infotainment systems and vehicle data access protocols

1) Navigator Interface: exposes the interface to vehicle information services
2) Vehicle Interface: the initial entry point to get access to the vehicle information
3) Zone interface: physical and logical zones
4) VehicleIneterfaceCallback
5) AvailableCallback
6) VehicleInterfaceError (permission denied, invalid operation, timeout, invalid zone, unknown, error, message)
7) VehicleInterface : the base interface to get all vehicle properties
8) VehicleCOnfigurationInterface : access to static vehicle information
9) VehicleSignalInterface: access to variables vehicle info
10) Data Availability : available, not supported, not supported security policy, supported …

the billions level product

Think about these guys in the world, who defined products/services used by billions people, they are more than model innovation, but really make a diffrence in most people’s life.

e.g. iPhone, facebook, Google, they are not created from nowhere, but went through product iterations by iterations, and they only imerge when the tech, the market, the time all are in perfect.

How many people in history achieved here? in any sense, it’s the history choose that person, not that person made history. so take it easy even you are not the 0.01%.

in the promising market

most people in their life time neither can be the next Jobs, nor Bill Gates. that’s the reality, no sad but clean expectation in the end before really in the last day of life.

the second goal is easier, find a promising market and lead a small product, maybe lucky invovled in a domain market finally. You are not significant, but one of other 5000 competitors. Even this career path, however, you can’t expect the normal lifestyle: start at 25 and retire at 55 with enough 401K to death. If so, mostly you will be fired out someday in 30s or 40s. Chinese say, “if you dont plan far, you will be in trouble soon”

so what may be the promising market subset in automotive software in next 5 years? generally say: 1) service, consulting; 2) self-business; 3)tech expert. in specificly saying: 1) electricity, energy infrastructure; 2) connected, cloud infrastructure; 3) autonomous vehicle.4) mobile apps, which is the carrier for the first 3.

I mean the trend is so clear these days. No one can say he dont’ know where should stand in future. but where are you now? I like the model Elon Musk mentioned when do future plan: what’s your reality, what’s your goal, how to meet the gap, than focus on acting.

will automotive software like mobile smartphones ?

It’s interesting even now there are few third-party or independent “automotive software” companines, on opposite, in mobile market, there are lots of small or big third-party developing companines around Andriod, iOS, the mobile ecosystem is plenty and diversity. the reality in automotive field is lack of abstraction and separation between bottom hardware and top applications.

in a mature mobile ecosystem, developer -> end-users
in automotive software ecosystem, devleoper –> OEM –> end-users

some auto allience is working on(AutoSAR). as developers, either gain some knowledge in hardware/control to solve the gap, or waiting for the day.

what I expect on the way, may be like mobile time:
1) automotive OS platform
2) vehicle apps
3) infrastures extending

once the platform is unified, suppose many new auto branchs will emergy. like HTC, Xiaomi, Vivo, Huawei, Lenvo branches after Andriod OS. then new market stratgey is highly required, also traditional OEMs will be heavily impacted.

OEM don’t like mobile ecosystem

this may happen soon or never, since OEM don’t like this trend. most possiblely, automotive software developers will highly rely on OEMs. so where will I stand in next 5-years ?

OEM is good at strategy study and product integration. at a tech supplier, the benefit is more product driven experience.

OEM suppose to have the advantage at automotive platform built-up, but reality is big Internet/software companies with product-level solutions, and OEM doesn’t.

it is clear for me in next 5-years to jump into electric, connected, autonomous related industries, either at OEM level or supplier level. Also it is the time to do some study at automotive platform vendors.