MOUNT AN SMB NETWORK DRIVE ON RASPBERRY PI

original post: http://geeks.noeit.com/mount-an-smb-network-drive-on-raspberry-pi/

In this tutorial we will describe how to connect your Raspberry Pi to a network drive and permanently mount it to your system. Even though this article uses a Raspberry Pi as an example to connect to an SMB drive, the steps used can be applied to any Debian based system, such as Ubuntu.

If you have a Raspberry Pi you might have noticed that the storage possibilities are kind of limited unless you have some external storage. Even though you can get SD cards with 64+gb of storage, you probably want more if you have a lot of music and movies that you are streaming through your Pi.

There are several choices when it comes to storage for your Pi, such as network drives, flash drives, or external USB HDDs. Using a network drive you can not only access your files from the Pi, but from any computer connected to your network, which is very convenient.

Prerequisites

Before we start, I will assume you already

  1. have a network drive connected to your LAN, and
  2. know its LAN IP address

Note: remember to change all text in red to your own values.

 

Installation

In order to mount the drive, you need to have cifs-utils installed on your system. If you are running a newer version of Raspbian or RaspBMC you should already have this installed. You can check whether it is installed or not by running the following command:

dpkg -s cifs-utils

If it is installed, it should output something like this:

Package: cifs-utils
 Status: install ok installed
 Priority: optional
 Section: otherosfs
 Installed-Size: 189
 Maintainer: Debian Samba Maintainers <pkg-samba-maint@lists.alioth.debian.org> Architecture: armhf
 Version: 2:5.5-1
 ...

If it says that it’s not installed, you need to install it:

sudo apt-get install cifs-utils

 

Mounting unprotected (guest) network folders

You might have public folders on your network drive that can be accessed by anyone without having to provide any credentials. These are mounted in the same way as password-protected folders (we will mount these in the next section), but with a few different options.

First, let’s create a directory on the Pi where we want to mount the directory. You will need a separate directory for each network folder that you want to mount. I will create the folders in the /media folder:

sudo mkdir -p /media/networkshare/public

Then edit your /etc/fstab file (with root privileges) and add this line:

//192.168.0.18/publicshare /media/networkshare/public cifs guest,uid=1000,gid=1000,iocharset=utf8 0 0

The first part is the IP of your network drive, and the public folder you want to mount.
The second part is the folder on your local machine where you want to mount the network share.
The third part indicates what type of drive you want to mount (cifs).

The last part is the set of options you can pass, and here’s an explanation of the ones we are using:

  • guest is basically telling the network drive that it’s a public share, and you don’t need a password to access it (not to confuse with username),
  • uid=1000 makes the Pi user with this id the owner of the mounted share, allowing them to rename files,
  • gid=1000 is the same as uid but for the user’s group,
  • iocharset=utf8 allows access to files with names in non-English languages.

Note: If there is any space in the server path, you need to replace it by \040, for example //192.168.0.18/My\040Documents

To find the uid and gid for your username, use the following command:

id username

Now that we have added this to our /etc/fstab, we need to (re)mount all entries listed in /etc/fstab:

sudo mount -a

Now you can access your network drive from /media/networkshare/public (or wherever you chose to mount it).

 

Mount password-protected network folders

Mounting a password-protected share is very similar to mounting a public ones, with some minor changes to the options we pass. Let’s start by making a new folder where we want to mount the password-protected share:

sudo mkdir -p /media/networkshare/protected

Again, open /etc/fstab (with root privileges), and add this line:

//192.168.0.18/protectedshare /media/networkshare/protected cifs username=msusername,password=mspassword,uid=1000,gid=1000,iocharset=utf8 0 0

While this is a perfectly valid way of mounting your protected folder, it’s not very secure. Since /etc/fstab is readable by everyone, so are your credentials in it. So, let’s make it more secure by using a credentials file. This file will contain nothing else but your username and password, but we will make readable only to you. This way, other users on the system won’t be able to see your credentials.

Using a text editor, create a file that will contain the credentials for your protected network share:

vim ~/.smbcredentials

Enter your username and password for the protected share in the file:

username=msusername
password=mspassword

Save the file.

Change the permissions of the file to make sure only you can read it:

chmod 600 ~/.smbcredentials

Then edit your /etc/fstab file and change the line where we are mounting the protected share to look like this:

//192.168.0.18/protectedhare /media/networkshare/protected cifs credentials=/home/username/.smbcredentials,uid=1000,gid=1000,iocharset=utf8 0 0

Save the file.

Again, we need to (re)mount all entries listed in /etc/fstab:

sudo mount -a

 

Now you’re all set to access your public and protected folders from your Pi.

 

How to wake up a pc by PHP

source: 
http://php.net/manual/en/ref.sockets.php
http://www.rkrishardy.com/2009/12/permission-denied-13-when-opening-socket-in-php-apache/

<?php
/**
 * Wake-on-LAN
 *
 * @return boolean
 *   TRUE:    Socked was created successfully and the message has been sent.
 *   FALSE:   Something went wrong
 *
 * @param string|array  $mac   You will WAKE-UP this WOL-enabled computer, you
 *                             need to add the MAC-address here. Mac can be
 *                             array too.
 *
 * @param string|array  $addr  You will send and broadcast to this address.
 *                             Normally you need to use the 255.255.255.255
 *                             address, so I made it as the default. You don't need to do anything with this.
 *                       
 *                             If you get permission denied errors when using
 *                             255.255.255.255 have permission denied problems
 *                             you can set $addr = false to get the broadcast
 *                             address from the network interface using the
 *                             ifconfig command.
 *
 *                             $addr can be array with broadcast IP values
 *
 * Example 1:
 *   When the message has been sent you will see the message "Done...."
 *   if ( wake_on_lan('00:00:00:00:00:00'))
 *      echo 'Done...';
 *   else
 *      echo 'Error while sending';
 */

function wake_on_lan($mac, $addr=false, $port=7) {
    if ($addr === false){
        exec("ifconfig | grep Bcast | cut -d \":\" -f 3 | cut -d \" \" -f 1",$addr);
        $addr=array_flip(array_flip($addr));
    }
    if(is_array($addr)){
        $last_ret = false;
        for ($i = 0; $i < count($addr); $i++)
            if ($addr[$i] !== false) {
                $last_ret = wake_on_lan($mac, $addr[$i], $port);
            }
        return $last_ret;
    }
    if (is_array($mac)){
        $ret = array();
        foreach($mac as $k =< $v)
            $ret[$k] = wake_on_lan($v, $addr, $port);
        return $ret;
    }
    //Check if it's an real MAC-address and split it into an array
    $mac = strtoupper($mac);
    if (!preg_match("/([A-F0-9]{1,2}[-:]){5}[A-F0-9]{1,2}/", $mac, $maccheck))
        return false;
    $addr_byte = preg_split("/[-:]/", $maccheck[0]);
 
    //Creating hardware adress
    $hw_addr = '';
    for ($a = 0; $a < 6; $a++)//Changing mac adres from HEXEDECIMAL to DECIMAL
        $hw_addr .= chr(hexdec($addr_byte[$a]));
  
    //Create package data
    $msg = str_repeat(chr(255),6);
    for ($a = 1; $a <= 16; $a++)
        $msg .= $hw_addr;
    //Sending data
    if (function_exists('socket_create')){
        //socket_create exists
        $sock = socket_create(AF_INET, SOCK_DGRAM, SOL_UDP);    //Can create the socket
        if ($sock){
            $sock_data = socket_set_option($sock, SOL_SOCKET, SO_BROADCAST, 1); //Set
            if ($sock_data){
                $sock_data = socket_sendto($sock, $msg, strlen($msg), 0, $addr,$port); //Send data
                if ($sock_data){
                    socket_close($sock); //Close socket
                    unset($sock);
                    return true;
                }
            }
        }
        @socket_close($sock);
        unset($sock);
    }
    $sock=fsockopen("udp://" . $addr, $port);
    if($sock){
        $ret=fwrite($sock,$msg);
        fclose($sock);
    }
    if($ret)
        return true;
    return false;  
}

