树莓派上搭建自己的 python 开发环境

一般情况下,在烧录完镜像以后就可以直接在树莓派上通过 thony idle 去进行 python 的开发了.

但是用惯了 pycharm 和习惯了 vim 编程的我怎么可以直接用文本编辑器写代码呢?

效率完全没有了啊!

安装完镜像环境后,就可以在树莓派上开发了,为了开发opencv for python,我在树莓派上搭建了vim的python开发环境,除了配置.vimrc以外还要给各位小伙伴安利一款VIM python 自动补全插件:pydiction。

这是在纯shell环境下进行python编程的一款利器, 全屏编辑器结合这款利器各种 python 补全不再是问题。
pydiction可以实现下面python代码的自动补全:

简单python关键词补全
python 函数补全带括号
python 模块补全
python 模块内函数,变量补全
from module import sub-module 补全


  1. 安装 vim

sudo apt-get  update

sudo apt-get -y install vim git

2. 下载插件

mkdir -p ~/.vim/bundle

cd ~/.vim/bundle

git clone https://github.com/rkulla/pydiction.git

3. 配置~/.vimrc

vim ~/.vimrc

4. 在配置文件最下面填写

#载入文件类型插件

filetype plugin on

#配置插件路径

let g:pydiction_location = ‘~/.vim/bundle/pydiction/complete-dict’

#设置补全菜单的高度

let g:pydiction_menu_height = 3

然后就可以通过 vim 进行代码编写了.这时候就有了自动补全的功能.

#配色方案(可用 :highlight 查看配色方案细节)

colorscheme murphy

#打开语法高亮

syntax on

#侦测文件类型

filetype on

#载入文件类型插件

filetype plugin on

#为不同文件类型使用不用缩进

filetype indent on

#显示行号

set number

#打开自动缩进

set autoindent

#使用 C/C++ 的缩进方式

set cindent

#为 C 程序提供自动缩进

set smartindent

#设置自动缩进长度为四个空格

set shiftwidth=4

#按退格键时可以一次删掉 4 个空格

set softtabstop=4

#设定 tab 键长度为 4

set tabstop=4

#将 tab 展开为空格

set expandtab

#去掉输入错误时的提示声音

set noerrorbells

#右下角显示光标位置

set ruler

#总是显示状态行

set laststatus=2

#自定义状态行
set statusline=%F%m%r%h%w[%L][%{&ff}]%y[%p%%][%04l,%04v]

#当前列数+当前行数+当前光标位置百分比+使用的语法高亮器+文件格式+文件总行数+预览标志+帮助文件标志+只读标志+已修改标志+当前文件绝对路径

#强调匹配的括号

set showmatch

#光标短暂跳转到匹配括号的时间, 单位是十分之一秒

set matchtime=2

#显示当前正在键入的命令

set showcmd

# 设置自动切换目录为当前文件所在目录,用 :sh 时候会很方便

set autochdir

# 搜索时忽略大小写

set ignorecase

#随着键入即时搜索

set incsearch

#有一个或以上大写字母时仍大小写敏感

set smartcase

#代码折叠

set foldenable

set foldmethod=indent

#在左侧显示折叠的层次

set foldcolumn=4

#针对 Python 文件的设定

if has(“autocmd”)

autocmd FileType python set tabstop=4 shiftwidth=4 expandtab

endif

#配置pydiction插件路径

let g:pydiction_location = ‘/home/pi/.vim/bundle/pydiction/complete-dict’

#设置pydiction补全菜单的高度

let g:pydiction_menu_height = 3

希望对大家有用,谢谢!

利用树莓派和官方摄像头实现延时摄影

最近看了一个朋友用树莓派做的延时视频,感觉挺不错的,突然也想做一个. 手头正好有树莓派和摄像头,所以也尝试着做了一下,非常简单.

首先说明一下什么是延时摄影:

要创建延时视频,只需将Raspberry Pi配置为定期拍摄照片(例如每分钟),然后使用应用程序将图片拼接成视频。原理就这么简单.

有两种方法可以做到这一点。如果是官方摄像头,实现起来就更加简单了.

使用Raspistill的内置延时模式

raspistill应用程序具有内置的延时模式,使用--timelapse(或-tl)命令行开关。

