note collected from internet source

===================================

Raspberry pi, uart should pin is enabled by default? yes

Raspberry Pi’s Mini-UART

Warning: Misleading information ahead – See Warren Gay’s comments.
The Raspberry Pi actually has two UARTs. One UART  is part of the internal ARM architecture of the Broadcom BCM2835 chip, in the core of the Raspberry Pi and not accessible externally.  The other UART is sometimes called the RPi’s “Serial Port” (even thou the USB supports serial communications, and therefore a serial port).  The serial port being reference here is serviced by a UART, sometime refereed to as the  “Mini-UART” since it doesn’t appear to be very rich in functionality.  It is basically be used as a console port for access to the Raspberry Pi.  The serial console is a convenient way to interact with the Raspberry Pi for debugging or your network is down and it is the destination of console messages (including boot-up messages).  From the Raspberry Pi pinout and the eLinux wiki, I can see that the serial port (aka Mini-UART) on the Pi is on GPIO Pin 14 (TX) and GPIO Pin 15 (RX):

Since the GPIO pins give access to the Mini UART, you can establish a serial console, which can be used to log in to the Pi, and many other things.  However, normal console device communicate with -12V (logical “1″) and +12V (logical “0″) RS-232, which may just fry something in the 3.3V Pi. Even “TTL level” serial at 5V runs the same risk.  See this tutorial for one example on how to build 3.3V to RS-232 levels converter with a MAX3232CPE and a few passive components.

You can reconfigure the RPi so that the Mini UART isn’t acting as a serial console and use it for outer purposes (e.g. communicate with an attached Arduino or Xbee).  Using the Raspberry Pi’s serial port requires some Linux reconfiguration and the abandonment of the serial console, and potentially some level conversion, but it could be useful. The Mini-UART pins to provide access to Linux’s /dev/ttyAMA0 serial port.  To be able to use the serial port to connect and talk to other devices, the serial port console login needs to be disabled and the post “Raspberry Pi and the Serial Port” shows you how.

Again, keep in mind that RX and TX lines are available on the GPIOs but operate at 3.3 volts. You’ll need a board or cable to level convert 3.3 volt UART signals to connect with other devices (e.g. RS-232, USB).

Disable Serial Port Login

To enable the serial port for your own use you need to disable login on the port. There are two files that need to be edited

The first and main one is /etc/inittab

This file has the command to enable the login prompt and this needs to be disabled. Edit the file and move to the end of the file. You will see a line similar to

T0:23:respawn:/sbin/getty -L ttyAMA0 115200 vt100

Disable it by adding a # character to the beginning. Save the file.

#T0:23:respawn:/sbin/getty -L ttyAMA0 115200 vt100

Disable Bootup Info

When the Raspberry Pi boots up, all the bootup information is sent to the serial port. Disabling this bootup information is optional and you may want to leave this enabled as it is sometimes useful to see what is happening at bootup. If you have a device connected (i.e. Arduino) at bootup, it will receive this information over the serial port, so it is up to you to decide whether this is a problem or not.

You can disable it by editing the file /boot/cmdline.txt

The contents of the file look like this

dwc_otg.lpm_enable=0 console=ttyAMA0,115200 kgdboc=ttyAMA0,115200 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline rootwait

Remove all references to ttyAMA0 (which is the name of the serial port). The file will now look like this

dwc_otg.lpm_enable=0 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline rootwait

BBB has usbnet for quick conn

Launchpad G2553 is 9600 uart!

USB 2.0 to TTL UART 6PIN CP2102 Module Converter Connector Adaptor Cable UK