if (@wake_on_lan('00:00:00:00:00:00')) {
    echo 'Done...';
} else {
    echo 'Error while sending';
}
?>

How do I start to to play videos automatically while boot?

Seems like the answer to your question is contained within an other question on this site.

I am trying to play videos automatically when the Raspberry Pi boots. I decided to use crontab for that:

@reboot /storage/.config/autostart.sh

The autostart.sh file contains the following code:

xbmc-send -a “PlayMedia(/storage/videos/)”

The Raspberry Pi successfully automatically starts to play videos from /storage/videos/ directory when it reboots.

Hope that helps.

 

 

This is like asking “How do I fix my car when it won’t start?” Your question is way to broad to answer. The process will remain basically the same form case to case. Here are some steps that you can go through to figure this out.

  1. GOOGLE
  2. Using Terminal, shell, SSH, etc., figure out the command that will start the video as desired.
  3. READ this document to figure out how to turn that shell command into a bash script.http://www.calpoly.edu/~rasplund/script.html
  4. READ this document to figure out how to run that bash script on boothttp://www.cyberciti.biz/faq/linux-execute-cron-job-after-system-reboot/
  5. Reboot, test and troubleshoot.

javascript如何阻止click事件连续触发

中包含一个checkbox,点击时不仅激活checkbox的click事件,还会激活td或者tr的click事件,称作bubble event。

解决方法是:

$(“table tbody td”).click(function(e){
if(e.target.nodeName.toUpperCase() == “INPUT”){
alert(“It’s an input!”);
return;
}else{
alert(“It’s not an input!”);
}
});

How can I kill a process by name instead of PID?

前段时间为了投票,在服务器上面开了N个php进程,每次要退出的时候都要ps -eaf|grep php,然后根据pid一个一个kill,傻傻的操作了很多次。其实早就知道有killall的指令,但一次都没用过。这次实在受不了了,还是查了一下,用下面这个方法挺好

 

kill `pidof php`

备用方法,未验证
export pid=`ps | grep process_name | awk 'NR==1{print $1}' | cut -d' ' -f1`;kill $pid
pkill -f "Process name" 这个试过了,因为是php xxx.php方式,貌似没法用。

树莓派spi液晶屏支持(fbtft)[转]

 

转自 老徐拉灯 的博客

原文地址:http://blog.csdn.net/xdw1985829/article/details/39583239

树莓派官方支持av及HDMI输出,板子上预留了一个csi接口的液晶显示屏,但是一直没有相应的模组出现。在很多应用场合我们需要一些小型的液晶屏显示一些基本的信息,所以小屏驱动很是必要。

在github上有一个开源工程:notro/fbtft,完整的实现了framebuffer驱动,让树莓派完美支持tft液晶,下面对移植过程进行一个简单说明

一、官网地址

工程首页:https://github.com/notro

fbtft源码:https://github.com/notro/fbtft

编译好的固件(基于3.12.25+):https://github.com/notro/rpi-firmware

使用说明(wiki):https://github.com/notro/fbtft/wiki

二、使用编译好的固件(3.12.25+)

环境:树莓派

https://github.com/notro/rpi-firmware

1、打开SPI

树莓派默认spi是关掉的,我们需要打开

sudo vi /etc/modprobe.d/raspi-blacklist.conf

把下面这句话前面的#号删掉

blacklist spi-bcm2708

2、下载:

1)以模块的形式编译进内核(需要手动或脚本加载模块)3.12.25+(试验成功
sudo REPO_URI=https://github.com/notro/rpi-firmware rpi-update
2)直接编译进内核(笔者没有试验
sudo REPO_URI=https://github.com/notro/rpi-firmware BRANCH=builtin rpi-update

3)以模块的形式编译进内核(需要手动或脚本加载模块,最新版本,笔者试过启动不起来,不知道哪出问题

sudo REPO_URI=https://github.com/notro/rpi-firmware BRANCH=latest rpi-update

4)直接下载压缩包,手动安装(适合树莓派不能联网的时候

http://tronnes.org/downloads/2014-06-20-wheezy-raspbian-2014-07-25-fbtft-master-firmware.zip

3、配置

1)手动加载模块:

sudo modprobe fbtft_device name=adafruit22

name后面的名字,要跟相应的液晶驱动芯片移植

笔者使用的液晶芯片为:fb_ra8875,所以这里写的是:er_tftm050_2

其它芯片请查阅:https://github.com/notro/fbtft/blob/master/fbtft_device.c 文件

正常会提示以下信息

fbtft_device:  SPI devices registered:
fbtft_device:      spidev spi0.0 500kHz 8 bits mode=0x00
fbtft_device:      spidev spi0.1 500kHz 8 bits mode=0x00
fbtft_device:  ‘fb’ Platform devices registered:
fbtft_device:      bcm2708_fb id=-1 pdata? no
fbtft_device: Deleting spi0.0
fbtft_device:  GPIOS used by ‘adafruit22’:
fbtft_device:    ‘reset’ = GPIO25
fbtft_device:    ‘led’ = GPIO23
fbtft_device:  SPI devices registered:
fbtft_device:      spidev spi0.1 500kHz 8 bits mode=0x00
fbtft_device:      fb_hx8340bn spi0.0 32000kHz 8 bits mode=0x00

graphics fb1: fb_hx8340bn frame buffer, 176×220, 75 KiB video memory, 16 KiB buffer memory, fps=20, spi0.0 at 32 MHz

在/dev/目录下出现: /dev/fb1设备

2)自动加载模块

sudo vi  /etc/modules

加入以下语句,既可以在启动时自动加载模块

spi-bcm2708

fbtft_device name=er_tftm050_2  speed=28000000 fps=25 verbose=0

红色部分根据实际情况调整,可能出现花屏现象
4、使用(官方给出的方法,笔者测试不成功)

1)手动启动x11和控制台到新的液晶屏
X Windows显示在fb1上:
$FRAMEBUFFER=/dev/fb1 startx

Console显示在fb1上:
$con2fbmap 1 1

2)自动登陆x11

sudo vi /etc/inittab
#1:2345:respawn:/sbin/getty –noclear 38400 tty1
1:2345:respawn:/bin/login -f pi tty1 </dev/tty1 >/dev/tty1 2>&1

sudo vi /etc/rc.local

su -l pi -c “env FRAMEBUFFER=/dev/fb1 startx &”

5、使用(笔者使用这个测试通过)

1)将fb0上的内容直接拷贝到fb1上,fb0和fb1同步

https://github.com/notro/fbtft/wiki/Framebuffer-use#framebuffer-mirroring

$git clone https://github.com/tasanakorn/rpi-fbcp

$cd rpi-fbcp/
$mkdir build
$cd build/
$cmake ..
$make
$sudo install fbcp /usr/local/bin/fbcp

启动:fbcp &

关闭fbcp:killall fbcp

2)启动时使用fb1

$sudo apt-get install xserver-xorg-video-fbdev

$sudo vi /usr/share/X11/xorg.conf.d/99-fbdev.conf

加入以下语句:

Section “Device”
Identifier “myfb”
Driver “fbdev”
Option “fbdev” “/dev/fb1”
EndSection

启动:startx

 

测试:

apt-get -y install fbi

fbi -d /dev/fb1 -T 1 -noverbose -a test.jpg

三、由内核及源码编译

1、下载、编译内核源码:

请见《树莓派开发系列教程8——树莓派内核编译与固件升级

2、下载、编译fbtft源码

$cd linux(进入下载好的内核源码目录)

$cd drivers/video

$git clone https://github.com/notro/fbtft.git(下载fbtft源码,也可以在别的地方下载好,拷贝过来)

   修改内核源码的Kconfig及Makefine

  Add to drivers/video/Kconfig:   source “drivers/video/fbtft/Kconfig”

  Add to drivers/video/Makefile:  obj-y += fbtft/

$make menuconfig(在配置界面加入所选用液晶的驱动支持)

  1.  Device Drivers  —>
  2.  Graphics support  —>
  3. <M> Support for small TFT LCD display modules  —>
  4. <M>   FB driver for the HX8353D LCD Controller
  5. <M>   FB driver for the ILI9320 LCD Controller
  6. <M>   FB driver for the ILI9325 LCD Controller
  7. <M>   FB driver for the ILI9340 LCD Controller
  8. <M>   FB driver for the ILI9341 LCD Controller
  9. < >     FB driver for the ILI9481 LCD Controller
  10. <M>   FB driver for the ILI9486 LCD Controller
  11. <M>   FB driver for the PCD8544 LCD Controller
  12. <M>   FB driver for the RA8875 LCD Controller

$make

基于树莓派Raspberry: 字符设备内核驱动程序框架编写[转]

之前写了一篇移植2.4寸TFT驱动到树莓派的文章,那篇博文中的驱动代码是国外大牛写的,看了一下,还是有很多地方没理解,是得好好再学习一下内核驱动的编写,这里就从字符设备驱动开始,采用最简单的LED驱动来建立内核驱动移植的驱动框架.

个人原创,转载请注明原文出处:

http://blog.csdn.net/embbnux/article/details/17712547

参考文章:

http://blog.csdn.net/hcx25909/article/details/16860725

内核驱动与普通单片机模块驱动的差别就是在于,写内核驱动的时候,要提供内核调用的接口,使内核能找到相应的驱动入口,用户通过告诉内核要干嘛,内核再去调用那个驱动,驱动的最底层和单片机模块是一样的,同样是对GPIO的操作,配置输入输出,以及某些特殊的寄存器. LED的点亮就是对GPIO的操作 .

对于ARM的GPIO调用需要通过IO映射的方法,要操作内存上对应的地址.

对于bcm2708上的io对应关系,可以查看bcm2835的手册,和stm32基本上是一样的,因为同为ARM体系:SouthEast

我参考的那博客讲这个比较清楚,可以参考下,由于树莓派的内核以及很好的提供了GPIO调用的接口,即把内存操作封装了很好,这里就不像那篇博客那样再自己写函数通过内存操作来进行GPIO操作,觉得有点麻烦,但是对于学好底层很有用.

  一  首先上个驱动程序

 

这里直接把该程序添加到内核的源码目录里面,也可在自己的目录下,但是要写Makefile.

在/drivers/char/新建rasp_led.c,内核中的kconfig文件和makefile文件,参照前一篇文章

led.c:

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
/********************************************************************/
/***************Rasp led 驱动程序************************************/
/***************作者: Embbnux Ji*************************************/
/***************博客: http://blog.csdn.net/embbnux/ *****************/
/********************************************************************/
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/device.h>
#include <mach/platform.h>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
#include <linux/platform_device.h>
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/ioctl.h>
#include <linux/cdev.h>
#include <linux/delay.h>
#include <linux/uaccess.h>
#include <linux/init.h>
#include <linux/gpio.h>
#define DEVICE_NAME "Pi_Led"
#define DRIVER_NAME "pi_led"
//class声明内核模块驱动信息,是UDEV能够自动生成/dev下相应文件
static dev_t pi_led_devno; //设备号
static struct class *pi_led_class;
static struct cdev pi_led_class_dev;
struct gpio_chip *gpiochip;
#define led_pin 4 //gpio 4
//这部分函数为内核调用后open的设备IO操作,和裸板程序一样
int open_flag=0;
static int pi_led_open(struct inode *inode, struct file *filp)
{
 printk("Open led ing!\n");
 if(open_flag ==0){
 open_flag =1;
 printk("Open led success!\n");
 return 0;
 }
 else{
 printk("Led has opened!\n");
 }
 return 0;
}
//这部分函数为内核调用后ioctl的设备IO操作,和裸板程序一样
static long pi_led_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
 switch(cmd){
 case 0:
 gpiochip->set(gpiochip, led_pin, 0);
 printk("Led up!\n");
 break;
 case 1:
 gpiochip->set(gpiochip, led_pin, 1);
 printk("Led down!\n");
 break;
 }
 return 0;
}
static int pi_led_release(struct inode *inode,struct file *file){
 printk("Led has release!\n");
 return 0;
}
//file_operations使系统的open,ioctl等函数指针指向我们所写的led_open等函数,
//这样系统才能够调用
static struct file_operations pi_led_dev_fops = {
 .owner =THIS_MODULE,
 .open =pi_led_open,
 .unlocked_ioctl = pi_led_ioctl,
 .release = pi_led_release,
};
static int is_right_chip(struct gpio_chip *chip, void *data)
{
if (strcmp(data, chip->label) == 0)
 return 1;
 return 0;
}
//内核加载后的初始化函数.
static int __init pi_led_init(void)
{
 struct device *dev;
 int major; //自动分配主设备号
 major = alloc_chrdev_region(&pi_led_devno,0,1,DRIVER_NAME);
 //register_chrdev 注册字符设备使系统知道有LED这个模块在.
 cdev_init(&pi_led_class_dev, &pi_led_dev_fops);
 major = cdev_add(&pi_led_class_dev,pi_led_devno,1);
 //注册class
 pi_led_class = class_create(THIS_MODULE,DRIVER_NAME);
 dev = device_create(pi_led_class ,NULL,pi_led_devno,NULL,DRIVER_NAME);
 gpiochip = gpiochip_find("bcm2708_gpio", is_right_chip);
 gpiochip->direction_output(gpiochip, led_pin, 1);
 gpiochip->set(gpiochip, led_pin, 0);
 printk("pi led init ok!\n");
 return 0;
}
//内核卸载后的销毁函数.
void pi_led_exit(void)
{
 gpio_free(led_pin);
 device_destroy(pi_led_class,pi_led_devno);
 class_destroy(pi_led_class);
 cdev_del(&pi_led_class_dev);
 unregister_chrdev_region(pi_led_devno, 1);
 printk("pi led exit ok!\n");
}
module_init(pi_led_init);
module_exit(pi_led_exit);
MODULE_DESCRIPTION("Rasp Led Driver");
MODULE_AUTHOR("Embbnux Ji < http://blog.csdn.net/embbnux >");
MODULE_LICENSE("GPL");

二  源码框架分析