切换之后的值是拍摄之间的时间(以毫秒为单位)。

raspistill -t 30000 -tl 2000 -o image%04d.jpg

请注意%04d输出文件名中的数字:这表示文件名中要显示照片编号。因此,例如,上面的命令将每隔两秒(2000毫秒)产生一次照片的捕获,总时间为30秒(30000毫秒),名为image0001.jpg,image0002.jpg,依此类推,直到image0015.jpg。

%04d指示四位数字,有前导零添加,以弥补所需的位数。因此,例如,%08d会产生一个八位数的数字。0 这个位,如果你不想要前导零,你可以不加。

如果输入的- t 为0,则应用程序将以其最小时间间隔进行拍摄照片。请注意,捕获之间存在大约30毫秒的最小强制暂停,以确保可以进行曝光计算。

使用cron(计划任务)

使用自定义拍照的好方法是使用cron

打开cron 表进行编辑:

crontab -e

这将询问您要使用哪个编辑器,或者在默认编辑器中打开。在编辑器中打开文件后,添加以下行以安排每分钟拍照.

camera.sh 可以自己写个拍摄的脚本,其中2>&1是将错误输出输入到标准输出上.

* * * * * /home/pi/camera.sh 2>&1

保存并退出,您应该看到以下消息:

crontab: installing new crontab

确保您的脚本不保存使用相同文件名拍摄的每张照片。否则将每次覆盖原有的图片。

将图像拼接在一起

现在,您需要将照片拼接成一个视频。

你可以在Pi上使用,mencoder非常赞, 但处理速度很慢。也可以将图像文件传输到台式计算机或笔记本电脑并在那里处理视频,那样会快一些,因为如果你拍摄了24小时的图片,每小时的每分钟拍摄5张图片的话,数据量也是大的惊人的.处理起来也是时间更长.但是如果在树莓派上通过脚本自行处理了,最后得到的视频就可以直接播放了. 如果你会推流处理,那还可以直接推到直播平台. 也是很好的.

切换到包含所有图像的文件夹,并将文件名重定向到一个文本文件。例如:

ls *.jpg > pics.list

在RASPBERRY PI上

虽然速度很慢(由于使用软件进行编码而不是使用Raspberry Pi硬件加速),但您可以使用各种可用工具将JPEG图像拼接在一起。其中有个软件叫avconv,需要安装, 安装好以后就可以拼接转码了。

sudo apt-get install libav-tools

现在,可以使用这些工具将JPEG文件转换为H264格式的视频文件。

avconv -r 24 -i image%04d.jpg -r 24 -vcodec libx264 -vf scale=800:480 timelapse.mp4

在Raspberry Pi 3上,它可以每秒编码多于一帧。其他Pi型号的性能会有所不同.

目前我这边使用的参数是:

  • -r 24在输入和输出文件中假设每秒二十四帧。
  • -i image%04.jpg输入文件规范(用于匹配捕获期间生成的文件)。
  • -vcodec libx264使用软件x264编码器进行编码。
  • -vf scale = 800:480  调整为输出720p。您还可以使用1920:1080或更低分辨率,具体取决于你自己的要求, 例如,我是要在52pi.taobao.com 买的800×480分辨率。请注意,Pi只能播放高达1080p的视频,但如果您打算以4K播放,则可以在此设置。
  • timelapse.mp4输出文件的名称。

avconv具有针对不同编码选项和其他设置的综合参数集。这些可以使用列出avconv --help

在另一台LINUX计算机上

您可以使用与Raspberry Pi相同的说明,或者替代包,例如mencoder

sudo apt-get install mencoder

现在运行以下命令:

mencoder -nosound -ovc lavc -lavcopts vcodec=mpeg4:aspect=16/9:vbitrate=8000000 -vf scale=1920:1080 -o timelapse.avi -mf type=jpeg:fps=24 mf://@pics.list

一旦完成,您应该有一个视频文件,timelapse.avi

然后你就可以用播放器播放查看了.

omxplayer -o hdmi  timelapse.avi

效果是不是杠杠滴?

[找回失落的记忆]树莓派+Pygame模块编写俄罗斯方块

