villivateur
/
pinout.vvzero.com
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

init zh language

This commit is contained in:
Villivateur Von 2022-01-05 23:15:31 +08:00
parent b8f16b9c73
commit 0a34aa639a
251 changed files with 14778 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

65
src/zh/overlay/30a-relay-hat.md Normal file
View File

@ -0,0 +1,65 @@
<!--
---
name: 30A Relay HAT
class: board
type: io, relay
formfactor: HAT
manufacturer: PlasmaDan
description: Raspberry Pi HAT I/O board with dual 30A SPDT power relays.
url: https://plasmadan.com/30arelayhat
github: https://github.com/plasmadancom/30A-Relay-HAT
schematic: https://plasmadan.com/30a-relay-hat-schematic
buy: https://plasmadan.com/30arelayhat
image: '30a-relay-hat.png'
pincount: 40
eeprom: yes
power:
'1':
'2':
'4':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'3':
mode: i2c
'5':
mode: i2c
i2c:
'0x20':
alternate: [ '0x21', '0x22', '0x23', '0x24', '0x25', '0x26', '0x27' ]
name: MCP23008
device: MCP23008
-->
# 30A Relay HAT
The 30A Relay HAT is a dual SPDT power relay I/O board based on the Microchip MCP23008 I2C expander. Ideally suited to automation or industrial control, switching of household appliances, industrial machinery or automotive applications.
## Features
* 2 opto-isolated SPDT power relays
* 30A / 15A @ 250V AC (NO / NC)
* Supports up to 6mm<sup>2</sup> / 10 AWG cable
* 2oz copper PCB ensures maximum current flow
* Easy to use [interactive web GUI](https://io.plasmadan.com/30arelayhat/)
* Based on the MCP23008 8-port GPIO expander
* Jumper selectable I2C address & GPIO voltage (3.3V / 5V)
* Can be used with 3.3V or 5V I2C host devices (eg, Arduino)
* Built-in user programmable ID EEPROM
## Easy Installer
Our easy installer takes care of the setup process automatically.
```
sudo wget https://git.plasmadan.com/install.sh
sudo sh install.sh
```
Alternatively, you can install manually. See our [setup guide](https://github.com/plasmadancom/HAT-GUI#setup-guide).

123
src/zh/overlay/3d-xmas-tree.md Normal file
View File

@ -0,0 +1,123 @@
<!--
---
name: 3D Xmas Tree
class: board
type: other
formfactor: Custom
manufacturer: PiHut
description: A 3D Christmas tree PCB with red LEDs controlled by the Raspberry Pi GPIO pins
url: https://thepihut.com/products/3d-xmas-tree-for-raspberry-pi
buy: https://thepihut.com/products/3d-xmas-tree-for-raspberry-pi
image: '3d-xmas-tree.png'
pincount: 40
eeprom: no
power:
ground:
'6':
pin:
'3':
name: Star LED (Yellow)
direction: output
active: high
'7':
name: Tree LED (Red)
direction: output
active: high
'10':
name: Tree LED (Red)
direction: output
active: high
'33':
name: Tree LED (Red)
direction: output
active: high
'40':
name: Tree LED (Red)
direction: output
active: high
'22':
name: Tree LED (Red)
direction: output
active: high
'24':
name: Tree LED (Red)
direction: output
active: high
'29':
name: Tree LED (Red)
direction: output
active: high
'19':
name: Tree LED (Red)
direction: output
active: high
'36':
name: Tree LED (Red)
direction: output
active: high
'11':
name: Tree LED (Red)
direction: output
active: high
'13':
name: Tree LED (Red)
direction: output
active: high
'37':
name: Tree LED (Red)
direction: output
active: high
'18':
name: Tree LED (Red)
direction: output
active: high
'21':
name: Tree LED (Red)
direction: output
active: high
'32':
name: Tree LED (Red)
direction: output
active: high
'31':
name: Tree LED (Red)
direction: output
active: high
'38':
name: Tree LED (Red)
direction: output
active: high
'35':
name: Tree LED (Red)
direction: output
active: high
'8':
name: Tree LED (Red)
direction: output
active: high
'12':
name: Tree LED (Red)
direction: output
active: high
'23':
name: Tree LED (Red)
direction: output
active: high
'26':
name: Tree LED (Red)
direction: output
active: high
'16':
name: Tree LED (Red)
direction: output
active: high
'15':
name: Tree LED (Red)
direction: output
active: high
-->
#3D Xmas Tree
A 3D Christmas tree PCB with red LEDs controlled by the Raspberry Pi GPIO pins: can be used as a programmable Christmas decoration. Available as a DIY soldering kit, or pre-soldered.
Features 24 GPIO-controllable red LEDs (simple digital outputs on the relevant GPIO pins), and 1 GPIO-controllable yellow LED as the star.

20
src/zh/overlay/3v3-power.md Normal file
View File

@ -0,0 +1,20 @@
<!--
---
name: 3v3 Power
class: interface
type: pinout
description: Raspberry Pi 3v3 Power Pins
pincount: 2
pin:
'1':
'17':
-->
# 3v3 Power
All Raspberry Pi models since the B+ can provide up to 500mA on the 3v3 pins, thanks to a switching regulator. In some cases it may be possible to draw more but, due to lack of documentation and testing on the actual limits, 500mA is given as a rule of thumb.
The 3v3 supply pin on the early Raspberry Pi had a maximum available current of only 50mA.
The 5v supply coupled with a 3v3 regulator is recommended for powering 3.3v projects.
The Piversify blog has [an exploration of the 3v3 supply rail on the Raspberry Pi B+](https://raspberrypise.tumblr.com/post/144555785379/exploring-the-33v-power-rail)

42
src/zh/overlay/4tronix-picon-zero.md Normal file
View File

@ -0,0 +1,42 @@
<!--
---
name: Picon Zero
class: board
type: motor
formfactor: pHAT
manufacturer: 4tronix
description: A robot controller board for the Raspberry Pi
url: http://4tronix.co.uk/piconzero/
buy: http://4tronix.co.uk/store/index.php?rt=product/product&product_id=552
image: '4tronix-picon-zero.png'
pincount: 40
eeprom: no
power:
'2':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'3':
mode: i2c
'5':
mode: i2c
'38':
name: Ultrasonic
mode: input/output
i2c:
'0x22':
name: PiconZero
device: ATMega328
-->
# Picon Zero
The Picon Zero is an add-on PCB for the Raspberry Pi that is physically the same size as a Raspberry Pi Zero and so is ideal as a pseudo-Hat (pHat) for the Pi Zero. However, it can of course be used on any Raspberry Pi with a 40-pin GPIO connector.
As well as 2 full H-Bridge motor drivers, the Picon Zero has a number of Input and Output pins that can be configured in a variety of ways, allowing you to easily add analog inputs or neopixel outputs to your Raspberry Pi without any complicated software and kernel specific drivers. It also provides an interface for an HC-SR04 ultrasonic distance sensor and opens up 5 GPIO pins from the Raspberry Pi for you to use as you see fit.

54
src/zh/overlay/4tronix-pistep2d.md Normal file
View File

@ -0,0 +1,54 @@
<!--
---
name: PiStep2 Dual
class: board
type: motor
formfactor: pHAT
manufacturer: 4tronix
description: A Dual Stepper Motor Driver for Raspberry Pi
url: http://4tronix.co.uk/store/index.php?rt=product/product&product_id=554
github:
buy: http://4tronix.co.uk/store/index.php?rt=product/product&product_id=554
image: '4tronix-pistep2d.png'
pincount: 40
eeprom: no
power:
'2':
'17':
ground:
'30':
'34':
'39':
pin:
'11':
name: MotorA_0
mode: output
'12':
name: MotorA_1
mode: output
'13':
name: MotorA_2
mode: output
'15':
name: MotorA_3
mode: output
'16':
name: MotorB_0
mode: output
'18':
name: MotorB_1
mode: output
'22':
name: MotorB_2
mode: output
'7':
name: MotorB_3
mode: output
-->
# PiStep2 Dual
Drive 2 uni-polar stepper motors using a single control board with the PiStep2 Dual.
* Uses a ULN2803 Darlington driver chip to drive the motors
* Ideal for use with 28BYJ48 stepper motors
* Supported in Scratch GPIO as well as in Python

78
src/zh/overlay/4tronix-pistep2q.md Normal file
View File

@ -0,0 +1,78 @@
<!--
---
name: PiStep2 Quad
class: board
type: motor
formfactor: pHAT
manufacturer: 4tronix
description: A Quad Stepper Motor Driver for Raspberry Pi
url: http://4tronix.co.uk/store/index.php?rt=product/product&product_id=554
github:
buy: http://4tronix.co.uk/store/index.php?rt=product/product&product_id=554
image: '4tronix-pistep2q.png'
pincount: 40
eeprom: no
power:
'2':
'17':
ground:
'30':
'34':
'39':
pin:
'11':
name: MotorA_0
mode: output
'12':
name: MotorA_1
mode: output
'13':
name: MotorA_2
mode: output
'15':
name: MotorA_3
mode: output
'16':
name: MotorB_0
mode: output
'18':
name: MotorB_1
mode: output
'22':
name: MotorB_2
mode: output
'7':
name: MotorB_3
mode: output
'33':
name: MotorC_0
mode: output
'32':
name: MotorC_1
mode: output
'31':
name: MotorC_2
mode: output
'29':
name: MotorC_3
mode: output
'38':
name: MotorD_0
mode: output
'37':
name: MotorD_1
mode: output
'36':
name: MotorD_2
mode: output
'35':
name: MotorD_3
mode: output
-->
# PiStep2 Quad
Drive 4 uni-polar stepper motors using a single control board with the PiStep2 Quad.
* Uses ULN2803 Darlington driver chips to drive the motors
* Ideal for use with 28BYJ48 stepper motors
* Supported in Scratch GPIO as well as in Python

34
src/zh/overlay/4tronix-pistop.md Normal file
View File

@ -0,0 +1,34 @@
<!--
---
name: Pi Stop
class: board
type: led
formfactor: Custom
manufacturer: 4tronix
description: LED Traffic Lights for Raspberry Pi
url: http://4tronix.co.uk/store/index.php?rt=product/product&product_id=390
buy: http://4tronix.co.uk/store/index.php?rt=product/product&product_id=390
image: '4tronix-pistop.png'
pincount: 4
eeprom: no
ground:
'9':
pin:
'11':
name: Green
mode: output
active: high
'13':
name: Amber
mode: output
active: high
'15':
name: Red
mode: output
active: high
-->
# Pi Stop Traffic Lights
The PiStop is placed vertically into the GPIO connectors and can be fitted into several positions in the board. It can be fitted into 26-pin headers as well as 40-pin headers.
PiStop only uses 3 GPIO pins plus ground, but you can fit multiple PiStops into one header, although not all positions are possible simultaneously as some pins are shared across the options. Note that only one position is illustrated in the pinout, but any succession of 3 GPIO next to a ground pin is suitable.

80
src/zh/overlay/4tronix-robohat.md Normal file
View File

@ -0,0 +1,80 @@
<!--
---
name: RoboHat
class: board
type: io,motor
formfactor: HAT
manufacturer: 4tronix
description: Robotics controller HAT
url: http://4tronix.co.uk/store/index.php?rt=product/product&product_id=547
github:
buy: http://4tronix.co.uk/store/index.php?rt=product/product&product_id=547
image: '4tronix-robohat.png'
pincount: 40
eeprom: yes
power:
'1':
'2':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'32':
name: MotorA_0
mode: output
'33':
name: MotorA_1
mode: output
'35':
name: MotorB_0
mode: output
'36':
name: MotorB_1
mode: output
'18':
name: out0
mode: output
active: high
'22':
name: out1
mode: output
active: high
'12':
name: out2
mode: output
active: high
'31':
name: out3
mode: output
active: high
'7':
name: in0
mode: input
'11':
name: in1
mode: input
'29':
name: in2
mode: input
'13':
name: in3
mode: input
'15':
name: in4
mode: input
'16':
name: in5
mode: input
'38':
name: Ultrasonic
mode: input/output
-->
# RoboHat
The RoboHat is a complete robot controller for small robots. It has 2 full H-bridges using DRV8833 for up to 1.5A per channel, a 5V switch-mode regulator to generate the 5V for the Raspberry Pi, 6 buffered inputs that can accept 2.5V to 5.5V and convert to 3.3V and 4 outputs driven up to 5V. All the I/O is via GVS (Ground, Volts, Signal) 3-pin terminals so it is easy to plug in 3-pin sensors or small servos directly. There is also a connector plug in an HC-SR04 ultrasonic distance sensor with the necessary circuitry to read the value using a single GPIO pin.

16
src/zh/overlay/5v-power.md Normal file
View File

@ -0,0 +1,16 @@
<!--
---
name: 5v Power
class: interface
type: pinout
description: Raspberry Pi 5v Power Pins
pincount: 2
pin:
'2':
'4':
-->
# 5v Power
The 5v power pins are connected directly to the Pi's power input and will capably provide the full supply current of your mains adaptor, minus that used by the Pi itself.
With a decent power supply, such as the official Pi adaptor, you can expect to pull about 1.5A. This varies by Pi model and adapter used. Devices that require a high current- such as LED panels, long LED strips or motors- should use an external power supply.

85
src/zh/overlay/RealTimeHAT.md Normal file
View File

@ -0,0 +1,85 @@
<!--
---
name: Real-Time HAT
class: board
type: multi
formfactor: Custom
manufacturer: InnoRoute GmbH
collected: Other
description: The Real-Time HAT extends the Gigabit-Ethernet interface of the Raspberry Pi, adding professional networking functions.
github: https://github.com/InnoRoute/RealtimeHAT
url: https://innoroute.com/realtimehat/
image: 'RealTimeHAT.png'
pincount: 40
eeprom: yes
power:
'1':
'2':
'4':
ground:
'6':
'9':
'14':
'17':
'20':
'25':
'30':
'34':
'39':
pin:
'3':
mode: i2c
'5':
mode: i2c
'7':
name: PHY_MDC
'11':
name: PHY_MDIO
'13':
name: FPGA_Interrupt
direction: Input
'15':
name: Buffer_Full
direction: Input
'19':
mode: spi
'21':
mode: spi
'23':
mode: spi
'24':
mode: spi
'26':
mode: spi
'27':
mode: i2c
'28':
mode: i2c
i2c:
'0x50':
name: ID EEPROM
device: I2C0 - ID EEPROM
'0x24':
name: PMIC
device: I2C1 - PMIC
'0x43':
name: IO Expender
device: I2C1 - IO Expander
-->
# Real-Time HAT
Real-Time HAT extends the Gigabit-Ethernet interface of the Raspberry Pi, adding professional networking functions.
Typical applications are **industrial real-time communication** and **network monitoring**.
The HAT provides **3 Gigabit-Ethernet ports**, one of which is connected to the Raspberry Pi's Ethernet port.
Connection to the Raspberry Pi is realized via the GPIO connector and via a (short) Ethernet cable. The SPI0 interface is used for main configuration, using either CE0# or CE1#.
Additional information on use cases, programming interfaces etc. can be found on [InnoRoute's website](https://innoroute.com/realtimehat/), which includes details on using the HAT as an **endpoint in Time-Sensitive Networks**, as a **3-port Ethernet switch**, or to **measure and monitor** any kind of the traffic forwarded through the HAT.
To install the necessary software, use the following commands:
```bash
git clone https://github.com/InnoRoute/RealtimeHAT
cd RealtimeHAT
./install.sh
```

47
src/zh/overlay/ab-1-wire-pi-plus.md Normal file
View File

@ -0,0 +1,47 @@
<!--
---
name: 1 Wire Pi Plus
class: board
type: com
formfactor: HAT
manufacturer: AB Electronics UK
description: 1-Wire to I2C host interface
url: https://www.abelectronics.co.uk/p/60/1-wire-pi-plus
github: https://github.com/abelectronicsuk
schematic: https://www.abelectronics.co.uk/docs/pdf/schematic-1-wire-pi-plus-v2.pdf
buy: https://www.abelectronics.co.uk/p/60/1-wire-pi-plus
image: 'ab-1-wire-pi-plus.png'
pincount: 40
eeprom: no
power:
'1':
'2':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'3':
mode: i2c
'5':
mode: i2c
i2c:
'0x18':
alternate: ['0x19', '0x1A', '0x1B']
name: DS2482
device: DS2482-100
-->
#1 Wire Pi Plus
The 1 Wire Pi Plus from AB Electronics UK is a communication board supporting the 1-Wire® protocol designed for use on the Raspberry Pi. A 5V buffered I2C port is also provided on the board.
The 1-Wire® port on the 1 Wire Pi Plus is based around a DS2482-100 I2C to 1-Wire® bridge device. The DS2482-100 provides bi-directional protocol conversion between the I2C port on the Raspberry Pi and any attached 1-Wire® slave devices. An ESD Protection Diode is used to protect the 1 Wire Pi Plus and Raspberry Pi from electrostatic spikes on the 1-Wire® port. Connections to the 1-Wire® port can be made through the RJ-12 socket or the solder points on the PCB.
I2C address select solder jumpers give you the ability to set the I2C address of the 1 Wire Pi Plus allowing the board to be used with other I2C devices on the same bus.
[https://www.abelectronics.co.uk/kb/article/3/owfs-with-i2c-support-on-raspberry-pi](https://www.abelectronics.co.uk/kb/article/3/owfs-with-i2c-support-on-raspberry-pi "Configuring and using the 1-Wire® port on your Raspberry Pi")

47
src/zh/overlay/ab-1-wire-pi-zero.md Normal file
View File

@ -0,0 +1,47 @@
<!--
---
name: 1 Wire Pi Zero
class: board
type: com
formfactor: pHAT
manufacturer: AB Electronics UK
description: 1-Wire to I2C host interface
url: https://www.abelectronics.co.uk/p/76/1-wire-pi-zero
github: https://github.com/abelectronicsuk
schematic: https://www.abelectronics.co.uk/docs/pdf/schematic-1-wire-pi-zero.pdf
buy: https://www.abelectronics.co.uk/p/76/1-wire-pi-zero
image: 'ab-1-wire-pi-zero.png'
pincount: 40
eeprom: no
power:
'1':
'2':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'3':
mode: i2c
'5':
mode: i2c
i2c:
'0x18':
alternate: ['0x19', '0x1A', '0x1B']
name: DS2482
device: DS2482-100
-->
#1 Wire Pi Zero
The 1 Wire Pi Zero from AB Electronics UK is a communication board supporting the 1-Wire® protocol designed for use on the Raspberry Pi Zero. A 5V buffered I2C port is also provided on the board.
The 1-Wire® port on the 1 Wire Pi Zero is based around a DS2482-100 I2C to 1-Wire® bridge device. The DS2482-100 provides bi-directional protocol conversion between the I2C port on the Raspberry Pi and any attached 1-Wire® slave devices. An ESD Protection Diode is used to protect the 1 Wire Pi Zero and Raspberry Pi from electrostatic spikes on the 1-Wire® port. Connections to the 1-Wire® port can be made through the RJ-12 socket or the solder points on the PCB.
I2C address select solder jumpers give you the ability to set the I2C address of the 1 Wire Pi Zero allowing the board to be used with other I2C devices on the same bus.
[https://www.abelectronics.co.uk/kb/article/3/owfs-with-i2c-support-on-raspberry-pi](https://www.abelectronics.co.uk/kb/article/3/owfs-with-i2c-support-on-raspberry-pi "Configuring and using the 1-Wire® port on your Raspberry Pi")

65
src/zh/overlay/ab-adc-differential-pi.md Normal file
View File

@ -0,0 +1,65 @@
<!--
---
name: ADC Differential Pi
class: board
type: adc
formfactor: pHAT
manufacturer: AB Electronics UK
description: 8 channel Analogue to Digital Converter
url: https://www.abelectronics.co.uk/p/65/adc-differential-pi-raspberry-pi-analogue-to-digital-converter
github: https://github.com/abelectronicsuk
schematic: https://www.abelectronics.co.uk/docs/pdf/schematic-adc-differential-pi.pdf
buy: https://www.abelectronics.co.uk/p/65/adc-differential-pi-raspberry-pi-analogue-to-digital-converter
image: 'ab-adc-differential-pi.png'
pincount: 40
eeprom: no
power:
'1':
'2':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'3':
mode: i2c
'5':
mode: i2c
i2c:
'0x68':
alternate: [ '0x69', '0x6A', '0x6B', '0x6C', '0x6D', '0x6E', '0x6F' ]
name: MCP3424
device: MCP3424
'0x69':
alternate: [ '0x68', '0x6A', '0x6B', '0x6C', '0x6D', '0x6E', '0x6F' ]
name: MCP3424
device: MCP3424
-->
# ADC Differential Pi
The ADC Differential Pi is an 8 channel 18 bit analogue to digital converter designed to work with the Raspberry Pi. The ADC Differential Pi is based on two Microchip MCP3424 A/D converters each containing 4 analogue inputs. The MCP3424 is a delta-sigma A/D converter with low noise differential inputs.
## Features
- 8 x 18-bit differential inputs
- Control via the Raspberry Pi I2C port
- Stack up to 4 ADC Differential Pi boards on a single Raspberry Pi
- Jumper selectable I2C addresses (8 choices)
- Buffered 5V I2C port
- Based on the MCP3424 from Microchip Technologies Inc
- Input range of ±2.048V
- On-board 2.048V reference voltage (Accuracy ± 0.05%, Drift: 15 ppm/°C)
- On-Board Programmable Gain Amplifier (PGA): Gains of 1, 2, 4 or 8
- Programmable Data Rate Options:
- 3.75 SPS (18 bits)
- 15 SPS (16 bits)
- 60 SPS (14 bits)
- 240 SPS (12 bits)
- One-Shot or Continuous Conversion Options
Python, C, C++, Node.js and Windows 10 IOT libraries are available on GitHub.

65
src/zh/overlay/ab-adc-pi-plus.md Normal file
View File

@ -0,0 +1,65 @@
<!--
---
name: ADC Pi Plus
class: board
type: adc
formfactor: HAT
manufacturer: AB Electronics UK
description: 8 channel Analogue to Digital Converter
url: https://www.abelectronics.co.uk/p/56/ADC-Pi-Plus-Raspberry-Pi-Analogue-to-Digital-converter
github: https://github.com/abelectronicsuk
schematic: https://www.abelectronics.co.uk/docs/stock/raspberrypi/adcpiplus/adc-pi-plus-schematic.pdf
buy: https://www.abelectronics.co.uk/p/56/ADC-Pi-Plus-Raspberry-Pi-Analogue-to-Digital-converter
image: 'ab-adc-pi-plus.png'
pincount: 40
eeprom: no
power:
'1':
'2':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'3':
mode: i2c
'5':
mode: i2c
i2c:
'0x68':
alternate: [ '0x69', '0x6A', '0x6B', '0x6C', '0x6D', '0x6E', '0x6F' ]
name: MCP3424
device: MCP3424
'0x69':
alternate: [ '0x68', '0x6A', '0x6B', '0x6C', '0x6D', '0x6E', '0x6F' ]
name: MCP3424
device: MCP3424
-->
# ADC Pi Plus (Discontinued)
The ADC Pi Plus is an 8 channel 17 bit analogue to digital converter designed to work with the Raspberry Pi. The ADC Pi Plus is based on two Microchip MCP3424 A/D converters each containing 4 analogue inputs. The MCP3424 is a delta-sigma A/D converter with low noise differential inputs. The board is stackable allowing you to use up to four ADC Pi Plus boards on a Raspberry Pi.
## Features
- 8 x 17-bit 0 to 5V Single Ended Inputs
- Control via the Raspberry Pi I2C port
- Stack up to 4 ADC Pi Plus boards on a single Raspberry Pi
- Jumper selectable I2C addresses (0x68 to 0x6F)
- Buffered 5V I2C port
- Based on the MCP3424 from Microchip Technologies Inc
- Single Ended full-scale range of 5.0V
- On-board 2.048V reference voltage (Accuracy ± 0.05%, Drift: 15 ppm/°C)
- On-Board Programmable Gain Amplifier (PGA): Gains of 1, 2, 4 or 8
- Programmable Data Rate Options:
- 3.75 SPS (17 bits)
- 15 SPS (15 bits)
- 60 SPS (13 bits)
- 240 SPS (11 bits)
- One-Shot or Continuous Conversion Options
Arduino, C, Node.js, Windows 10 IOT, Python 2 and Python 3 libraries are available on GitHub.

63
src/zh/overlay/ab-adc-pi.md Normal file
View File

@ -0,0 +1,63 @@
<!--
---
name: ADC Pi
class: board
type: adc
formfactor: pHAT
manufacturer: AB Electronics UK
description: 8 channel Analogue to Digital Converter
url: https://www.abelectronics.co.uk/p/69/adc-pi-raspberry-pi-analogue-to-digital-converter
github: https://github.com/abelectronicsuk
schematic: https://www.abelectronics.co.uk/docs/pdf/schematic-adc-pi.pdf
buy: https://www.abelectronics.co.uk/p/69/adc-pi-raspberry-pi-analogue-to-digital-converter
image: 'ab-adc-pi.png'
pincount: 40
eeprom: no
power:
'1':
'2':
ground:
'6':
'14':
'20':
'30':
'34':
'39':
pin:
'3':
mode: i2c
'5':
mode: i2c
i2c:
'0x68':
alternate: [ '0x69', '0x6A', '0x6B', '0x6C', '0x6D', '0x6E', '0x6F' ]
name: MCP3424
device: MCP3424
'0x69':
alternate: [ '0x68', '0x6A', '0x6B', '0x6C', '0x6D', '0x6E', '0x6F' ]
name: MCP3424
device: MCP3424
-->
# ADC Pi
The ADC Pi is an 8 channel 17 bit analogue to digital converter designed to work with the Raspberry Pi. The ADC Pi is based on two Microchip MCP3424 A/D converters each containing 4 analogue inputs. The MCP3424 is a delta-sigma A/D converter with low noise differential inputs.
## Features
- 8 x 17-bit 0 to 5V Single Ended Inputs
- Control via the Raspberry Pi I2C port
- Stack up to 4 ADC Pi boards on a single Raspberry Pi
- Jumper selectable I2C addresses (0x68 to 0x6F)
- Buffered 5V I2C port
- Based on the MCP3424 from Microchip Technologies Inc
- Single Ended full-scale range of 5.0V
- On-board 2.048V reference voltage (Accuracy ± 0.05%, Drift: 15 ppm/°C)
- On-Board Programmable Gain Amplifier (PGA): Gains of 1, 2, 4 or 8
- Programmable Data Rate Options:
- 3.75 SPS (17 bits)
- 15 SPS (15 bits)
- 60 SPS (13 bits)
- 240 SPS (11 bits)
- One-Shot or Continuous Conversion Options
Python, C, C++, Node.js and Windows 10 IOT libraries are available on GitHub.

52
src/zh/overlay/ab-adcdac-pi-zero.md Normal file
View File

@ -0,0 +1,52 @@
<!--
---
name: ADC-DAC Pi Zero
class: board
type: adc
formfactor: pHAT
manufacturer: AB Electronics UK
description: 2 channel Analogue to Digital Converter and 2 channel Digital to Analogue Converter
url: https://www.abelectronics.co.uk/p/74/adc-dac-pi-zero-raspberry-pi-adc-and-dac-expansion-board
github: https://github.com/abelectronicsuk
schematic: https://www.abelectronics.co.uk/docs/pdf/schematic-adc-dac-pi-zero.pdf
buy: https://www.abelectronics.co.uk/p/74/adc-dac-pi-zero-raspberry-pi-adc-and-dac-expansion-board
image: 'ab-adcdac-pi-zero.png'
pincount: 40
eeprom: no
power:
'1':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'19':
mode: spi
'21':
mode: spi
'23':
mode: spi
'24':
mode: spi
'26':
mode: spi
install:
'devices':
- 'spi'
-->
# ADC-DAC Pi Zero
The ADC-DAC Pi Zero is a 2 channel 12 bit analogue to digital converter and 2 channel 12 bit digital to analogue converter designed to work with the Raspberry Pi. Designed for the same footprint as the Raspberry Pi Zero the ADC-DAC Pi Zero is also compatible with full size Raspberry Pi models.
The ADC-DAC Pi Zero is based on the Microchip MCP3202 A/D converter containing 2 analogue inputs with 12 bit resolution with a Microchip MCP4822 dual channel 12-bit DAC with internal voltage reference.
Max ADC Sample Rate: 100 ksamples/sec
Max ADC Sample Rate under Python: 12,000 samples per second.
Python, C, C++, Node.js and Windows 10 IOT libraries are available on GitHub.

66
src/zh/overlay/ab-expander-pi.md Normal file
View File

@ -0,0 +1,66 @@
<!--
---
name: Expander Pi
class: board
type: adc, dac, io, rtc
formfactor: HAT
manufacturer: AB Electronics UK
description: 8 ADC inputs, 2 DAC outputs, 16 IO channels and a Real-Time Clock
url: https://www.abelectronics.co.uk/p/50/expander-pi
github: https://github.com/abelectronicsuk
schematic: https://www.abelectronics.co.uk/docs/pdf/schematic-expander_pi.pdf
buy: https://www.abelectronics.co.uk/p/50/expander-pi
image: 'ab-expander-pi.png'
pincount: 40
eeprom: no
power:
'1':
'2':
ground:
'6':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'3':
mode: i2c
'5':
mode: i2c
'19':
mode: spi
'21':
mode: spi
'22':
name: LDAC
mode: output
active: high
'23':
mode: spi
'24':
mode: spi
'26':
mode: spi
i2c:
'0x20':
name: MCP23017
device: MCP23017
'0x68':
name: DS1307
device: DS1307
-->
# Expander Pi
Expander Pi is a versatile digital and analogue expansion board. It allows you to connect your Raspberry Pi to switches, lights, sensors, and many other devices giving you a way to communicate with the outside world.
## Features
8 channel MCP3208 12-bit ADC with a maximum sample rate of 100 ksps and includes a 4.096 volt precision voltage reference.
2 channel MCP4822 12-bit DAC with an internal voltage reference.
16 digital I/O channels, using an MCP23017 16-bit I/O expander with a maximum input of 5 volts on each channel.
A Real Time Clock using a DS1307 RTC and a CR2032 battery to maintain the date and time when the main system power is not available.
Python, C, C++, Node.js and Windows 10 IOT libraries are available on GitHub.

62
src/zh/overlay/ab-io-pi-plus.md Normal file
View File

@ -0,0 +1,62 @@
<!--
---
name: IO Pi Plus
class: board
type: io
formfactor: HAT
manufacturer: AB Electronics UK
description: 32 Channel Digital Expansion Board
url: https://www.abelectronics.co.uk/p/54/io-pi-plus
github: https://github.com/abelectronicsuk
schematic: https://www.abelectronics.co.uk/docs/pdf/schematic-iopiplus-2-1.pdf
buy: https://www.abelectronics.co.uk/p/54/io-pi-plus
image: 'ab-io-pi-plus.png'
pincount: 40
eeprom: no
power:
'1':
'2':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'3':
mode: i2c
'5':
mode: i2c
i2c:
'0x20':
alternate: [ '0x21', '0x22', '0x23', '0x24', '0x25', '0x26', '0x27' ]
name: MCP23017
device: MCP23017
'0x21':
alternate: [ '0x20', '0x22', '0x23', '0x24', '0x25', '0x26', '0x27' ]
name: MCP23017
device: MCP23017
-->
# IO Pi Plus
The IO Pi Plus is a 32 channel digital expansion board designed for use on the Raspberry Pi. The board is based around the MCP23017 16-bit I/O expander from Microchip Technology Inc.
A pair of MCP23017 expanders are included on the board allowing you to connect up to 32 digital inputs or outputs to the Raspberry Pi. The IO Pi Plus Expander is powered through the host Raspberry Pi using the GPIO port and extended pins on the GPIO connector allow you to stack the IO Pi Plus along with other expansion boards.
## Features
- 32 Digital Inputs/Outputs
- Control via the Raspberry Pi I2C port
- Stack up to 4 IO Pi boards on a single Raspberry Pi
- Jumper selectable I2C addresses
- External 5V Input with isolation jumper
- Based on the MCP23017 from Microchip Technologies Inc
- Configurable interrupt output pins - Configurable as active-high, active-low or open-drain
- INTA and INTB can be configured to operate independently or together
- Configurable interrupt source - Interrupt-on-change from configured register defaults or pin changes
- Polarity Inversion register to configure the polarity of the input port data
Python, C, C++, Node.js and Windows 10 IOT libraries are available on GitHub.

58
src/zh/overlay/ab-io-pi-zero.md Normal file
View File

@ -0,0 +1,58 @@
<!--
---
name: IO Pi Zero
class: board
type: io
formfactor: pHAT
manufacturer: AB Electronics UK
description: 16 Channel Digital Expansion Board
url: https://www.abelectronics.co.uk/p/71/io-pi-zero
github: https://github.com/abelectronicsuk
schematic: https://www.abelectronics.co.uk/docs/pdf/schematic-iopizero.pdf
buy: https://www.abelectronics.co.uk/p/71/io-pi-zero
image: 'ab-io-pi-zero.png'
pincount: 40
eeprom: no
power:
'1':
'2':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'3':
mode: i2c
'5':
mode: i2c
i2c:
'0x20':
alternate: [ '0x21', '0x22', '0x23', '0x24', '0x25', '0x26', '0x27' ]
name: MCP23017
device: MCP23017
-->
# IO Pi Zero
The IO Pi Zero is a 16 channel digital expansion board designed for use on the Raspberry Pi Zero. The board is based around the MCP23017 16-bit I/O expander from Microchip Technology Inc.
The IO Pi Zero Expander is powered through the host Raspberry Pi using the GPIO port and extended pins on the GPIO connector allow you to stack the IO Pi Zero along with other expansion boards.
## Features
- 16 Digital Inputs/Outputs
- Control via the Raspberry Pi I2C port
- Stack up to 8 IO Pi boards on a single Raspberry Pi
- Jumper selectable I2C addresses
- External 5V Input with isolation solder bridge
- Based on the MCP23017 from Microchip Technologies Inc
- Configurable interrupt output pins - Configurable as active-high, active-low or open-drain
- INTA and INTB can be configured to operate independently or together
- Configurable interrupt source - Interrupt-on-change from configured register defaults or pin changes
- Polarity Inversion register to configure the polarity of the input port data
Python, C, C++, Node.js and Windows 10 IOT libraries are available on GitHub.

49
src/zh/overlay/ab-rs485-pi.md Normal file
View File

@ -0,0 +1,49 @@
<!--
---
name: RS485 Pi
class: board
type: com
formfactor: pHAT
manufacturer: AB Electronics UK
description: UART to RS485 Converter
url: https://www.abelectronics.co.uk/p/77/rs485-pi
github: https://github.com/abelectronicsuk
schematic: https://www.abelectronics.co.uk/docs/pdf/schematic-rs485pi.pdf
buy: https://www.abelectronics.co.uk/p/77/rs485-pi
image: 'ab-rs485-pi.png'
pincount: 40
eeprom: no
power:
'1':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'8':
mode: UART
'10':
mode: UART
-->
# RS485 Pi
The RS485 Pi is a UART to RS485 serial converter for the Raspberry Pi.
The RS485 port is connected to the UART port on the Raspberry Pi using a SN65HVD72 interface. The SN65HVD72 IC converts the 3.3V UART port to RS485 differential voltages allowing communication with RS485 compatible devices over a twisted pair cable. The RS485 port can be accessed through the DB9 port or the solder points on the PCB.
The RS485 Pi contains protection against voltage spikes in the form of a TVS Diode and two 10O, Pulse-Proof Thick-Film Resistors. A 120O terminator resistor is included with the board.
## Features
- RS-485 Half Duplex Port.
- Up to 250 kbps transfer rate.
- Use the Raspberry Pi to control external RS-485 devices.
- Stackable with other Raspberry Pi accessory boards.
- Mounting holes for use with the AB Electronics UK mounting kits (sold separately)
[Configuring the UART communication on the Raspberry Pi](https://www.abelectronics.co.uk/kb/article/20/raspberry-pi-serial-port-usage)

46
src/zh/overlay/ab-rtc-pi-plus.md Normal file
View File

@ -0,0 +1,46 @@
<!--
---
name: RTC Pi Plus
class: board
type: rtc
formfactor: HAT
manufacturer: AB Electronics UK
description: Real-Time Clock Module for the Raspberry Pi
url: https://www.abelectronics.co.uk/p/70/rtc-pi
github: https://github.com/abelectronicsuk
schematic: https://www.abelectronics.co.uk/docs/stock/raspberrypi/rtcpi/rtcpi-schematic.pdf
buy: https://www.abelectronics.co.uk/p/70/rtc-pi
image: 'ab-rtc-pi-plus.png'
pincount: 40
eeprom: no
power:
'1':
'2':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'3':
mode: i2c
'5':
mode: i2c
i2c:
'0x68':
name: DS1307
device: DS1307
-->
# RTC Pi Plus (Discontinued)
The RTC Pi Plus is a battery backed real-time clock module for the Raspberry Pi. It keeps track of the time while the Raspberry Pi is switched off and allows the Raspberry Pi to retrieve the current date and time from the RTC Pi Plus when it is switched back on.
The RTC Pi Plus is powered through the host Raspberry Pi using the GPIO port and extended pins on the GPIO connector allow you to stack the RTC Pi Plus along with other expansion boards. The RTC Pi Plus uses the DS1307 RTC real time clock and a CR2032 battery to maintain the date and time when the main system power is not available.
Unlike most other DS1307 based RTC modules the RTC Pi also includes an I2C logic level converter allowing you to connect other 5V I2C devices to your Raspberry Pi.
Arduino, C, Node.js, Windows 10 IOT, Python 2 and Python 3 libraries are available on GitHub.

46
src/zh/overlay/ab-rtc-pi.md Normal file
View File

@ -0,0 +1,46 @@
<!--
---
name: RTC Pi
class: board
type: rtc
formfactor: pHAT
manufacturer: AB Electronics UK
description: Real-Time Clock Module for the Raspberry Pi
url: https://www.abelectronics.co.uk/p/70/rtc-pi
github: https://github.com/abelectronicsuk
schematic: https://www.abelectronics.co.uk/docs/pdf/schematic-rtcpi-v3.pdf
buy: https://www.abelectronics.co.uk/p/70/rtc-pi
image: 'ab-rtc-pi.png'
pincount: 40
eeprom: no
power:
'1':
'2':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'3':
mode: i2c
'5':
mode: i2c
i2c:
'0x68':
name: DS1307
device: DS1307
-->
# RTC Pi
The RTC Pi is a battery backed real-time clock module for the Raspberry Pi. It keeps track of the time while the Raspberry Pi is switched off and allows the Raspberry Pi to retrieve the current date and time from the RTC Pi when it is switched back on.
The RTC Pi is powered through the host Raspberry Pi using the GPIO port and extended pins on the GPIO connector allow you to stack the RTC Pi along with other expansion boards. The RTC Pi uses the DS1307 RTC real time clock and a CR2032 battery to maintain the date and time when the main system power is not available.
Unlike most other DS1307 based RTC modules the RTC Pi also includes an I2C logic level converter allowing you to connect other 5V I2C devices to your Raspberry Pi.
Python, C, C++, Node.js and Windows 10 IOT libraries are available on GitHub.

45
src/zh/overlay/ab-serial-pi-plus.md Normal file
View File

@ -0,0 +1,45 @@
<!--
---
name: Serial Pi Plus
class: board
type: com
formfactor: HAT
manufacturer: AB Electronics UK
description: UART to RS232 Converter
url: https://www.abelectronics.co.uk/p/51/serial-pi-plus
github: https://github.com/abelectronicsuk
schematic: https://www.abelectronics.co.uk/docs/pdf/schematic-serial-pi-plus.pdf
buy: https://www.abelectronics.co.uk/p/51/serial-pi-plus
image: 'ab-serial-pi-plus.png'
pincount: 40
eeprom: no
power:
'1':
ground:
'6':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'8':
mode: UART
'10':
mode: UART
-->
# Serial Pi Plus
The Serial Pi Plus is a UART to RS232 serial converter for the Raspberry Pi.
The RS232 port is connected to the UART port on the Raspberry Pi using a MAX3232 interface. The MAX3232 IC converts the 3.3V UART port to RS232 voltages allowing communication with RS232 compatible devices over a DB9 serial cable or with the use of a null-modem cable the board allows terminal access with linux on the Raspberry Pi using a terminal application. The RS232 port can be accessed through the DB9 port or the solder points on the PCB.
## Features
- RS232 Master Port.
- Control the Raspberry Pi over RS232 or connect to external serial accessories.
- Stackable with other Raspberry Pi accessory boards.
- Mounting holes for use with the AB Electronics UK mounting kits (sold separately)
[Configuring the RS232 communication on the Raspberry Pi](https://www.abelectronics.co.uk/kb/article/20/raspberry-pi-serial-port-usage)

45
src/zh/overlay/ab-serial-pi-zero.md Normal file
View File

@ -0,0 +1,45 @@
<!--
---
name: Serial Pi Zero
class: board
type: com
formfactor: pHAT
manufacturer: AB Electronics UK
description: UART to RS232 Converter
url: https://www.abelectronics.co.uk/p/75/serial-pi-zero
github: https://github.com/abelectronicsuk
schematic: https://www.abelectronics.co.uk/docs/pdf/schematic-serialpizero.pdf
buy: https://www.abelectronics.co.uk/p/75/serial-pi-zero
image: 'ab-serial-pi-zero.png'
pincount: 40
eeprom: no
power:
'1':
ground:
'6':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'8':
mode: UART
'10':
mode: UART
-->
# Serial Pi Zero
The Serial Pi Zero is a UART to RS232 serial converter for the Raspberry Pi Zero.
The RS232 port is connected to the UART port on the Raspberry Pi using a MAX3232 interface. The MAX3232 IC converts the 3.3V UART port to RS232 voltages allowing communication with RS232 compatible devices over a DB9 serial cable or with the use of a null-modem cable the board allows terminal access with linux on the Raspberry Pi using a terminal application. The RS232 port can be accessed through the DB9 port or the solder points on the PCB.
## Features
- RS232 Master Port.
- Control the Raspberry Pi over RS232 or connect to external serial accessories.
- Stackable with other Raspberry Pi accessory boards.
- Mounting holes for use with the AB Electronics UK mounting kits (sold separately)
[Configuring the RS232 communication on the Raspberry Pi](https://www.abelectronics.co.uk/kb/article/20/raspberry-pi-serial-port-usage)

46
src/zh/overlay/ab-servo-pwm-pi-zero.md Normal file
View File

@ -0,0 +1,46 @@
<!--
---
name: Servo PWM Pi Zero
class: board
type: io,motor
formfactor: pHAT
manufacturer: AB Electronics UK
description: 16-channel, 12-bit PWM Controller
url: https://www.abelectronics.co.uk/p/72/servo-pwm-pi-zero
github: https://github.com/abelectronicsuk
schematic: https://www.abelectronics.co.uk/docs/pdf/schematic-servopi-zero.pdf
buy: https://www.abelectronics.co.uk/p/72/servo-pwm-pi-zero
image: 'ab-servo-pwm-pi-zero.png'
pincount: 40
eeprom: no
power:
'1':
'2':
ground:
'6':
'14':
'20':
'30':
'39':
pin:
'3':
mode: i2c
'5':
mode: i2c
'7':
name: OE
mode: output
active: high
i2c:
'0x40':
alternate: [ '0x40', '0x41', '0x42', '0x43', '0x44', '0x45', '0x46', '0x47', '0x48', '0x49', '0x4A', '0x4B', '0x4C', '0x4D', '0x4E', '0x4F','0x50', '0x51', '0x52', '0x53', '0x54', '0x55', '0x56', '0x57', '0x58', '0x59', '0x5A', '0x5B', '0x5C', '0x5D', '0x5E', '0x5F','0x60', '0x61', '0x62', '0x63', '0x64', '0x65', '0x66', '0x67', '0x68', '0x69', '0x6A', '0x6B', '0x6C', '0x6D', '0x6E', '0x6F','0x70', '0x71', '0x72', '0x73', '0x74', '0x75', '0x76', '0x77', '0x78', '0x79', '0x7A', '0x7B', '0x7C', '0x7D', '0x7E', '0x7F' ]
name: PCA9685
device: PCA9685
-->
# Servo PWM Pi Zero
The Servo PWM Pi Zero is a 16-channel, 12-bit PWM controller for the Raspberry Pi, suitable for driving LEDs and radio control servos. The board is based around PCA9685 PWM I2C LED controller IC from NXT and can drive each of the 16 outputs with 12 bit (4096 steps) duty cycle from 0% to 100%.
The output frequency is programmable from a typical 40Hz to 1000Hz. Each output driver is programmed to be either open-drain with a 22 mA current sink capability at 5 V or totem pole with a 22 mA sink, 10 mA source capability at 5 V. 220R current limiting resistors are used on each channel allowing you to connect servos or LEDs directly to the outputs.
Python, C, C++, Node.js and Windows 10 IOT libraries are available on GitHub.

45
src/zh/overlay/adafruit-16x2-lcd.md Normal file
View File

@ -0,0 +1,45 @@
<!--
---
name: 16x2 Character LCD
class: board
type: display
formfactor: Custom
manufacturer: Adafruit
description: 16x2 Character LCD and Keypad
url: https://learn.adafruit.com/adafruit-16x2-character-lcd-plus-keypad-for-raspberry-pi
buy: https://www.adafruit.com/products/1109
image: adafruit-16x2-lcd.png
pincount: 26
eeprom: no
power:
'2':
ground:
'6':
pin:
'3':
mode: i2c
'5':
mode: i2c
i2c:
'0x20':
name: MCP23017
device: MCP23017
-->
# 16x2 Character LCD
This plate makes it easy to use a 16x2 Character LCD. Most character LCDs use lots of GPIO pins, but since this uses I2C you only need two pins.
The keypad gives you buttons to input to the display and it comes with a python library to make it super easy to program.
Note that the same pinout applies to both positive, negative and normal LCD.
To install:
```bash
sudo apt-get update
sudo apt-get install build-essential python-dev python-smbus python-pip git
sudo pip install RPi.GPIO
git clone https://github.com/adafruit/Adafruit_Python_CharLCD.git
cd Adafruit_Python_CharLCD
sudo python setup.py install
```

77
src/zh/overlay/adafruit-animated-eyes-bonnet.md Normal file
View File

@ -0,0 +1,77 @@
<!--
---
name: Snake Eyes Bonnet
class: board
type: display
formfactor: pHAT
manufacturer: Adafruit
description: Two 128x128 pixel OLED or TFT LCD for the Raspberry Pi
url: https://learn.adafruit.com/animated-snake-eyes-bonnet-for-raspberry-pi/
buy: https://www.adafruit.com/products/3356
image: adafruit-animated-eyes-bonnet.png
pincount: 40
eeprom: no
power:
'1':
'2':
ground:
'9':
'25':
'39':
'34':
'30':
'20':
'14':
'6':
pin:
'3':
mode: i2c
'5':
mode: i2c
'33':
name: ADC Alert
'15':
name: Button Wink Left
'16':
name: Button Wink Both
'18':
name: Button Wink Right
'19':
mode: spi
'21':
mode: spi
'23':
mode: spi
'24':
mode: spi
'29':
name: DC
'31':
name: Reset
'36':
mode: spi
'38':
mode: spi
'40':
mode: spi
'24':
mode: spi
i2c:
'0x48':
name: Analog Input
device: ads1015
-->
# Snake Eyes Bonnet
The Snake Eyes Bonnet is a Raspberry Pi accessory for driving two 128x128 pixel OLED or TFT LCD displays, and also provides four analog inputs for sensors.
It's perfect for making cosplay masks, props, spooky sculptures for halloween, animatronics, robots...anything where you want to add a pair of animated eyes!
It's a follow-on of sorts to another project: Electronic Animated Eyes Using Teensy 3.2. The Teensy 3.2 is a very capable microcontroller, and the code for that project squeezed every bit of space and performance from it. So why not convert over to a Pi?
To install:
```bash
curl -O https://raw.githubusercontent.com/adafruit/Raspberry-Pi-Installer-Scripts/master/pi-eyes.sh
sudo bash pi-eyes.sh
```

64
src/zh/overlay/adafruit-arcade-bonnet.md Normal file
View File

@ -0,0 +1,64 @@
<!--
---
name: Arcade Bonnet
class: board
type: io
formfactor: pHAT
manufacturer: Adafruit
description: Connect joystick, buttons and speakers to your Pi
url: https://learn.adafruit.com/adafruit-arcade-bonnet-for-raspberry-pi
buy: https://www.adafruit.com/products/3422
image: adafruit-arcade-bonnet.png
pincount: 40
eeprom: no
power:
'1':
'2':
ground:
'6':
'9':
'14':
'20':
'30':
'34':
'39':
'25':
pin:
'3':
mode: i2c
'5':
mode: i2c
'12':
name: I2S Clk
'35':
name: I2S FS
'40':
name: I2S Dout
i2c:
'0x26':
name: MCP23017
device: MCP23017
-->
# Arcade Bonnet
This Adafruit Arcade Bonnet is designed to make small emulator projects a little easier to build. Here are the board's features:
It is the same size as a Pi Zero, so for really compact builds, this is super small. You can use it with a Pi 2, 3, B+ or any 2x20 connector Pi.
It has JST sockets so you can plug in six arcade buttons easily.
Header breakouts for use with both clicky-type switched joysticks and...
Header breakout and converter for using analog-type joysticks or thumbsticks with potentiometers inside
A 3W speaker output that can drive 4-8 ohm speakers for when using with a TV output, HDMI display or PiTFT.
Switches are all managed with an I2C-GPIO converter with interrupt out. The converter is very fast and frees up all the pins so you can use this Bonnet with a PiTFT or any other accessory/device that uses a lot of pins!
To install:
```bash
curl -O https://raw.githubusercontent.com/adafruit/Raspberry-Pi-Installer-Scripts/master/arcade-bonnet.sh
sudo bash arcade-bonnet.sh
curl -sS https://raw.githubusercontent.com/adafruit/Raspberry-Pi-Installer-Scripts/master/i2samp.sh | bash
```

67
src/zh/overlay/adafruit-cap-mpr121.md Normal file
View File

@ -0,0 +1,67 @@
<!--
---
name: Capacitive Touch HAT
class: board
type: touch
formfactor: HAT
manufacturer: Adafruit
description: Create electronics that can react to human touch with up to 12 individual sensors
url: https://www.adafruit.com/products/2340
github: https://github.com/adafruit/Adafruit_Python_MPR121
buy: https://www.adafruit.com/products/2340
image: 'adafruit-cap-mpr121.png'
pincount: 40
eeprom: yes
power:
'1':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'3':
mode: i2c
'5':
mode: i2c
i2c:
'0x5A':
name: Cap Touch
device: mpr121
install:
'devices':
- 'i2c'
'apt':
- 'python-smbus'
- 'python3-smbus'
- 'python-dev'
- 'python3-dev'
-->
# Capacitive Touch HAT
This Raspberry Pi add-on board provides 12 capacitive touch inputs and all the logic to read them over a simple I2C communication bus.
Baded on the MPR121 chip, this HAT allows you to create electronics that can react to human touch, with up to 12 individual sensors.
## Code
```python
from Adafruit_MPR121 import MPR121
from time import sleep
cap = MPR121.MPR121()
last_touched = cap.touched()
while True:
current_touched = cap.touched()
for i in range(12):
pin_bit = 1 << i
if current_touched & pin_bit and not last_touched & pin_bit:
print("{} touched!".format(i))
last_touched = current_touched
sleep(0.1)
```

48
src/zh/overlay/adafruit-gps-hat.md Normal file
View File

@ -0,0 +1,48 @@
<!--
---
name: Ultimate GPS HAT
class: board
type: gps,rtc
formfactor: HAT
manufacturer: Adafruit
description: Add precision time and location to your Raspberry Pi
url: https://learn.adafruit.com/adafruit-ultimate-gps-hat-for-raspberry-pi
schematic: https://learn.adafruit.com/assets/21938
buy: https://www.adafruit.com/products/2324
image: 'adafruit-gps-hat.png'
pincount: 40
eeprom: no
power:
'1':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'7':
name: PPS
'8':
mode: UART
'10':
mode: UART
-->
# Ultimate GPS HAT
The Ultimate GPS HAT from Adafruit adds precision time and location to your Raspberry Pi.
Features:
* 165 dBm sensitivity, 10 Hz updates, 66 channels
* Only 20mA current draw
* Built in Real Time Clock (RTC)
* PPS output on fix
* Works up to ~32Km altitude
* Internal patch antenna + u.FL connector for external active antenna
* Fix status LED blinks when the GPS has determined the current coordinates
* break-outs for all the Raspberry Pi's extra pins
* Prototyping area for adding LEDs, sensors, and more

65
src/zh/overlay/adafruit-joybonnet.md Normal file
View File

@ -0,0 +1,65 @@
<!--
---
name: Joy Bonnet
class: board
type: io
formfactor: pHAT
manufacturer: Adafruit
description: Handheld Arcade Controller for Raspberry Pi
url: https://learn.adafruit.com/adafruit-joy-bonnet-for-raspberry-pi
github: https://github.com/adafruit/adafruit-retrogame
buy: https://www.adafruit.com/product/3464
image: 'adafruit-joybonnet.png'
pincount: 40
eeprom: no
power:
'1':
'2':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'3':
mode: i2c
'5':
mode: i2c
'15':
name: Player 1
'16':
name: Player 2
'31':
name: Button B
'32':
name: Button A
'33':
name: Button Y
'36':
name: Button X
'37':
name: Start
'38':
name: Select
i2c:
'0x48':
name: ADC
device: ADS1015
-->
# Joy Bonnet
This add on board fits perfectly on top of your Raspberry Pi Zero (any kind) and gives you hand-held arcade controls.
The controls will act like a keyboard, for easy-to-use operation within any emulator or media player.
The Joy Bonnet works best with RetroPie/EmulationStation. You can emulate NES and MAME game controllers easily, but any emulator should work.
To install:
```bash
curl -O https://raw.githubusercontent.com/adafruit/\
Raspberry-Pi-Installer-Scripts/master/joy-bonnet.sh
sudo bash joy-bonnet.sh
```

60
src/zh/overlay/adafruit-motor-hat.md Normal file
View File

@ -0,0 +1,60 @@
<!--
---
name: DC & Stepper Motor HAT
class: board
type: motor
formfactor: HAT
manufacturer: Adafruit
description: Drive 4 DC Motors or 2 Stepper Motors with a Raspberry Pi
url: https://learn.adafruit.com/adafruit-dc-and-stepper-motor-hat-for-raspberry-pi
buy: https://www.adafruit.com/products/2348
image: adafruit-motor-hat.png
pincount: 40
eeprom: yes
power:
'17':
'1':
ground:
'9':
'25':
'39':
'34':
'30':
'20':
'14':
'6':
pin:
'3':
mode: i2c
'5':
mode: i2c
i2c:
'0x20':
name: TB6612
device: TB6612
-->
# DC & Stepper Motor HAT
Let your robotic dreams come true with the new DC+Stepper Motor HAT from Adafruit. This Raspberry Pi add-on is perfect for any motion project as it can drive up to 4 DC or 2 Stepper motors with full PWM speed control.
Since the Raspberry Pi does not have a lot of PWM pins, we use a fully-dedicated PWM driver chip onboard to both control motor direction and speed. This chip handles all the motor and speed controls over I2C. Only two pins (SDA & SCL) are required to drive the multiple motors, and since it's I2C you can also connect any other I2C devices or HATs to the same pins. In fact, you can even stack multiple Motor HATs, up to 32 of them, for controlling up to 64 stepper motors or 128 DC motors (or a mix of the two)
## Specifications
4 H-Bridges: TB6612 chipset provides 1.2A per bridge with thermal shutdown protection, internal kickback protection diodes.
Can run motors on 4.5VDC to 13.5VDC.
Up to 4 bi-directional DC motors with individual 8-bit speed selection (so, about 0.5% resolution)
Up to 2 stepper motors (unipolar or bipolar) with single coil, double coil, interleaved or micro-stepping.
Polarity protected 2-pin terminal block and jumper to connect external 5-12VDC power
To install:
```bash
git clone https://github.com/adafruit/Adafruit-Motor-HAT-Python-Library.git
cd Adafruit-Motor-HAT-Python-Library
sudo apt-get install python-dev
sudo python setup.py install
```

65
src/zh/overlay/adafruit-oled-bonnet.md Normal file
View File

@ -0,0 +1,65 @@

<!--
---
name: OLED Bonnet
class: board
type: Display
formfactor: pHAT
manufacturer: Adafruit
description: A 128x64 display with jostick and buttons for your Pi
url: https://learn.adafruit.com/adafruit-128x64-oled-bonnet-for-raspberry-pi
github: https://github.com/adafruit/Adafruit_Python_SSD1306
buy: https://www.adafruit.com/product/3531
image: 'adafruit-oled-bonnet.png'
pincount: 40
eeprom: no
power:
'1':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'3':
mode: i2c
'5':
mode: i2c
'7':
name: Joystick center
'13':
name: Joystick left
'16':
name: Joystick right
'11':
name: Joystick up
'15':
name: Joystick down
'29':
name: Button A
'31':
name: Button B
i2c:
'0x3c':
name: Display Driver
device: ssd1306
-->
# OLED Bonnet
The OLED Bonnet is a simple 128x64 display for the Raspberry pi with a 5-way joystick and 2 push buttons.
The 1.3" screen is made of a 128x64 individual white OLED pixels and because the display makes its own light, no backlight is required. This reduces the power required to run the OLED and is why the display has such high contrast.
To install the necessary software, use the following commands:
```bash
sudo apt-get install git python-imaging python-smbus
git clone https://github.com/adafruit/Adafruit_Python_SSD1306
cd Adafruit_Python_SSD1306
sudo python setup.py install
```

45
src/zh/overlay/adafruit-pi-oled.md Normal file
View File

@ -0,0 +1,45 @@
<!--
---
name: PiOLED
class: board
type: Display
formfactor: Custom
manufacturer: Adafruit
description: A small 128x32 display for your Pi
url: https://learn.adafruit.com/adafruit-pioled-128x32-mini-oled-for-raspberry-pi
github: https://github.com/adafruit/Adafruit_Python_SSD1306
buy: https://www.adafruit.com/product/3527
image: 'adafruit-pi-oled.png'
pincount: 6
eeprom: no
power:
'1':
ground:
'6':
pin:
'3':
mode: i2c
'5':
mode: i2c
i2c:
'0x3c':
name: Display Driver
device: ssd1306
-->
# PiOLED
The PiOLED is a small 128x32 OLED display designed to sit on top of just the first six pins of the Pi’s Header. It uses I2c to communicate which means there are plenty of spare pins for buttons, LED’s and sensors.
The OLED display has a very high contrast ratio leading to clear and crisp text and images and as the display produces it’s own light this also means the PiOLED is extremely low power.
The display is about 1” in diagonal and allows for 30FPS updates rates allowing for simple animations and the SSD1306 chipset is easily controlled using a simple python library.
To install the necessary software, use the following commands:
```bash
sudo apt-get install git python-imaging python-smbus
git clone https://github.com/adafruit/Adafruit_Python_SSD1306
cd Adafruit_Python_SSD1306
sudo python setup.py install
```

32
src/zh/overlay/adafruit-pi-rtc.md Normal file
View File

@ -0,0 +1,32 @@
<!--
---
name: PiRTC
class: board
type: rtc
formfactor: Custom
manufacturer: Adafruit
description: Add a simple RTC to your Pi
url: https://learn.adafruit.com/adding-a-real-time-clock-to-raspberry-pi/set-up-and-test-i2c
buy: https://www.adafruit.com/products/3386
image: adafruit-pi-rtc.png
pincount: 6
eeprom: no
power:
'1':
ground:
'6':
pin:
'3':
mode: i2c
'5':
mode: i2c
i2c:
'0x68':
name: PCF8523
device: PCF8523
-->
# PiRTC
This is a great battery-backed real time clock (RTC) that allows your Raspberry Pi project to keep track of time if the power is lost. Perfect for data-logging, clock-building, time-stamping, timers and alarms, etc. Equipped with PCF8523 RTC, it works great with the Raspberry Pi and has native kernel support.
This RTC will keep the time for about 5 years. The PCF8523 is simple and inexpensive but not a high precision device. It may lose or gain a second or two per day.

77
src/zh/overlay/adafruit-pigrrl-pcb.md Normal file
View File

@ -0,0 +1,77 @@
<!--
---
name: PiGRRL Gamepad
class: board
type: io
formfactor: Custom
manufacturer: Adafruit
description: An add-on board for the Raspberry Pi
url: https://learn.adafruit.com/pigrrl-2
buy: https://www.adafruit.com/product/3015
image: 'adafruit-pigrrl-pcb.png'
pincount: 40
eeprom: no
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'8':
name: 'Button A'
mode: input
active: low
'10':
name: 'Button B'
mode: input
active: low
'12':
name: 'Button Y'
mode: input
active: low
'32':
name: 'Button L'
mode: input
active: low
'33':
name: 'Button R'
mode: input
active: low
'38':
name: 'Button X'
mode: input
active: low
'7':
name: 'D-Pad Left'
mode: input
active: low
'29':
name: Select
mode: input
active: low
'31':
name: Start
mode: input
active: low
'35':
name: 'D-Pad Right'
mode: input
active: low
'36':
name: 'D-Pad Up'
mode: input
active: low
'37':
name: 'D-Pad Down'
mode: input
active: low
-->
# PiGRRL Gamepad
The PiGRRL Gamepad PCB is designed for use in portable gaming projects like the PiGRRL 2 but it's basically a set of buttons wired between ground and select GPIO.
All button inputs should be configured with their corresponding internal pull-ups. Note that there are no protection circuitry, so be sure not to drive the GPIO high and short them to ground via button actions!

57
src/zh/overlay/adafruit-pitft-35-plus.md Normal file
View File

@ -0,0 +1,57 @@
<!--
---
name: PiTFT Plus 3.5"
class: board
type: display
formfactor: Custom
manufacturer: Adafruit
description: A TFT Display for the Raspberry Pi
url: https://learn.adafruit.com/adafruit-pitft-3-dot-5-touch-screen-for-raspberry-pi
github: https://github.com/adafruit/Adafruit-PiTFT-3.5-Plus-PCB
schematic: https://learn.adafruit.com/assets/26348
buy: https://www.adafruit.com/products/2441
image: 'adafruit-pitft-35-plus.png'
pincount: 40
eeprom: setup
power:
'1':
'2':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'12':
name: Backlight Control
mode: output
'18':
name: RT Interrupt
mode: input
'22':
name: TFT Data/Command
mode: output
'19':
mode: spi
'21':
mode: spi
'23':
mode: spi
'24':
name: TFT Chip Select
mode: chipselect
'26':
name: RT Chip Select
mode: chipselect
-->
# PiTFT Plus 3.5"
The PiTFT+ features a 3.5" display with 480x320 16-bit color pixels and a resistive touch overlay and is engineered specifically to work with the Raspberry Pi 3, 2 and the Model A+/B+.
The display uses the hardware SPI pins as well as GPIO #25 and #24. GPIO #18 can be used to PWM dim the backlight. A 2x13 'classic' GPIO header on the bottom, with additional GPIO pins broken out into solder pads, allows you to use more of the GPIO.
The PiTFT+ can be used as a display for running the X interface, or the console. You can also have an HDMI display separately connected to complement the setup, keeping in mind that there can only be one X session running (so you'll need to choose where X should be output, on the HDMI or the PiTFT+).

71
src/zh/overlay/adafruit-rgb-matrix-hat.md Normal file
View File

@ -0,0 +1,71 @@
<!--
---
name: RGB Matrix HAT + RTC
class: board
type: led,rtc
formfactor: HAT
manufacturer: Adafruit
description: Run large HUB75 matrices of a Raspberry Pi
url: https://learn.adafruit.com/adafruit-rgb-matrix-plus-real-time-clock-hat-for-raspberry-pi
buy: https://www.adafruit.com/products/2345
image: adafruit-rgb-matrix-hat.png
pincount: 40
eeprom: yes
power:
'1':
'2':
ground:
'9':
'25':
'39':
'34':
'30':
'20':
'14':
'6':
pin:
'3':
mode: I2C
'5':
mode: I2C
'29':
'33':
'31':
'32':
'36':
'16':
'7':
'11':
'40':
'15':
'37':
'13':
'38':
i2c:
'0x68':
name: DS1307
device: DS1307
-->
# RGB Matrix HAT + RTC
This HAT plugs into your Pi and makes it super easy to control RGB matrices such as those you see in the likes of Times square enabling you to create a colourful scrolling display or mini LED wall with ease. A 5V power supply is also required, not included, for powering the matrix itself. The Pi cannot do it due to the high currents. To calculate the max current of your matrix set up, multiply the width of all the chained matrix by 0.12 : A 32 pixel wide matrix needs 32*0.12 = 3.85A so pick up a 5V 4A power supply. Please note: this HAT is only for use with HUB75 type RGB Matrices. Not for use with NeoPixel, DotStar, or other 'addressable' LEDs.
## Features
Simple design - plug in power, plug in IDC cable, run our Python code!
Power protection circuitry - you can plug a 5V 4A wall adapter into the HAT and it will automatically protect against negative, over or under-voltages! Yay for no accidental destruction of your setup.
Onboard level shifters to convert the RasPi's 3.3V to 5.0V logic for clean and glitch free matrix driving
DS1307 Real Time Clock can keep track of time for the Pi even when it is rebooted or powered down, to make for really nice time displays
To install:
```bash
sudo apt-get update
sudo apt-get install python-dev python-imaging
wget https://github.com/adafruit/rpi-rgb-led-matrix/archive/master.zip
unzip master.zip
cd rpi-rgb-led-matrix-master/
make
```

49
src/zh/overlay/adafruit-servo-hat.md Normal file
View File

@ -0,0 +1,49 @@
<!--
---
name: Servo/PWM HAT
class: board
type: io,motor
formfactor: HAT
manufacturer: Adafruit
description: A 16-Channel Servo / PWM HAT for Raspberry Pi
url: https://www.adafruit.com/product/2327
github: https://github.com/adafruit/Adafruit_Python_PCA9685
buy: https://www.adafruit.com/product/2327
image: 'adafruit-servo-hat.png'
pincount: 40
eeprom: yes
power:
'1':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'3':
mode: i2c
'5':
mode: i2c
i2c:
'0x40':
name: PWM Controller
device: pca9685
install:
'devices':
- 'i2c'
'apt':
- 'python-smbus'
- 'python3-smbus'
- 'python-dev'
- 'python3-dev'
-->
# Servo/PWM HAT
The Adafruit Servo/PWM HAT allows you to drive up to 16 servos or PWM outputs over I2C with only 2 pins.
The on-board PWM controller will drive all 16 channels simultaneously with no additional processing overhead for the Raspberry Pi. Using a binary addressing system set by jumpers you can solder on the PCB, it is possible to stack up to 62 HATs to control up to 992 servos, using nothing more than the I2C bus.
Important note: servos can use a lot of power and it is not a good idea to use the Raspberry Pi's 5v pin to power them up. Electrical noise and 'brownouts' from excess current draw could cause your Pi to act erratically, reset and/or overheat. Keep the Pi power supply and the servos power supply completely separate!

45
src/zh/overlay/adafruit-speaker-bonnet.md Normal file
View File

@ -0,0 +1,45 @@
<!--
---
name: Speaker Bonnet
class: board
type: audio
formfactor: pHAT
manufacturer: Adafruit
description: 3W Stereo Amplifier Bonnet for Raspberry Pi
url: https://learn.adafruit.com/adafruit-speaker-bonnet-for-raspberry-pi
schematic: https://learn.adafruit.com/assets/37882
buy: https://www.adafruit.com/products/3346
image: 'adafruit-speaker-bonnet.png'
pincount: 40
eeprom: no
power:
'1':
'2':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'12':
name: I2S
'35':
name: I2S
'40':
name: I2S
-->
# Speaker Bonnet
The Speaker Bonnet is a 3W stereo amplifier add-on for the Raspberry Pi. It uses I2S, so you get really crisp audio. The digital data goes right into the amplifier so there's no static like you hear from the headphone jack. It works with any and all Raspberry Pi computers with a 2x20 connector - A+, B+, Zero, Pi 2, Pi 3.
Once soldered just plug in any 4Ω to 8Ω speakers through the terminal blocks or Adafruit’s speaker set through the JST.
To install:
```bash
curl -sS https://raw.githubusercontent.com/adafruit/\
Raspberry-Pi-Installer-Scripts/master/i2samp.sh | bash
```

60
src/zh/overlay/adafruit-tft-kippah.md Normal file
View File

@ -0,0 +1,60 @@
<!--
---
name: DPI TFT Kippah
class: board
type: display
formfactor: HAT
manufacturer: Adafruit
description: Run 40 pin TFT's of a Raspberry Pi
url: https://learn.adafruit.com/adafruit-dpi-display-kippah-ttl-tft
buy: https://www.adafruit.com/products/2453
image: adafruit-tft-kippah.png
pincount: 40
eeprom: no
power:
'1':
'2':
ground:
'9':
'25':
'39':
'34':
'30':
'20':
'14':
'6':
pin:
'3':
'5':
'7':
'29':
'31':
'26':
'24':
'21':
'19':
'23':
'32':
'33':
'8':
'10':
'36':
'11':
'12':
'35':
'38':
'40':
-->
# DPI TFT Kippah
A TFT panel connected to a Raspberry Pi without the use of an HDMI decoder? What is this sorcery??? It's the DPI Kippah from Adafruit! This HAT-like* board snaps onto a Raspberry Pi B+, A+, Pi 2, Pi 3 or Zero and with a little software configuration, allows you to have what normally would go out the HDMI port come up on a nice little flat screen.
The catch is this add on board uses nearly every pin available on the Raspberry Pi and those pins are hardcoded, they cannot be moved or rearranged. The pins used are GPIO 2 through 21 inclusive. That means you don't get the UART RX/TX pins (no console cable) and you don't get the standard user I2C pins, the EEPROM I2C pins, or hardware SPI pins. You do get to use pins #22, #23, #24, #25, #26 and #27, and the USB ports are fine to use too.
The other catch is that this display replaces the HDMI/NTSC output, so you can't have the DPI HAT and HDMI working at once, nor can you 'flip' between the two.
Also, there's no PWM's available so you can't have precision backlight control unless you somehow rig up an external PWM generator with a 555 or something.
Please note it is the same pinout for the touchscreen and none touchscreen version of the board.
For installation instructions please follow Adafruit's tutorial linked below

84
src/zh/overlay/adafruit_matrix_bonnet.md Normal file
View File

@ -0,0 +1,84 @@
<!--
---
name: RGB Matrix Bonnet
class: board
type: led
formfactor: pHAT
manufacturer: Adafruit
description: Easily control large matrices
url: https://learn.adafruit.com/adafruit-rgb-matrix-bonnet-for-raspberry-pi/overview
github: https://github.com/adafruit/Raspberry-Pi-Installer-Scripts/blob/master/rgb-matrix.sh
schematic: https://cdn-learn.adafruit.com/assets/assets/000/051/031/original/adafruit_products_schem.png?1518648935
buy: https://www.adafruit.com/product/3211
image: 'adafruit_matrix_bonnet.png'
pincount: 40
eeprom: no
power:
'1':
'2':
'4':
'17':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'29':
name: 'Matrix R1'
'33':
name: 'Matrix G1'
'31':
name: 'Matrix B1'
'32':
name: 'Matrix R2'
'36':
name: 'Matrix G2'
'16':
name: 'Matrix B2'
'7':
name: 'Matrix OE'
'11':
name: 'Matrix CLK'
'40':
name: 'Matrix LAT'
'15':
name: 'Matrix A'
'37':
name: 'Matrix B'
'13':
name: 'Matrix C'
'38':
name: 'Matrix D'
'18':
name: 'Matrix E'
-->
# RGB Matrix Bonnet
This HAT plugs into your Pi and makes it super easy to control RGB matrices, such as those you see in the likes of Times square, enabling you to create a colourful scrolling display or mini LED wall.
* A 5V power supply is also required for powering the matrix itself.
* To calculate the max current of your matrix set up, multiply the width of all the chained matrix by 0.12 : A 32 pixel wide matrix needs 32*0.12 = 3.85A so pick up a 5V 4A power supply.
* This HAT is only for use with HUB75 type RGB Matrices. Not for use with NeoPixel, DotStar, or other 'addressable' LEDs.
Features:
* Simple design - plug in power, plug in IDC cable, code.
* Power protection circuitry - you can plug a 5V 4A wall adapter into the HAT and it will automatically protect against negative, over or under-voltages.
* On-board level shifters - these convert the Raspberry Pi's 3.3V to 5.0V logic for clean and glitch free matrix driving
This bonnet is compatible with any Pi that has a 2x20 header.
To install:
```bash
curl -O https://raw.githubusercontent.com/adafruit/Raspberry-Pi-Installer-Scripts/master/rgb-matrix.sh
sudo bash rgb-matrix.sh
```

59
src/zh/overlay/aiy-vision-bonnet.md Normal file
View File

@ -0,0 +1,59 @@
<!--
---
name: AIY Vision Bonnet
class: board
type: sensor,other
formfactor: pHAT
manufacturer: Google
description: A pHAT that helps you build an intelligent camera that can see and recognize objects using machine learning
url: https://aiyprojects.withgoogle.com/vision
github: https://github.com/google/aiyprojects-raspbian
image: 'aiy-vision-bonnet.png'
pincount: 40
eeprom: yes
power:
'1':
'2':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'3':
mode: i2c
'5':
mode: i2c
'15':
mode: gpio
name: Buzzer
'16':
mode: gpio
name: Button
'19':
mode: spi
'21':
mode: spi
'23':
mode: spi
'24':
mode: spi
'31':
mode: gpio
name: Pi to Myriad IRQ
'33':
mode: gpio
name: Myriad to Pi IRQ
'37':
mode: gpio
-->
# AIY Vision Bonnet
The AIY Vision Bonnet comes with the AIY Vision Kit by Google—a do-it-yourself intelligent camera. The Vision Bonnet connects to your Raspberry Pi to create an intelligent camera that can see and recognize objects using on-device machine learning (ML) models.
The bonnet includes hardware to accelerate vision-based ML models, a connector for the Raspberry Pi Camera v2, a 10-pin button connector, and 4 unique GPIO pins called `PIN_A`, `PIN_B`, `PIN_C`, and `PIN_D`.

59
src/zh/overlay/aiy-voice-bonnet.md Normal file
View File

@ -0,0 +1,59 @@
<!--
---
name: AIY Voice Bonnet
class: board
type: audio,sensor
formfactor: pHAT
manufacturer: Google
description: A pHAT that helps you build an intelligent speaker with voice recognition that connects to the Google Assistant
url: https://aiyprojects.withgoogle.com/voice
github: https://github.com/google/aiyprojects-raspbian
image: 'aiy-voice-bonnet.png'
pincount: 40
eeprom: yes
power:
'1':
'2':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'3':
mode: i2c
'5':
mode: i2c
'8':
mode: uart
name: TXD breakout
'10':
mode: uart
name: RXD breakout
'12':
mode: i2s
name: I2S BCLK
'16':
mode: gpio
name: Button
'35':
mode: i2s
name: I2S LRCLK
'38':
mode: i2s
name: I2S SDIN
'40':
mode: i2s
name: I2S SDOUT
-->
# AIY Voice Bonnet
The AIY Voice Bonnet comes with the AIY Voice Kit V2 by Google—a do-it-yourself intelligent speaker. The Voice Bonnet connects to your Raspberry Pi to create a natural language processor that can respond to your voice and connect to the Google Assistant.
The bonnet includes hardware to facilitate audio capture and playback, stereo speaker terminals, a headphone jack, an 8-pin button connector, UART breakout pins, and 4 unique GPIO pins called `PIN_A`, `PIN_B`, `PIN_C`, and `PIN_D`.
**Note:** If you have the AIY Voice Kit V1, instead see the [Voice Hat](/pinout/voice_hat), which is the full-size HAT version of this board.

72
src/zh/overlay/analog-zero.md Normal file
View File

@ -0,0 +1,72 @@
<!--
---
name: Analog Zero
class: board
type: adc
formfactor: pHAT
manufacturer: RasPiO
description: A 10-bit 8-channel ADC for Raspberry Pi
url: http://rasp.io/analogzero/
github: https://github.com/raspitv/analogzero
buy: http://rasp.io/analogzero/
image: 'analog-zero.png'
pincount: 40
eeprom: no
power:
'1':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'19':
mode: spi
'21':
mode: spi
'23':
mode: spi
'24':
mode: spi
install:
'devices':
- 'spi'
-->
# Analog Zero
The RasPiO Analog Zero offers a compact, inexpensive, easy way to add eight analogue channels to your Raspberry Pi. RasPiO Analog Zero uses an MCP3008 analog to digital converter. It's an SPI driven, 10-bit, 8-channel ADC.
With RasPiO Analog Zero you can:
* read up to 8 analog inputs at once
* make a weather station
* make a digital thermometer
* make a voltmeter
* use potentiometer dials for control and display
* read analog sensors or voltages
* make your own embedded device with minimal footprint
## Code
```python
from gpiozero import MCP3008
from time import sleep
left_pot = MCP3008(0)
light = MCP3008(1)
temperature = MCP3008(2)
right_pot = MCP3008(3)
while True:
print("Left pot value is {}".format(left_pot.value))
print("Light sensor value is {}".format(light.value))
print("Temperature sensor value is {}".format(temperature.value))
print("Right pot value is {}".format(right_pot.value))
sleep(1)
```
[GPIO Zero docs: MCP3008](http://gpiozero.readthedocs.io/en/v1.3.1/api_spi.html#gpiozero.MCP3008)

77
src/zh/overlay/anavi-flex.md Normal file
View File

@ -0,0 +1,77 @@
<!--
---
name: Flex
class: board
type: io,led,multi,relay,sensor
formfactor: HAT
manufacturer: Anavi
collected: Other
description: RabbitMax Flex is a Raspberry Pi HAT board for IoT with an IR transmitter and receiver, relay, button, buzzer, RGB LED, 5x cable slots for I2C sensors, and a slot for 16x2 LCD display module.
url: http://anavi.technology/
github: https://github.com/AnaviTech/anavi-examples
buy: https://www.indiegogo.com/projects/rabbitmax-flex-raspberry-pi-hat-for-iot
image: 'anavi-flex.png'
pincount: 40
eeprom: yes
power:
'1':
'2':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'3':
mode: i2c
'5':
mode: i2c
'7':
name: LCD Display (RS)
'11':
name: IR LED
'12':
name: IR Receiver
'13':
name: LCD Display (Data 0)
'15':
name: LCD Display (Data 1)
'19':
name: LCD Display (Data 2)
'21':
name: LCD Display (Data 3)
'23':
name: Button
mode: input
active: low
'29':
name: Relay
'31':
name: Piezo Buzzer
'33':
name: RGB LED (blue)
'35':
name: RGB LED (green)
'37':
name: RGB LED (red)
'40':
name: LCD Display (E)
-->
# Flex
The Anavi Flex is a flexible HAT for Raspberry Pi suitable for do it yourself (DIY) weather station, automated desk assistant or prototyping Internet of Things (IoT).
RabbitMax Flex Raspberry Pi HAT includes:
* Relay
* IR LED
* IR photo sensor
* Buzzer
* Button
* RGB LED
* Slot for modular LCD character display
* Slots for up to 5 plug and play I2C sensors

62
src/zh/overlay/appliance-hat-mini.md Normal file
View File

@ -0,0 +1,62 @@
<!--
---
name: Appliance HAT Mini
class: board
type: io, relay
formfactor: pHAT
manufacturer: PlasmaDan
description: Raspberry Pi pHAT I/O board with 2 quick connect 16A relays.
url: https://plasmadan.com/appliancehatmini
github: https://github.com/plasmadancom/Appliance-HAT-Mini
schematic: https://plasmadan.shop/appliance-hat-mini-v1-0-schematic/
buy: https://plasmadan.com/appliancehatmini
image: 'appliance-hat-mini.png'
pincount: 40
eeprom: no
power:
'1':
'2':
'4':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'3':
mode: i2c
'5':
mode: i2c
i2c:
'0x20':
alternate: [ '0x21', '0x22', '0x23', '0x24', '0x25', '0x26', '0x27' ]
name: MCP23017
device: MCP23017
-->
# Appliance HAT Mini
The Appliance HAT Mini is a dual SPST relay I/O board based on the Microchip MCP23017 I2C expander. Ideally suited to switching of household appliances, industrial control or home automation applications.
## Features
* 2 opto-isolated quick connect power relays
* Up to 16A @ 250V AC
* Easy to use [interactive web GUI](https://io.plasmadan.com/appliancehatmini/)
* Based on the MCP23017 16-port GPIO expander
* Jumper selectable I2C address & GPIO voltage (3.3V / 5V)
* Can be used with 3.3V or 5V I2C host devices (eg, Arduino)
## Easy Installer
Our easy installer takes care of the setup process automatically.
```
sudo wget https://git.plasmadan.com/install.sh
sudo sh install.sh
```
Alternatively, you can install manually. See our [setup guide](https://github.com/plasmadancom/HAT-GUI#setup-guide).

63
src/zh/overlay/appliance-hat.md Normal file
View File

@ -0,0 +1,63 @@
<!--
---
name: Appliance HAT
class: board
type: io, relay
formfactor: HAT
manufacturer: PlasmaDan
description: Raspberry Pi HAT I/O board with 6 quick connect 16A relays.
url: https://plasmadan.com/appliancehat
github: https://github.com/plasmadancom/Appliance-HAT
schematic: https://plasmadan.shop/appliance-hat-v1-1-schematic/
buy: https://plasmadan.com/appliancehat
image: 'appliance-hat.png'
pincount: 40
eeprom: yes
power:
'1':
'2':
'4':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'3':
mode: i2c
'5':
mode: i2c
i2c:
'0x20':
alternate: [ '0x21', '0x22', '0x23', '0x24', '0x25', '0x26', '0x27' ]
name: MCP23017
device: MCP23017
-->
# Appliance HAT
The Appliance HAT is a 6 channel SPST relay I/O board based on the Microchip MCP23017 I2C expander. Ideally suited to switching of household appliances, industrial control or home automation applications.
## Features
* 6 opto-isolated quick connect power relays
* Up to 16A @ 250V AC
* Easy to use [interactive web GUI](https://io.plasmadan.com/appliancehat/)
* Based on the MCP23017 16-port GPIO expander
* Jumper selectable I2C address & GPIO voltage (3.3V / 5V)
* Can be used with 3.3V or 5V I2C host devices (eg, Arduino)
* Built-in user programmable ID EEPROM
## Easy Installer
Our easy installer takes care of the setup process automatically.
```
sudo wget https://git.plasmadan.com/install.sh
sudo sh install.sh
```
Alternatively, you can install manually. See our [setup guide](https://github.com/plasmadancom/HAT-GUI#setup-guide).

50
src/zh/overlay/audioinjector-zero.md Normal file
View File

@ -0,0 +1,50 @@
<!--
---
name: Audio Injector Zero Sound Card
class: board
type: audio,sensor
formfactor: pHAT
manufacturer: Audio Injector
collected: Other
description: A soundcard with stereo input and output, phones amplifier and electret microhpone input.
url: https://www.audioinjector.net/rpi-zero
github: https://github.com/Audio-Injector/stereo-and-zero
image: 'audioinjector-zero.png'
pincount: 40
eeprom: no
power:
'2':
'4':
'17':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'3':
mode: i2c
'5':
mode: i2c
'12':
mode: i2s
name: I2S BCLK
'35':
mode: i2s
name: I2S LRCLK
'38':
mode: i2s
name: I2S SDIN
'40':
mode: i2s
name: I2S SDOUT
-->
# Audio Injector Zero sound card
A sound card with full functionality, inputs, outputs, headphone amp. and an electret microphone connector. Small enough to fit a Zero!
The zero includes hardware to facilitate stereo audio capture and playback, headphone playback and electret microphone capture. It includes IO breakout boards, cables, headers, audio connectors and the microphone. The headers aren't populated so that you can integrate this small sound card into your designs and wire at will.

75
src/zh/overlay/audioplus.md Normal file
View File

@ -0,0 +1,75 @@
<!--
---
name: RASPIAUDIO AUDIO+
class: board
type: audio
formfactor: phat
manufacturer: RASPIAUDIO
description: An I2S digital to analog audio converter
buy: https://raspiaudio.com
image: 'audioplus.png'
pincount: 40
eeprom: no
power:
'1':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'12':
name: I2S
'35':
name: I2S
'40':
name: I2S
install:
'devices':
- 'i2s'
-->
# Audio +
RaspiAudio enables your Raspberry Pi ( Pi 3, 2, B+, A+, and Zero) with a state of the art audio DAC.
Great for home audio sound systems, an internet radio, or any project with audio.
##Features
1. DAC I2s 24-bit 96KHz audio with studio sampling quality
2. Included dual RCA phono connector line out stereo (soldering required)
3. Line out stereo jack 3.5mm
4. Female header 2x20 (soldering required)
5. Compatible with Raspberry Pi 3, 2, B+, A+, and Zero
## Installation for Raspbian users
* Plug Audio+ firmly on top of your Raspberry Pi GPIO and turn on your Pi
* Make sure your audio jack is plugged in to your amplifier
* Open a terminal and type:
```bash
sudo wget -O - script.raspiaudio.com | bash
```
* Answer yes to reboot
* If everything went fine you should hear a test sound when typing this command:
```bash
sudo speaker-test -l5 -c2 -t wav
```
* NEW! : On the next reboot you will be able to control the volume from your desktop or by using the command-line tool `alsamixer`

89
src/zh/overlay/audioplus_speakerplus.md Normal file
View File

@ -0,0 +1,89 @@
<!--
---
name: RASPIAUDIO AUDIO+ SPEAKERS+
class: board
type: audio,io
formfactor: phat
manufacturer: RASPIAUDIO
description: An I2S digital to analog audio converter with 2X5W STEREO AMP FOR ONBOARD/EXTERNAL SPEAKERS
buy: https://raspiaudio.com
image: 'audioplus_speakerplus.png'
pincount: 40
eeprom: no
power:
'1':
'2':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'12':
name: I2S Clock
'16':
name: Button
mode: input
active: low
'22':
name: LED
mode: output
active: high
'35':
name: I2S WS
'40':
name: I2S Data
install:
'devices':
- 'i2s'
-->
# Audio+ Speaker+
## 2X5W STEREO AMP FOR ONBOARD/EXTERNAL SPEAKERS
* Great for any portable radio project where you need built in speaker
* Power your old speaker directly
* No extra power supply required
##Features:
(There is no microphone on this board, for a microphone see our other model MIC+)
1. 2x5w Stereo Amplification 2 onboard speaker included
2. DAC I2s 24-bit audio with studio sampling quality
3. Line out stereo 3.5mm jack
4. Onboard red button, 1 status led
5. Extension screw terminal for external speakers (2 to 8 ohm)
6. Extension screw terminal for external push button, external led.
7. Soldered Long female header 2x20 (NO soldering required) Compatible with Raspberry Pi 3, 2, B+, A+, and Zero
## Installation for Raspbian users
* Plug Audio+ firmly on top of your Raspberry Pi GPIO and turn on your Pi
* Open a terminal and type the following to download and run the installer:
```bash
sudo wget -O - script.raspiaudio.com | bash
```
* Say yes TO the reboot
* On the next reboot you have to run the test to finish the installation (it is an ALSA oddness):
```bash
sudo speaker-test -l5 -c2 -t wav
```
* Reboot again and you will be able to control the volume from your desktop or by using the command-line tool `alsamixer`

109
src/zh/overlay/audioplus_speakerplus_micplus.md Normal file
View File

@ -0,0 +1,109 @@
<!--
---
name: RASPIAUDIO AUDIO+ SPEAKERS+ MIC+
class: board
type: audio,io
formfactor: phat
manufacturer: RASPIAUDIO
description: An I2S digital to analog audio converter with 2X5W STEREO AMP FOR ONBOARD/EXTERNAL SPEAKERS and detachable ONBOARD I2S MICROPHONE
buy: https://raspiaudio.com
image: 'audioplus_speakerplus_micplus.png'
pincount: 40
eeprom: no
power:
'1':
'2':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'12':
name: I2S Clock
'16':
name: Button
mode: input
active: low
'22':
name: LED
mode: output
active: high
'35':
name: I2S WS
'36':
name: Google Driver
'38':
name: I2S D-In
'40':
name: I2S D-Out
install:
'devices':
- 'i2s'
-->
# Audio+ Speaker+ Microphone+
## 2X5W STEREO AMP FOR ONBOARD/EXTERNAL SPEAKERS
* Experiment with the Google AIY assistant (100% pin to pin compatible).
* Use open source assistants such as ADRIAN, SNIPS project and others
* Voice changer
* Great for any portable radio project where you need a built in speaker
* Power your old speaker directly
* No extra power supply required
## Features
1. Microphone I2S High sensitivity on board (can be separate from the main board using the included cable)
2. 2x5w Stereo Amplification anf 2 onboard speaker included
3. DAC I2s 24-bit audio with studio sampling quality
4. Line out stereo 3.5mm jack
5. Onboard red button, 1 status led
6. Extension screw terminal for external speakers (2 to 8 ohm)
7. Extension screw terminal for external push button and external led.
8. Soldered Long female header 2x20 (NO soldering required) Compatible with Raspberry Pi 3, 2, B+, A+, and Zero
## Installation
* Plug Audio+ firmly on top of your Raspberry Pi GPIO and turn on your Pi
* Open a terminal and type the following to download and run the installer:
```bash
sudo wget -O mic mic.raspiaudio.com
sudo bash mic
```
* Say yes to reboot
* On the next reboot you must run the test to finish the installation (it is an ALSA oddness):
```bash
sudo wget -O test test.raspiaudio.com
sudo bash test
```
* Push the onboard button, you should hear "Front Left" "Front Right" then the recorded sequence by the microphone.
* If the volume is too low you can adjust the gain of the microphone by rebooting and typing the following into a terminal:
```bash
alsamixer
```

101
src/zh/overlay/automation-hat.md Normal file
View File

@ -0,0 +1,101 @@
<!--
---
name: Automation HAT
class: board
type: adc,io,motor,relay
formfactor: HAT
manufacturer: Pimoroni
description: An all-in-one home automation and control board
url: http://shop.pimoroni.com/products/automation-hat
github: https://github.com/pimoroni/automation-hat
buy: http://shop.pimoroni.com/products/automation-hat
image: 'automation-hat.png'
pincount: 40
eeprom: yes
power:
'2':
'17':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'3':
mode: i2c
'5':
mode: i2c
'29':
name: Output 1
mode: output
active: high
'31':
name: Output 3
mode: output
active: high
'32':
name: Output 2
mode: output
active: high
'33':
name: Relay 1
mode: output
active: high
'35':
name: Relay 2
mode: output
active: high
'36':
name: Relay 3
mode: output
active: high
'37':
name: Input 1
mode: input
active: high
'38':
name: Input 2
mode: input
active: high
'40':
name: Input 3
mode: input
active: high
i2c:
'0x54':
name: LED Driver
device: sn3218
'0x48':
name: Analog Input
device: ads1015
install:
'devices':
- 'i2c'
'apt':
- 'python-smbus'
- 'python3-smbus'
'python':
- 'automationhat'
'python3':
- 'automationhat'
-->
# Automation HAT
Automation HAT is a home monitoring and automation controller for the Raspberry Pi; with relays, analog channels, powered outputs, and buffered inputs. All 24V tolerant.
To get the HAT set up and ready to go you can use the one-line product installer:
```bash
curl -sS https://get.pimoroni.com/automationhat | bash
```
Then import it into your Python script and start tinkering:
```bash
import automationhat
automationhat.relay.one.on()
```

90
src/zh/overlay/automation-phat.md Normal file
View File

@ -0,0 +1,90 @@
<!--
---
name: Automation pHAT
class: board
type: adc,io,motor,relay
formfactor: pHAT
manufacturer: Pimoroni
description: An all-in-one home automation and control board
url: http://shop.pimoroni.com/products/automation-phat
github: https://github.com/pimoroni/automation-hat
buy: http://shop.pimoroni.com/products/automation-phat
image: 'automation-phat.png'
pincount: 40
eeprom: no
power:
'2':
'17':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'3':
mode: i2c
'5':
mode: i2c
'29':
name: Output 1
mode: output
active: high
'31':
name: Output 3
mode: output
active: high
'32':
name: Output 2
mode: output
active: high
'36':
name: Relay 1
mode: output
active: high
'37':
name: Input 1
mode: input
active: high
'38':
name: Input 2
mode: input
active: high
'40':
name: Input 3
mode: input
active: high
i2c:
'0x48':
name: Analog Input
device: ads1015
install:
'devices':
- 'i2c'
'apt':
- 'python-smbus'
- 'python3-smbus'
'python':
- 'automationhat'
'python3':
- 'automationhat'
-->
# Automation pHAT
Automation pHAT is a home monitoring and automation controller for the Raspberry Pi; with relays, analog channels, powered outputs, and buffered inputs. All 24V tolerant.
To get the pHAT set up and ready to go you can use the one-line product installer:
```bash
curl -sS https://get.pimoroni.com/automationhat | bash
```
Then import it into your Python script and start tinkering:
```bash
import automationhat
automationhat.relay.one.on()
```

66
src/zh/overlay/blinkt.md Normal file
View File

@ -0,0 +1,66 @@
<!--
---
name: 'Blinkt!'
class: board
type: led
formfactor: Custom
manufacturer: Pimoroni
description: Slimline board with 8 super-bright RGB LED indicators
url: http://blog.pimoroni.com/blinkt/
github: https://github.com/pimoroni/blinkt
buy: https://shop.pimoroni.com/products/blinkt
image: 'blinkt.png'
pincount: 40
eeprom: no
power:
'2':
'4':
ground:
'6':
pin:
'16':
name: Data
mode: output
active: high
'18':
name: Clock
mode: output
active: high
-->
# Blinkt!
Blinkt! is a super slimline Raspberry Pi Add-on board with 8 APA-102 LEDs.
## 5V Power
Blinkt! does not require *both* Physical Pin 2 and Physical Pin 4:
* Physical Pin 4 is used for 5v power on all Blinkt! boards since 2018
* Physical Pin 2 was used for 5v power on first run Blinkt! boards prior to 2018
If your Blinkt! doesn't work with one, try swapping over to the other or - if all else fails - wiring both.
## Installing
To get started you can use the one-line product installer:
```bash
curl -sS https://get.pimoroni.com/blinkt | bash
```
## Code
```python
from blinkt import set_pixel, show
from random import randint
from time import sleep
while True:
for pixel in range(8):
r = randint(0, 255)
g = randint(0, 255)
b = randint(0, 255)
set_pixel(pixel, r, g, b)
show()
sleep(0.1)
```

53
src/zh/overlay/breakout-garden-hat.md Normal file
View File

@ -0,0 +1,53 @@
<!--
---
name: Breakout Garden HAT
class: board
type: io
formfactor: HAT
manufacturer: Pimoroni
description: Break out your i2c bus to 6 edge connectors.
url: https://shop.pimoroni.com/products/breakout-garden-hat
github: https://github.com/pimoroni/breakout-garden
buy: https://shop.pimoroni.com/products/breakout-garden-hat
image: 'breakout-garden-hat.png'
pincount: 40
eeprom: yes
power:
'1':
'2':
'4':
'17':
ground:
'9':
'25':
'39':
pin:
'3':
mode: i2c
'5':
mode: i2c
'7':
name: Interrupt
mode: input
'36':
name: EEPROM WP
mode: output
active: low
-->
# Breakout Garden HAT
Breakout Garden HAT breaks out your Pi's i2c (inter-integrated circuit) bus into 6 convenient edge connectors designed to accommodate Pimoroni breakout boards.
This means you can prototype your breakout-based designs with no soldering or connection hassles and write and test your code before assembling your final creation.
The top of Breakout Garden HAT is an unbroken ground plane, so if you're wiring it off your Pi you will only need one ground pin (pick from the ones marked). The 5v line is regulated to 3v3 for the breakouts, and either pin will do. The 3v3 pins are only used for the EEPROM so you can safely omit them.
For easy off-board wiring, or use with something like an Arduino you could use the SDA, SCL, INT, GND and 5V connections on the breakout header.
To get the HAT set up and ready to go you can use the one-line product installer:
```bash
curl -sS https://get.pimoroni.com/breakoutgarden | bash
```
And follow the instructions!

39
src/zh/overlay/button-shim.md Normal file
View File

@ -0,0 +1,39 @@
<!--
---
name: Button SHIM
class: board
type: io
formfactor: Custom
manufacturer: Pimoroni
description: 5 tacile switches and one RGB LED for the Raspberry Pi
url: https://shop.pimoroni.com/products/button-shim
buy: https://shop.pimoroni.com/products/button-shim
image: 'button-shim.png'
pincount: 40
eeprom: no
power:
'4':
'17':
ground:
'6':
pin:
'3':
mode: i2c
'5':
mode: i2c
-->
# Button SHIM
Button SHIM is designed to add 5 tactile push buttons and a single RGB indicator LED to your Raspberry Pi project. Designed to be soldered right onto the GPIO pins of your Pi, it's great for adding buttons to a project using Scroll pHAT or another display add-on.
To install the library, run the one-line installer like so:
```bash
curl https://get.pimoroni.com/buttonshim | bash
```
Features:
* 5 tactile push buttons
* can be soldered right onto the Pi header
* RGB status LED

37
src/zh/overlay/camjam-edukit-3-motor-controller.md Normal file
View File

@ -0,0 +1,37 @@
<!--
---
name: CamJam EduKit 3 motor controller board
class: board
type: motor
formfactor: Custom
manufacturer: PiHut
description: A motor controller board to control two motor channels and break out unused pins. Please note, pinouts for the original version and the new version are the same.
url: https://camjam.me/?page_id=1035
buy: https://thepihut.com/collections/camjam-edukit/products/camjam-edukit-3-robotics
github: https://github.com/CamJam-EduKit/EduKit3/
image: 'camjam-edukit-3-motor-controller.png'
pincount: 26
eeprom: no
pin:
'21':
name: MotorA_0
mode: output
'19':
name: MotorA_1
mode: output
'26':
name: MotorB_0
mode: output
'24':
name: MotorB_1
mode: output
-->
# CamJam EduKit 3 motor controller board
This motor controller board is part of CamJam EduKit 3 - Robotics but is also [available separately from The Pi Hut](https://thepihut.com/products/camjam-edukit-motor-controller). It provides two motor outputs for 6V motors using a DRV8833 H Bridge and breaks out most of the unused pins to a female header on top of the board.
Pins that are broken out to the header are as follows: 5v, 3v3, SDA and SCL (for I2C devices), 4, 17, 18, 22, 23, 24, 25, 27, and Ground.
The board expects 4 AA batteries to be used to power the board, although it will accept up to 10V if you have more powerful motors available. A flyback diode is provided to protect your board and Raspberry Pi if you should accidentally wire up the power source the wrong way around.
The motor controller board was designed by Rachel Rayns for The Pi Hut. Educational material was written by [Tim Richardson](https://twitter.com/Geeky_Tim) and tested by [Michael Horne](https://twitter.com/recantha) over at [CamJam](https://camjam.me/edukit).

54
src/zh/overlay/carberry.md Normal file
View File

@ -0,0 +1,54 @@
<!--
---
name: Carberry
class: board
type: other
formfactor: Custom
manufacturer: Paser
collected: Other
description: add-on board designed to inteface with car electronics
url: http://www.carberry.it/en/p/347/Carberry/
buy: http://www.carberry.it
image: 'carberry.png'
pincount: 26
eeprom: no
power:
'2':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'8':
name: TXD / Transmit
direction: output
'10':
name: RXD / Receive
direction: input
'12':
name: LIRC
'13':
name: Shutdown
-->
# Carberry
Carberry is an add-on board for Raspberry Pi that can be used to interface between car electronics and your Pi. It allows the development of end-user applications, such as media centers, vehicle diagnostics, data logging, fleet management, tracking, black-boxes, burglar alarms, carputing, internet, and much more.
##Features
- Accelerometer
- Magnetometer
- RTCC
- 2x CAN BUS
- 2x GMLAN
- 2x LADDER
- 1x LIN
- 2x GPI
- 2x GPO
- 1x GPIO CMOS
- 1x IGNITION IN
- 1x IGNITION OUT

97
src/zh/overlay/cirruslogic-audio-card.md Normal file
View File

@ -0,0 +1,97 @@
<!--
---
name: Cirrus Logic Audio Card
class: board
type: audio
formfactor: HAT
manufacturer: Element14
collected: Other
description: Audio Card with unprecedented level of features and performance for Raspberry Pi
url: http://www.element14.com/community/community/raspberry-pi/raspberry-pi-accessories/cirrus_logic_audio_card
buy: http://www.element14.com/community/community/raspberry-pi/raspberry-pi-accessories/cirrus_logic_audio_card
image: 'cirruslogic-audio-card.png'
pincount: 40
power:
'1':
'2':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'3':
name: SDA1
mode: i2c
description: WM8804 I2C - SDA
'5':
name: SCL1
mode: i2c
description: WM8804 I2C - SCLK
'11':
name: GPIO_GEN0
mode: input
description: WM5102 RST
'12':
name: PCM_CLK
mode: input
description: WM5102 AIF PCM - BCLK
'15':
name: GPIO_GEN3
mode: input
description: WM5102 LDO Enable
'16':
name: GPIO_GEN4
mode: input
description: WM8804 Control I/F Config
'19':
name: SPI_MOSI
mode: spi
description: WM5102 SPI - MOSI
'21':
name: SPI_MISO
mode: spi
description: WM5102 SPI - MISO
'23':
name: SPI_SCLK
mode: spi
description: WM5102 SPI - SCLK1
'24':
name: SPI_CE0_N
mode: input
description: WM8804 RST
'26':
name: SPI_CE1_N
mode: input
description: WM5102 SPI - CE
'35':
name: PCM_FS
mode: input
description: WM5102 AIF PCM - FS
'38':
name: PCM_DIN
mode: input
description: WM5102 AIF PCM - DIN
'40':
name: PCM_DOUT
mode: input
description: WM5102 AIF PCM - DOUT
i2c:
'0x1a':
name: S/PDIF transceiver
device: WM8804
-->
# Cirrus Logic Audio Card
Offers a wealth of features, perfect for avid audiophiles wanting to use their Raspberry Pi for audio applications.
* Capable of rendering HD Audio, at 24-bit, 192kHz
* 3.5mm 4-pole jack for a headset/boom mic combination for gaming or VoIP applications
* Two DMIC microphones on-board for stereo recording
* 3.5mm jack for Stereo Line Input for high quality audio recording or capture
* 3.5 mm jack Stereo Line Output for connection to devices such as external stereo amplifiers or powered speakers
* Stereo Digital input and output (SPDIF)

114
src/zh/overlay/coral-enviro-board.md Normal file
View File

@ -0,0 +1,114 @@
<!--
---
name: Coral Environmental Sensor Board
class: board
type: adc,sensor
formfactor: pHAT
manufacturer: Google
description: An Environmental Sensor and Grove Breakout Board
url: https://coral.withgoogle.com/products/environmental
github: https://coral.googlesource.com/coral-cloud/
buy: https://coral.withgoogle.com/products/environmental
image: 'coral-enviro-board.png'
pincount: 40
eeprom: yes
power:
'1':
'2':
'4':
'17':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'3':
mode: i2c
'5':
mode: i2c
'8':
mode: uart
'10':
mode: uart
'12':
mode: pwm
'13':
name: OPT3002_INT
mode: input
active: low
'16':
name: Push Button
mode: input
active: low
'18':
name: OLED DC
mode: output
active: high
'19':
mode: spi
'21':
mode: spi
'22':
name: OLED RESET
mode: output
active: low
'23':
mode: spi
'24':
mode: spi
'29':
name: A71CH_RST_N
mode: output
active: low
'33':
mode: pwm
'35':
name: HDC2010_DRDY
mode: input
active: high
'40':
name: LED
mode: output
active: high
i2c:
'0x30':
name: Cyptographic Secure Element
device: ECC608
'0x40':
name: Humidity/Temperature Sensor
device: HDC2010
'0x45':
name: Wide Spectrum Ambient Light Sensor
device: OPT3002
'0x49':
name: Single-Channel ADC
device: TLA2021
'0x76':
name: Barometric Pressure Sensor
device: BMP280
-->
# Coral Environmental Sensor Board
The Coral Environmental Sensor Board adds multiple environmental sensors and Grove connectors for external devices. It works with all 40-pin Raspberry Pi variants as well as the Coral Dev Board.
## Features
* 128x32 OLED Display (SSD1306-based SPI interface)
* Ambient light sensor (OPT3002, 0x45 on i2c bus)
* Barometric pressure sensor (BMP280, 0x76 on i2c bus)
* Humidity / temperature sensor (HDC2010, 0x40 on i2c bus)
* Crypto-processor with Google keys (ECC608, 0x30 on i2c bus)
* Four Grove connectors:
1x UART
1x I2C
1x PWM
1x 3.3/5V analog (using TLA2022 ADC, 0x49 on i2c bus)
* General purpose button
* General purpose LED

63
src/zh/overlay/ctrl-hat.md Normal file
View File

@ -0,0 +1,63 @@
<!--
---
name: CTRL HAT
class: board
type: io, relay, motor
formfactor: HAT
manufacturer: PlasmaDan
description: SIP style solid state relay (SSR) home automation and industrial control HAT for Raspberry Pi.
url: https://plasmadan.com/ctrlhat
github: https://github.com/plasmadancom/CTRL-HAT
schematic: https://plasmadan.shop/ctrl-hat-v1-2-schematic/
buy: https://plasmadan.com/ctrlhat
image: 'ctrl-hat.png'
pincount: 40
eeprom: yes
power:
'1':
'2':
'4':
ground:
'6':
'9':
'14':
'20':
'25':
pin:
'3':
mode: i2c
'5':
mode: i2c
i2c:
'0x20':
alternate: [ '0x21', '0x22', '0x23', '0x24', '0x25', '0x26', '0x27' ]
name: MCP23017
device: MCP23017
-->
# CTRL HAT
The CTRL HAT is a 4 channel solid state power relay controller board based on the Microchip MCP23017 I2C expander. Designed for switching high power loads without the need for costly extra hardware such as SSR modules or contactors.
Ideally suited to automation or industrial control applications requiring high-speed switching, or switching of loads not suitable for regular mechanical relays, such as motors, power supplies, or noise sensitive equipment such as amplifiers.
## Features
* Support 4 industry standard SIP type solid state relays
* Up to 10A @ 250V / 16A @ 250V (forced air cooled)
* Huge range of compatible solid state relays ([known list](https://github.com/plasmadancom/CTRL-HAT#known-compatible-solid-state-relays))
* Easy to use [interactive web GUI](https://io.plasmadan.com/ctrlhat)
* Based on the MCP23017 16-port GPIO expander
* Jumper selectable I2C address & GPIO voltage (3.3V / 5V)
* Can be used with 3.3V or 5V I2C host devices (eg, Arduino)
* Built-in user programmable ID EEPROM
## Easy Installer
Our easy installer takes care of the setup process automatically.
```
sudo wget https://git.plasmadan.com/install.sh
sudo sh install.sh
```
Alternatively, you can install manually. See our [setup guide](https://github.com/plasmadancom/HAT-GUI#setup-guide).

33
src/zh/overlay/cube-bit-base.md Normal file
View File

@ -0,0 +1,33 @@
<!--
---
name: cube:bit Base
class: board
type: other
formfactor: Custom
manufacturer: 4tronix
description: Base for your Cube:Bit allowing easy connection of power and signal and directly able to plug in a Raspberry Pi Zero.
url: https://shop.4tronix.co.uk/products/cube-bit-base-for-power-microbit-and-raspberry-pi-cubebit
buy: https://shop.4tronix.co.uk/products/cube-bit-base-for-power-microbit-and-raspberry-pi-cubebit
image: 'cube-bit-base.png'
pincount: 40
eeprom: no
pin:
power:
'2':
pin:
'12':
name: Data
direction: output
mode: pwm
description: WS2812 Data
-->
# cube:bit Base
Base for your Cube:Bit allowing easy connection of power and signal and directly able to plug in a Raspberry Pi Zero.
There is a 40pin GPIO header that you can plug a Raspberry Pi Zero into and it will be powered from the 5V and connect on GPIO 12 (pin 18) to the neopixel array. This is the standard pin for driving neopixels on the Raspberry Pi. Note that there isn't room to fit a full-size Raspberry Pi (though with a GPIO cable you could do that as well)

100
src/zh/overlay/discohat.md Normal file
View File

@ -0,0 +1,100 @@
<!--
---
name: DiscoHAT
class: board
type: audio
formfactor: HAT
manufacturer: Kertatuote
collected: Other
description: Computer controlled DMX lights, sounds and special effects
url: http://discohat.com
buy: http://discohat.com/shop
image: 'discohat.png'
pincount: 40
eeprom: yes
power:
'1':
'2':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'8':
name: TXD
active: high
mode: output
description: DMX out
'13':
name: Button1
active: low
mode: input
description: Button 1
'15':
name: Button2
active: low
mode: input
description: Button 2
'22':
name: Button3
active: low
mode: input
description: Button 3
'18':
name: Button4
active: low
mode: input
description: Button 4
'16':
name: Button5
active: low
mode: input
description: Button 5
'37':
name: Button6
active: low
mode: input
description: Button 6
'32':
name: Button7
active: low
mode: input
description: Button 7
'36':
name: Button8
active: low
mode: input
description: Button 8
'19':
name: MOSI
mode: spi
description: LED strip data
'23':
name: SCLK
mode: spi
description: LED strip clock
-->
# DiscoHAT
DiscoHAT is a small board allowing you to do computer controlled lights, sounds and special effects.
It is an essential building block for making custom light and sound systems. You can easily create your own home disco based on it. It is also usable for small theatre groups, bands or school projects.
With DiscoHAT you can control DMX equipment and LED strips. It also has interfaces for up to 8 push-buttons that can be configured to start light and sound sequences.
DiscoHAT was created to be used with QLC+ an Open Source light and sound control software that is absolutely AMAZING. The push buttons can trigger scenes (steady lights), chases (lights changing in a pattern) and shows (lights synced to music) from stage without need for displays, keyboards or mice. With a WiFi dongle you can also control the lights from your tablet or mobile phone.
The Raspberry Pi 2 has a bit more power and is recommended for DiscoHAT. You can also exchange the 40 pin connector with the 26 pin connector for using it on older Raspberries but then you lose HAT functionality and 4 buttons. The connectors are not soldered to DiscoHAT. It uses SMD through pin sockets.
DiscoHAT is being used by myself in our theatre productions. The DMX output and the push-buttons are optically isolated and ESD protected to cope with static electricity that easily builds up on stage due to long wires, hot air, plastic surfaces and nylon clothing.
The system has been in use for two plays so far and it is time to share the good things with other entertainers.
Break a leg,
Karri

61
src/zh/overlay/display-o-tron-hat.md Normal file
View File

@ -0,0 +1,61 @@
<!--
---
name: Display-o-Tron HAT
class: board
type: display
formfactor: HAT
manufacturer: Pimoroni
description: A 3-line character LCD with a 6-zone RGB backlight and 6 touch buttons
url: https://shop.pimoroni.com/products/display-o-tron-hat
github: https://github.com/pimoroni/displayotron
buy: https://shop.pimoroni.com/products/display-o-tron-hat
image: 'display-o-tron-hat.png'
pincount: 40
eeprom: yes
power:
'1':
'2':
ground:
'6':
'9':
'39':
pin:
'3':
mode: i2c
'5':
mode: i2c
'19':
mode: spi
'22':
name: LCD Register Select
mode: output
active: high
'23':
mode: spi
'24':
name: LCD Chip Select
mode: chipselect
active: high
'32':
name: LCD Reset
mode: output
active: low
i2c:
'0x54':
name: Backlight
device: sn3218
'0x2c':
name: Cap Touch
device: cap1166
-->
# Display-o-Tron HAT
Display-o-Tron HAT uses both SPI and I2c to drive the LCD display, back-light and touch. However both of these busses can be shared with other devices.
To get the HAT set up and ready to go you can use the one-line product installer:
```bash
curl -sS https://get.pimoroni.com/displayotron | bash
```
And follow the instructions!

71
src/zh/overlay/display-o-tron.md Normal file
View File

@ -0,0 +1,71 @@
<!--
---
name: Display-o-Tron 3000
class: board
type: display
formfactor: Custom
manufacturer: Pimoroni
description: A 3-line character LCD with an RGB backlight and joystick
url: https://shop.pimoroni.com/products/displayotron-3000
github: https://github.com/pimoroni/dot3k
buy: https://shop.pimoroni.com/products/displayotron-3000
image: 'display-o-tron.png'
pincount: 26
eeprom: no
power:
'2':
'17':
ground:
'6':
'9':
'14':
'25':
pin:
'3':
mode: i2c
'5':
mode: i2c
'7':
name: Joystick Button
mode: input
active: low
'11':
name: Joystick Left
mode: input
active: low
'13':
name: Joystick Up
mode: input
active: low
'15':
name: Joystick Right
mode: input
active: low
'19':
mode: spi
'21':
name: Joystick Down
mode: input
active: low
'22':
name: LCD CMD/DATA
mode: output
active: high
'23':
mode: spi
i2c:
'0x54':
name: Backlight
device: sn3218
-->
# Display-o-Tron 3000
The Display-o-Tron 3000 is a 3-line character LCD with an RGB back-light and joystick
To get the module set up and ready to go you can use the one-line product installer:
```bash
curl -sS https://get.pimoroni.com/displayotron | bash
```
And follow the instructions!

43
src/zh/overlay/dresden-elektronik-raspbee.md Normal file
View File

@ -0,0 +1,43 @@
<!--
---
name: RaspBee
class: board
type: iot,radio
formfactor: Custom
manufacturer: dresden elektronik
collected: Other
description: A Zigbee add-on board for the Raspberry Pi
url: https://phoscon.de/raspbee
github: https://github.com/dresden-elektronik/deconz-rest-plugin
buy: https://phoscon.de/raspbee#buy
image: 'dresden-elektronik-raspbee.png'
pincount: 12
eeprom: no
power:
'2':
ground:
'6':
'9':
pin:
'8':
name: TXD
mode: UART
'10':
name: RXD
mode: UART
'11':
name: RESET
mode: input
active: low
'12':
name: SW1
mode: GPIO
-->
# RaspBee Zigbee add-on board
The add-on board adds full Zigbee capabilities to a Raspberry Pi, to use lights, sensors and switches from various vendors.
* Supports Zigbee 3.0, Zigbee Light Link (ZLL) and Zigbee Home Automation (ZHA) devices
* Supports up to 200 devices
* On board power-amplifier for a signal-range of max. 200 m (650ft) in free line of sight
* Supported by the most popular open source home automation systems

54
src/zh/overlay/drum-hat.md Normal file
View File

@ -0,0 +1,54 @@
<!--
---
name: Drum HAT
class: board
type: instrument,touch
formfactor: HAT
manufacturer: Pimoroni
description: An 8 pad finger Drum HAT for your Raspberry Pi
url: http://shop.pimoroni.com/products/drum-hat
github: https://github.com/pimoroni/drum-hat
buy: http://shop.pimoroni.com/products/drum-hat
image: 'drum-hat.png'
pincount: 40
eeprom: yes
power:
'2':
'17':
ground:
'30':
'34':
'39':
pin:
'3':
mode: i2c
'5':
mode: i2c
'22':
name: Alert
mode: input
'40':
name: Reset
mode: output
i2c:
'0x2c':
name: Cap Touch
device: cap1188
-->
# Drum HAT
Drum HAT is the companion to Piano HAT. It uses the same cap touch sensor to provide 8 finger-sized drum pads. Use it to play music in Python, control software drum synths on your Pi, take control of hardware drum machines, or just build it into an elaborate drum-controlled project.
## Features
* 8 touch sensitive buttons
* 8 LED
* Works with Piano HAT (it uses a CAP1188 chip with a non-conflicting i2c address at 0x2c).
To get the HAT set up and ready to go you can use the one-line product installer:
```bash
curl -sS https://get.pimoroni.com/drumhat | bash
```
And follow the instructions!

116
src/zh/overlay/emlid-navio2.md Normal file
View File

@ -0,0 +1,116 @@
<!--
---
name: Navio2 Autopilot
class: board
type: gps,motor,sensor
formfactor: HAT
manufacturer: Emlid
collected: Other
description: Full drone controller for Raspberry Pi
url: https://docs.emlid.com/navio2/
github: https://github.com/emlid/Navio2
buy: https://emlid.com/shop/navio2/
image: 'emlid-navio2.png'
pincount: 40
eeprom: setup
power:
'1':
'2':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'3':
name: MS5611 Data
mode: i2c
'5':
name: MS5611 Clock
mode: i2c
'7':
name: Red LED
mode: output
active: high
'13':
name: Green LED
mode: output
active: high
'15':
name: LSM9DS1 Magneto CS
mode: chipselect
active: high
'16':
name: MPU9250 Interrupt
mode: output
active: high
'18':
name: RCIO PC10
'19':
mode: spi
'21':
mode: spi
'22':
name: LSM9DS1 Accel/Gyro CS
mode: chipselect
active: high
'23':
mode: spi
'24':
'26':
name: MPU9250 Chip Select
mode: chipselect
active: high
'29':
name: RCIO PC11
'31':
name: Blue LED
mode: output
active: high
'32':
name: RCIO Clock
'33':
name: RCIO Data
'35':
name: RCIO MISO
mode: spi
'36':
name: RCIO Chip Select
mode: chipselect
active: high
'38':
name: RCIO MOSI
mode: spi
'40':
name: RCIO SCLK
mode: spi
i2c:
'0x77':
name: Barometer
device: MS5611
-->
# Navio2 Autopilot
The Navio2 Autopilot is designed both for your own custom robotic projects and as a platform for Linux version of APM (ArduPilot).
Navio2 eliminates the need for multiple on-board controllers making development easier and increasing robustness. It extends connectivity and allows control of all kinds of moving robots: cars, boats, multirotors, planes.
For accurate knowledge of position and orientation Navio2 is equipped with double IMU and GPS/Glonass/Beidou receiver. PWM, ADC, SBUS and PPM are integrated in Linux sysfs via the on-board RC I/O co-processor, allowing easy access from any programming language.
## Features
* MS5611 Barometer (I2C1)
* MPU9250 9DOF IMU (SPI0)
* LSM9DS1 9DOF IMU (SPI0)
* Ublox M8N Glonass/GPS/Beidou (SPI0)
* 14 PWM servo outputs (RCIO/SPI1)
* PPM/S.Bus input (RCIO/SPI1)
* 6-channel ADC (RCIO/SPI1)
* Integrated RGB LED
* UART, I2C terminals for extensions
* Power module connector
* Triple redundant power supply

49
src/zh/overlay/energenie-pi-mote.md Normal file
View File

@ -0,0 +1,49 @@
<!--
---
name: Pi-mote
class: board
type: com
formfactor: Custom
manufacturer: Energenie
collected: Other
description: Add-on that allows control of Energenie smart plugs from a Raspberry Pi
url: https://energenie4u.co.uk/res/pdfs/ENER314%20UM.pdf
buy: https://energenie4u.co.uk/catalogue/product/ENER314
image: 'energenie-pi-mote.png'
pincount: 26
eeprom: no
power:
'1':
ground:
'6':
pin:
'11':
name: D0 Encoder
mode: output
active: high
'13':
name: D3 Encoder
mode: output
active: high
'15':
name: D1 Encoder
mode: output
active: high
'16':
name: D2 Encoder
mode: output
active: high
'18':
name: Mode Select
mode: output
active: high
'22':
name: Modulator CE
mode: output
active: high
-->
# Pi-mote
The Pi-mote is a RF transmitter add-on board that allows control of up to 4 Energenie radio controlled sockets independently using Python.
With it you will be able to control your electrical sockets within a range of up to 30 metres, through doors, walls and ceilings.

71
src/zh/overlay/enviro-phat.md Normal file
View File

@ -0,0 +1,71 @@
<!--
---
name: Enviro pHAT
class: board
type: adc,sensor
formfactor: pHAT
manufacturer: Pimoroni
description: A package of environmental sensors for IoT projects
url: https://shop.pimoroni.com/products/enviro-phat
github: https://github.com/pimoroni/enviro-phat
buy: https://shop.pimoroni.com/products/enviro-phat
image: 'enviro-phat.png'
pincount: 40
eeprom: no
power:
'2':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'3':
mode: i2c
'5':
mode: i2c
'7':
mode: output
name: LEDs
i2c:
'0x1d':
name: Motion Sensor
device: LSM303D
'0x29':
name: Light/Colour Sensor
device: TCS3472
'0x49':
name: 4-Channel Analog Input
device: ADS1015
'0x77':
name: Temp/Pressure Sensor
device: BMP280
-->
# Enviro pHAT
Coupled with a Pi Zero, Enviro pHAT is an affordable mix of sensors, ideal for monitoring server rooms, bedrooms, ballrooms or anything you might want to observe. It also includes a 4-channel ADC, for adding sensors of your own. It works with all of the 40-pin Raspberry Pi variants - 3/2/B+/A+/Zero.
## Features
* BMP280 temperature/pressure sensor (0x77 on the i2c bus)
* TCS3472 light and RGB colour sensor (0x29 on the i2c bus)
(with two GPIO controlled LEDs for illumination)
* LSM303D accelerometer/magnetometer sensor (0x1d on the i2c bus)
* ADS1015 4-channel 5v tolerant 12-bit ADC (0x49 on the i2c bus)
(3.3v 12-bit ADC at address 0x48 in first production run of the board)
To get the pHAT set up and ready to go you can use the one-line product installer:
```bash
curl -sS https://get.pimoroni.com/envirophat | bash
```
Then import it into your Python script and start tinkering:
```bash
from envirophat import light, motion, weather, analog, leds
```

49
src/zh/overlay/espiot-phat.md Normal file
View File

@ -0,0 +1,49 @@
<!--
---
name: ESP IoT pHAT
class: board
type: mcu,io,iot
formfactor: pHAT
manufacturer: Pimoroni
description: an ESP8266 module programmable from your Pi
url: https://shop.pimoroni.com/products/esp8266-phat
buy: https://shop.pimoroni.com/products/esp8266-phat
image: 'esp8266-phat.png'
pincount: 40
eeprom: no
power:
'2':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'8':
name: TXD / Transmit
direction: output
active: high
'10':
name: RXD / Receive
direction: input
active: high
'11':
name: Chip Reset
active: low
'13':
name: Chip Program
active: low
-->
# ESP IoT pHAT
The ESP IoT pHAT is an ESP8266 based add-on for the Raspberry Pi. It provides some GPIO and one ADC channel, broken out to use alongside a small prototyping area. Perfect for RPi Zero but works with A+/B+/2 too!
To get the pHAT set up and ready to go you can use the one-line product installer:
```bash
curl -sS https://get.pimoroni.com/iotphat | bash
```

129
src/zh/overlay/explorer-hat-pro.md Normal file
View File

@ -0,0 +1,129 @@
<!--
---
name: Explorer HAT Pro
class: board
type: adc,io,motor,multi,touch
formfactor: HAT
manufacturer: Pimoroni
description: An all-in-one light, input, motor, touch and output add-on board
url: http://shop.pimoroni.com/products/explorer-hat
github: https://github.com/pimoroni/explorer-hat
buy: http://shop.pimoroni.com/products/explorer-hat
image: 'explorer-hat-pro.png'
pincount: 40
eeprom: yes
power:
'2':
'17':
ground:
'6':
'9':
'14':
'25':
'30':
'39':
pin:
'3':
mode: i2c
'5':
mode: i2c
'7':
name: LED 1
mode: output
active: high
'11':
name: LED 2
mode: output
active: high
'13':
name: LED 3
mode: output
active: high
'15':
name: Input 2
mode: input
active: high
'16':
name: Input 1
mode: input
active: high
'18':
name: Input 3
mode: input
active: high
'22':
name: Input 4
mode: input
active: high
'29':
name: LED 4
mode: output
active: high
'31':
name: Output 1
mode: output
active: high
'32':
name: Output 2
mode: output
active: high
'33':
name: Output 3
mode: output
active: high
'35':
name: Motor 1 +
mode: output
active: high
'36':
name: Output 4
mode: output
active: high
'37':
name: Motor 2 -
mode: output
active: high
'38':
name: Motor 1 -
mode: output
active: high
'40':
name: Motor 2 +
mode: output
active: high
i2c:
'0x28':
name: Cap Touch
device: cap1208
'0x48':
name: Analog Input
device: ads1015
install:
'devices':
- 'i2c'
'apt':
- 'python-smbus'
- 'python3-smbus'
- 'python-dev'
- 'python3-dev'
'python':
- 'explorerhat'
'python3':
- 'explorerhat'
-->
# Explorer HAT Pro
5V inputs and outputs, touch pads, LEDs, analog inputs and an H-Bridge motor driver make up the Explorer HAT Pro; a jack of all trades prototyping side-kick for your Raspberry Pi.
To get the HAT set up and ready to go you can use the one-line product installer:
```bash
curl -sS https://get.pimoroni.com/explorerhat | bash
```
Then import it into your Python script and start tinkering:
```bash
import explorerhat
explorerhat.light.on()
```

110
src/zh/overlay/explorer-hat.md Normal file
View File

@ -0,0 +1,110 @@
<!--
---
name: Explorer HAT
class: board
type: io,touch
formfactor: HAT
manufacturer: Pimoroni
description: An all-in-one light, input, touch and output add-on board
url: http://shop.pimoroni.com/products/explorer-hat
github: https://github.com/pimoroni/explorer-hat
buy: http://shop.pimoroni.com/products/explorer-hat
image: 'explorer-hat.png'
pincount: 40
eeprom: yes
power:
'2':
'17':
ground:
'6':
'9':
'14':
'25':
'30':
'39':
pin:
'3':
mode: i2c
'5':
mode: i2c
'7':
name: LED 1
mode: output
active: high
'11':
name: LED 2
mode: output
active: high
'13':
name: LED 3
mode: output
active: high
'15':
name: Input 2
mode: input
active: high
'16':
name: Input 1
mode: input
active: high
'18':
name: Input 3
mode: input
active: high
'22':
name: Input 4
mode: input
active: high
'29':
name: LED 4
mode: output
active: high
'31':
name: Output 1
mode: output
active: high
'32':
name: Output 2
mode: output
active: high
'33':
name: Output 3
mode: output
active: high
'36':
name: Output 4
mode: output
active: high
i2c:
'0x28':
name: Cap Touch
device: cap1208
install:
'devices':
- 'i2c'
'apt':
- 'python-smbus'
- 'python3-smbus'
- 'python-dev'
- 'python3-dev'
'python':
- 'explorerhat'
'python3':
- 'explorerhat'
-->
# Explorer HAT
5V inputs and outputs, touch pads and LEDs make up the Explorer HAT; a jack of all trades prototyping side-kick for your Raspberry Pi.
To get the HAT set up and ready to go you can use the one-line product installer:
```bash
curl -sS https://get.pimoroni.com/explorerhat | bash
```
Then import it into your Python script and start tinkering:
```bash
import explorerhat
explorerhat.light.on()
```

111
src/zh/overlay/explorer-phat.md Normal file
View File

@ -0,0 +1,111 @@
<!--
---
name: Explorer pHAT
class: board
type: adc,io,motor
formfactor: pHAT
manufacturer: Pimoroni
description: An all-in-one input, output and motor add-on board
buy: https://shop.pimoroni.com/products/explorer-phat
github: https://github.com/pimoroni/explorer-hat
buy: https://shop.pimoroni.com/products/explorer-phat
image: 'explorer-phat.png'
pincount: 40
eeprom: no
power:
'2':
'17':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'3':
mode: i2c
'5':
mode: i2c
'15':
name: Input 2
mode: input
active: high
'16':
name: Input 1
mode: input
active: high
'18':
name: Input 3
mode: input
active: high
'22':
name: Input 4
mode: input
active: high
'31':
name: Output 1
mode: output
active: high
'32':
name: Output 2
mode: output
active: high
'33':
name: Output 3
mode: output
active: high
'35':
name: Motor 1 +
mode: output
active: high
'36':
name: Output 4
mode: output
active: high
'37':
name: Motor 2 -
mode: output
active: high
'38':
name: Motor 1 -
mode: output
active: high
'40':
name: Motor 2 +
mode: output
active: high
i2c:
'0x48':
name: Analog Input
device: ads1015
install:
'devices':
- 'i2c'
'apt':
- 'python-smbus'
- 'python3-smbus'
- 'python-dev'
- 'python3-dev'
'python':
- 'explorerhat'
'python3':
- 'explorerhat'
-->
# Explorer pHAT
5V inputs and outputs, analog inputs and an H-Bridge motor driver make up the Explorer pHAT; a jack of all trades prototyping side-kick for your Raspberry Pi. Perfect for RPi Zero but works with A+/B+/2 too!
To get the pHAT set up and ready to go you can use the one-line product installer:
```bash
curl -sS https://get.pimoroni.com/explorerhat | bash
```
Then import it into your Python script and start tinkering:
```bash
import explorerhat
```

63
src/zh/overlay/fepi-audio-z-V2.md Normal file
View File

@ -0,0 +1,63 @@
<!--
---
name: Fe-Pi Audio Z V2
class: board
type: audio
formfactor: pHAT
manufacturer: Fe-Pi
description: A complete audio solution for the Raspberry Pi
url: https://fe-pi.com/products/fe-pi-audio-z-v2
buy: https://fe-pi.com/products/fe-pi-audio-z-v2
image: 'fepi-audio-z-V2.png'
pincount: 40
eeprom: no
power:
'1':
'2':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'3':
mode: i2c
'5':
mode: i2c
'12':
name: BCLK (Bit Clock)
mode: i2s
'35':
name: LRCLK (Left/Right Clock)
mode: i2s
'38':
name: DIN (Data In)
mode: i2s
'40':
name: DOUT (Data Out)
mode: i2s
i2c:
'0x0a':
name: SGTL5000
device: SGTL5000XNAA3/R2
-->
# Fe-Pi Audio Z V2
The Fe-Pi Audio Z V2 is designed to provide a complete low cost audio solution for Raspberry Pi 2, 3, and Zero, needing line-in, line-out, headphone-out/mic-in, and stereo speakers.
## Features
* Small Raspberry Pi Zero PCB footprint.
* SGTL5000 low power stereo codec.
* 3.5 mm, 4 contact, jack for Headphone/MIC (black).
* 3.5 mm jack for stereo Line Out (green), and stereo Line In (pink).
* ADC > 90 dB SNR and -72 dB THD+N
* Line-Out > 100 dB SNR and -85 dB THD+N
* HP Output > 100 dB SNR and -80 dB THD+N, 62.5 mW max into 16 ohm.
* Hardware level controls for Headphone Volume, Line In, Line Out. ALSA support.
* 2x20pin 2.54mm female header and 40pin male breakable header included!
* Optional RCA jack for Composite Video output when used with Raspberry Pi Zero.

62
src/zh/overlay/fepi-audio-z.md Normal file
View File

@ -0,0 +1,62 @@
<!--
---
name: Fe-Pi Audio Z
class: board
type: audio
formfactor: pHAT
manufacturer: Fe-Pi
description: A complete audio solution for the Raspberry Pi
url: http://fe-pi.com/products/fe-pi-audio-z-v1
buy: http://fe-pi.com/products/fe-pi-audio-z-v1
image: 'fepi-audio-z.png'
pincount: 40
eeprom: no
power:
'1':
'2':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'3':
mode: i2c
'5':
mode: i2c
'12':
name: BCLK (Bit Clock)
mode: i2s
'35':
name: LRCLK (Left/Right Clock)
mode: i2s
'38':
name: DIN (Data In)
mode: i2s
'40':
name: DOUT (Data Out)
mode: i2s
i2c:
'0x0a':
name: SGTL5000
device: SGTL5000XNAA3/R2
-->
# Audio Z
The Fe-Pi Audio Z is designed to provide a complete low cost audio solution for Raspberry Pi 2, 3, and Zero, needing line-in, line-out, and headphone-out/mic-in.
## Features
* Small Raspberry Pi Zero PCB footprint
* 3.5 mm, 4 contact, jack for Headphone/MIC (black)
* 3.5 mm jack for stereo Line Out (green), and stereo Line In (pink)
* ADC > 90 dB SNR and -72 dB THD+N
* Line-Out > 100 dB SNR and -85 dB THD+N
* HP Output > 100 dB SNR and -80 dB THD+N, 62.5 mW max into 16 ohm
* Hardware level controls for Headphone Volume, Line In, Line Out. ALSA support
* 2x20pin 2.54mm female header and 40pin male breakable header included

66
src/zh/overlay/fepi-audio.md Normal file
View File

@ -0,0 +1,66 @@
<!--
---
name: Fe-Pi Audio Card
class: board
type: audio
formfactor: HAT
manufacturer: Fe-Pi
description: A complete audio solution for the Raspberry Pi
url: https://fe-pi.com/products/fe-pi-audio-v1
buy: https://fe-pi.com/products/fe-pi-audio-v1
image: 'fepi-audio.png'
pincount: 40
eeprom: no
power:
'1':
'2':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'3':
mode: i2c
'5':
mode: i2c
'12':
name: BCLK (Bit Clock)
mode: i2s
'35':
name: LRCLK (Left/Right Clock)
mode: i2s
'38':
name: DIN (Data In)
mode: i2s
'40':
name: DOUT (Data Out)
mode: i2s
i2c:
'0x0a':
name: SGTL5000
device: SGTL5000XNAA3/R2
-->
# Audio Z
The Fe-Pi Audio is designed to provide a complete low cost audio solution for Raspberry Pi 2, 3, and Zero, needing line-in, line-out, headphone-out/mic-in, and stereo speakers.
## Features
* SPI, UART, and I2C 2.54mm(.100) breakout pads are available for external use.
* Raspberry Pi 2, 3 PCB footprint.
* SGTL5000 low power stereo codec.
* 3.5 mm, 4 contact, jack for Headphone/MIC (black).
* RCA jacks for stereo Line In, and Line Out.
* 4 pin screw terminal for Speaker Out.
* At minimum, 3 Amp power supply is recommended for the Raspberry Pi, if speakers are used!
* ADC > 90 dB SNR and -72 dB THD+N
* Line-Out > 100 dB SNR and -85 dB THD+N
* HP Output > 100 dB SNR and -80 dB THD+N, 62.5 mW max into 16 ohm.
* Speaker Output > 1.4W per channel, into 8 ohms.
* Hardware level controls for Headphone Volume, Line In, Line Out. ALSA support.
* 2x20pin 2.54mm female header included!

57
src/zh/overlay/fepi-digital-audio-z-V1.md Normal file
View File

@ -0,0 +1,57 @@
<!--
---
name: Fe-Pi Digital Audio Z V1
class: board
type: audio
formfactor: pHAT
manufacturer: Fe-Pi
description: S/PDIF audio solution for the Raspberry Pi
url: https://fe-pi.com/products/fe-pi-digital-audio-z-v1
buy: https://fe-pi.com/products/fe-pi-digital-audio-z-v1
image: 'fepi-digital-audio-z-V1.png'
pincount: 40
eeprom: no
power:
'1':
'2':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'3':
mode: i2c
'5':
mode: i2c
'12':
name: BCLK (Bit Clock)
mode: i2s
'35':
name: LRCLK (Left/Right Clock)
mode: i2s
'38':
name: DIN (Data In)
mode: i2s
'40':
name: DOUT (Data Out)
mode: i2s
i2c:
'0x3B':
name: S/PDIF Digital Interface Transceiver
device: WM8804G
-->
# Fe-Pi Digital Audio Z V1
The Fe-Pi Digital Audio Z V1 is designed to provide a complete low cost audio solution for Raspberry Pi 2, 3, and Zero, needing S/PDIF output.
## Features
* Small Raspberry Pi Zero PCB footprint.
* Cirrus Logic WM8804 S/PDIF Digital Interface Transceiver.
* RCA and optical TOSLINK Output jacks.
* 2x20pin 2.54mm female header and 40pin male breakable header included!

54
src/zh/overlay/flick-hat.md Normal file
View File

@ -0,0 +1,54 @@
<!--
---
name: Flick HAT
class: board
type: gesture
formfactor: HAT
manufacturer: Pi Supply
description: Flick HAT is a 3D tracking and gesture pHAT.
url: https://www.pi-supply.com/product/flick-large-standalone-3d-tracking-gesture-breakout/
github: https://github.com/PiSupply/Flick
buy: https://www.pi-supply.com/product/flick-hat-3d-tracking-gesture-hat-raspberry-pi/
image: 'flick-hat.png'
pincount: 40
eeprom: setup
power:
'1':
'2':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'3':
mode: i2c
'5':
mode: i2c
'11':
name: Reset
'13':
name: TS
i2c:
'0x42':
name: Gesture controller
device: MGC3130
-->
# Flick HAT
Integrate Flick into your I2C project to give you multiple ways of controlling it. Using the near field gesture technology, you’re able to hide your project behind non conductive material (wood/acrylic) and still use Flick.
## Features
* 3D tracking
* Gesture sensing up to 15cm
* Touch and Tap sensing
* Communicates with the Raspberry Pi via I2C
* No soldering required
* Level shifting chip to enable board to work with 3V3 or 5V0 power and logic
* One line installer
* Fully CE and FCC tested and approved

54
src/zh/overlay/flick-zero.md Normal file
View File

@ -0,0 +1,54 @@
<!--
---
name: Flick Zero
class: board
type: gesture
formfactor: pHAT
manufacturer: Pi Supply
description: Flick Zero is a 3D tracking and gesture pHAT.
url: https://www.pi-supply.com/product/flick-large-standalone-3d-tracking-gesture-breakout/
github: https://github.com/PiSupply/Flick
buy: https://www.pi-supply.com/product/flick-zero-3d-tracking-gesture-phat-pi-zero/
image: 'flick-zero.png'
pincount: 40
eeprom: no
power:
'1':
'2':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'3':
mode: i2c
'5':
mode: i2c
'11':
name: Reset
'13':
name: TS
i2c:
'0x42':
name: Gesture controller
device: MGC3130
-->
# Flick Zero
Integrate Flick into your I2C project to give you multiple ways of controlling it. Using the near field gesture technology, you’re able to hide your project behind non conductive material (wood/acrylic) and still use Flick.
## Features
* 3D tracking
* Gesture sensing up to 15cm
* Touch and Tap sensing
* Communicates with the Raspberry Pi via I2C
* No soldering required
* Level shifting chip to enable board to work with 3V3 or 5V0 power and logic
* One line installer
* Fully CE and FCC tested and approved

51
src/zh/overlay/fourletter-phat.md Normal file
View File

@ -0,0 +1,51 @@
<!--
---
name: Four Letter pHAT
class: board
type: display
formfactor: pHAT
manufacturer: Pimoroni
description: A four 14-segment displays for the Raspberry Pi
url: https://shop.pimoroni.com/products/four-letter-phat
github: https://github.com/pimoroni/fourletter-phat
buy: https://shop.pimoroni.com/products/four-letter-phat
image: 'fourletter-phat.png'
pincount: 40
eeprom: yes
power:
'2':
'17':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'3':
mode: i2c
'5':
mode: i2c
i2c:
'0x70':
name: Matrix Driver
device: HT16K33
-->
# Four Letter pHAT
Four Letter pHAT is a four 14-segment display that can be used to display text, numbers, and a host of other characters. Its Matrices are a retro-style green, similar to old digital alarm clock and are driven by the HT16K33 chip over I2C.
## Features
* Four 14-segment displays
* HT16K33 driver chip
* Compatible with Raspberry Pi A+/B+, 2, 3 and Zero/Zero W
To get the pHAT set up and ready to go you can use the one-line product installer:
```bash
curl https://get.pimoroni.com/fourletterphat | bash
```

74
src/zh/overlay/gertvga-666.md Normal file
View File

@ -0,0 +1,74 @@
<!--
---
name: GertVGA 666
class: board
type: other
formfactor: Custom
manufacturer: Pi Supply
description: The Gert VGA 666 is a breakout/add on board for the Raspberry Pi for using a VGA monitor.
url: https://www.kickstarter.com/projects/pisupply/gert-vga-666-kit-hardware-vga-for-raspberry-pi
github: https://github.com/PiSupply/Gert-VGA-666
schematic: https://github.com/fenlogic/vga666/blob/master/documents/vga_manual.pdf
buy: https://www.pi-supply.com/product/gert-vga-666-hardware-vga-raspberry-pi/
image: 'gertvga-666.png'
pincount: 40
eeprom: no
power:
'1':
'2':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'3':
name: V-SYNC
'5':
name: H-SYNC
'7':
name: Blue 2
'8':
name: Green 6
'10':
name: Green 7
'11':
name: Red 3
'12':
name: Red 4
'19':
name: Green 2
'21':
name: Blue 7
'23':
name: Green 3
'24':
name: Blue 6
'26':
name: Blue 5
'29':
name: Blue 3
'31':
name: Blue 4
'32':
name: Green 4
'33':
name: Green 5
'35':
name: Red 5
'36':
name: Red 2
'38':
name: Red 6
'40':
name: Red 7
-->
# GertVGA 666
The Gert VGA 666 (6 bits per colour channel, hence 666) is a breakout/add on board for the Raspberry Pi. It is an open source hardware design released publicly by Gert van Loo.
It is a neat and very useful solution for using a VGA screen/monitor with your Raspberry Pi and is far cheaper than an HDMI to VGA adapter or similar. The VGA connection is driven natively in hardware over the GPIO pins (using a parallel interface) and uses around the same CPU load as the HDMI connection on board. It is capable of displaying 1080p60 VGA video with no CPU load.

61
src/zh/overlay/gfx-hat.md Normal file
View File

@ -0,0 +1,61 @@
<!--
---
name: GFX HAT
class: board
type: display
formfactor: HAT
manufacturer: Pimoroni
description: A 128x64 graphic LCD with a 6-zone RGB backlight and 6 touch buttons
url: https://shop.pimoroni.com/products/gfx-hat
github: https://github.com/pimoroni/gfx-hat
buy: https://shop.pimoroni.com/products/gfx-hat
image: 'gfx-hat.png'
pincount: 40
eeprom: yes
power:
'1':
'2':
ground:
'6':
'9':
'39':
pin:
'3':
mode: i2c
'5':
mode: i2c
'19':
mode: spi
'31':
name: LCD Data/Command
mode: output
active: high
'23':
mode: spi
'24':
name: LCD Chip Select
mode: chipselect
active: high
'29':
name: LCD Reset
mode: output
active: low
i2c:
'0x54':
name: Backlight
device: sn3218
'0x2c':
name: Cap Touch
device: cap1166
-->
# GFX HAT
GFX HAT uses both SPI and I2c to drive the LCD display, back-light and touch. However both of these busses can be shared with other devices.
To get the HAT set up and ready to go you can use the one-line product installer:
```bash
curl -sS https://get.pimoroni.com/gfxhat | bash
```
And follow the instructions!

97
src/zh/overlay/gpio-i2c-phat.md Normal file
View File

@ -0,0 +1,97 @@
<!--
---
name: GPIO I2C pHAT
class: board
type: io
formfactor: pHAT
manufacturer: PlasmaDan
description: 4 Extra I2C Buses for Raspberry Pi.
url: https://plasmadan.com/gpioi2c
github: https://github.com/plasmadancom/GPIO-I2C-pHAT
buy: https://plasmadan.com/gpioi2c
image: 'gpio-i2c-phat.png'
pincount: 40
eeprom: no
pin:
'7':
name: I2C3 SDA
mode: i2c
direction: both
active: high
'15':
name: I2C6 SDA
mode: i2c
direction: both
active: high
'16':
name: I2C6 SCL
mode: i2c
direction: both
active: high
'29':
name: I2C3 SCL
mode: i2c
direction: both
active: high
'21':
name: I2C4 SCL
mode: i2c
direction: both
active: high
'24':
name: I2C4 SDA
mode: i2c
direction: both
active: high
'32':
name: I2C5 SDA
mode: i2c
direction: both
active: high
'33':
name: I2C5 SCL
mode: i2c
direction: both
active: high
-->
# GPIO I2C pHAT
The GPIO I2C pHAT is an I2C switch which mounts under your HAT to remap its I2C pins (GPIO 2 & GPIO 3) to 1 of 4 additional I2C buses, without the need for a multiplexer or expander.
Makes use of the extra hardware I2C buses introduced on Raspberry Pi 4 (BCM2711) or software I2C (bit bang). Switching is controlled using a 4-position double-pole slide switch, which allows you to quickly switch between buses.
## Features
* Adds 4 additional I2C buses with breakout
* User selectable I2C GPIO pin remapping
* Hardware I2C compatible (Pi 4)
* Slide switch allows fast bus switching
* No-conflict solder jumpers
* Stackable design
* Immersion gold plated copper
## Usage
Add required dtoverlay parameter(s) to ```/boot/config.txt``` and reboot.
Mount the GPIO I2C pHAT board to your Pi, use the slide switch to select your preferred I2C bus and stack your I2C based HAT on top.
## Hardware I2C (Pi 4 Only)
```
dtoverlay=i2c3
dtoverlay=i2c4
dtoverlay=i2c5
dtoverlay=i2c6
```
## Software I2C (Bit Bang)
```
dtoverlay=i2c-gpio,bus=6,i2c_gpio_sda=22,i2c_gpio_scl=23
dtoverlay=i2c-gpio,bus=5,i2c_gpio_sda=12,i2c_gpio_scl=13
dtoverlay=i2c-gpio,bus=4,i2c_gpio_sda=8,i2c_gpio_scl=9
dtoverlay=i2c-gpio,bus=3,i2c_gpio_sda=4,i2c_gpio_scl=5
```
Note: When using multiple software I2C buses, it's best to add the parameters from highest to lowest, i.e., 6, 5, 4, 3.

27
src/zh/overlay/ground.md Normal file
View File

@ -0,0 +1,27 @@
<!--
---
name: Ground
class: interface
type: pinout
description: Raspberry Pi Ground Pins
pincount: 1
pin:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
-->
# Ground
The Ground pins on the Raspberry Pi are all electrically connected, so it doesn't matter
which one you use if you're wiring up a voltage supply.
Generally the one that's most convenient or closest to the rest of your connections is tidier
and easier, or alternatively the one closest to the supply pin that you use.
For example, it's a good idea to use Physical Pin 17 for 3v3 and Physical Pin 25 for ground when using
the SPI connections, as these are right next to the important pins for SPI0.

106
src/zh/overlay/hyperpixel.md Normal file
View File

@ -0,0 +1,106 @@
<!--
---
name: Hyperpixel
class: board
type: display
formfactor: Custom
manufacturer: Pimoroni
description: A high-resolution 3.5" TFT display for the Raspberry Pi
url: https://shop.pimoroni.com/products/hyperpixel
github: https://github.com/pimoroni/hyperpixel
buy: https://shop.pimoroni.com/products/hyperpixel
image: 'hyperpixel.png'
pincount: 40
eeprom: no
power:
'1':
'2':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'bcm0':
name: DPI Clock
'bcm1':
name: DPI EN
'bcm2':
name: DPI V-Sync
'bcm3':
name: DPI H-Sync
'bcm4':
name: Blue 2
'bcm5':
name: Blue 3
'bcm6':
name: Blue 4
'bcm7':
name: Blue 5
'bcm8':
name: Blue 6
'bcm9':
name: Blue 7
'bcm12':
name: Green 2
'bcm13':
name: Green 3
'bcm14':
name: Green 4
'bcm15':
name: Green 5
'bcm16':
name: Green 6
'bcm17':
name: Green 7
'bcm20':
name: Red 2
'bcm21':
name: Red 3
'bcm22':
name: Red 4
'bcm23':
name: Red 5
'bcm24':
name: Red 6
'bcm25':
name: Red 7
'bcm10':
name: Touch Data
mode: i2c
'bcm11':
name: Touch Clock
mode: i2c
'bcm18':
name: LCD Chip Select
mode: output
'bcm19':
name: Backlight Control
mode: output
'bcm26':
name: LCD Program Data
mode: output
'bcm27':
name: Touch Interrupt
mode: output
-->
# HyperPixel
HyperPixel is a high-resolution 3.5" TFT display for the Raspberry Pi. Using a high-speed DPI interface, it boosts a 60 FPS frame rate and a resolution of approximately 270 pixels per inch (800x480).
The display is capable of displaying 18-bits of colour (6 bits per colour, DPI mode 6 - RGB666), and provides capacitive multi-touch capabilities, more sensitive and responsive to touch than a resistive touch display.
HyperPixel is compatible with any 40-pin version of the Pi, including Pi Zero and Pi Zero W.
Dimensions: 56.5x86x10mm (WxHxD, depth includes header and display).
To get the display set up, you can use the one-line product installer:
```bash
curl https://get.pimoroni.com/hyperpixel | bash
```
And follow the instructions!

115
src/zh/overlay/hyperpixel4.md Normal file
View File

@ -0,0 +1,115 @@
<!--
---
name: Hyperpixel4
class: board
type: display
formfactor: Custom
manufacturer: Pimoroni
description: An 800x480 pixel 60FPS 4" TFT display for the Raspberry Pi
url: https://shop.pimoroni.com/products/hyperpixel
github: https://github.com/pimoroni/hyperpixel4
buy: https://shop.pimoroni.com/products/hyperpixel
image: 'hyperpixel4.png'
pincount: 40
eeprom: no
power:
'1':
'2':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'bcm0':
name: DPI Clock
'bcm1':
name: DPI EN
'bcm2':
name: DPI V-Sync
'bcm3':
name: DPI H-Sync
'bcm4':
name: Blue 2
'bcm5':
name: Blue 3
'bcm6':
name: Blue 4
'bcm7':
name: Blue 5
'bcm8':
name: Blue 6
'bcm9':
name: Blue 7
'bcm12':
name: Green 2
'bcm13':
name: Green 3
'bcm14':
name: Green 4
'bcm15':
name: Green 5
'bcm16':
name: Green 6
'bcm17':
name: Green 7
'bcm20':
name: Red 2
'bcm21':
name: Red 3
'bcm22':
name: Red 4
'bcm23':
name: Red 5
'bcm24':
name: Red 6
'bcm25':
name: Red 7
'bcm10':
name: Touch Data
mode: i2c
'bcm11':
name: Touch Clock
mode: i2c
'bcm18':
name: LCD Chip Select
mode: output
'bcm19':
name: Backlight Control
mode: output
'bcm26':
name: LCD Program Data
mode: output
'bcm27':
name: Touch Interrupt
mode: output
-->
# HyperPixel 4
HyperPixel 4 is a 4" TFT display for the Raspberry Pi. Using a high-speed DPI interface, it boosts a 60 FPS frame rate and a resolution of approximately 270 pixels per inch (800x480).
The display is capable of displaying 18-bits of colour (6 bits per colour, DPI mode 6 - RGB666), and provides capacitive multi-touch capabilities, more sensitive and responsive to touch than a resistive touch display.
HyperPixel 4 is compatible with any 40-pin version of the Pi, including Pi Zero and Pi Zero W.
HyperPixel 4 is larger than a standard HAT to accommodate the
display and will overhang both the USB ports and over the
other end of the Pi. It requires an extension header (supplied)
to connect.
Because HyperPixel 4 uses every Raspberry Pi pin it's difficult
to use it in conjunction with other devices, but it does break
out the software I2C bus (i2c 3) which you can share with the
touch-screen controller.
To get the display set up, you can use the one-line product installer:
```bash
curl https://get.pimoroni.com/hyperpixel4 | bash
```
And follow the instructions!

51
src/zh/overlay/i2c.md Normal file
View File

@ -0,0 +1,51 @@
<!--
---
name: I2C
class: interface
type: pinout
description: Raspberry Pi I2C pins
url: http://www.raspberry-projects.com/pi/programming-in-python/i2c-programming-in-python/using-the-i2c-interface-2
pin:
'3':
name: Data
direction: both
active: high
'5':
name: Clock
direction: both
active: high
'27':
name: EEPROM Data
direction: both
active: high
'28':
name: EEPROM Clock
direction: both
active: high
-->
# I2C - Inter Integrated Circuit
GPIO 2 and GPIO 3 - the Raspberry Pi's I2C1 pins - allow for two-wire communication with a variety of external sensors and devices.
The I2C pins include a fixed 1.8 kΩ pull-up resistor to 3.3v. They are not suitable for use as general purpose IO where a pull-up might interfere.
I2C is a multi-drop bus, multiple devices can be connected to these same two pins. Each device has its own unique I2C address.
You can verify the address of connected I2C peripherals with a simple one-liner:
```bash
sudo apt-get install i2c-tools
sudo i2cdetect -y 1
```
You can then access I2C from Python using the smbus library:
```python
import smbus
DEVICE_BUS = 1
DEVICE_ADDR = 0x15
bus = smbus.SMBus(DEVICE_BUS)
bus.write_byte_data(DEVICE_ADDR, 0x00, 0x01)
```
GPIO 0 and GPIO 1 - I2C0 - can be used as an alternate I2C bus, but are typically used by the system to read the HAT EEPROM.

47
src/zh/overlay/icubex-pishield.md Normal file
View File

@ -0,0 +1,47 @@
<!--
---
name: PiShield
class: board
type: adc
formfactor: Custom
manufacturer: Infusion Systems
collected: Other
description: 5V Analog to Digital Converter and 5V I2C level shifter
url: https://infusionsystems.com/pishield/
github: https://github.com/I-CubeX/PythonExamples
schematic: https://infusionsystems.com/pishield/?page_id=137
buy: https://infusionsystems.com/pishield/?page_id=8
image: 'icubex-pishield.png'
pincount: 26
eeprom: no
power:
'1':
'2':
ground:
'6':
'9':
'20':
pin:
'19':
mode: spi
'21':
mode: spi
'23':
mode: spi
'24':
mode: spi
install:
'devices':
- 'spi'
-->
# PiShield
The I-CubeX PiShield is a 5V sensor interface board that supports 8 channels of 10-bit ADC input via SPI as well as providing landings for 5V I2C devices. Level conversion to/from 5V is provided for both analog as well as digital sensors.
## Features
- Designed for [I-CubeX Sensors](http://infusionsystems.com/catalog/index.php/cPath/24), but works with any 5V analog sensor via a standard 3-pin header (VCC, SIG, GND)
- ADC performed using MCP3008 chip, and works with existing libraries and applications (including wiringPi)
- Supports up to 8 analog sensors via 3-pin headers, and 4 digital sensors via 2x3-pin headers
- Enough header protrusion to allow another 26 pin header to be stacked on top

52
src/zh/overlay/iface-1wire.md Normal file
View File

@ -0,0 +1,52 @@
<!--
---
name: 1-WIRE
class: interface
type: pinout
description: Raspberry Pi One-Wire pins
url: https://www.kernel.org/doc/Documentation/w1/w1.generic
pin:
'bcm4':
name: Data
-->
# W1-GPIO - One-Wire Interface
One-wire is a single-wire communication bus typically used to connect sensors to the Pi.
The Raspberry Pi supports one-wire on any GPIO pin, but the default is GPIO 4.
To enable the one-wire interface you need to add the following line to /boot/config.txt, before rebooting your Pi:
```
dtoverlay=w1-gpio
```
or
```
dtoverlay=w1-gpio,gpiopin=x
```
if you would like to use a custom pin (the default is GPIO 4)
Alternatively you can enable the one-wire interface on demand using `raspi-config`, or the following:
```
sudo modprobe w1-gpio
```
Newer kernels (4.9.28 and later) allow you to use dynamic overlay loading instead, including creating multiple 1-Wire busses to be used at the same time:
```
sudo dtoverlay w1-gpio gpiopin=4 pullup=0 # header pin 7
sudo dtoverlay w1-gpio gpiopin=17 pullup=0 # header pin 11
sudo dtoverlay w1-gpio gpiopin=27 pullup=0 # header pin 13
```
once any of the steps above have been performed, and discovery is complete you can list the devices that your Raspberry Pi has discovered via all 1-Wire busses (by default GPIO 4), like so:
```
ls /sys/bus/w1/devices/
```
Using w1-gpio on the Raspberry Pi typically needs a 4.7 kΩ pull-up resistor connected between the GPIO pin and a 3.3v supply (e.g. header pin 1 or 17). Other means of connecting 1-Wire devices to the Raspberry Pi are also possible, such as using i2c to 1-Wire bridge chips.

72
src/zh/overlay/iface-dpi.md Normal file
View File

@ -0,0 +1,72 @@
<!--
---
name: DPI
class: interface
type: pinout
description: Raspberry Pi DPI pins
url: https://www.raspberrypi.org/documentation/hardware/raspberrypi/dpi/
pin:
'bcm0':
name: CLK
'bcm1':
name: DEN
'bcm2':
name: V-SYNC
'bcm3':
name: H-SYNC
'bcm4':
name: Blue 0
'bcm5':
name: Blue 1
'bcm6':
name: Blue 2
'bcm7':
name: Blue 3
'bcm8':
name: Blue 4
'bcm9':
name: Blue 5
'bcm10':
name: Blue 6
'bcm11':
name: Blue 7
'bcm12':
name: Green 0
'bcm13':
name: Green 1
'bcm14':
name: Green 2
'bcm15':
name: Green 3
'bcm16':
name: Green 4
'bcm17':
name: Green 5
'bcm18':
name: Green 6
'bcm19':
name: Green 7
'bcm20':
name: Red 0
'bcm21':
name: Red 1
'bcm22':
name: Red 2
'bcm23':
name: Red 3
'bcm24':
name: Red 4
'bcm25':
name: Red 5
'bcm26':
name: Red 6
'bcm27':
name: Red 7
-->
# DPI - Display Parallel Interface
One of the alternate functions selectable on bank 0 of the Raspberry Pi GPIO is DPI. DPI (Display Parallel Interface) is a 24-bit parallel interface with 28 clock and synchronisation signals.
This interface allows parallel RGB displays to be attached to the Raspberry Pi GPIO either in RGB24 (8 bits for red, green and blue) or RGB666 (6 bits per colour) or RGB565 (5 bits red, 6 green, and 5 blue). It is available as alternate function 2 (ALT2) on GPIO bank 0.
The pinout presented here is for the RGB24 mode, see url below for documentation of the RGB666 and RGB565 modes.

33
src/zh/overlay/iface-gpclk.md Normal file
View File

@ -0,0 +1,33 @@
<!--
---
name: GPCLK
class: interface
type: pinout
description: Raspberry Pi General Purpose Clock
pin:
'bcm4':
name: GPCLK0
'bcm5':
name: GPCLK1
'bcm6':
name: GPCLK2
-->
# GPCLK - General Purpose CLock
General Purpose Clock pins can be set up to output a fixed frequency without any ongoing software control.
The following clock sources are available:
```
0 0 Hz Ground
1 19.2 MHz oscillator
2 0 Hz testdebug0
3 0 Hz testdebug1
4 0 Hz PLLA
5 1000 MHz PLLC (changes with overclock settings)
6 500 MHz PLLD
7 216 MHz HDMI auxiliary
8-15 0 Hz Ground
```
Other frequencies can be achieved by setting a clock-divider in the form of `SOURCE/(DIV_I + DIV_F/4096)`. Note, that the [BCM2835 ARM Peripherals](https://www.raspberrypi.org/documentation/hardware/raspberrypi/bcm2835/BCM2835-ARM-Peripherals.pdf) document contains an error and states that the denominator of the divider is 1024 instead of 4096.

38
src/zh/overlay/iface-jtag.md Normal file
View File

@ -0,0 +1,38 @@
<!--
---
name: JTAG
class: interface
type: pinout
description: Raspberry Pi JTAG pins
pin:
'bcm4':
name: TDI (Alt5)
'bcm5':
name: TDO (Alt5)
'bcm6':
name: RTCK (Alt5)
'bcm12':
name: TMS (Alt5)
'bcm13':
name: TCK (Alt5)
'bcm22':
name: TRST (Alt4)
'bcm23':
name: RTCK (Alt4)
'bcm24':
name: TDO (Alt4)
'bcm25':
name: TCK (Alt4)
'bcm26':
name: TDI (Alt4)
'bcm27':
name: TMS (Alt4)
-->
# JTAG - Joint Test Action Group
JTAG is a standardised interface for debugging integrated circuits which you can use to debug your Raspberry Pi.
There are two separate JTAG interfaces available on the Pi:
* Alt5 on GPIOs 4, 5, 6, 12 and 13
* Alt4 on GPIOs 22, 23, 24, 25, 26 and 27

19
src/zh/overlay/iface-pcm.md Normal file
View File

@ -0,0 +1,19 @@
<!--
---
name: PCM
class: interface
type: pinout
description: Raspberry Pi PCM pins
pin:
'bcm18':
name: CLK
'bcm19':
name: FS
'bcm20':
name: DIN
'bcm21':
name: DOUT
-->
# PCM - Pulse-code Modulation
PCM (Pulse-code Modulation) is a digital representation of sampled analog. On the Raspberry Pi it's a form of digital audio output which can be understood by a DAC for high quality sound.

19
src/zh/overlay/iface-pwm.md Normal file
View File

@ -0,0 +1,19 @@
<!--
---
name: PWM
class: interface
type: pinout
description: Raspberry Pi PWM pins
pin:
'32':
name: PWM0
'33':
name: PWM1
'12':
name: PWM0
'35':
name: PWM1
-->
# PWM - Pulse-width Modulation
PWM (Pulse-width Modulation) is a method of creating an analog voltage by toggling a digital pin on and off.

25
src/zh/overlay/iface-sd.md Normal file
View File

@ -0,0 +1,25 @@
<!--
---
name: SDIO
class: interface
type: pinout
description: Raspberry Pi SD0/SD1 pins
pin:
'bcm22':
name: CLK
'bcm23':
name: CMD
'bcm24':
name: DAT0
'bcm25':
name: DAT1
'bcm26':
name: DAT2
'bcm27':
name: DAT3
-->
# SDIO - SD Card Interface
SDIO is the SD host/eMMC interface on the Raspberry Pi. SD host signals are normally used for the microSD slot.
These pins are "SD host" on Alt0 and "eMMC" on Alt3.

73
src/zh/overlay/inkyphat.md Normal file
View File

@ -0,0 +1,73 @@
<!--
---
name: Inky pHAT
class: board
type: display
formfactor: pHAT
manufacturer: Pimoroni
description: An e-paper display for your Raspberry Pi
url: https://shop.pimoroni.com/products/inky-phat
github: https://github.com/pimoroni/inky
buy: https://shop.pimoroni.com/products/inky-phat
image: 'inkyphat.png'
pincount: 40
eeprom: no
power:
'1':
'2':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'11':
name: Busy
mode: input
'13':
name: Reset
mode: output
active: low
'15':
name: Data/Command
mode: output
active: high
'19':
mode: spi
'23':
mode: spi
'24':
name: Chip Select
mode: chipselect
active: high
'3':
mode: i2c
'5':
mode: i2c
i2c:
0x50:
device: Inky ID EEPROM
-->
# Inky pHAT
Inky pHAT is a low-energy, red/black, red/black/white or yellow/black/white electronic paper display for the Raspberry Pi. Multi-colour EPD displays, like the one on Inky pHAT, use ingenious electrophoresis to pull coloured particles up and down on the display. The coloured particles reflect light, unlike most display types, so they're visible under bright lights.
The unit comes fully-assembled, with the display securely stuck down to the Inky pHAT PCB and connected via a ribbon cable. The Inky pHAT is compatible with all 40-way Raspberry Pis.
To get the pHAT up and running, you can use the one-line product installer:
```bash
curl https://get.pimoroni.com/inky | bash
```
And follow the instructions!
Note: For the old first edition Inky pHAT you should use:
```bash
curl https://get.pimoroni.com/inkyphat | bash
```

68
src/zh/overlay/iqaudio-pi-dac.md Normal file
View File

@ -0,0 +1,68 @@
<!--
---
name: Pi-DAC+
class: board
type: audio
formfactor: HAT
manufacturer: IQaudIO
description: An I2S digital to analog audio converter HAT for the Pi
url: http://www.iqaudio.co.uk/audio/8-pi-dac-0712411999650.html
buy: http://www.iqaudio.co.uk
image: 'iqaudio-pi-dac.png'
pincount: 40
eeprom: yes
power:
'1':
'2':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'3':
mode: i2c
'5':
mode: i2c
'12':
name: I2S
'15':
name: Mute/Unmute
description: Pi-AMP+ only (optional)
'16':
name: Rotary Encoder
description: (optional)
'18':
name: Rotary Encoder
description: (optional)
'22':
name: IR Sensor
description: (optional)
'35':
name: I2S
'38':
name: I2S
'40':
name: I2S
install:
'devices':
- 'i2c'
-->
# Pi-DAC+
The Pi-DAC+ takes the digital audio signals (I2S) from the Raspberry Pi and through the
onboard Texas Instruments PCM5122 DAC delivers variable output (hardware volume
control) analog audio to the Pi-DAC+ Phono connectors. The PI-DAC+ also, via the
Texas Instruments TPA6133A headphone amp, supports the direct use of headphones via
the Pi-DAC+ 3.5mm audio jack.
The Pi-DAC+ uses GPIO22 to mute/unmute the Pi-AMP+.
You can use GPIO25 to connect an IR sensor and GPIO23/24 for a rotary encoder. Both of
these parts are optional, but are broken out on the Pi-DAC+ for convenient access.
Note: pins reserved for the rotary encoder and IR sensor can be used for other purposes if those add-ons have not been fitted and enabled by software.

59
src/zh/overlay/iqaudio-pi-digiamp.md Normal file
View File

@ -0,0 +1,59 @@
<!--
---
name: Pi-DigiAMP+
class: board
type: audio
formfactor: HAT
manufacturer: IQaudIO
description: A combined DAC and 35w amplifier board
url: http://www.iqaudio.co.uk/home/9-pi-digiamp-0712411999650.html
buy: http://www.iqaudio.co.uk
image: 'iqaudio-pi-digiamp.png'
pincount: 40
eeprom: yes
power:
'1':
'2':
ground:
'6':
'9':
'14':
'20':
'25':
'30':
'34':
'39':
pin:
'3':
mode: i2c
'5':
mode: i2c
'12':
name: I2S
'15':
name: Mute/Unmute
'16':
name: Rotary Encoder
description: (optional)
'18':
name: Rotary Encoder
description: (optional)
'22':
name: IR Sensor
description: (optional)
'35':
name: I2S
'38':
name: I2S
'40':
name: I2S
install:
'devices':
- 'i2c'
-->
# Pi-DigiAMP+
The Pi-DigiAMP+ is an add-on board that includes a Digital to Analog Converter (DAC) and powerful 35w stereo amplifier. If you want to turn your Raspberry Pi into a working Hi Fi stereo, just add speakers and you're off.
You can use GPIO25 to connect an IR sensor and GPIO23/24 for a rotary encoder. Both of these parts are optional, but are broken out on the Pi-DAC+ for convenient access.
Note: pins reserved for the rotary encoder and IR sensor can be used for other purposes if those add-ons have not been fitted and enabled by software.

Some files were not shown because too many files have changed in this diff Show More