我们首先从内核模块的入口,module_init(pi_led_init)这个函数看起,可以看出初始化后调用pi_led_init这个函数.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
//内核加载后的初始化函数.
static int __init pi_led_init(void)
{
 struct device *dev;
 int major; //自动分配主设备号
 major = alloc_chrdev_region(&pi_led_devno,0,1,DRIVER_NAME);
 //register_chrdev 注册字符设备使系统知道有LED这个模块在.
 cdev_init(&pi_led_class_dev, &pi_led_dev_fops);
 major = cdev_add(&pi_led_class_dev,pi_led_devno,1);
 //注册class
 pi_led_class = class_create(THIS_MODULE,DRIVER_NAME);
 dev = device_create(pi_led_class ,NULL,pi_led_devno,NULL,DRIVER_NAME);
 gpiochip = gpiochip_find("bcm2708_gpio", is_right_chip);
 gpiochip->direction_output(gpiochip, led_pin, 1);
 gpiochip->set(gpiochip, led_pin, 0);
 printk("pi led init ok!\n");
 return 0;
}

初始化时首先分配给这个函数设备号,注册该设备,通过class注册使能够在/dev/目录下自动生成相应的设备文件,用户通过操作这个文件,来告诉内核怎么做.

由于是字符设备,所以对该文件的操作通过open,write,ioctl等函数,所以要把这个函数和底层的操作函数对应起来,这就要用到file_operation这个结构体,来声明:

1
2
3
4
5
6
7
8
//file_operations使系统的open,ioctl等函数指针指向我们所写的led_open等函数,
//这样系统才能够调用
static struct file_operations pi_led_dev_fops = {
 .owner =THIS_MODULE,
 .open =pi_led_open,
 .unlocked_ioctl = pi_led_ioctl,
 .release = pi_led_release,
};

这里就让open函数对应到pi_led_open函数,ioctl函数对应到pi_led_ioctl函数;

然后我们就只需要编写相应的pi_led_open以及pi_led_ioctl;这些函数里面的操作就是最底层的GPIO操作,和单片机是一样的.

三  GPIO操作

内核里面的GPIO操作函数,被定义在#include <linux/gpio.h>,这个头文件里面,树莓派官方做好了树莓派的GPIO在内核里面的注册,所以调用gpio.h里面的函数即可进行树莓派的GPIO操作.

1
gpiochip = gpiochip_find("bcm2708_gpio", is_right_chip);

通过上面这个函数把内核的GPIO操作和BCM2708的GPIO操作关联起来;

bcm2708的操作可以查看/arch/arm/mach-bcm2708/bcm2708_gpio.c文件,具体也是对内存地址的操作:

1
2
3
4
5
6
7
8
9
10
11
12
13
#define GPIOFSEL(x) (0x00+(x)*4)
#define GPIOSET(x) (0x1c+(x)*4)
#define GPIOCLR(x) (0x28+(x)*4)
#define GPIOLEV(x) (0x34+(x)*4)
#define GPIOEDS(x) (0x40+(x)*4)
#define GPIOREN(x) (0x4c+(x)*4)
#define GPIOFEN(x) (0x58+(x)*4)
#define GPIOHEN(x) (0x64+(x)*4)
#define GPIOLEN(x) (0x70+(x)*4)
#define GPIOAREN(x) (0x7c+(x)*4)
#define GPIOAFEN(x) (0x88+(x)*4)
#define GPIOUD(x) (0x94+(x)*4)
#define GPIOUDCLK(x) (0x98+(x)*4)

这里定义的就是相应的GPIO寄存器的地址.

四  测试程序

ssh进入树莓派,在主目录下新建led.c

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
28
#include<stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <sys/ioctl.h>
 #include <sys/time.h>
 int main(int argc, char **argv)
 {
 int on;
 int led_no;
 int fd;
 int i;
fd = open("/dev/pi_led", 0);
 if (fd < 0) {
 fd = open("/dev/pi_led", 0);
 }
 if (fd < 0) {
 perror("open device led");
 exit(1);
 }
for(i=0;i<=20;i++){
on = i%2;
ioctl(fd, on, led_no);
sleep(1);
}
close(fd);
return 0;
}

Center

加载postgres模块后apache无法启动

想在本地搭建一个PostgreSQL的运行环境,完成之后,始终在apache/php环境无法加载postgresql模块。启动的时候无法加载libpq.dll,将postgresql的libpq拷贝到php目录无效,拷贝到windows目录无效,拷贝到windows\system32目录也无效,只好在网上找解决方法。搜到以下方法:

refering to the libpq.dll that comes bundled with PHP, like this:

LoadFile “C:/php/libpq.dll”