昨天晚上,在家整理东西的时候, 突然翻找出来很早以前小时候的 Gameboy(可能不是这个名字了), 装电池的那种,很古老,只有一款游戏就是俄罗斯方块, 突然回忆就拉回了小学时代和同学一起比拼俄罗斯方块分数的日子,每天都无忧无虑的,不用考虑房贷,车保险….然后突然有一个想法,为什么不用树莓派做一个游戏机呢? 网上教程一堆一堆的, 都是用 retropie, lakka之类的系统实现一个模拟器的平台, 我觉得不够极客, 如果自己用 python 写一个游戏不是更好? 又能巩固 python 的代码能力,又可以让树莓派一机多用, 不仅只是个游戏机, 还可以是下载器,gitlab, 或者是一个 OSMC, 家庭媒体中心呢?

翻找了一下我的 Maker 材料箱, 找到一个吃灰已久的树莓派3B, 通过官方下载全新的镜像,然后烧录系统, 更新系统,配置 ssh, 配置主机名,配置字符集,配置 IP 地址等等一系列操作后. 利用 python 命令执行一下看看版本信息:

$ python -V
Python 2.7.10

就用默认版本吧, 然后去检查一下 pygame 的状态,默认情况下, pygame 已经集成在系统里面了, 如果没有要去官方站点上下载一下并安装, 连接如下: http://pygame.org/wiki/tutorials,官方的这个链接上已经说明:http://pygame.org/wiki/GettingStarted#Raspberry PI

Raspberry PI

This comes with pygame already installed on the default raspberian installation.

那么接下来的事儿就简单多了. 下面是我准备的材料:

  1. 树莓派3 B 型  x1
  2. 16GB class 10 的 TF 卡一张, 最好有SD 卡套方便进行系统烧录
  3. 5v2.5A 电源一套,为了方便,我这里采用的是52Pi 官方的 USB-HUB, 专为树莓派设计, 购买点我
  4. 5寸电阻触摸屏( GPIO 引脚控制), 购买点我 
  5. 外壳你可以自己 DIY 或者利用以下链接下载 STL 文件然后转码成 Gcode 交给3D 打印机打印.3D打印外壳链接

好了,我要开始操作了,首先你要做的事儿是把设备接驳起来,像这样:

然后启动后配置好网络后执行我写好的脚本就可以进行分辨率调节:

git clone https://github.com/yoyojacky/52Pi.git

cd ~/52Pi/

chmod +x restool.sh

sudo ./restool.sh

然后重启, 屏幕的分辨率和电容触摸的驱动就加载好了.

后面需要执行屏幕校准:

cd ~/52Pi/

chmod +x calibrator.sh

sudo ./calibrator.sh

基本配置告一段落了,然后检查 pygame 的版本:

pip list

或者通过 python 的 IDE 直接进行查询,在终端键入python 然后回车继续输入如下 python 代码:

 import  pygame

pygame.ver

看到如下图示:

说明pygame 的模块已经安装过,系统中包含这个模块了,就可以开始下面的操作了.

然后创建一个目录:

mkdir -pv  /home/pi/mygame/music

sudo vim.tiny  /home/pi/mygame/russianblock.py

我一次性创建了一个目录结构, mygame 目录下面创建一个 python 文件, 名字为: russianblock.py

然后可以两首 MP3的歌曲进去, 也可以直接下载我提供的素材:

Have A Drink On Me,Rolling in the Deep

然后继续添加如下python 代码:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
import random, time, pygame, sys
from pygame.locals import *

FPS = 25
WINDOWWIDTH = 640
WINDOWHEIGHT = 480
BOXSIZE = 20
BOARDWIDTH = 10
BOARDHEIGHT = 20
BLANK = '.'

MOVESIDEWAYSFREQ = 0.15
MOVEDOWNFREQ = 0.1

XMARGIN = int((WINDOWWIDTH - BOARDWIDTH * BOXSIZE) / 2)
TOPMARGIN = WINDOWHEIGHT - (BOARDHEIGHT * BOXSIZE) - 5
#        R  G  B
WHITE    = (255, 255, 255)
GRAY    = (185, 185, 185)
BLACK    = ( 0,  0,  0)
RED     = (155,  0,  0)
LIGHTRED  = (175, 20, 20)
GREEN    = ( 0, 155,  0)
LIGHTGREEN = ( 20, 175, 20)
BLUE    = ( 0,  0, 155)
LIGHTBLUE  = ( 20, 20, 175)
YELLOW   = (155, 155,  0)
LIGHTYELLOW = (175, 175, 20)

