Changes between Version 73 and Version 74 of Developer/Simulators/QEMU/CANEmulation

Timestamp:

09/15/13 11:54:58 (11 years ago)

Author:

Jinyang

Comment:

Developer/Simulators/QEMU/CANEmulation

@@ -9 +9 @@
 =  Environment  =
 
-The OS will be Linux and the current CAN driver to test will be Socket CAN (as it's maintlined into Linux)
+The CAN simulation environment is based on QEMU-1.4.2, because 1.5.0 was just released, and we wanted a solid starting point. The OS will be Linux and the current CAN driver to test will be Socket CAN (as it's maintlined into Linux)
  *  Host: The host is Ubuntu-13.04 including the basic building tools and some other softwares.
  *  Guest: This is also a Linux environment which we build from scratch. The linux kernel is [https://www.kernel.org/pub/linux/kernel/v3.0/linux-3.4.48.tar.bz2 Linux-3.4.48], the commands are statically compiled using [http://www.busybox.net/downloads/busybox-1.21.0.tar.bz2 Busybox-1.21.0] and also some other files including configure files, start scripts, etc.
@@ -29 +29 @@
 
 The purpose of starting with a minimal Linux (as opposed to RTEMS) environment in qemu is the software configurations have been more thoroughly tested and documented. The first phase of the project should start out using the last stable release... unless it's minor digit is a 0... usually the minor digit being anything above a 0 means the free and open source software FOSS had some bug-fix releases.
-=  CAN project example  =
-
-The section below is largely based upon http://jin-yang.github.io/2013/07/24/build-minimal-linux-environment.html by Jin-Yang during the summer of 2013. The CAN simulation environment is based on QEMU-1.4.2, because 1.5.0 was just released, and we wanted a solid starting point.
 =  Installing Qemu  =
 
@@ -43 +40 @@
 First, we should configure QEMU using the following command, this will take about two minutes. QEMU has two modes to simulate a platform, the user mode and the system mode. We only need the i386 system simulation environment here, so only system mode (i386-softmmu) is needed. In order to save time, we just compile the source-code that relates to i386-softmmu.
 
-'''Note:''' For simplicity of coding, we select the hard-coded --prefix=/opt/qemu so we can write scripts assuming that's where our installed qemu is.
+'''NOTE:''' For simplicity of coding, we select the hard-coded --prefix=/opt/qemu so we can write scripts assuming that's where our installed qemu is.
 
   ./configure --prefix=/opt/qemu --target-list="i386-softmmu" --enable-sdl && make && sudo make install
@@ -51 +48 @@
  *  --enable-sdl: we also need the sdl (Simple DirectMedia Layer) support.
 
-To call the just installed qemu you can add ''/opt/qemu/bin'' to the PATH environment variable or just use ''/opt/qemu/bin/qemu-system-i386'' to start QEMU.
+To call the just installed qemu you can add ''/opt/qemu/bin'' to the PATH environment variable or just use ''/opt/qemu/bin/qemu-system-i386'' to start QEMU. Here, we just write a simple shell script and you can start the qemu just use command ''sudo ./qemu.sh''
 =  Building Linux Environment  =
 ==  Building the Kernel  ==
@@ -59 +56 @@
 In this section, the environment is based on [https://www.kernel.org/pub/linux/kernel/v3.0/linux-3.4.48.tar.bz2 linux-3.4.48], [http://www.busybox.net/downloads/busybox-1.21.0.tar.bz2 busybox-1.21.0] and Ubuntu 13.04. You can get those source file from their official website.
 
-The simplest way to compile a effective kernel is to generate a default one by typing ''make i386_defconfig; make bzImage''. However, this will waste a lot of time on compiling and running something which we do not need. So, we build a minimal kernel through the following commands.
-   cd linux-3.4.48
-   make mrproper
-   make allnoconfig
-   make menuconfig                             # '''Note:''' Detailed instructions below
-   make bzImage                                # make the kernel image
-   make modules
-   make modules_install INSTALL_MOD_PATH=temp
+The simplest way to compile a effective kernel is to generate a default one by typing ''make i386_defconfig; make bzImage''. However, this will waste a lot of time on compiling and running something which we do not need yet. So, we will build a minimal kernel through the following commands.
+   cd linux-3.4.48                             # change to the linux kernel directory
+   make mrproper                               # clean up the source code
+   make allnoconfig                            # disable all configure options
+   make menuconfig                             # '''NOTE:''' Detailed instructions below
+   make bzImage                                # compile the kernel image
+   make modules                                # compile the linux modules
+   make modules_install INSTALL_MOD_PATH=temp  # install the linux modules to a temperary directory
    find -name bzImage                          # find the kernel image
-   cp ./arch/i386/boot/bzImage ~qemu/.         # put in the working directory
-
-Then, the modules has installed to ''temp'' directory.
-
-In the 'make menuconfig' step we will chose 
-
- - General setup
+   cp ./arch/i386/boot/bzImage ~qemu/.         # copy it to the working directory
+
+Then, the modules has installed to ''temp'' directory, so you can copy them to the necessary directory if need.
+
+In the 'make menuconfig' step we will chose the following options
+
+ - General setup                               # for convenience
   - (-QEMU) Local version - append to kernel release 
   
- - Enable loadable module support
+ - Enable loadable module support              # support for the modules
   - Forced module loading
   - Module unloading
   
- - Bus options (PCI etc.)
+ - Bus options (PCI etc.)                      # a PCI device developed here, so we need the kernel supports
   - PCI support
     - PCI Express support
       - Root Port Advanced Error Reporting support
  
- - Executable file formats / Emulations
+ - Executable file formats / Emulations        # to run examples
    - Kernel support for ELF binaries
  
- - Networking support
+ - Networking support                          # we using NFS, maybe some of the options don't need
    - Networking options
     - Packet socket
@@ -110 +107 @@
       - TCP: advanced congestion control
        - CUBIC TCP
-  - <M> CAN bus subsystem support
+    
+  - <M> CAN bus subsystem support               # actually we build a new CAN driver, not necessary
     - <M> Raw CAN Protocol (raw access with CAN-ID filtering)
     - <M> Broadcast Manager CAN Protocol (with contest filtering)
@@ -123 +121 @@
  - Device Drivers
   - Character devices 
-    - Serial drivers
+    - Serial drivers                            # for serial test
       - <M> 8250/16550 and compatible serial support
-  - Network device support
+  - Network device support                      # for NFS
     - Network core driver support
     - Universal TUN/TAP device driver support 
@@ -149 +147 @@
    cd busybox-1.20.0
    make defconfig
-   make menuconfig          # Note: ''Busybox Settings -> Build options -> Build Busybox as a static binary''
+   make menuconfig          # '''NOTE:''' ''Busybox Settings -> Build options -> Build Busybox as a static binary''
    make
    make install CONFIG_PREFIX=~/qemu/rootfs # choose this hard coded value for simplicity when writing scripts
+
+We also need some necessary directories and some files to build the root file system. However, it's not the main part of the project, you can get more help from google. You can just get the from a public repository https://github.com/Jin-Yang/LINUX-QEMU.git
+
 ==  Set up network environment  ==
 
 We use TUN/TAP to connect host with qemu. We start by writing the '''ifup-qemu''' script. We will put it in the ''~/qemu'' directory so it will be in the correct place relative to the other files.
+
+'''NOTE:''' this need the root privilege.
 
  #!/bin/sh
@@ -173 +176 @@
    -net tap,vlan=0,ifname=tap0,script=~/qemu/ifup-qemu
 
+If you have got a copy from https://github.com/Jin-Yang/LINUX-QEMU.git, then you can start the qemu just by command ''sudo ./qemu.sh''
 
 =  Step 2: Introduce SocketCAN and SJA1000  =
 
-We have built a minimal linux environment now. Before we built the PCI-CAN device in QEMU, we will introduce the Linux driver SocketCAN and CAN device SJA1000.
+We have built a minimal linux environment now. Before we built the PCI-CAN device in QEMU, we will introduce the Linux driver SocketCAN and CAN device SJA1000 at first.
 =  SocketCAN  =
 
-The SocketCAN package is an implementation of CAN protocols (Controller Area Network) for Linux. You can get a manual from the source of Linux Kernel at Documention/networking/can.txt .
-
-Simplely, we only need to insert the vcan module. Following is what we need to do.
+The SocketCAN package is a Linux driver of CAN (Controller Area Network) protocols for Linux. You can get a manual from the source of Linux Kernel at Documention/networking/can.txt
+
+Simplely, we only need to insert the vcan module and use virtual socketcan device to test the socketcan. Following is what we need to do.
   $ sudo insmod /lib/modules/`uname -r`/kernel/drivers/net/can/vcan.ko
   $ sudo ip link add type vcan
@@ -193 +197 @@
 The SJA1000, a stand-alone CAN controller, is produced by Philips Semiconductors which is more than a simple replacement of the PCA82C200. You can get more useful information from [http://www.nxp.com/documents/data_sheet/SJA1000.pdf SJA1000 Datasheet] and [http://www.mct.net/download/philips/can_appnote.pdf SJA1000 Application Note].
 
-SJA1000 is intended to replace the PCA82C200 because it is hardware and software compatible. It has two modes including BasicCAN mode and PeliCAN mode.
+SJA1000 is intended to replace the PCA82C200 because it is hardware and software compatible. It has two modes including BasicCAN mode and PeliCAN mode, the details you can get from the above two documents.