(原文地址:http://stackoverflow.com/questions/551734/php-not-loading-php-pgsql-dll-on-windows)

在http.conf文件中增加这一行,完美解决。其实这个答案之前有混淆的问题,比如加载pg目录的libpq.dll,似乎无效,只能用php目录里面自带的libpq.dll。

Firefox 调试 插件/扩展

在一个项目中要开发一个firefox的扩展,结果一直没找到好的调试方法,痛苦的要命。之前在网上找到用chromebug,试了很多次都没有成功,只好在代码里面用代码打印到控制台。

项目已经过去了很久,最近需要修改点代码,重新遇到调试的问题,在网上又搜了一遍,找到了一个方法,测试了一下,居然可以设置断点调试了,可喜可贺。

方法就是修改firefox的设置,在地址栏输入about:config,然后允许chrome调试和远程调试:

devtools.chrome.enable => true

devtools.debugger.remote-enable => true

然后在firefox里Tools > Web Developer > Browser Console.,打开调试窗口,里面有个debugger,这里就可以开始了。

 

以下是原文和地址

http://stackoverflow.com/questions/17547364/how-to-debug-a-firefox-extension-with-chromebug/17579253#17579253

Update April 2014: The browser debugger is now integrated in the “Browser Toolbox” and you no longer need to set about:config prefs. Just use the developer tools configuration/settings panel: “enable chrome debugging” and “enable remote debugging”. The “Browser Toolbox” will then be available in the developer tools panel.

Chromebug has not worked for me for many months. I think it’s just been silently abandoned but thankfully on Firefox 19 or later, it’s possible to use the built-in JS debugger on the browser itself. Go to about:config and set the following two prefs:

devtools.chrome.enabled: true
devtools.debugger.remote-enabled: true

After you restart the browser, the Web Developer menu will contain a “Browser Debugger” entry.

More info here: https://developer.mozilla.org/en/docs/Debugging_JavaScript

If possible, I’d suggest using Aurora for your debugging because the built-in debugger was a little limited when first launched and keeps getting better with every release.

Arduino学习笔记A11 – Arduino模拟电脑键盘(基于AVR-USB的USB-HID设备) [转]

Arduino模拟电脑键盘(基于AVR-USB的USB-HID设备)

关于此帖子的其他讨论,还可以看看
http://geek-workshop.com/thread-2303-1-1.html
http://geek-workshop.com/thread-2310-1-1.html

键盘作为经典的输入设备,使用在很多互动中都有特别的优势,比如我们可以通过键盘直接给flash传递按键事件。而无需通过串口之类的特殊接口,虽然我们可以拆一个传统的键盘,然后将里面的按键引出来,但是这样有一个缺点,就是键值不能动态改变并且不能一次多键。使用模拟键盘的话,我们就可以随意在程序设置按键的时间和键值。比如本文的例子就是按下一个按键,模拟键盘就在电脑输入“HELLO WORLD”。

硬件部分:
材料清单:
Arduino x1
68Ω电阻 x2 (没有68Ω的话,用50~100Ω电阻也行)
2.2kΩ电阻 x1 (没有2.2kΩ的话,用1.5k~2.2k电阻也行)
USB连接线(一端是USB口,另一端是电线) x1
3.6v 稳压管(建议选用功耗0.25~0.5w的)x2
194146uld4tdhd1b111w9d1942021gy6n1v41yne26ia

电路原理图:
120616mer6qi8i8smt5qs6
电路图解说:
1、两个68Ω的电阻起到限流和保护作用,防止在意外情况下损坏计算机的USB端口或单片机的端口。
2、2.2kΩ电阻是上拉电阻,用于分辨总线状态。如果上拉电阻接于D+和+5v端则是高速USB设备,接于D-与+5v端,则是低速设备。此处键盘传输速率不高,接到D-作为低速设备即可。
3、D+和D-上的3.6V稳压二极管D1和D2起到限制数据线上的电平的作用。因为在USB规范中规定数据线D+和D-上的电平范围是3.0V至3.6V,而AVR单片机的输出电平是Vcc。如果单片机的Vcc是5V,在没有D1和D2的情况下将造成电平不匹配,会造成在很多计算机中无法正确识别出USB设备。如果用户系统的Vcc在3.0V至3.6V之间,就可以省略这两个稳压二极管。从这里也可以看出用户系统的Vcc必须高于3V。
4、由于低速AVRUSB所需要的是1.5MHz时钟,而单片机每8条指令就能精确完成一个数据位的采集。所以AVRUSB最小单片机时钟频率是12MHz。并且可以使用的时钟频率有12MHz、12.8MHz、15MHz、16MHz、16.5MHz、20MHz,其他的不支持。所以如果使用最小系统制作此模拟键盘的话8MHz的话,ATMega8L不能用。
————————
软件部分:

Arduino支持库文件:
http://soft1.wmzhe.com/download/ … ino/UsbKeyboard.zip
UsbKeyboard.zip (112.45 KB, 下载次数: 1421)
文件下载后解压到arduino编译器的libraries文件夹下面。

注意:

1、UsbKeyboard库中,usbconfig.h里面可以更改USB接线的引脚定义,下面给出一个大概解释(下面的PORTD是指AVR单片机的PORTD,要查询Arduino原理图才能得到是Arduino的哪个引脚):

#define USB_CFG_IOPORTNAME D
USB输入输出引脚使用AVR单片机的PORTD,如果改成B就是使用PORTB
#define USB_CFG_DMINUS_BIT 4
USB的D-接PORTD的第四位PD4,对应Arduino D4
#define USB_CFG_DPLUS_BIT  2
USB的D+接PORTD的第二位PD2,对应Arduino D2
#define USB_CFG_PULLUP_IOPORTNAME D
USB上拉引脚使用AVR单片机的PORTD,如果改成B就是使用PORTB
#define USB_CFG_PULLUP_BIT  5
USB的上拉电阻接PORTD的第五位PD5,对应Arduino  D5

2、在UsbKeyboard库的UsbKeyboard.h里面,有关于模拟键值的表
#define KEY_A       4
#define KEY_B       5
#define KEY_C       6
#define KEY_D       7
#define KEY_E       8
等。但不齐全。经过测试,其实这个键盘基本可以模拟几乎所有键值(Power,Sleep,Pause似乎不能)。
比如方向键右左下上分别对应79,80,81,82数字。即写成
UsbKeyboard.sendKeyStroke(79);
UsbKeyboard.sendKeyStroke(81);
等。由于整理比较麻烦,大家可以自己下载个KeyboardTest软件测试不同数字下面的键值。

程序示例:
下面的例子演示了用Arduino虚拟键盘的应用例子。打开记事本,然后将Arduino的D12引脚和GND连起来,就会打印HELLO WORLD字样。

ARDUINO 代码复制打印

  1. /*
  2. Arduino模拟键盘 by Ansifa
  3. 2012.6.8
  4. 功能描述:插上此模拟键盘,打开记事本,然后按下按钮,即可在记事本打印出HELLO WORLD字样
  5. 接线方法:
  6. <img src=”http://www.geek-workshop.com/forum.php?mod=image&aid=5359&size=300×300&key=e9fa5559e6d5724d51f770bc6c55b941&nocache=yes&type=fixnone” border=”0″ aid=”attachimg_5359″ alt=””>
  7. Arduino D2接68Ω电阻后,接USB线D+
  8. Arduino D4接68Ω电阻后,接USB线D-
  9. Arduino D5接2.2kΩ电阻后,接USB线D-
  10. Arduino D2接3.6v稳压管到GND
  11. Arduino D4接3.6v稳压管到GND
  12. +5v接USB线VCC
  13. GND接USB线GND
  14. Arduino D1接一个开关到GND
  15. 附:USB线序颜色(由于各生产厂不同,不一定准确,仅供参考)
  16. *USB键鼠:      |        *USB接口
  17. 白<->VCC        |        红<->VCC
  18. 橙<->D-         |        白<->D-
  19. 绿<->D+         |        绿<->D+
  20. 蓝<->GND        |        黑<->GND
  21. */
  22. #include “UsbKeyboard.h”
  23. int KEYPIN = 1;                //按键接在D1引脚,也可以改成任何引脚
  24. void setup()
  25. {
  26.   TIMSK0 &= !(1 << TOIE0);        //
  27.   pinMode(KEYPIN, INPUT);
  28.   digitalWrite(KEYPIN, HIGH);
  29. }
  30. void loop()
  31. {
  32.   UsbKeyboard.update();
  33.   if(digitalRead(KEYPIN) == HIGH)
  34.   {
  35.     delay(100);
  36.     if(digitalRead(KEYPIN) == LOW)
  37.     {
  38.       UsbKeyboard.sendKeyStroke(KEY_H);
  39.       UsbKeyboard.sendKeyStroke(KEY_E);
  40.       UsbKeyboard.sendKeyStroke(KEY_L);
  41.       UsbKeyboard.sendKeyStroke(KEY_L);
  42.       UsbKeyboard.sendKeyStroke(KEY_O);
  43.       UsbKeyboard.sendKeyStroke(KEY_SPACE);
  44.       UsbKeyboard.sendKeyStroke(KEY_W);
  45.       UsbKeyboard.sendKeyStroke(KEY_O);
  46.       UsbKeyboard.sendKeyStroke(KEY_R);
  47.       UsbKeyboard.sendKeyStroke(KEY_L);
  48.       UsbKeyboard.sendKeyStroke(KEY_D);
  49.       UsbKeyboard.sendKeyStroke(KEY_ENTER);
  50.     }
  51.   }
  52. }

注意,先插上Arduino数据线,将程序写入Arduino。然后拔掉数据线,将模拟键盘USB线接到电脑,即可使用。

下面随便点实物图

刚焊好的正反面
194204xv880393zvisyxn32154270440zvdpvvocmaqc

插数据线写程序进Arduino:
1941595x18zxgzaan1fgk5

转自http://www.geek-workshop.com/thread-1137-1-1.html, 版权归原作者所有

Arduino读取键盘[转载]

Arduino读取键盘

Arduino_and_Keypad
这里提供两种方式从Arduino读取键盘。第一种方式是使用矩阵式(Matrix)键盘,另一种方式是使用PS2键盘。
矩阵键盘(Matrix keypad)
首先必须安装Arduino Keypad键盘库(Keypad library),Arduino Keypad键盘库可以从Arduino Playground下载。Arduino Keypad键盘库让你读取矩阵式键盘而不用编写复杂的代码,此键盘库可以读取3×4, 4×4以及各种矩阵结构的键盘。
使用Arduino Keypad键盘库注意事项
  • 该键盘库是属于无阻塞式,按下谋键不放,其余(接下来)的代码还是会继续运行
  • 如果编写控制键盘处运用到delay(),这将造成键盘反应迟顿
  • 按下谋键,getKey()只返回一个键值,而不是自动重复。松开按键时,可以追踪其RELEASED event

安装Arduino Keypad键盘库

  • 下载Arduino Keypad键盘库
  • 将下载了的文件(keypad.zip)解压至Arduino软件的libraries文件夹,如图
Arduino_keypad_library
  • 打开Arduino软件
  • 选择File>Examples>Keypad,将会看见以下画面,表示Arduino Keypad键盘库安装成功
Arduino_keypad_examples
4×4矩阵keypad示范
根据下面接线连接键盘至Arduino
4x4_matrix_membrane_keypad_pinout
Arduino
4×4 Keypad
D2
1
D3
2
D4
3
D5
4
D6
5
D7
6
D8
7
D9
8
上载以下代码至Arduino
#include <Keypad.h>

const byte ROWS = 4; // Four rows
const byte COLS = 4; // Four columns

//Define the keymap
char keys[ROWS][COLS] = {
{‘1′,’2′,’3′,’A’},
{‘4′,’5′,’6′,’B’},
{‘7′,’8′,’9′,’C’},
{‘*’,’0′,’#’,’D’}
};

//// Connect keypad ROW0, ROW1, ROW2 and ROW3 to these Arduino pins.
byte rowPins[ROWS] = {6,7,8,9};

// Connect keypad COL0, COL1, COL2 and COL3 to these Arduino pins.
byte colPins[COLS] = {2,3,4,5}; //connect to column pinouts

// Create the Keypad
Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );

void setup(){
Serial.begin(9600);
}

void loop(){
char key = keypad.getKey();

if (key != NO_KEY){
Serial.println(key);
}
}

使用Arduino软件自带的串口监视器(Serial Monitor)来测试此程序(Baud rate必须设成9600)。当按下谋键时,其返回值将显示在串口监视器。


PS2键盘
首先必须安装Arduino PS2键盘库(PS2keyboard library),Arduino PS2键盘库可以从这里下载
安装Arduino PS2键盘库
  • 下载Arduino PS2键盘库
  • 将下载了的文件(PS2keyboard.zip)解压至Arduino软件的libraries文件夹
  • 安装方法与安装keypad相似,请参考之。
 
PS2键盘示范
根据下面接线连接键盘至Arduino
PS2_keyboarad_pinout
Keyboard
Arduino
4 (+5V)
5V
3 (GND)
GND
5 (Clock)
Digital Pin 3
1 (Datak)
Digital Pin 4

上载以下代码至Arduino

#include <PS2Keyboard.h>

const int DataPin = 8;
const int IRQpin = 5;

PS2Keyboard keyboard;

void setup() {
delay(1000);
keyboard.begin(DataPin, IRQpin);
Serial.begin(9600);
Serial.println(“Keyboard Test:”);
}

void loop() {
if (keyboard.available()) {

char c = keyboard.read();  // read the next key

// check for some of the special keys
if (c == PS2_ENTER) {
Serial.println();
} else if (c == PS2_TAB) {
Serial.print(“[Tab]”);
} else if (c == PS2_ESC) {
Serial.print(“[ESC]”);
} else if (c == PS2_PAGEDOWN) {
Serial.print(“[PgDn]”);
} else if (c == PS2_PAGEUP) {
Serial.print(“[PgUp]”);
} else if (c == PS2_LEFTARROW) {
Serial.print(“[Left]”);
} else if (c == PS2_RIGHTARROW) {
Serial.print(“[Right]”);
} else if (c == PS2_UPARROW) {
Serial.print(“[Up]”);
} else if (c == PS2_DOWNARROW) {
Serial.print(“[Down]”);
} else if (c == PS2_DELETE) {
Serial.print(“[Del]”);
} else {
Serial.print(c);  // otherwise, just print all normal characters
}
}
}

使用Arduino软件自带的串口监视器(Serial Monitor)来测试此程序(Baud rate必须设成9600)。当按下谋键时,其返回值将显示在串口监视器。


增加按键音效
按照下面图象连接PC扬声器(此PC扬声器可以从废棄的电脑主板拆岀来),然後稍微更改代码。由于没有此PC扬声器的规格说明,估计供电5V且功率非常小,能够直接由Arduino驱动。如果不放心,可以在Aruino pin10与扬声器之间添加一个100欧姆电阻器。

Connecting_PC_speaker_to_Arduino

代码方面使用了tone()函数,具体可以浏览Arduino Reference网站
http://arduino.cc/en/Reference/Tone

tone()用法

  • tone(pin, frequency)
  • tone(pin, frequency, duration)
  1. pin是连接扬声器的引脚
  2. frequency是输出频率,频率越低,音频就越低。
  3. duration音频输出持续时间
  1. #include <Keypad.h>
  2. const byte ROWS = 4; // Four rows
  3. const byte COLS = 4; // Four columns
  4. //Define the keymap
  5. char keys[ROWS][COLS] = {
  6. {‘1′,’2′,’3′,’A’},
  7. {‘4′,’5′,’6′,’B’},
  8. {‘7′,’8′,’9′,’C’},
  9. {‘*’,’0′,’#’,’D’}
  10. };
  11. //// Connect keypad ROW0, ROW1, ROW2 and ROW3 to these Arduino pins.
  12. byte rowPins[ROWS] = {6,7,8,9};
  13. // Connect keypad COL0, COL1, COL2 and COL3 to these Arduino pins.
  14. byte colPins[COLS] = {2,3,4,5}; //connect to column pinouts
  15. // Create the Keypad
  16. Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );
  17. void setup(){
  18. Serial.begin(9600);
  19. }
  20. void loop(){
  21. char key = keypad.getKey();
  22. if (key != NO_KEY){
  23. delay(50); //act as debounce
  24. beep();
  25. Serial.println(key);
  26. }
  27. }
  28. #define SPEAKER_PIN 10
  29. void beep(){
  30. tone(SPEAKER_PIN,2000,90);
  31. delay(20);
  32. noTone(SPEAKER_PIN);
  33. }
转自
http://ediy.com.my/index.php/2012-10-21-15-15-03/2013-04-14-05-06-50/item/65-arduino%E8%AF%BB%E5%8F%96%E9%94%AE%E7%9B%98

在树莓派上的XBMC增加一个静音按钮(mute button for XBMC on Raspberry Pi)

也许有人会问有了手机控制或者红外控制为什么还要有一个物理的静音按钮呢?设想一下以下场景:

当你在电视上看大片看得正爽的时候,来了个电话,是到手机上找app来控制呢,还是手忙脚乱的找遥控器来静音,或者直接到电视机边上按个静音键方便呢?

正是因为如此,才有了这个创意。

基本思路:一个简单的轻触式按钮连接到Pi的gpio口,在Pi上运行一个python程序,当按钮按下时,给XBMC发送静音指令。

附加功能:每按一次,LED闪一下

扩展功能:不满足于静音功能的,还可以多增加几个按钮来完成其他的功能,比如播放、暂停、快进、发送邮件、甚至求救报警功能。

开始动手

原料:

树莓派 1个(这个你肯定有了吧,没有就入一个吧)

轻触式按钮 1个

LED 1个

3k3电阻 2个

洞洞板、连接线、面包板之类,看自己情况使用。

步骤1:

焊洞洞板,示意电路图如下:

dianlu

 

为了防止LED以及GPIO口电流太大,加了限流电阻。

board1

实际焊接图,请忽略左边五个按钮和左边的电阻,这是我留着备用的。

按照电路图连接到Pi上。

步骤2,安装python的gpio库,如果已经安装了,请跳过此步

cd /tmp
cd gpio
wget https://pypi.python.org/packages/source/R/RPi.GPIO/RPi.GPIO-0.5.7.tar.gz
tar xvzf RPi.GPIO-*.tar.gz
cd RPi.GPIO-*/
sudo python setup.py install
如果安装的时候出现错误:
source/py_gpio.c:23:20: fatal error: Python.h: No such file or directory
这是因为缺少Python.h文件,没安装python编译环境:
sudo apt-get install python-dev
步骤3:开始我们的python程序吧
#!/user/bin/env python

import RPi.GPIO as GPIO
import time
import urllib
import urllib2
import json

def mute():
url=’http://你的Pi的ip地址:8080/jsonrpc’
values = {“jsonrpc”:”2.0″,”method”:”Application.SetMute”,”id”:1,”params”:{“mute”:”toggle”}}

jdata = json.dumps(values)
req = urllib2.Request(url, jdata)
req.add_header(‘Content-Type’,’application/json’)
response = urllib2.urlopen(req)
return response.read()

GPIO.setmode(GPIO.BOARD)
GPIO.setup(11,GPIO.OUT)
GPIO.setup(12,GPIO.IN)
while True:
in_value= GPIO.input(12)
if in_value ==False:
mute();
GPIO.output(11,False)
time.sleep(0.5)
GPIO.output(11,True)
while in_value == False:
in_value = GPIO.input(12)

然后运行python key.py,按下按钮看看屏幕右上角已经有了静音标志了?再按一下,又消失了。
还可以在这个代码基础上修改做别的操作,希望这个能够起到抛砖引玉的作用。

[翻译]通过树莓派发送短信Send SMS Messages from Raspberry Pi

本站首发,转载请注明作者及引用网址

原文地址:

https://www.raspberrypi.org/forums/viewtopic.php?f=29&t=69286&sid=89b99af621144e400c588b4ef6cad708

 

写这篇文章背景故事很简单。我有一个树莓派,花了35刀的一个超小的arm计算机。我用它运行Nagios来监控我的服务器(因为过段时间我要出去旅行)。我希望当我的服务器有警报信息的时候,它会给我发一条短信,而我实在不原意在花钱买个SMS网关,太奢侈了,实际上email就可以了,但我更喜欢短信。然后我就开始找解决方案。

我在githut上找到一个允许我通过简单的python脚本来发送短信,地址是https://github.com/korylprince/pygvoicelib。下面的步骤将讲述如何如何通过pi来发送短信。步骤1:确保你的PI已经安装了系统并且有internet连接
步骤2:注册一个google voice帐号,这里需要一个gmail的帐号。
步骤3:在你的google帐号里面允许2步验证,地址是https://accounts.google.com/b/0/IssuedAuthSubTokens

步骤4:创建一个指定应用的密码,打开https://accounts.google.com/b/0/IssuedAuthSubTokens,移到最下面,在name框里填上Raspberry Pi(或者任何你想要的名字来标示你的设备),然后点击生成密码。
你将会得到一个一次性的密码

步骤5:登陆到你的Pi打开命令行或者通过putty连接到SSH

然后进入到你的home目录,比如我的是/home/pi

cd /home/pi

步骤6: 从github克隆所有代码

首先运行下面的指令来阻止ssl错误

export GIT_SSL_NO_VERIFY=1

然后运行下面的指令来克隆

 

git clone https://github.com/korylprince/pygvoicelib.git

步骤7:让Pi得到google的授权

cd到刚创建的pygvoicelib目录
运行以下指令:

python get_auth.py

将会提示你输入你gmail帐号和你在第四步得到的的应用的密码。在你输入这些信息以后,你会看到很多参数显示在终端上。记住以下参数,你在后面的步骤里将会用到
username
apppass
auth_token
rnr_se

步骤8:创建一个脚本来发送短信

运行下面的指令,你也可以用nano来编辑

vi text.py

将下列的代码贴到你创建的文件里面

#!/usr/bin/python
import pygvoicelib
number = raw_input(‘number:’)
txtmsg = raw_input(‘message:’)
client = pygvoicelib.GoogleVoice(username,apppass,auth_token,rnr_se)
client.sms(number,txtmsg)

用你在第7步创建的的username,apppass,auth_token,和rnr_se来替换这个文件中的参数
示例Example:

#!/usr/bin/python
import pygvoicelib
number = raw_input(‘number:’)
txtmsg = raw_input(‘message:’)
client = pygvoicelib.GoogleVoice(‘name@gmail.com’,'asdfahrwsthjtrh’,’4k3EozF_Qmrg3tD2_m56nQtFHCVSaTdUxb7HvcaN6g3PV929VH0eH4GGVOVpbVK2O6EaGFzMDYA6PhPjaEHr0ZGjO1GQN3RGhQLXqePWfglbXnA2n7XpUophOk5qztQyv2fYM7eYgtVCYeO6txTqbDQAAANsAAABZ7d0GTL2pJsUauPkH4Z3cpbJFqjfLZYfhok1b11pIMDnEOypZgIcOVdPEt8jEMx7oY9hHJeJoDQZYndDJDu8uoDbDWgxl87GMy990snKWR8iy8VIB17769eVWboa3224U8DLZLUWMpP0d4hfsDK5MQ’,'L6tph126BjmNjDcfTZGaWYeb+sk=’)
client.sms(number,txtmsg)

步骤9:发送短信

运行以下的指令

python text.py

它将提示你输入电话号码以及短信内容

步骤10:庆祝,打开一瓶啤酒然后好好的享受吧。

我另外也在我的blog写了这个操作步骤:http://citycorpse.com

精彩回复:

by default_user8 » Wed Feb 12, 2014 7:10 pm
Try sms via email key
here is a list by provider
Provider Format
Sprint phonenumber@messaging.sprintpcs.com
Verizon phonenumber@vtext.com
T-Mobile phonenumber@tmomail.net
AT&T phonenumber@txt.att.net
AIM +1phonenumber
by drgeoff » Thu Feb 13, 2014 10:16 am
DougieLawson wrote:I don’t think using Google Voice to send SMS messages is available outside the US & Canada. 我觉得这个除了美国和加拿大以外的地方都用不了

For 99% of the population of USA and Canada, that is the whole world. :lol:

对于美国和加拿大的99%人口来说,这就是整个世界了。
老美的傲慢和自豪感觉得他们的世界就是整个世界了,当然也是调侃的语气啦,至少人家分享的精神就很好。
至于说google voice不能在天朝用的问题,只能通过翻墙来解决了。可以在手机上装一个google voice的客户端,接受推送还是可以的。另外一个解决方案就是用飞信了,注册以后,发送邮件到13xxx@139.com,就可以收到短信了,完全免费哦,不过只能发送到移动号码,电信和联通的貌似也有类似功能,但是没有用过,可以试验一下。

[转]断网自动重启树莓派

断网自动重启树莓派

原文地址:http://vanraspi.dnamer.net/wordpress/?p=10

作为服务器, 树莓派还不是很稳定, 主要体现在我的无线网卡时不时的会停止工作, 相信访问我网站的朋友有时会发现我的网站挂了, 不能访问。
但是我发现只要重新启动, 一般就能解决问题,而且重启速度很快, 大约在1分钟以内。 所以, 我们需要一个脚本来监视树莓派断网没有:

将上述脚本保存到/home/pi/mybash/checknet.sh, 并 chmod +xchecknet.sh使得可以执行。
最后你可以添加一条任务到crontab:
sudo scrontab e
然后在最后添加:
*/5 * * * * /bin/bash /home/pi/mybash/checknet.sh
至此你就可以每五分钟检查一次是否能ping通百度,如果不行则重启并将重启时间写入日志 /var/log/checknet.log.

arduino 使用多个SPI设备 how to running multiple SPI device on arduino

how to running PN532 and W5100 on same board

最近研究arduino开发板,尝试将NFC板(PN532)和网络扩展板(w5100)组合在一起,碰到个问题,这两块板子都是通过SPI总线和arduino通信,同时占用pin10,11,12,13三个口,其中10是片选信号SS。这两个设备始终无法同时工作,出现很多莫名其妙的问题。

154149rr5dubo9wbj9wlrw

比如我编译IDE自带的webserver程序,设置了ip地址为192.168.1.15,启动以后,ping 192.168.1.15可以通,但在串口接收到 ip地址为192.139.1.15,甚至是192.192.192.192,或者其他乱七八糟的地址。在PC上访问http://192.168.1.15无法打开。拔除NFC扩展板,web访问正常。然后开始漫长google之路。

参考链接

http://arduino.cc/en/Main/ArduinoEthernetShield

1.首先确认两个设备不能使用同一个SS pin,将nfc的nss针插到其他pin(貌似1,2,4,不能使用,4是SD卡的片选),我选择5,然后在arduino的setup里面增加

pinMode(5,OUTPUT);

digitalWrite(5,HIGH);

测试同时连接NFC和网络,只初始化网卡,webserver正常;如果同时初始化网卡和NFC,依旧无法访问webserver

参考链接

http://www.circuitsathome.com/mcu/running-multiple-slave-devices-on-arduino-spi-bus

2.继续google,发现两个设备的setBitOrder似乎不同,PN532是LSBFIRST,而网络是WSBFIRST,

找到原因后就简单了,只需要启动不同设备的时候,不仅仅设置SS,还要重新设置SPI的参数。

找到PN532.cpp的begin(),大约在43行,将

pn532_SPI.setDataMode(SPI_MODE0);
pn532_SPI.setBitOrder(LSBFIRST);
/*Set the SPI frequency to be one sixteenth of the
frequency of the system clock*/
pn532_SPI.setClockDivider(SPI_CLOCK_DIV16);

注释掉,然后在自己的程序里面分别写上

void enablePN() {
digitalWrite(ETH_SS, HIGH);
digitalWrite(NFC_SS, LOW);
SPI.setDataMode(SPI_MODE0);
SPI.setBitOrder(LSBFIRST);
SPI.setClockDivider(SPI_CLOCK_DIV16);
delay(10);
}

void enableETH() {
digitalWrite(ETH_SS, LOW);
digitalWrite(NFC_SS, HIGH);
SPI.setBitOrder(MSBFIRST);
SPI.setClockDivider(SPI_CLOCK_DIV4);
SPI.setDataMode(SPCR & SPI_MODE_MASK);
SPCR &= ~(_BV(DORD));
SPI.setClockDivider( SPCR & SPI_CLOCK_MASK);
delay(10);
}

需要网卡的时候enableETH,需要NFC的时候启用enablePN,完美解决。

 

 

完整测试代码如下:

/* Web Server
* A simple web server that shows the value of the analog input pins.
*/

 

#include <SPI.h>
#include <Ethernet.h>
#include <PN532.h>
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };

byte ip[] = { 192, 168, 1, 15 };

EthernetServer server(80);
#define NFC_DEMO_DEBUG 1
#define PN532_CS 5
PN532 nfc(PN532_CS);

void initNFC()
{
#ifdef NFC_DEMO_DEBUG
Serial.println(“Begin start NFC!”);
#endif
nfc.begin();

uint32_t versiondata = nfc.getFirmwareVersion();
if (! versiondata) {
#ifdef NFC_DEMO_DEBUG
Serial.print(“Didn’t find PN53x board”);
#endif
//while (1); // halt
return;
// skip NFC, continue other step without NFC
}
#ifdef NFC_DEMO_DEBUG
// Got ok data, print it out!
Serial.print(“Found chip PN5”);
Serial.println((versiondata>>24) & 0xFF, HEX);
Serial.print(“Firmware ver. “);
Serial.print((versiondata>>16) & 0xFF, DEC);
Serial.print(‘.’);
Serial.println((versiondata>>8) & 0xFF, DEC);
Serial.print(“Supports “);
Serial.println(versiondata & 0xFF, HEX);
#endif
// configure board to read RFID tags and cards
nfc.SAMConfig();
}
void NFCReading()
{
uint32_t id;
// look for MiFare type cards
id = nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A);

if (id != 0) {
#ifdef NFC_DEMO_DEBUG
Serial.print(“Read card #”);
Serial.println(id);
#endif
}
}
void WebPrint(EthernetClient client)
{

if (client) {
// an http request ends with a blank line
boolean current_line_is_blank = true;
while (client.connected()) {
if (client.available()) {
char c = client.read();
// if we’ve gotten to the end of the line (received a newline
// character) and the line is blank, the http request has ended,
// so we can send a reply
if (c == ‘\n’ && current_line_is_blank) {
// send a standard http response header
client.println(“HTTP/1.1 200 OK”);
client.println(“Content-Type: text/html”);
client.println();

// output the value of each analog input pin
client.print(“welcome to tinyos”);
client.println(“<br />”);
client.print(“//*************************************”);
client.println(“<br />”);
client.print(“www.tinyos.net.cn”);
client.println(“<br />”);
client.print(“//*************************************”);
client.println(“<br />”);
for (int i = 0; i < 6; i++) {
client.print(“analog input “);
client.print(i);
client.print(” is “);
client.print(analogRead(i));
client.println(“<br />”);
}
break;
}
if (c == ‘\n’) {
// we’re starting a new line
current_line_is_blank = true;
} else if (c != ‘\r’) {
// we’ve gotten a character on the current line
current_line_is_blank = false;
}
}
}
client.stop();
}
}
#define ETH_SS 10
#define NFC_SS 5
void enablePN() {
digitalWrite(ETH_SS, HIGH);
digitalWrite(NFC_SS, LOW);
SPI.setDataMode(SPI_MODE0);
SPI.setBitOrder(LSBFIRST);
SPI.setClockDivider(SPI_CLOCK_DIV16);
delay(10);
}

void enableETH() {
digitalWrite(ETH_SS, LOW);
digitalWrite(NFC_SS, HIGH);
SPI.setBitOrder(MSBFIRST);
SPI.setClockDivider(SPI_CLOCK_DIV4);
SPI.setDataMode(SPCR & SPI_MODE_MASK);
SPCR &= ~(_BV(DORD));
SPI.setClockDivider( SPCR & SPI_CLOCK_MASK);
delay(10);
}
void setup()
{
Serial.begin(9600);
pinMode(10, OUTPUT);
pinMode(5, OUTPUT);
pinMode(4, OUTPUT);
enableETH();
Ethernet.begin(mac, ip);
server.begin();
Serial.print(“server is at “);
Serial.println(Ethernet.localIP());
enablePN();
initNFC();
//digitalWrite(5,HIGH);
//digitalWrite(10,LOW);
}

void loop()
{
// pinMode(4,HIGH);
//digitalWrite(5,HIGH);
//digitalWrite(10,LOW);
enableETH();
EthernetClient client = server.available();
WebPrint(client);
enablePN();
//delay(100);
//digitalWrite(5,HIGH);
//digitalWrite(10,LOW);
NFCReading();
//delay(100);
}

 

后记:通过这种方式实现了网络、NFC、SD卡读写的协同工作。