BORDERCOLOR = BLUE
BGCOLOR = BLACK
TEXTCOLOR = WHITE
TEXTSHADOWCOLOR = GRAY
COLORS   = (   BLUE,   GREEN,   RED,   YELLOW)
LIGHTCOLORS = (LIGHTBLUE, LIGHTGREEN, LIGHTRED, LIGHTYELLOW)
assert len(COLORS) == len(LIGHTCOLORS) # each color must have light color

TEMPLATEWIDTH = 5
TEMPLATEHEIGHT = 5

S_SHAPE_TEMPLATE = [['.....',
           '.....',
           '..OO.',
           '.OO..',
           '.....'],
          ['.....',
           '..O..',
           '..OO.',
           '...O.',
           '.....']]

Z_SHAPE_TEMPLATE = [['.....',
           '.....',
           '.OO..',
           '..OO.',
           '.....'],
          ['.....',
           '..O..',
           '.OO..',
           '.O...',
           '.....']]

I_SHAPE_TEMPLATE = [['..O..',
           '..O..',
           '..O..',
           '..O..',
           '.....'],
          ['.....',
           '.....',
           'OOOO.',
           '.....',
           '.....']]

O_SHAPE_TEMPLATE = [['.....',
           '.....',
           '.OO..',
           '.OO..',
           '.....']]

J_SHAPE_TEMPLATE = [['.....',
           '.O...',
           '.OOO.',
           '.....',
           '.....'],
          ['.....',
           '..OO.',
           '..O..',
           '..O..',
           '.....'],
          ['.....',
           '.....',
           '.OOO.',
           '...O.',
           '.....'],
          ['.....',
           '..O..',
           '..O..',
           '.OO..',
           '.....']]

L_SHAPE_TEMPLATE = [['.....',
           '...O.',
           '.OOO.',
           '.....',
           '.....'],
          ['.....',
           '..O..',
           '..O..',
           '..OO.',
           '.....'],
          ['.....',
           '.....',
           '.OOO.',
           '.O...',
           '.....'],
          ['.....',
           '.OO..',
           '..O..',
           '..O..',
           '.....']]

T_SHAPE_TEMPLATE = [['.....',
           '..O..',
           '.OOO.',
           '.....',
           '.....'],
          ['.....',
           '..O..',
           '..OO.',
           '..O..',
           '.....'],
          ['.....',
           '.....',
           '.OOO.',
           '..O..',
           '.....'],
          ['.....',
           '..O..',
           '.OO..',
           '..O..',
           '.....']]

PIECES = {'S': S_SHAPE_TEMPLATE,
     'Z': Z_SHAPE_TEMPLATE,
     'J': J_SHAPE_TEMPLATE,
     'L': L_SHAPE_TEMPLATE,
     'I': I_SHAPE_TEMPLATE,
     'O': O_SHAPE_TEMPLATE,
     'T': T_SHAPE_TEMPLATE}


def main():
  global FPSCLOCK, DISPLAYSURF, BASICFONT, BIGFONT
  pygame.init()
  FPSCLOCK = pygame.time.Clock()
  DISPLAYSURF = pygame.display.set_mode((WINDOWWIDTH, WINDOWHEIGHT))
  BASICFONT = pygame.font.Font('freesansbold.ttf', 18)
  BIGFONT = pygame.font.Font('freesansbold.ttf', 100)
  pygame.display.set_caption('Tetromino')

  showTextScreen('YoYoJacky')
  while True: # game loop
    if random.randint(0, 1) == 0:
      pygame.mixer.music.load('music/Have A Drink On Me.mp3')
    else:
      pygame.mixer.music.load('music/Rolling In The Deep.mp3')
    pygame.mixer.music.play(-1, 0.0)
    runGame()
    pygame.mixer.music.stop()
    showTextScreen('Game Over')


