<repo_name>Hatsune39/raspberryPi<file_sep>/installations/pi-setup-lirc.sh
#! /bin/bash

sudo apt update

sudo apt install -y lirc

sudo sed -i 's/DRIVER="UNCONFIGURED"/DRIVER="default"/g' /etc/lirc/hardware.conf
sudo sed -i 's/DEVICE=""/DEVICE="\/dev\/lirc0"/g' /etc/lirc/hardware.conf
sudo sed -i 's/MODULES=""/MODULES="lirc-rpi"/g' /etc/lirc/hardware.conf

# enable  lirc-rpi
sudo sed -i 's/#dtoverlay=lirc-rpi/dtoverlay=lirc-rpi,gpio_in_pin=24,gpio_out_pin=10/g' /boot/config.txt

# record
# irrecord -d /dev/lirc0 ~/lircd.conf

cd ~
wget https://github.com/newnius/raspberryPi/raw/master/installations/lircd.conf
sudo mv ~/lircd.conf /etc/lirc/lircd.conf

# add .lircrc events
wget https://github.com/newnius/raspberryPi/raw/master/installations/.lircrc

sudo reboot
# irexec -d
<file_sep>/sensors/distance.py
#!/usr/bin/python
#-*- coding: utf-8 -*-
# HC-SR04超声波传感器

import time
import RPi.GPIO as GPIO
import os

GPIO.setmode(GPIO.BCM) #使用BCM编码方式
#定义引脚
GPIO_ECHO = 22
GPIO_TRIGGER = 23

#设置引脚为输入和输出
GPIO.setwarnings(False)
GPIO.setup(GPIO_TRIGGER, GPIO.OUT)
GPIO.setup(GPIO_ECHO, GPIO.IN)

def detect():
  GPIO.output(GPIO_TRIGGER, False)
  time.sleep(0.5)

  GPIO.output(GPIO_TRIGGER, True)
  time.sleep(0.00001)

  GPIO.output(GPIO_TRIGGER, False)

  start = time.time()
  while(GPIO.input(GPIO_ECHO))==0: #当有障碍物时，传感器输出低电平，所以检测低电平
    start = time.time()

  while(GPIO.input(GPIO_ECHO))==1: #当有障碍物时，传感器输出低电平，所以检测低电平
    stop = time.time()

  elapsed = stop-start   #计算一共花费多长时间  
  distance = elapsed * 34300  #计算距离，就是时间乘以声速  
  distance = distance / 2  #除以2得到一次的距离而不是来回的距离  
  print "Distance : %.1fcm" % distance  

while True:
  detect()
  time.sleep(1)

GPIO.cleanup()
<file_sep>/installations/os_install.md
# OS install

Based on MacOS

## Format SD card