1.This is a USB 2.0 to TTL UART 6PIN CP2102 Module Serial Converter. Connect MCU easily to your computer!
2.Stable and reliable chipset CP2102
3.USB specification 2.0 compliant with full-speed 12Mbps.
4.Standard USB type A male and TTL 6pin connector. 6pins for 3.3V, RST, TXD, RXD, GND & 5V.
5.All handshaking and modem interface signals.
6. Baud rates: 300 bps to 1.5 Mbps.
7. Byte receive buffer; 640 byte transmit buffer.
8. Hardware or X-On/X-Off handshaking supported.
9. Event character support Line break transmission.
10.USB suspend states supported via SUSPEND pins.
11.Temperature Range: -40 to +85.
12.Supports Windows 98SE, 2000, XP, Vista, Window7, Mac OS 9, Mac OS X & Linux 2.40.
 

JUSTIN COOPER

The Adafruit IO Python library will export the UART device tree overlays as a convenience. There are five serial ports brought to the expansion headers (UART3 only has a single direction, TX), and one (UART0, serial J1) with dedicated headers that aren’t available to use in your Python programs.

Setup

To setup and export the UART, you can do the following:

1. import Adafruit_BBIO.UART as UART
3. UART.setup(“UART1″)

That’s it!

Also, there is a cleanup() method ready to go, but it’s not currently working due to a bug in the kernel that causes kernel panics when unloading device tree overlays. We’ll update this when it’s working. A workaround is to either leave the UART enabled, or restart your BeagleBone Black.

Pin Table for UART

Using UART with Python

You can use the pyserial module in Python, but you’ll first need to install it using pip. If you don’t have pip installed, you can follow the instructions on the installation pages for this tutorial.

SSH into the BeagleBone Black, and execute the following command:

1. pip install pyserial

Below is a very simple python program that is a good starting point. Save it to a file, and execute it with ‘python file_name.py’

1. import Adafruit_BBIO.UART as UART
2. import serial
4. UART.setup(“UART1″)
6. ser = serial.Serial(port = “/dev/ttyO1″, baudrate=9600)
7. ser.close()
8. ser.open()
9. if ser.isOpen():
10.   print “Serial is open!”
11.         ser.write(“Hello World!”)
12. ser.close()
14. # Eventually, you’ll want to clean up, but leave this commented for now,
15. # as it doesn’t work yet
16. #UART.cleanup()

Testing and Using the UART

You can easily test that everything is working, without having to code anything, or installing any other dependencies to get started.

Next, you’ll want to connect two wires to the UART pins. We’re just going to cross the RX/TX of the UART1 and UART2. The first wire should connect from P9_24 to P9_22. The second wire should connect from P9_26 to P9_21.

Next, export the UART1 and UART2 in the python interpreter with the Adafruit IO library:

1. root@beaglebone:~# python
2. Python 2.7.3 (default, May 29 2013, 21:25:00)
3. [GCC 4.7.3 20130205 (prerelease)] on linux2
4. Type “help”, “copyright”, “credits” or “license” for more information.
5. >>> import Adafruit_BBIO.UART as UART
6. >>> UART.setup(“UART1″)
7. >>> UART.setup(“UART2″)
8. >>> exit()

Once you’ve done that, execute the following commands to launch minicom (using two separate ssh sessions using your terminal of choice, mine are separated by tabs in OS X):

1. #first terminal window:
2. minicom -b 9600 -D /dev/ttyO1
4. #second terminal window:
5. minicom -b 9600 -D /dev/ttyO2

It should look like this once you’ve opened minicom:

Now, type in one of the terminal windows, and hit enter. Look at the other terminal, and you should see something like this:

You can exit from minicom by typing Ctrl-A, then Z, then X, and hit enter at the dialog.

in cpp.properties global setting file (sudo scite on  Linux)

#at the begining of this config file:

file.patterns.java=*.java;*.jad;*.pde;*.groovy

file.patterns.js=*.js;*.es;*.js6
#file.patterns.qml=*.qml

##############add for C++11 mingw32##########

#add more header and lib file path to support third party lib

cpluspluspts= -pedantic  -Os   -std=c++11  -I D:\Software\mingw64\include -L D:\Software\mingw64\lib

# support only single file compile directly into binary, no makefile is needed
cc=$(GCCPATH)\g++ $(ccopts)  -c $(FileNameExt) -o $(FileName).o