def runGame():
  # setup variables for the start of the game
  board = getBlankBoard()
  lastMoveDownTime = time.time()
  lastMoveSidewaysTime = time.time()
  lastFallTime = time.time()
  movingDown = False # note: there is no movingUp variable
  movingLeft = False
  movingRight = False
  score = 0
  level, fallFreq = calculateLevelAndFallFreq(score)

  fallingPiece = getNewPiece()
  nextPiece = getNewPiece()

  while True: # game loop
    if fallingPiece == None:
      # No falling piece in play, so start a new piece at the top
      fallingPiece = nextPiece
      nextPiece = getNewPiece()
      lastFallTime = time.time() # reset lastFallTime

      if not isValidPosition(board, fallingPiece):
        return # can't fit a new piece on the board, so game over

    checkForQuit()
    for event in pygame.event.get(): # event handling loop
      if event.type == KEYUP:
        if (event.key == K_p):
          # Pausing the game
          DISPLAYSURF.fill(BGCOLOR)
          pygame.mixer.music.stop()
          showTextScreen('Paused') # pause until a key press
          pygame.mixer.music.play(-1, 0.0)
          lastFallTime = time.time()
          lastMoveDownTime = time.time()
          lastMoveSidewaysTime = time.time()
        elif (event.key == K_LEFT or event.key == K_a):
          movingLeft = False
        elif (event.key == K_RIGHT or event.key == K_d):
          movingRight = False
        elif (event.key == K_DOWN or event.key == K_s):
          movingDown = False

      elif event.type == KEYDOWN:
        # moving the piece sideways
        if (event.key == K_LEFT or event.key == K_a) and isValidPosition(board, fallingPiece, adjX=-1):
          fallingPiece['x'] -= 1
          movingLeft = True
          movingRight = False
          lastMoveSidewaysTime = time.time()

        elif (event.key == K_RIGHT or event.key == K_d) and isValidPosition(board, fallingPiece, adjX=1):
          fallingPiece['x'] += 1
          movingRight = True
          movingLeft = False
          lastMoveSidewaysTime = time.time()

        # rotating the piece (if there is room to rotate)
        elif (event.key == K_UP or event.key == K_w):
          fallingPiece['rotation'] = (fallingPiece['rotation'] + 1) % len(PIECES[fallingPiece['shape']])
          if not isValidPosition(board, fallingPiece):
            fallingPiece['rotation'] = (fallingPiece['rotation'] - 1) % len(PIECES[fallingPiece['shape']])
        elif (event.key == K_q): # rotate the other direction
          fallingPiece['rotation'] = (fallingPiece['rotation'] - 1) % len(PIECES[fallingPiece['shape']])
          if not isValidPosition(board, fallingPiece):
            fallingPiece['rotation'] = (fallingPiece['rotation'] + 1) % len(PIECES[fallingPiece['shape']])

        # making the piece fall faster with the down key
        elif (event.key == K_DOWN or event.key == K_s):
          movingDown = True
          if isValidPosition(board, fallingPiece, adjY=1):
            fallingPiece['y'] += 1
          lastMoveDownTime = time.time()

        # move the current piece all the way down
        elif event.key == K_SPACE:
          movingDown = False
          movingLeft = False
          movingRight = False
          for i in range(1, BOARDHEIGHT):
            if not isValidPosition(board, fallingPiece, adjY=i):
              break
          fallingPiece['y'] += i - 1

    # handle moving the piece because of user input
    if (movingLeft or movingRight) and time.time() - lastMoveSidewaysTime > MOVESIDEWAYSFREQ:
      if movingLeft and isValidPosition(board, fallingPiece, adjX=-1):
        fallingPiece['x'] -= 1
      elif movingRight and isValidPosition(board, fallingPiece, adjX=1):
        fallingPiece['x'] += 1
      lastMoveSidewaysTime = time.time()

    if movingDown and time.time() - lastMoveDownTime > MOVEDOWNFREQ and isValidPosition(board, fallingPiece, adjY=1):
      fallingPiece['y'] += 1
      lastMoveDownTime = time.time()

    # let the piece fall if it is time to fall
    if time.time() - lastFallTime > fallFreq:
      # see if the piece has landed
      if not isValidPosition(board, fallingPiece, adjY=1):
        # falling piece has landed, set it on the board
        addToBoard(board, fallingPiece)
        score += removeCompleteLines(board)
        level, fallFreq = calculateLevelAndFallFreq(score)
        fallingPiece = None
      else:
        # piece did not land, just move the piece down
        fallingPiece['y'] += 1
        lastFallTime = time.time()

    # drawing everything on the screen
    DISPLAYSURF.fill(BGCOLOR)
    drawBoard(board)
    drawStatus(score, level)
    drawNextPiece(nextPiece)
    if fallingPiece != None:
      drawPiece(fallingPiece)

    pygame.display.update()
    FPSCLOCK.tick(FPS)