download [SD Memory Card Formatter](https://www.sdcard.org/downloads/formatter/)

and format the SD card

## Download rasbian img file

download from [Raspbian Download Page](https://www.raspberrypi.org/downloads/raspbian/)

## Unmount SD card

```bash
# use `diskutil list` to see disk name
diskutil unmountDisk /dev/disk2
```

## dd img to SD card

```bash
sudo dd if=raspbian-stretch-lite.img of=/dev/rdisk2 bs=1m;sync
```

*use rdisk to boost, or it would takes rather a long time to write the image*

## Create ssh dir to enable ssh service

Create a dir named `ssh` under the root dir of SD card to enable ssh service

## Eject SD card

```bash
diskutil eject /dev/
```

## Update mirror (if necessary)

A full list of mirrors located at [Raspbian Mirrors](https://www.raspbian.org/RaspbianMirrors)

```
# /etc/apt/sources.list
deb https://mirrors.ustc.edu.cn/raspbian/raspbian/ stretch main contrib non-free rpi

# /etc/apt/sources.list.d/raspi.list
deb https://archive.raspberrypi.org/debian/ stretch main ui
```

*use ssl to get rid of `Hash Sum mismatch`. I hate the ICPs!*

## How to find the ip address

### By a monitor which supports HDMI

### Scan the network with nmap

### In the router management panel

## Ref

[MacOS下树莓派烧录img/iso文件到SD卡](https://www.jianshu.com/p/e95c406badaa)

[解决macOS使用dd指令写入/读取速度过慢的问题](https://zhuanlan.zhihu.com/p/34603784)

[系列 - 树莓派装机（二）](https://www.barretlee.com/blog/2018/06/14/rasyberry-pi-os/)

<file_sep>/cloudflared/install.sh
#!/bin/bash

# setup DoH

# install 32bit architecture
# see https://forum.armbian.com/topic/4764-running-32-bit-applications-on-aarch64/
dpkg --add-architecture armhf

apt-get update

apt-get install libc6:armhf libstdc++6:armhf

wget -O cloudflared.tgz https://bin.equinox.io/c/VdrWdbjqyF/cloudflared-stable-linux-arm.tgz \
  && tar -xzvf cloudflared.tgz \
  && rm cloudflared.tgz

./cloudflared
<file_sep>/sensors/climbing.py
#!/usr/bin/python
#-*- coding: utf-8 -*-

# 倾斜传感器模块

import time
import RPi.GPIO as GPIO
import os

GPIO.setmode(GPIO.BCM) #使用BCM编码方式

#定义引脚
GPIO_1 = 1
GPIO_2 = 2
GPIO_3 = 3
GPIO_4 = 4
GPIO_16 = 16
GPIO_21 = 21
GPIO_22 = 22
GPIO_23 = 23
GPIO_24 = 24
led = 21

#设置引脚为输入和输出
GPIO.setwarnings(False)

#设置23针脚为输入，接到红外避障传感器模块的out引脚
#GPIO.setup(GPIO_23,GPIO.IN)
GPIO.setup(GPIO_22,GPIO.IN)


def warn():   #亮灯来作为有障碍物时发出的警告  
#    GPIO.output(led,GPIO.HIGH)  
#    time.sleep(0.5)
#    GPIO.output(led,GPIO.LOW)
     time.sleep(0.5)
     print "warn"

while True:
    if(GPIO.input(GPIO_22)==0): #当有障碍物时，传感器输出低电平，所以检测低电平
      print "climbing"
    time.sleep(0.5)
GPIO.cleanup()
<file_sep>/sensors/16种传感器套件/DS1302实时时钟模块/DS1302 Experiment PIC/DS1302.C
/********************************************************
实验十九:   DS1302时钟芯片实验
说明:       因为该型号开发板只有四位数码管，
                为了方便看到实验效果只显示分与秒
实验现象:   数码管上显示分与秒 
          
CPU型号:    PIC16F877A
时钟:       4MHZ

日期：     2010-12-2
联系方法:   CJMCU
 ********************************************************/

#include <pic.h>	//调用头文件
__CONFIG(0x3F32);       //芯片配置字

#define	uchar  unsigned	char
#define     uint   unsigned         int

//联接DS1302的端口定义
#define ds1302_rst  RC2                      //定义1302的RST接在PC4
#define ds1302_io   RC1                      //定义1302的IO接在PC3
#define ds1302_sclk RC0                      //定义1302的时钟接在PC2
#define set_ds1302_rst_ddr() TRISC2=0        //复位端置为输出 
#define set_ds1302_rst() ds1302_rst=1        //复位端置1
#define clr_ds1302_rst() ds1302_rst=0        //复位端清0
#define set_ds1302_io_ddr() TRISC1=0         //数据端置为输出
#define set_ds1302_io() ds1302_io=1          //数据端置1
#define clr_ds1302_io() ds1302_io=0          //数据端清0

#define clr_ds1302_io_ddr() TRISC1=1         //数据端置为输入
#define in_ds1302_io() PORTC&0X02            //数据端输入数据
#define set_ds1302_sclk_ddr() TRISC0=0       //时钟端置为输出
#define set_ds1302_sclk() ds1302_sclk=1      //时钟端置1
#define clr_ds1302_sclk() ds1302_sclk=0      //时钟端清0


#define ds1302_sec_add 0x80                  //秒数据地址
#define ds1302_min_add 0x82                  //分数据地址
#define ds1302_hr_add 0x84                   //时数据地址
#define ds1302_date_add 0x86                 //日数据地址
#define ds1302_month_add 0x88                //月数据地址
#define ds1302_day_add 0x8a                  //星期数据地址
#define ds1302_year_add 0x8c                 //年数据地址
#define ds1302_control_add 0x8e              //控制数据地址
#define ds1302_charger_add 0x90       
#define ds1302_clkburst_add 0xbe

uchar timer[8];    //时钟数据

//共阴数码管0-F显示代码
uchar Table[]={0xc0,0xf9,0xa4,0xb0,0x99,
               0x92,0x82,0xf8,0x80,0x90,0xff};      
//转换后的显示数据
uchar s[4];
//定义扫描计数器
uchar sel=0;
uchar temp_pa=0xFF;
/*************************************
*         DS1302操作函数组    *
*************************************/
//写入1302数据函数：
//入口：add为写入地址码，data为写入数据
//返回：无
void ds1302_write(uchar add,uchar data) 
{ 
     uchar i=0; 
     set_ds1302_io_ddr();     //配置IO为输出
     NOP();NOP();  
     clr_ds1302_rst();        //清复位，停止所有操作
     NOP();NOP();  
     clr_ds1302_sclk();       //清时钟，准备操作
     NOP();NOP();  
     set_ds1302_rst();        //置复位，开始操作
     NOP();NOP();  
     for(i=8;i>0;i--)         //此循环写入控制码
     { 
         if(add&0x01)
         set_ds1302_io();     //当前位为1，置数据位
         else
         clr_ds1302_io();     //当前位为0，清数据位
         NOP();NOP();  
         set_ds1302_sclk();   //产生时钟脉冲，写入数据
         NOP();NOP();  
         clr_ds1302_sclk(); 
         NOP();NOP();  
         add>>=1;             //移位，准备写入下1位
      } 
     for(i=8;i>0;i--)         //此循环写入数据码 
     { 
         if(data&0x01)
         set_ds1302_io(); 
         else
         clr_ds1302_io(); 
         NOP();NOP(); 
         set_ds1302_sclk(); 
         NOP();NOP();  
         clr_ds1302_sclk(); 
         NOP();NOP();  
         data>>=1; 
     } 
     clr_ds1302_rst(); 
     NOP();NOP();  
     clr_ds1302_io_ddr();      //清输出状态
     NOP();NOP();  
}
//从1302中读出数据：
//入口：add为读数据所在地址
//返回：读出的数据data
uchar ds1302_read(uchar add) 
{ 
      uchar data=0; 
      uchar i=0; 
      add+=1;                //读标志 
      set_ds1302_io_ddr();   //端口输出 
      NOP();NOP(); 
      clr_ds1302_rst();      //清复位 
      NOP();NOP(); 
      clr_ds1302_sclk();     //清时钟
      NOP();NOP();  
      set_ds1302_rst();      //置复位
      NOP();NOP(); 
      for(i=8;i>0;i--)       //此循环写入地址码
      { 
          if(add&0x01)
          {set_ds1302_io();} 
          else
          {clr_ds1302_io();}
  
          NOP();NOP(); 
          set_ds1302_sclk(); 
          NOP();NOP();  
          clr_ds1302_sclk(); 
          NOP();NOP(); 
          add>>=1; 
       } 
       clr_ds1302_io_ddr();    //端口输入
       NOP();NOP(); 
       for(i=8;i>0;i--)        //此循环读出1302的数据
       { 
          data>>=1; 
          if(in_ds1302_io())
          {data|=0x80;}
          NOP();NOP(); 
          set_ds1302_sclk(); 
          NOP();NOP(); 
          clr_ds1302_sclk(); 
          NOP();NOP(); 
       } 
       clr_ds1302_rst(); 
       NOP();NOP();
       return(data); 
} 
//检查1302状态
uchar check_ds1302(void) 
{ 
     ds1302_write(ds1302_control_add,0x80); 
     if(ds1302_read(ds1302_control_add)==0x80) 
     return 1; 
     return 0; 
} 
//向1302中写入时钟数据
void ds1302_write_time(void) 
{ 
     ds1302_write(ds1302_control_add,0x00);    //关闭写保护 
     ds1302_write(ds1302_sec_add,0x80);        //暂停 
     ds1302_write(ds1302_charger_add,0xa9);    //涓流充电 
     ds1302_write(ds1302_year_add,timer[1]);   //年 
     ds1302_write(ds1302_month_add,timer[2]);  //月 
     ds1302_write(ds1302_date_add,timer[3]);   //日 
     ds1302_write(ds1302_day_add,timer[7]);    //周 
     ds1302_write(ds1302_hr_add,timer[4]);     //时 
     ds1302_write(ds1302_min_add,timer[5]);    //分 
     ds1302_write(ds1302_sec_add,timer[6]);    //秒 
     ds1302_write(ds1302_control_add,0x80);    //打开写保护 
}
//从1302中读出当前时钟
void ds1302_read_time(void) 
{ 
     timer[1]=ds1302_read(ds1302_year_add);    //年 
     timer[2]=ds1302_read(ds1302_month_add);   //月 
     timer[3]=ds1302_read(ds1302_date_add);    //日 
     timer[7]=ds1302_read(ds1302_day_add);     //周 
     timer[4]=ds1302_read(ds1302_hr_add);      //时 
     timer[5]=ds1302_read(ds1302_min_add);     //分 
     timer[6]=ds1302_read(ds1302_sec_add);     //秒 
}


//延时函数1
void delay_us(uchar i)
{
     for(;i;i--);    
}
   
//延时函数2
void delay(uint i)  
{
     uchar j;
     for(;i;i--)
     for(j=220;j;j--);    
}
	

void timer0_init(void)
{
     OPTION=0x07;     //TMR0----256分频
     INTCON=0XA0;     //开总中断及TMR0计数溢出断
     TMR0=0xE8;       //定时器初值
}

/* 定时器0中断入口函数 */

void interrupt TMR0INT()
{
     T0IF=0;
     TMR0=0xE8;	 
     PORTD=0xff;      //先关显示
	 PORTA=0XDF;
	 PORTD=s[sel];
	 switch(sel)
	 {
		case 0x00: PORTA=0X1D;break;
		           
	    case 0x01: PORTA=0X1B;break;
		           
	    case 0x02: PORTA=0X17;break;
		           
		case 0x03: PORTA=0X0F;break;           
	 }
     if(++sel>3)sel=0;   
     
}
//显示数据转换函数
void Process(void)//(uint i)
{
     s[3]=Table[(timer[5]&0xF0)>>4];
     s[2]=Table[(timer[5]&0x0F)]&0x7F;  //初始化显示数据，并将时分之间加小数点
     s[1]=Table[(timer[6]&0xF0)>>4];
     s[0]=Table[(timer[6]&0x0F)];
}
   
//主函数
void main(void)
{
     uint n,m=0;
     TRISA=0x00;          //设置按键A口为带上拉输入；
     PORTA=0xDF;

     TRISD=0x00;
     PORTD=0XFF;
     TRISE=0X03;
     PORTE=0X05;
     PORTE=0X00;   
	 
	 TRISC=0x00;          //定义C口为输出
     PORTC=0xff;

     timer[1]=0x09;   //年
     timer[2]=0x08;   //月
     timer[3]=0x20;   //日
     timer[4]=0x12;   //时
     timer[5]=0x12;   //分
     timer[6]=0x00;   //秒
     timer[7]=0x04;   //周
     ds1302_write_time();    //写入初始时钟
   
     timer0_init();          //设定定时器0

     while(1)
     {
     ds1302_read_time();     //读出当前时钟
     Process();              //显示数据转换
     delay(100);             //每100MS读一次
	 }
}

<file_sep>/sensors/16种传感器套件/DS1302实时时钟模块/DS1302实时时钟实验(ATMEGA128A）/DS1302.C


/********************************************************
实验十九:   DS1302时钟芯片实验
说明:       
            显示时 分 秒
实验现象:   数码管上显示分与秒 
          
CPU型号:  ATMEGA128A
时钟:     8MHZ
日期：    2011-3-17
联系方法: CJMCU
 ********************************************************/
#include <iom128v.h>
#include <macros.h>

//联接DS1302的端口定义
#define ds1302_rst PE4         //定义1302的RST接在PC4
#define ds1302_io PE3         //定义1302的IO接在PC3
#define ds1302_sclk PE2        //定义1302的时钟接在PC2
#define set_ds1302_rst_ddr() DDRE|=1<<ds1302_rst     //复位端置为输出 
#define set_ds1302_rst() PORTE|=1<<ds1302_rst    //复位端置1
#define clr_ds1302_rst() PORTE&=~(1<<ds1302_rst)   //复位端清0
#define set_ds1302_io_ddr() DDRE|=1<<ds1302_io    //数据端置为输出
#define set_ds1302_io() PORTE|=1<<ds1302_io    //数据端置1
#define clr_ds1302_io() PORTE&=~(1<<ds1302_io)    //数据端清0
#define clr_ds1302_io_ddr() DDRE&=~(1<<ds1302_io)   //数据端置为输入
#define in_ds1302_io() PINE&(1<<ds1302_io)     //数据端输入数据
#define set_ds1302_sclk_ddr() DDRE|=1<<ds1302_sclk   //时钟端置为输出
#define set_ds1302_sclk() PORTE|=1<<ds1302_sclk   //时钟端置1
#define clr_ds1302_sclk() PORTE &=~(1<<ds1302_sclk)  //时钟端清0
#define ds1302_sec_add 0x80        //秒数据地址
#define ds1302_min_add 0x82        //分数据地址
#define ds1302_hr_add 0x84         //时数据地址
#define ds1302_date_add 0x86        //日数据地址
#define ds1302_month_add 0x88        //月数据地址
#define ds1302_day_add 0x8a        //星期数据地址
#define ds1302_year_add 0x8c        //年数据地址
#define ds1302_control_add 0x8e       //控制数据地址
#define ds1302_charger_add 0x90       
#define ds1302_clkburst_add 0xbe
//简化宏定义
#define uchar unsigned char
#define uint unsigned int
//全局变量定义
uchar timer[8];    //时钟数据

//共阴数码管0-F显示代码
uchar Table[]={0xc0,0xf9,0xa4,0xb0,0x99,
               0x92,0x82,0xf8,0x80,0x90,0xff};      
//转换后的显示数据
uchar s[6];
//定义扫描计数器
uchar sel=0;
uchar temp_pa=0xFF;
/*************************************
*         DS1302操作函数组    *
*************************************/
//写入1302数据函数：
//入口：add为写入地址码，data为写入数据
//返回：无
void ds1302_write(uchar add,uchar data) 
{ 
     uchar i=0; 
     set_ds1302_io_ddr();     //配置IO为输出
     delay_us(20); 
     clr_ds1302_rst();        //清复位，停止所有操作
     delay_us(20);  
     clr_ds1302_sclk();       //清时钟，准备操作
     delay_us(20);  
     set_ds1302_rst();        //置复位，开始操作
     delay_us(20);  
     for(i=8;i>0;i--)         //此循环写入控制码
     { 
         if(add&0x01)
         set_ds1302_io();     //当前位为1，置数据位
         else
         clr_ds1302_io();     //当前位为0，清数据位
         delay_us(20);  
         set_ds1302_sclk();   //产生时钟脉冲，写入数据
         NOP();NOP();NOP();  
         clr_ds1302_sclk(); 
         delay_us(20);  
         add>>=1;             //移位，准备写入下1位
      } 
     for(i=8;i>0;i--)         //此循环写入数据码 
     { 
         if(data&0x01)
         set_ds1302_io(); 
         else
         clr_ds1302_io(); 
         delay_us(20); 
         set_ds1302_sclk(); 
         delay_us(20);  
         clr_ds1302_sclk(); 
         delay_us(20);  
         data>>=1; 
     } 
     clr_ds1302_rst(); 
     delay_us(20); 
     clr_ds1302_io_ddr();      //清输出状态
     delay_us(20);  
}
//从1302中读出数据：
//入口：add为读数据所在地址
//返回：读出的数据data
uchar ds1302_read(uchar add) 
{ 
      uchar data=0; 
      uchar i=0; 
      add+=1;                  //读标志 
      set_ds1302_io_ddr();     //端口输出 
      delay_us(20);
      clr_ds1302_rst();        //清复位 
      delay_us(20); 
      clr_ds1302_sclk();       //清时钟
      delay_us(20);  
      set_ds1302_rst();        //置复位
      delay_us(20);
      for(i=8;i>0;i--)         //此循环写入地址码
      { 
          if(add&0x01)
          {set_ds1302_io();} 
          else
          {clr_ds1302_io();}
  
          delay_us(20);
          set_ds1302_sclk(); 
          delay_us(20); 
          clr_ds1302_sclk(); 
          delay_us(20);
          add>>=1; 
       } 
       clr_ds1302_io_ddr();      //端口输入
       delay_us(20);
       for(i=8;i>0;i--)          //此循环读出1302的数据
       { 
          data>>=1; 
          if(in_ds1302_io())
          {data|=0x80;}
          delay_us(20);
          set_ds1302_sclk(); 
          delay_us(20);
          clr_ds1302_sclk(); 
          delay_us(20);
       } 
       clr_ds1302_rst(); 
       delay_us(20);
       return(data); 
} 
//检查1302状态
uchar check_ds1302(void) 
{ 
     ds1302_write(ds1302_control_add,0x80); 
     if(ds1302_read(ds1302_control_add)==0x80) 
     return 1; 
     return 0; 
} 
//向1302中写入时钟数据
void ds1302_write_time(void) 
{ 
     ds1302_write(ds1302_control_add,0x00);   //关闭写保护 
     ds1302_write(ds1302_sec_add,0x80);       //暂停 
     ds1302_write(ds1302_charger_add,0xa9);   //涓流充电 
     ds1302_write(ds1302_year_add,timer[1]);  //年 
     ds1302_write(ds1302_month_add,timer[2]); //月 
     ds1302_write(ds1302_date_add,timer[3]);  //日 
     ds1302_write(ds1302_day_add,timer[7]);   //周 
     ds1302_write(ds1302_hr_add,timer[4]);    //时 
     ds1302_write(ds1302_min_add,timer[5]);   //分 
     ds1302_write(ds1302_sec_add,timer[6]);   //秒 
     ds1302_write(ds1302_control_add,0x80);   //打开写保护 
}
//从1302中读出当前时钟
void ds1302_read_time(void) 
{ 
     timer[1]=ds1302_read(ds1302_year_add);   //年 
     timer[2]=ds1302_read(ds1302_month_add);  //月 
     timer[3]=ds1302_read(ds1302_date_add);   //日 
     timer[7]=ds1302_read(ds1302_day_add);    //周 
     timer[4]=ds1302_read(ds1302_hr_add);     //时 
     timer[5]=ds1302_read(ds1302_min_add);    //分 
     timer[6]=ds1302_read(ds1302_sec_add);    //秒 
}

/**************************************
*           扫描显示函数组     *
**************************************/
//延时函数1
void delay_us(uchar i)
{
     for(;i;i--);    
}
   
//延时函数2
void delay(uint i)                          //在1M时钟下为i ms
{
     uchar j;
     for(;i;i--)
     for(j=220;j;j--);    
}
	
/* 定时器0中断配置函数
预分频数:256
定时时间: 5mSec
实际时间:  4.864mSec (2.7%)
功能：用于LED数码管显示扫描*/ 
void timer0_init(void)
{
     TCNT0 = 0xED;     //装初值
	 TCNT0 = 0x00;     //装初值
	 OCR0  = 0x13;   //这个是比较值？
     TCCR0 = 0x04;     //启动定时器
}

/* 定时器0中断入口函数 */
#pragma interrupt_handler timer0_ovf_isr:17
void timer0_ovf_isr(void)
{
     TCNT0 = 0xED;    //重装初值

	 PORTC=0xff;      //先关显示
	 PORTA=0X00;
	 PORTC=s[sel];
	 switch(sel)
	 {
		case 0x00: PORTA=0X80;break;
		           
	    case 0x01: PORTA=0X40;break;
		           
	    case 0x02: PORTA=0X20;break;
		           
		case 0x03: PORTA=0X10;break;
		
		case 0x04: PORTA=0X08;break;
		
		case 0x05: PORTA=0X04;break;           
	 }
     if(++sel>5)sel=0;   
} 
//显示数据转换函数
void Process(void)//(uint i)
{
     s[5]=Table[(timer[4]&0xf0)>>4];
	 s[4]=Table[(timer[4]&0x0F)]&0x7F;
	 
	 s[3]=Table[(timer[5]&0xF0)>>4];
     s[2]=Table[(timer[5]&0x0F)]&0x7F;  //初始化显示数据，并将时分之间加小数点
     
	 s[1]=Table[(timer[6]&0xF0)>>4];
     s[0]=Table[(timer[6]&0x0F)];
}
   
//主函数
void main(void)
{
     uint n,m=0;
     DDRA=0xff;          //设置按键A口为带上拉输入；
     PORTA=0xFF;
     DDRE=0xff;
     PORTE=0X1C;
	 	 
	 DDRC=0xff;          //定义B口为输出
     PORTC=0xff;
	 
	 DDRF|=0X0E;
	 PORTF|=0X0E;
	 PORTF &=~BIT(3);
     PORTA=0XFF;
	
	 DDRB |=0X10;           //PB4设为输出
	 PORTB|=0X10;           //关闭PB4外接的LED
	 
     timer[1]=0x11;      //年
     timer[2]=0x03;      //月
     timer[3]=0x20;      //日
     timer[4]=0x12;      //时
     timer[5]=0x00;      //分
     timer[6]=0x00;      //秒
     timer[7]=0x00;      //周
	 delay(200);
     ds1302_write_time(); //写入初始时钟
     delay(100);
     CLI();               //先关闭所有中断

     timer0_init();       //设定定时器0

     MCUCR = 0x00;
     TIMSK = 0x05;        //允许定时器0、定时器1中断
     SEI();               //开总中断
 
     while(1)
     {
     ds1302_read_time();  //读出当前时钟
     Process();           //显示数据转换
     delay(500);          //每100MS读一次
	 }
}

<file_sep>/sensors/16种传感器套件/DS1302实时时钟模块/DS1302实时时钟实验(ATMEGA128A）/DS1302.mak
CC = iccavr
LIB = ilibw
CFLAGS =  -e -D__ICC_VERSION=722 -DATMega128  -l -g -MLongJump -MHasMul -MEnhanced -Wf-use_elpm 
ASFLAGS = $(CFLAGS) 
LFLAGS =  -g -e:0x20000 -ucrtatmega.o -bfunc_lit:0x8c.0x20000 -dram_end:0x10ff -bdata:0x100.0x10ff -dhwstk_size:30 -beeprom:0.4096 -fihx_coff -S2
FILES = DS1302.o 

DS1302:	$(FILES)
	$(CC) -o DS1302 $(LFLAGS) @DS1302.lk   -lcatm128
DS1302.o: C:\iccv7avr\include\iom128v.h C:\iccv7avr\include\macros.h C:\iccv7avr\include\AVRdef.h
DS1302.o:	..\..\..\BK-AVR~1\BK-AVR128配套实验程序\实1C23~1\DS1302.C
	$(CC) -c $(CFLAGS) ..\..\..\BK-AVR~1\BK-AVR128配套实验程序\实1C23~1\DS1302.C
<file_sep>/sensors/obstacle-detect.py
#!/usr/bin/python
#-*- coding: utf-8 -*-
# 避障传感器 壁障小车 黑白线识别

import time
import RPi.GPIO as GPIO
import os

GPIO.setmode(GPIO.BCM) #使用BCM编码方式
#定义引脚
GPIO_1 = 1
GPIO_2 = 2
GPIO_3 = 3
GPIO_4 = 4
GPIO_16 = 16
GPIO_21 = 21
GPIO_23 = 23
GPIO_24 = 24

led = 21
#设置引脚为输入和输出
GPIO.setwarnings(False)
#设置23针脚为输入，接到红外避障传感器模块的out引脚
GPIO.setup(GPIO_23,GPIO.IN)

#GPIO.setup(led,GPIO.OUT)

def warn():   #亮灯来作为有障碍物时发出的警告
#    GPIO.output(led,GPIO.HIGH)
#    time.sleep(0.5)
#    GPIO.output(led,GPIO.LOW)
     time.sleep(0.5)
     print "warn"

while True:
    #GPIO.input(GPIO_23)==0: #当有障碍物时，传感器输出低电平，所以检测低电平
    print GPIO.input(GPIO_23) #当有障碍物时，传感器输出低电平，所以检测低电平
GPIO.cleanup()
<file_sep>/installations/pi-setup-player.sh
#! /bin/bash

# sudo apt-get update

# install mplyer
sudo apt install -y mplayer2

# level up USB audio card
# this conf file is in /etc/modprobe.d/alsa-base.conf if not Raspbian Jessie
# http://5aimiku.com/archives/400.html 
sudo sed -i "s/options snd-usb-audio index=-2/options snd-usb-audio index=0/g" /lib/modprobe.d/aliases.conf

echo "need reboot"
<file_sep>/usr/local/services.sh
#! /bin/bash

# login to p.nju.edu.cn
nohup python /usr/local/pnju.py &

# run fan control
nohup python /usr/local/fan.py &

# start frp
nohup /usr/local/frp/frpc -c /usr/local/frp/frpc.ini &

# start DoH to fuck GFW
nohup /usr/local/cloudflared proxy-dns --port 15353 &

# start global vpn service
nohup bash /usr/local/global_vpn.sh &
<file_sep>/sensors/test.py
#!/usr/bin/python
#-*- coding: utf-8 -*-
import time
import RPi.GPIO as GPIO
import os

GPIO.setmode(GPIO.BCM) #使用BCM编码方式
#定义引脚
GPIO_OUT = 5
led = 4
#设置引脚为输入和输出
GPIO.setwarnings(False) 
#设置23针脚为输入，接到红外避障传感器模块的out引脚
GPIO.setup(GPIO_OUT,GPIO.IN) 
GPIO.setup(led,GPIO.OUT)     



GPIO.output(led,GPIO.LOW)
time.sleep(5)

def warn():   #亮灯来作为有障碍物时发出的警告
	GPIO.output(led,GPIO.HIGH)
	time.sleep(0.5)
	GPIO.output(led,GPIO.LOW)
	time.sleep(0.5)
		
#while True:
#	if GPIO.input(GPIO_OUT)==0: #当有障碍物时，传感器输出低电平，所以检测低电平
#		warn()


GPIO.cleanup()
<file_sep>/etc/rc.local
#!/bin/sh -e
#
# rc.local
#
# This script is executed at the end of each multiuser runlevel.
# Make sure that the script will "" on success or any other
# value on error.
#
# In order to enable or disable this script just change the execution
# bits.
#
# By default this script does nothing.

# Print the IP address
_IP=$(hostname -I) || true
if [ "$_IP" ]; then
  printf "My IP address is %s\n" "$_IP"
fi


ifconfig wlan0 down
ifconfig wlan0 192.168.68.1 netmask 255.255.255.0 up
iwconfig wlan0 power off
service dnsmasq restart
hostapd -B /etc/hostapd/hostapd.conf & > /dev/null 2>&1
sudo iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE  
sudo iptables -A FORWARD -i eth0 -o wlan0 -m state --state RELATED,ESTABLISHED -j ACCEPT  
sudo iptables -A FORWARD -i wlan0 -o eth0 -j ACCEPT


bash /usr/local/services.sh


exit 0
<file_sep>/usr/local/global_vpn.sh
#!/bin/bash

# restore Chineses IPs
ipset restore < /etc/chnroute.ipset

# add iptables chain
iptables -t nat -N SHADOWSOCKS

# exclude your own vps IPs

# exclude CloudFlare IPs
iptables -t nat -A SHADOWSOCKS -d 192.168.3.11/20 -j RETURN
iptables -t nat -A SHADOWSOCKS -d 192.168.3.11/22 -j RETURN
iptables -t nat -A SHADOWSOCKS -d 192.168.3.11/22 -j RETURN
iptables -t nat -A SHADOWSOCKS -d 172.16.31.10/22 -j RETURN
iptables -t nat -A SHADOWSOCKS -d 172.16.31.10/18 -j RETURN
iptables -t nat -A SHADOWSOCKS -d 172.16.17.32/18 -j RETURN
iptables -t nat -A SHADOWSOCKS -d 172.16.58.3/20 -j RETURN
iptables -t nat -A SHADOWSOCKS -d 192.168.3.11/20 -j RETURN
iptables -t nat -A SHADOWSOCKS -d 192.168.127.12/22 -j RETURN
iptables -t nat -A SHADOWSOCKS -d 172.16.58.3/17 -j RETURN
iptables -t nat -A SHADOWSOCKS -d 192.168.3.11/15 -j RETURN
iptables -t nat -A SHADOWSOCKS -d 192.168.3.11/12 -j RETURN
iptables -t nat -A SHADOWSOCKS -d 172.16.31.10/13 -j RETURN
iptables -t nat -A SHADOWSOCKS -d 131.0.72.0/22 -j RETURN

# excluce intranet ips & Chinese IPs
iptables -t nat -A SHADOWSOCKS -d 0.0.0.0/8 -j RETURN
iptables -t nat -A SHADOWSOCKS -d 10.0.0.0/8 -j RETURN
iptables -t nat -A SHADOWSOCKS -d 127.0.0.0/8 -j RETURN
iptables -t nat -A SHADOWSOCKS -d 169.254.0.0/16 -j RETURN
iptables -t nat -A SHADOWSOCKS -d 172.16.0.0/12 -j RETURN
iptables -t nat -A SHADOWSOCKS -d 192.168.0.0/16 -j RETURN
iptables -t nat -A SHADOWSOCKS -d 192.168.127.12/4 -j RETURN
iptables -t nat -A SHADOWSOCKS -d 240.0.0.0/4 -j RETURN
iptables -t nat -A SHADOWSOCKS -m set --match-set chnroute dst -j RETURN

# redirect traffic to redsocks
iptables -t nat -A SHADOWSOCKS -p tcp -j REDIRECT --to-ports 12345

# redirect traffic to SHADOWSOCKS
iptables -t nat -A OUTPUT -p tcp -j SHADOWSOCKS
iptables -t nat -A PREROUTING -p tcp -j SHADOWSOCKS

# overide default dns ns of devices
iptables -t nat -A PREROUTING -p udp --dport 53 -j REDIRECT --to-ports 53
iptables -t nat -A PREROUTING -p tcp --dport 53 -j REDIRECT --to-ports 53

exit 0
<file_sep>/installations/apt_install.sh
#!/bin/bash

```bash
sudo apt install -y git vim curl wget httpie tree
```


<file_sep>/installations/pi-setup-LCD5.sh
#! /bin/bash

git clone https://github.com/goodtft/LCD-show.git

chmod -R 755 LCD-show

cd LCD-show/

sudo ./LCD5-show
<file_sep>/sensors/16种传感器套件/DS1302实时时钟模块/DS1302时钟实验（51单片机)/DS1302时钟芯片实验2.C


/***************************************************************************
实验十九:   DS1302时钟芯片实验

CPU型号:  AT89S52或兼容型号
系统时钟:   11.0592MHZ
编译环境:   keil uVision4
日期：      2009-8-2
联系方法:    CJMCU 
****************************************************************************/
/*********************************包含头文件********************************/
#include <reg52.h>
#include <intrins.h>
#define uchar unsigned char
/*********************************端口定义**********************************/
sbit DS1302_CLK = P1^0;
sbit DS1302_IO = P1^1;
sbit DS1302_RST = P1^2;

/*******************************共阳LED段码表*******************************/
uchar code LED_TAB[]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90};

/******************************定义全局变量*********************************/
uchar second,minute,hour,week,day,month,year;   
uchar time[]={0x09,0x08,0x15,0x03,0x12,0x12,0x00}; //初始时间数组

/****************************************************************************
函数功能:数码管扫描延时子程序
入口参数:
出口参数:
****************************************************************************/
void delay1(void)
{
     int k;
     for(k=0;k<400;k++);
}

/****************************************************************************
函数功能:数码管显示子程序
入口参数:k
出口参数:
****************************************************************************/
void display(void)
{
     P2=0x01;
     P0=LED_TAB[minute/16];
     delay1();

     P2=0x02;
     P0=LED_TAB[minute%16] & 0X7F;
     delay1();

     P2=0x04;
     P0=LED_TAB[second/16];
     delay1();

     P2=0x08;
     P0=LED_TAB[second%16];
     delay1();
}

/*****************************************************************************
函数功能:向DS1302送一字节数据子程序
入口参数:
出口参数:
*****************************************************************************/
void InputByte(uchar byte1)
{
     char i;
     for(i=8;i>0;i--)
     {
     DS1302_IO=(bit)(byte1&0x01);
     DS1302_CLK=1;
     _nop_();
     DS1302_CLK=0;
     byte1>>=1;
     }
     return;
}

/*****************************************************************************
函数功能:读DS1302一个字节子程序
入口参数:
出口参数:
*****************************************************************************/
uchar outputbyte(void) 
{
      uchar i;
      uchar ucdat=0;
      for(i=8;i>0;i--)
      {
      DS1302_IO=1;
      ucdat>>=1;
      if(DS1302_IO)ucdat|=0x80;
      DS1302_CLK=1;
      _nop_();
      DS1302_CLK=0;
      }
      return(ucdat);
}

/*****************************************************************************
函数功能:向DS1302某地址写一字节数据子程序
入口参数:addr,TDat
出口参数:
*****************************************************************************/
void write_ds1302(uchar addr,uchar TDat)
{
     DS1302_RST=0;
     _nop_();
     DS1302_CLK=0;
     _nop_();
     DS1302_RST=1;
     InputByte(addr);
     _nop_();
     InputByte(TDat);
     DS1302_CLK=1;
     _nop_();
     DS1302_RST=0;
}

/*****************************************************************************
函数功能:读DS1302地址子程序
入口参数:add
出口参数:timedata
*****************************************************************************/
uchar read_ds1302(uchar addr)
{
      uchar timedata;
      DS1302_RST=0;
      _nop_();
      DS1302_CLK=0;
      _nop_();
      DS1302_RST=1;
      InputByte(addr);
      timedata=OutputByte();
      DS1302_CLK=1;
      _nop_();
      DS1302_RST=0;
      return(timedata);
}

/*****************************************************************************
函数功能:初始化DS1302子程序
入口参数:time[](全局变量)
出口参数:
*****************************************************************************/
void initial_ds1302()
{
     write_ds1302(0x8e,0x00);      //写保护寄存器，在对时钟或RAM写前WP一定要为0
     write_ds1302(0x8c,time[0]);   //年
     write_ds1302(0x88,time[1]);   //月
     write_ds1302(0x86,time[2]);   //日
     write_ds1302(0x8A,time[3]);   //星期
     write_ds1302(0x84,time[4]);   //时
     write_ds1302(0x82,time[5]);   //分
     write_ds1302(0x80,time[6]);   //秒
     write_ds1302(0x8e,0x80);      //写保护寄存器
}

/*****************************************************************************
函数功能:读DS1302时间子程序
入口参数:
出口参数:全局变量(second,minute,hour,week,day,month,year)
*****************************************************************************/
void read_time()
{
     second=read_ds1302(0x81);   //秒寄存器
     minute=read_ds1302(0x83);   //分
     hour=read_ds1302(0x85);     //时
     week=read_ds1302(0x8B);     //星期
     day=read_ds1302(0x87);      //日
     month=read_ds1302(0x89);    //月
     year=read_ds1302(0x8d);     //年
}

/*****************************************************************************
函数功能:主程序
入口参数:
出口参数:
*****************************************************************************/
void main(void)
{
     initial_ds1302();     //初始化DS1302
     while(1)
     {
     read_time();          //读取时间
     display();            //显示时间
     }
}
<file_sep>/installations/pi-setup-wifi.sh
#! /bin/bash

sudo apt update

sudo apt install -y hostapd dnsmasq

sudo bash -c "cat >>/etc/dnsmasq.conf <<EOF
#this line existes to make sure below starts in a new line
interface=wlan0
dhcp-range=192.168.68.24,192.168.68.200,255.255.255.0,12h
EOF"

sudo bash -c "cat >/etc/hostapd/hostapd.conf <<EOF
interface=wlan0
hw_mode=g
channel=10
auth_algs=1
wpa=2
wpa_key_mgmt=WPA-PSK
wpa_pairwise=CCMP
rsn_pairwise=CCMP
wpa_passphrase=<PASSWORD>
ssid=SSID
EOF"

# enable ip_forward
sudo sed -i "s/#net.ipv4.ip_forward=[01]/net.ipv4.ip_forward=1/g" /etc/sysctl.conf

# open wifi on startup
sudo sed -i "s/exit 0//g" /etc/rc.local

sudo bash -c "cat >>/etc/rc.local <<EOF
ifconfig wlan0 down
ifconfig wlan0 192.168.68.1 netmask 255.255.255.0 up
iwconfig wlan0 power off
service dnsmasq restart
hostapd -B /etc/hostapd/hostapd.conf & > /dev/null 2>&1
sudo iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE  
sudo iptables -A FORWARD -i eth0 -o wlan0 -m state --state RELATED,ESTABLISHED -j ACCEPT  
sudo iptables -A FORWARD -i wlan0 -o eth0 -j ACCEPT

exit 0
EOF"

# sudo reboot
echo -e "now reboot to take effect"
<file_sep>/sensors/1.py
#!/usr/bin/python
#-*- coding: utf-8 -*-
import time
import RPi.GPIO as GPIO
import os

GPIO.setmode(GPIO.BCM) #使用BCM编码方式
#定义引脚
GPIO_1 = 1
GPIO_2 = 2
GPIO_3 = 4
GPIO_4 = 4
GPIO_14 = 14
GPIO_16 = 16
GPIO_21 = 21
GPIO_22 = 22
GPIO_23 = 23
GPIO_24 = 24

led = 21   
#设置引脚为输入和输出  
GPIO.setwarnings(False)   
#设置23针脚为输入，接到红外避障传感器模块的out引脚  
#GPIO.setup(GPIO_23,GPIO.IN)   
GPIO.setup(GPIO_14,GPIO.OUT)
#GPIO.setup(GPIO_24,GPIO.IN)

  
def warn():   #亮灯来作为有障碍物时发出的警告  
#    GPIO.output(led,GPIO.HIGH)  
#    time.sleep(0.5)
#    GPIO.output(led, GPIO.LOW)
     time.sleep(0.5)
     print "warn"
          
while True:  
    print "low"
    GPIO.output(GPIO_14, GPIO.LOW) #当有障碍物时，传感器输出低电平，所以检测低电平  
    time.sleep(15)
    print "high"
    GPIO.output(GPIO_14, GPIO.HIGH) #当有障碍物时，传感器输出低电平，所以检测低电平  
    time.sleep(15)

GPIO.cleanup()
<file_sep>/fan.py
#!/usr/bin/python
#-*- coding: utf-8 -*-
import time, os, datetime
import RPi.GPIO as GPIO

GPIO_OUT = 14
LOG_PATH = '/var/log/fan_control.log'
IS_DEBUG=False

def read_cpu_temperature():
  with open("/sys/class/thermal/thermal_zone0/temp", 'r') as f:
    temperature = float(f.read()) / 1000
  log('DEBUG', 'Current CPU temperature is %s' % temperature)
  return temperature

def start_fan():
  log('INFO', 'power on.')
  GPIO.output(GPIO_OUT, GPIO.HIGH)

def stop_fan():
  log('INFO', 'power off.')
  GPIO.output(GPIO_OUT, GPIO.LOW)
 
def setup_GPIO():
  GPIO.setmode(GPIO.BCM)
  GPIO.setwarnings(False)   
  GPIO.setup(GPIO_OUT, GPIO.OUT) 

def control_fan():
  is_close = True
  try:
    while True:
      temp = read_cpu_temperature()
      if is_close:
        if temp>=50:
          start_fan() 
          is_close = False
      else:
        if temp<=45:
          stop_fan()
          is_close = True    
      time.sleep(10)
  except Exception, e:
    GPIO.cleanup()
    log('WARN', e)

def log(level, msg):
  log_msg = '[%s]: %s (%s)' % (level, msg, datetime.datetime.now() )
  if IS_DEBUG:
    print log_msg
    return 
  if level == 'DEBUG':
    return
  try:
    with open(LOG_PATH, 'a') as f:
      f.write(log_msg+'\n')
  except Exception as e:
    print "Unable to log, %s" % e

if __name__ == '__main__':
  os.environ["TZ"] = 'Asia/Shanghai'
  time.tzset()
  log('INFO', 'started.')
  setup_GPIO()
  control_fan()
  log('INFO', 'quit.')
<file_sep>/README.md
# raspberryPi
raspberryPi related works

#### Note

All of these works are based on pi3 & Raspbian Jessie -> stretch
<file_sep>/sensors/README.md
## sensors detect & control scripts

### Pin of sensors
![Pin of sensors](sensors_list.jpg "Pin of sensors")