#################modify #####################
command.compile.$(file.patterns.cplusplus)=$(GCCPATH)\g++ $(cpluspluspts) $(FileNameExt) -o $(FileName)
command.build.$(file.patterns.cplusplus)=$(make.command)
command.go.$(file.patterns.cplusplus)=PATH $(GCCPATH);%PATH%  &&  $(FileName)
command.go.needs.$(file.patterns.cplusplus)=$(GCCPATH)\g++ $(cpluspluspts) $(FileNameExt) -o $(FileName)

##################add ######################
command.go.*.js=node.exe $(FileNameExt)
#es6 is not standard file suffix
command.go.*.js6=node.exe  –harmony $(FileNameExt)
###################################
keywords.$(file.patterns.qml)=$(keywordclass.javascript)
QT5PATH=C:\Qt\5.2.0\mingw48_32\bin;C:\Qt\Tools\mingw48_32\bin;%PATH%
command.go.*.qml=PATH $(QT5PATH) && qmlscene  $(FileNameExt)
#if it does not work, ->  start qmlscene from Qt for desktop command prompt!
#######################################
#tab openning needs to be adjusted,  append *.groovy    to java pattern for the timebeing
#file.patterns.groovy=*.groovy
#GROOVYPATH=D:\Software\Groovy2\bin\
#script need not compile and make
#command.compile.*.groovy=groovyc $(FileNameExt)
keywords.$(file.patterns.groovy)=$(keywordclass.java)
command.go.*.groovy=groovy $(FileNameExt)
###################################

Due to the recent research requirement, I need to replot and analysis signal of high sampling rate (several mega samples per seconds) with PCIe card.

I planned to use numpy and matplotlib to plot, but I was a bit worried on the capability of using npTDMS and matplotlib to processing big data (100MB to 1GB, but big data in modern sense)

A quick test shows it works (to draw array of several mega samples), seems not worse than NI AIdem for visualization, all subject to serious delay during zooming in. However, the loading is much slower,  as npTDMS is pure python, not C API implemented.

And the program just consume as little memory as it is on disk size.

Continue reading →

follow the tutorial and make usbnet boot automatically
http://hipstercircuits.com/enable-serialuarttty-on-beaglebone-black/

on my BBB debian wheezy:

sudo cat  /etc/modprobe.d/usbnet.conf

#auto load usbnet
options g_multi file=/usbnet.img stall=0
#there is a usbnet.img already there under /

Continue reading →

(1)install unofficial python extension package  binary installer

Unofficial Windows Binaries for Python Extension Packages

by Christoph Gohlke, Laboratory for Fluorescence Dynamics, University of California, Irvine.

1. Thread in RT-Thread works like  POSIX thread:  #include <posix_types.h>
2. Each thread has TCB (task control block),  like Linux kernel thread, share the global memory, but has its own stack (pre-decleared array with fixed size), has event and timer for each thread;  Thescheduler, which uses bitmap algorithm,  is similar with Linux kernel
3. RT-Thread is high performance RTOS, mainly focusing on ARM cortex-M 32bit CPU.
4. RTGUI/FTK   (object-oriented style widget,  just like GTK+)
5. Device model like Linux device tree.
6. IPv4 and IPv6 are supported by lwIP lib with <socket.h>, but 6LowPAN is not supported as Contiki.
7. Simulator on Linux and Windows (32bit  x86 only) and good documentation.
8. Python scons building system; but it is easier than Makefile to control multiple targets building.

Most important, it is free even  for commercial usage, via applying free license and keep RT-thread banner.

Finally, this is the host place:  https://github.com/RT-Thread

Since there is only one hardware SPI, but it is used by Ethernet or Wifi shield. If you wantto conenct some other sensors via SPI, the Ethernet lib is reluctant to cooperate.

So a software bit-banging library may be necessary.

Four SPI modes are supported, just change the macro definition in header file.

Continue reading →

I am tired to upload figures , I just give it as PDF file with figures inside

Setup Codelite to work with visual studio toolset (totorial version)