def makeTextObjs(text, font, color):
  surf = font.render(text, True, color)
  return surf, surf.get_rect()


def terminate():
  pygame.quit()
  sys.exit()


def checkForKeyPress():
  # Go through event queue looking for a KEYUP event.
  # Grab KEYDOWN events to remove them from the event queue.
  checkForQuit()

  for event in pygame.event.get([KEYDOWN, KEYUP]):
    if event.type == KEYDOWN:
      continue
    return event.key
  return None


def showTextScreen(text):
  # This function displays large text in the
  # center of the screen until a key is pressed.
  # Draw the text drop shadow
  titleSurf, titleRect = makeTextObjs(text, BIGFONT, TEXTSHADOWCOLOR)
  titleRect.center = (int(WINDOWWIDTH / 2), int(WINDOWHEIGHT / 2))
  DISPLAYSURF.blit(titleSurf, titleRect)

  # Draw the text
  titleSurf, titleRect = makeTextObjs(text, BIGFONT, TEXTCOLOR)
  titleRect.center = (int(WINDOWWIDTH / 2) - 3, int(WINDOWHEIGHT / 2) - 3)
  DISPLAYSURF.blit(titleSurf, titleRect)

  # Draw the additional "Press a key to play." text.
  pressKeySurf, pressKeyRect = makeTextObjs('Press a key to play.', BASICFONT, TEXTCOLOR)
  pressKeyRect.center = (int(WINDOWWIDTH / 2), int(WINDOWHEIGHT / 2) + 100)
  DISPLAYSURF.blit(pressKeySurf, pressKeyRect)

  while checkForKeyPress() == None:
    pygame.display.update()
    FPSCLOCK.tick()


def checkForQuit():
  for event in pygame.event.get(QUIT): # get all the QUIT events
    terminate() # terminate if any QUIT events are present
  for event in pygame.event.get(KEYUP): # get all the KEYUP events
    if event.key == K_ESCAPE:
      terminate() # terminate if the KEYUP event was for the Esc key
    pygame.event.post(event) # put the other KEYUP event objects back


def calculateLevelAndFallFreq(score):
  # Based on the score, return the level the player is on and
  # how many seconds pass until a falling piece falls one space.
  level = int(score / 10) + 1
  fallFreq = 0.27 - (level * 0.02)
  return level, fallFreq

def getNewPiece():
  # return a random new piece in a random rotation and color
  shape = random.choice(list(PIECES.keys()))
  newPiece = {'shape': shape,
        'rotation': random.randint(0, len(PIECES[shape]) - 1),
        'x': int(BOARDWIDTH / 2) - int(TEMPLATEWIDTH / 2),
        'y': -2, # start it above the board (i.e. less than 0)
        'color': random.randint(0, len(COLORS)-1)}
  return newPiece


def addToBoard(board, piece):
  # fill in the board based on piece's location, shape, and rotation
  for x in range(TEMPLATEWIDTH):
    for y in range(TEMPLATEHEIGHT):
      if PIECES[piece['shape']][piece['rotation']][y][x] != BLANK:
        board[x + piece['x']][y + piece['y']] = piece['color']


def getBlankBoard():
  # create and return a new blank board data structure
  board = []
  for i in range(BOARDWIDTH):
    board.append([BLANK] * BOARDHEIGHT)
  return board


def isOnBoard(x, y):
  return x >= 0 and x < BOARDWIDTH and y < BOARDHEIGHT


def isValidPosition(board, piece, adjX=0, adjY=0):
  # Return True if the piece is within the board and not colliding
  for x in range(TEMPLATEWIDTH):
    for y in range(TEMPLATEHEIGHT):
      isAboveBoard = y + piece['y'] + adjY < 0
      if isAboveBoard or PIECES[piece['shape']][piece['rotation']][y][x] == BLANK:
        continue
      if not isOnBoard(x + piece['x'] + adjX, y + piece['y'] + adjY):
        return False
      if board[x + piece['x'] + adjX][y + piece['y'] + adjY] != BLANK:
        return False
  return True

def isCompleteLine(board, y):
  # Return True if the line filled with boxes with no gaps.
  for x in range(BOARDWIDTH):
    if board[x][y] == BLANK:
      return False
  return True


def removeCompleteLines(board):
  # Remove any completed lines on the board, move everything above them down, and return the number of complete lines.
  numLinesRemoved = 0
  y = BOARDHEIGHT - 1 # start y at the bottom of the board
  while y >= 0:
    if isCompleteLine(board, y):
      # Remove the line and pull boxes down by one line.
      for pullDownY in range(y, 0, -1):
        for x in range(BOARDWIDTH):
          board[x][pullDownY] = board[x][pullDownY-1]
      # Set very top line to blank.
      for x in range(BOARDWIDTH):
        board[x][0] = BLANK
      numLinesRemoved += 1
      # Note on the next iteration of the loop, y is the same.
      # This is so that if the line that was pulled down is also
      # complete, it will be removed.
    else:
      y -= 1 # move on to check next row up
  return numLinesRemoved


def convertToPixelCoords(boxx, boxy):
  # Convert the given xy coordinates of the board to xy
  # coordinates of the location on the screen.
  return (XMARGIN + (boxx * BOXSIZE)), (TOPMARGIN + (boxy * BOXSIZE))


def drawBox(boxx, boxy, color, pixelx=None, pixely=None):
  # draw a single box (each tetromino piece has four boxes)
  # at xy coordinates on the board. Or, if pixelx & pixely
  # are specified, draw to the pixel coordinates stored in
  # pixelx & pixely (this is used for the "Next" piece).
  if color == BLANK:
    return
  if pixelx == None and pixely == None:
    pixelx, pixely = convertToPixelCoords(boxx, boxy)
  pygame.draw.rect(DISPLAYSURF, COLORS[color], (pixelx + 1, pixely + 1, BOXSIZE - 1, BOXSIZE - 1))
  pygame.draw.rect(DISPLAYSURF, LIGHTCOLORS[color], (pixelx + 1, pixely + 1, BOXSIZE - 4, BOXSIZE - 4))


def drawBoard(board):
  # draw the border around the board
  pygame.draw.rect(DISPLAYSURF, BORDERCOLOR, (XMARGIN - 3, TOPMARGIN - 7, (BOARDWIDTH * BOXSIZE) + 8, (BOARDHEIGHT * BOXSIZE) + 8), 5)

  # fill the background of the board
  pygame.draw.rect(DISPLAYSURF, BGCOLOR, (XMARGIN, TOPMARGIN, BOXSIZE * BOARDWIDTH, BOXSIZE * BOARDHEIGHT))
  # draw the individual boxes on the board
  for x in range(BOARDWIDTH):
    for y in range(BOARDHEIGHT):
      drawBox(x, y, board[x][y])


def drawStatus(score, level):
  # draw the score text
  scoreSurf = BASICFONT.render('Score: %s' % score, True, TEXTCOLOR)
  scoreRect = scoreSurf.get_rect()
  scoreRect.topleft = (WINDOWWIDTH - 150, 20)
  DISPLAYSURF.blit(scoreSurf, scoreRect)

  # draw the level text
  levelSurf = BASICFONT.render('Level: %s' % level, True, TEXTCOLOR)
  levelRect = levelSurf.get_rect()
  levelRect.topleft = (WINDOWWIDTH - 150, 50)
  DISPLAYSURF.blit(levelSurf, levelRect)


def drawPiece(piece, pixelx=None, pixely=None):
  shapeToDraw = PIECES[piece['shape']][piece['rotation']]
  if pixelx == None and pixely == None:
    # if pixelx & pixely hasn't been specified, use the location stored in the piece data structure
    pixelx, pixely = convertToPixelCoords(piece['x'], piece['y'])

  # draw each of the boxes that make up the piece
  for x in range(TEMPLATEWIDTH):
    for y in range(TEMPLATEHEIGHT):
      if shapeToDraw[y][x] != BLANK:
        drawBox(None, None, piece['color'], pixelx + (x * BOXSIZE), pixely + (y * BOXSIZE))


def drawNextPiece(piece):
  # draw the "next" text
  nextSurf = BASICFONT.render('Next:', True, TEXTCOLOR)
  nextRect = nextSurf.get_rect()
  nextRect.topleft = (WINDOWWIDTH - 120, 80)
  DISPLAYSURF.blit(nextSurf, nextRect)
  # draw the "next" piece
  drawPiece(piece, pixelx=WINDOWWIDTH-120, pixely=100)


if __name__ == '__main__':
  main()

写好以后,先用命令执行测试一下:

sudo python russianblock.py

执行结果看到如下内容就说明成功了:

随便按一个键就可以开始玩儿了,使用键盘的上下左右控制移动, 用空格控制反转,记得把你的耳机插入树莓派3.5mm 的音频复合接口, 然后开始享受游戏的乐趣吧!

如果失败,音乐就停啦!

好了! 这个简单的教程就写到这里, 后期教大家利用 pygame 和树莓派制作更多的好玩儿的小游戏!

树莓派3B 爬虫蓝牙播放器

  

一直没有尝试使用一下树莓派3B 的蓝牙功能,今天特别想试试,于是就烧录了最新的raspbian镜像,然后接上5寸GPIO触摸屏和键盘鼠标,开始了调试,网上看了看其他人的教程,发现都很老了,有的还不能用。所以就诞生了这篇我自己能用的文章,算是做个记录吧。

首先你需要做的准备工作:

  1. 树莓派3B  如果你是2B ,那么你还需要一个USB 的蓝牙接收器(马云家可买)
  2. 树莓派电源5v/2A
  3. 8GB TF 卡一张,读卡器1个
  4. 树莓派外壳(可选) 为了好看和防尘, 还可以选择散热片和风扇,更加专业.
  5. 小米蓝牙小音箱.
  6. 无线网络环境.
  7. 去官方网站下载最新的 Raspbian 系统并且通过 win32_diskimager 烧录到你的 TF卡

好了,万事俱备, 只欠500万,接下来直接进入主题,插上电源,等待RPI开机后,系统中通过点选 wifi 图标先连入网络,然后打开一个终端,执行下面的命令进行更新和安装蓝牙软件:

sudo apt-get  update

sudo apt-get  -y  install  –no-install-recommends bluetooth

sudo service bluetooth status

检查是否有蓝牙服务,如果没有就再重启一下设备。或者用下面的命令尝试扫描一下:

hcitool scan

我之前还尝试了使用blueman,那个在图形上设置更加方便。

sudo apt-get  -y  install  bluetooth  bluez  blueman

但是我更倾向于这样设置:

蓝牙配对

如果看不清楚就看这里:

sudo  bluetoothctl

然后进入bluetooth的交互界面输入

agent  on

default-agent

然后开始扫描

scan on

当找到你的蓝牙设备后,执行配对就好了。

pair  B8:78:2E:12:0F:29   #这里要根据你实际情况选择.

这里输入你的蓝牙的MAC地址,就是类似B8:78:2E:12:0F:29这种

如果要用蓝牙音箱,记得使用blueman,那个有图形界面可以在图形上选择audio的输出方式,可以找到你的蓝牙设备,然后选择成为输出设备,然后就可以用我写好的python爬虫来进行音乐的搜索和播放了。

git  clone   https://github.com/yoyojacy/52Pi.git

cd  52Pi/

python   music.py

第一次执行的时候可能时间比较长,因为在更新系统和安装mplayer,不用担心,通过后就可以看到提示了,输入歌名或者歌手的名字就可以听到歌曲了。如果还想调整一下音量大小可以用:

alsamixer

然后按上下键调整就好了,最后记得ESC退出。

最后,转发的童鞋请注明出处! 谢谢~