The Banana Pi M1 features a native SATA II interface, which supports faster data transfer speeds than traditional USB storage options. This allows for the addition of external hard drives or SSDs to the system, making it suitable for applications such as network-attached storage (NAS), media servers, or any system requiring high-capacity storage with fast read/write speeds.

Connecting SATA storage devices directly to the board is ideal for projects that require large amounts of storage space or fast data retrieval, such as file sharing, backup solutions, or multimedia storage.

• SATA Type: SATA II (3Gbps)
• Connector Type: 7-pin SATA connector (supports both 2.5" and 3.5" drives with separate power supply)
• Use Cases: External storage, NAS, media server, backup solutions

The Banana Pi M1 features a native SATA II interface, which supports faster data transfer speeds than traditional USB storage options. This allows for the addition of external hard drives or SSDs to the system, making it suitable for applications such as network-attached storage (NAS), media servers, or any system requiring high-capacity storage with fast read/write speeds.

Connecting SATA storage devices directly to the board is ideal for projects that require large amounts of storage space or fast data retrieval, such as file sharing, backup solutions, or multimedia storage.

• SATA Type: SATA II (3Gbps)
• Connector Type: 7-pin SATA connector (supports both 2.5" and 3.5" drives with separate power supply)
• Use Cases: External storage, NAS, media server, backup solutions

The Banana Pi M1 comes equipped with a Gigabit Ethernet port (10/100/1000 Mbps), which allows for high-speed internet and local network connections. The inclusion of Gigabit Ethernet provides much faster data transfer compared to older 100Mbps Ethernet ports, making it ideal for network-heavy tasks such as media streaming, file transfers, or hosting servers.

This feature makes the Banana Pi M1 suitable for use in scenarios where fast and reliable network connectivity is required, such as in IoT projects, network servers, and SBC Home automation systems.

• Ethernet Speed: 10/100/1000 Mbps (Gigabit Ethernet)
• Connector: RJ45 Ethernet jack
• Use Cases: High-speed internet access, file sharing, SBC Home server, media server, network tasks
• Additional Features: Supports networking protocols like DHCP, static IP, and more

Independent command blocks for managing Raspberry Pi Ethernet interfaces. Click to copy to clipboard.

# List all network interfaces
ip link show
# or
ifconfig -a
      

# Show IP address of Ethernet interface eth0
ip addr show eth0
      

# Show Ethernet link speed
sudo ethtool eth0 | grep Speed
      

# Enable DHCP on eth0
sudo dhclient eth0
      

# Edit dhcpcd.conf to assign static IP
sudo nano /etc/dhcpcd.conf
# Add lines:
# interface eth0
# static ip_address=192.168.1.100/24
# Restart networking service
sudo systemctl restart dhcpcd
      

# Bring interface up
sudo ifconfig eth0 up
# Bring interface down
sudo ifconfig eth0 down
      

# Show interface statistics
ifconfig eth0
# Or RX/TX byte counters
cat /sys/class/net/eth0/statistics/rx_bytes
cat /sys/class/net/eth0/statistics/tx_bytes
      

The Banana Pi M1 includes a Serial Console (UART) interface for low-level system interaction, debugging, and recovery. The serial port can be accessed through a 4-pin header, which includes TX, RX, GND, and a 3.3V pin. This is especially useful for troubleshooting or configuring the board without needing a monitor or keyboard.

Serial communication via UART allows for commands and system logs to be transmitted over a simple terminal connection, providing a minimal interface for system management.

• Connector: 4-pin header (TX, RX, GND, 3.3V)
• Baud Rate: Default 115200
• Use Cases: Console access, system recovery, debugging, logging
• Additional Information: Can be connected to a USB-to-serial adapter for easy terminal access

# Enable and use UART (ttyS0)
screen /dev/ttyS0 115200
# Or using Python
python3 -c "import serial; s=serial.Serial('/dev/ttyS0',115200); s.write(b'Hello\n')"
        

The Banana Pi M1 supports a 3.7V Li-ion battery via a dedicated connector. This battery can provide backup power for the system, which is especially useful for maintaining real-time clock (RTC) functionality during power outages. Additionally, it ensures the device remains powered for portable applications or when running off-grid.

This feature is particularly useful in embedded or mobile projects where the Banana Pi M1 is deployed in remote or unstable power environments, allowing the system to keep time and prevent data loss.

• Battery Type: 3.7V Li-ion rechargeable battery
• Battery Connector: 2-pin JST connector
• Use Cases: RTC backup, portable applications, off-grid systems
• Battery Life: Depends on the power consumption of the connected system

In addition to HDMI, the Banana Pi M1 includes a composite video output through a 3.5mm jack, allowing the board to connect to older TVs or video equipment that supports composite video input. This feature is ideal for legacy systems or environments where HDMI or digital video outputs are not available.

The composite video output supports both PAL and NTSC video formats, making it suitable for a wide range of devices, especially those with analog video input.

• Connector: Phono connector
• Supported Video Formats: PAL/NTSC
• Use Cases: Connecting to CRT TVs, older video equipment, embedded video applications
• Additional Notes: Video output resolution is typically lower than HDMI, but suitable for basic displays

The Banana Pi M1 comes with a 24-bit LVDS LCD connector for connecting external LCD displays. This connector allows you to attach a wide variety of LCD screens, enabling the board to display graphics, user interfaces, or multimedia content.

It is commonly used with 7-inch to 10-inch LVDS screens, providing high-quality visuals for embedded projects, digital signage, or interactive kiosks. The display interface supports both basic GUI applications as well as complex multimedia tasks.

• Connector: 24-pin LVDS connector
• Supported Displays: 7-inch to 10-inch LVDS LCD displays
• Use Cases: Embedded applications, GUI-based systems, digital signage, interactive displays
• Resolution Support: Typically supports up to 1280x800 or 1920x1080, depending on the display

The Banana Pi M1 features a Camera Serial Interface (CSI), allowing it to connect to compatible camera modules for image or video capture. The 24-pin MIPI-CSI2 connector can support various camera types, including Raspberry Pi camera modules and other MIPI-CSI compatible sensors.

This feature is useful for applications in surveillance, robotics, machine vision, or media creation. The camera module can capture still images or video streams that can be processed or transmitted by the Banana Pi M1.

• Camera Connector: 24-pin MIPI-CSI2 connector
• Supported Cameras: Raspberry Pi camera module, MIPI-CSI compatible cameras
• Use Cases: Photography, security systems, image recognition, robotics, multimedia
• Supported Resolutions: Up to 5MP or higher, depending on the camera used

The Banana Pi M1 also supports the I2S (Inter-IC Sound) interface for high-quality audio data transfer. This is particularly useful for connecting digital audio devices such as DACs, ADCs, or audio codecs for professional-grade sound systems or audio processing applications.

I2S is a serial bus interface standard that allows for the transmission of digital audio data between devices with minimal interference, making it ideal for high-fidelity audio applications like sound recording or playback.

• Connector: 3.3V, GND, BCLK, LRCK, and DATA (Header pins)
• Supported Protocol: I2S (Inter-IC Sound)
• Use Cases: Audio DACs, ADCs, audio processing, sound recording, and playback systems
• Data Transfer Rate: 16-bit, 32-bit audio data transfer

# I2S support on Banana Pi is hardware-limited and requires custom kernel overlays
# Example: record using arecord
arecord -D plughw:1,0 -f cd test.wav
        

The Banana Pi M1 also supports the I2S (Inter-IC Sound) interface for high-quality audio data transfer. This is particularly useful for connecting digital audio devices such as DACs, ADCs, or audio codecs for professional-grade sound systems or audio processing applications.

I2S is a serial bus interface standard that allows for the transmission of digital audio data between devices with minimal interference, making it ideal for high-fidelity audio applications like sound recording or playback.

• Connector: 3.3V, GND, BCLK, LRCK, and DATA (Header pins)
• Supported Protocol: I2S (Inter-IC Sound)
• Use Cases: Audio DACs, ADCs, audio processing, sound recording, and playback systems
• Data Transfer Rate: 16-bit, 32-bit audio data transfer

# I2S support on Banana Pi is hardware-limited and requires custom kernel overlays
# Example: record using arecord
arecord -D plughw:1,0 -f cd test.wav
        

The Banana Pi M1 comes equipped with an SPI (Serial Peripheral Interface) bus for high-speed communication with a variety of peripheral devices such as sensors, displays, and memory chips. SPI is a full-duplex protocol that provides faster data transfer speeds compared to I2C, making it ideal for applications requiring high-speed data exchange.

It is commonly used for communication with devices like SD cards, LCD displays, and sensors, offering a flexible solution for many embedded systems.

• Connector: SPI pins on GPIO header (MISO, MOSI, SCK, and CS)
• Supported Protocol: SPI (Serial Peripheral Interface)
• Use Cases: Connecting SD cards, displays, sensors, and other SPI peripherals
• Supported Speeds: Up to 25 MHz (depending on configuration)

# Enable SPI and check device
ls /dev/spidev0.*
# Example using spidev in Python
python3 -c "import spidev; spi=spidev.SpiDev(); spi.open(0,0); spi.max_speed_hz=50000; print(spi.xfer([0xAA]))"
        

The Banana Pi M1 provides an I2C interface for communication with various I2C devices such as sensors, displays, and other peripherals. The board supports multiple I2C buses, allowing for flexibility in connecting a range of devices.

I2C is a two-wire protocol (SCL for clock and SDA for data) that simplifies communication between microcontrollers and peripheral devices, making it ideal for embedded applications where many devices need to be connected to a single bus.

• Connector: 2-pin header (SCL, SDA)
• Supported Protocol: I2C (Inter-Integrated Circuit)
• Use Cases: Connecting sensors, displays, RTCs, EEPROMs, and other I2C peripherals
• Supported Speeds: Up to 400 KHz (Fast-mode)

# Enable I2C and detect devices
i2cdetect -y 1
# Read register 0x00 from device at address 0x3C
i2cget -y 1 0x3c 0x00
        

The Banana Pi M1 offers a wide range of GPIO pins that can be configured as either input or output, making it highly flexible for controlling various devices such as LEDs, motors, relays, and other hardware peripherals. These pins can also be used for digital signal processing or as communication interfaces like I2C or SPI.

The board exposes a 26-pin header with a variety of functions, allowing for a wide range of use cases in embedded and IoT projects.

• GPIO Pins: 26 pins available (some shared with other functions like I2C, SPI, etc.)
• Supported Functions: Input, Output, PWM, Interrupts, Analog (via ADC)
• Use Cases: Controlling LEDs, sensors, motors, relays, and other peripherals
• Voltage: 3.3V logic (some pins may support 5V with caution)

# Export GPIO pin 18 and toggle output (using sysfs)
echo 18 > /sys/class/gpio/export
echo out > /sys/class/gpio/gpio18/direction
echo 1 > /sys/class/gpio/gpio18/value
sleep 1
echo 0 > /sys/class/gpio/gpio18/value
        

The Banana Pi M1 supports interrupts, which allow the processor to respond to external events without constantly polling for input. Interrupts are crucial for low-latency applications where the system must react immediately to an event such as a button press, sensor input, or communication signal.

Interrupts can be configured on specific GPIO pins or other peripherals, enabling the Banana Pi M1 to efficiently handle time-sensitive events.

• Interrupt Source: GPIO pins, timers, external devices
• Interrupt Types: Rising edge, falling edge, level-triggered
• Supported Hardware Interrupts: GPIO, timer overflows, external devices
• Use Cases: Button presses, sensor input detection, external event handling
• System Latency: Low latency response to events

Interrupts are typically handled in the Linux kernel using IRQ (Interrupt Request) handlers. You can configure GPIO pins for interrupts through the sysfs interface or through kernel drivers.

# GPIO interrupt via sysfs (polling example in Bash)
echo 18 > /sys/class/gpio/export
echo in > /sys/class/gpio/gpio18/direction
echo rising > /sys/class/gpio/gpio18/edge
while true; do read line < /sys/class/gpio/gpio18/value; echo "Interrupt!"; done
        

The Banana Pi M1 provides a 3.5mm audio jack for analog audio output, which can be connected to external speakers or headphones. The audio output can be configured for stereo sound, providing high-quality playback for various applications.

• Audio Output: 3.5mm stereo audio jack
• Use Cases: Audio playback, sound effects, multimedia systems
• Audio Format: Stereo (via audio jack)

Additionally, the board supports digital audio input through the I²S interface for microphones, which is useful for voice recognition or audio recording applications. External microphones can be connected via I²S to capture high-quality audio for various applications like voice assistants, sound recording, and more.

• Microphone Input: onboard microphone
• Microphone Input: I²S interface for connecting digital microphones
• Use Cases: Voice recognition, recording, multimedia applications
• Audio Format: Digital (via I²S)

The Banana Pi M1 includes a built-in IR receiver, allowing it to receive signals from standard IR remote controls. This makes the board suitable for applications like media centers, home automation interfaces, and other IR-controlled systems.

• Receiver Type: Onboard IR receiver connected to SoC GPIO
• Protocols Supported: NEC, RC-5, and other pulse-width modulation based IR protocols
• Use Cases: Remote control input, media playback control, home automation, robotics
• Software Support: Handled via Linux lirc drivers and input event interfaces (/dev/input/event*)

Install the necessary tools to work with the IR receiver under a Debian/Armbian-based Linux distribution:

sudo apt update
sudo apt install lirc evtest

This installs lirc for handling IR input and evtest for monitoring events.

Edit the LIRC hardware configuration to enable the IR driver and specify the input device:

sudo nano /etc/lirc/hardware.conf
# Example settings:
LIRCD_ARGS="--uinput"
LOAD_MODULES=true
DRIVER="UNCONFIGURED"
DEVICE="/dev/input/event0"
MODULES="sunxi-ir"

Ensure that DEVICE points to the correct input event. Use evtest to list the event devices.

Restart LIRC and verify that the IR receiver is capturing signals:

sudo systemctl restart lircd
sudo evtest

Press buttons on your IR remote. You should see events logged in evtest corresponding to button presses and releases.

Map raw IR scancodes to key events using ir-keytable:

# List remotes and protocols
ir-keytable --list-remote

# Test raw IR scancodes
ir-keytable -t

Once mapped, these key events can be used in applications like Kodi, custom scripts, or automation systems.

The Banana Pi M1 features timers and PWM (Pulse Width Modulation) capabilities, which are essential for controlling motor speeds, generating precise timing signals, and creating applications that need timing and frequency control.

The timers are typically used for periodic events such as controlling LEDs, generating audio signals, or driving motors. PWM allows for smooth control over motor speeds and other devices by varying the duty cycle of a square wave.

• Timer Support: 3 timers available for general-purpose timing tasks
• PWM Output: Available on GPIO pins, supports a variety of frequencies and duty cycles
• Use Cases: Motor control, LED dimming, sound generation, frequency generation
• Control Method: Configure PWM frequencies and duty cycle via software (via sysfs or PWM driver)
• Example Applications: Fan speed control, servo control, dimming LED lights

# Timer functionality generally accessed via kernel modules or high-res timers
# Example using sleep in Bash (not precise)
start=$(date +%s%N)
sleep 1
end=$(date +%s%N)
echo "Elapsed: $(( (end - start)/1000000 )) ms"
        

# PWM using sysfs (example for PWM chip 0, channel 0)
echo 0 > /sys/class/pwm/pwmchip0/export
echo 1000000 > /sys/class/pwm/pwmchip0/pwm0/period
echo 500000 > /sys/class/pwm/pwmchip0/pwm0/duty_cycle
echo 1 > /sys/class/pwm/pwmchip0/pwm0/enable
        

The Banana Pi M1 is equipped with a USB 2.0 host interface, allowing you to connect a wide variety of USB peripherals such as keyboards, mice, USB storage devices, and more. The board provides a Type-A USB port that can be used for connecting these devices, as well as additional USB functionality depending on the operating system and drivers in use.

USB 2.0 offers data transfer speeds of up to 480 Mbps, providing sufficient bandwidth for most typical USB devices. The USB ports also support plug-and-play functionality, which simplifies the process of connecting external devices.

• Connector: One USB 2.0 Type-A port
• Data Rate: Up to 480 Mbps (High-speed USB)
• Use Cases: Connecting keyboards, mice, USB storage, printers, audio devices, and other USB peripherals
• Power: Provides 5V power to connected devices (typically 500mA)

The USB Gadget feature on the Banana Pi M1 allows the board to act as a USB device, enabling it to function as a USB peripheral to a host system, such as a PC or another Raspberry Pi. This can be useful for projects where the Banana Pi M1 needs to communicate as a USB device, for example, as a keyboard, mouse, network device, or mass storage device.

USB Gadget mode is configured through the Linux kernel and typically requires specific drivers or configuration changes. This feature expands the usability of the Banana Pi M1 by allowing it to be used in unique embedded applications.

• Supported Gadget Modes: Network device, mass storage device, HID (keyboard, mouse, etc.)
• Connector: USB OTG port (via the micro-USB connector)
• Data Rate: 480 Mbps (High-speed USB)
• Use Cases: Creating custom USB devices for embedded applications, connecting to other devices as a peripheral
• Configuration: Configured through the Linux kernel with the appropriate USB gadget drivers

For example, the Banana Pi M1 can be configured as a USB Ethernet adapter or a virtual serial port to communicate with a host system, allowing it to interact in a wide range of projects.

The Banana Pi M1 can be configured to act as a USB device (HID, mass storage, or Ethernet). The following steps outline setting up a USB Ethernet gadget on Armbian or other Linux distributions:

# Load required kernel modules
sudo modprobe libcomposite

# Create gadget directory
sudo mkdir -p /sys/kernel/config/usb_gadget/g1
cd /sys/kernel/config/usb_gadget/g1

# Set basic device information
echo 0x1d6b > idVendor    # Linux Foundation
echo 0x0104 > idProduct   # Multifunction Composite Gadget
echo 0x0100 > bcdDevice
echo 0x0200 > bcdUSB

# Create English strings
mkdir -p strings/0x409
echo "0123456789" > strings/0x409/serialnumber
echo "Banana Pi" > strings/0x409/manufacturer
echo "USB Ethernet Gadget" > strings/0x409/product

# Create configuration
mkdir -p configs/c.1
mkdir -p configs/c.1/strings/0x409
echo "Config 1: CDC Ethernet" > configs/c.1/strings/0x409/configuration
echo 250 > configs/c.1/MaxPower

# Create Ethernet function
mkdir -p functions/ecm.usb0
HOST="02:11:22:33:44:55"
SELF="02:AA:BB:CC:DD:EE"
echo $HOST > functions/ecm.usb0/host_addr
echo $SELF > functions/ecm.usb0/dev_addr

# Bind function to configuration
ln -s functions/ecm.usb0 configs/c.1/

# Enable gadget
ls /sys/class/udc
echo $(ls /sys/class/udc) > UDC
    

After enabling the gadget, the Banana Pi M1 should appear as a USB Ethernet device on the host computer. Similar steps can be adapted for HID (keyboard/mouse) or mass storage gadgets by creating the appropriate functions in /sys/kernel/config/usb_gadget/g1/functions/.

The Banana Pi M1 is a versatile single-board computer that can run a variety of Linux-based operating systems. It features a SATA interface, Ethernet, HDMI, and GPIO pins, making it suitable for home servers, media centers, and embedded projects. The following cards provide detailed guidance on installing and configuring operating systems for this board.

The recommended operating system for the Banana Pi M1 is Armbian, a lightweight Debian/Ubuntu-based Linux distribution optimized for ARM devices. Armbian provides prebuilt images that support the M1's hardware, including SATA, Ethernet, and GPU acceleration.

Key Features of Armbian on Banana Pi M1:

• Optimized Debian/Ubuntu base with ARM support
• Low memory footprint and fast boot
• Full support for SATA drives via onboard SATA port
• Networking support (Ethernet, Wi-Fi via USB dongle)
• Access to standard package repositories via apt
• Easy kernel updates and hardware monitoring tools

1. Download the Image

Get the latest Armbian image for Banana Pi M1 from the official website:

• Download Armbian for BPi M1

2. Prepare the SD Card

Insert a microSD card (at least 8 GB) and format it to FAT32. Then write the image using your preferred flashing tool:

• Windows: Balena Etcher
• Linux/macOS: dd command

sudo dd if=armbian_image.img of=/dev/sdX bs=4M status=progress && sync

3. Initial Boot

Insert the SD card into the Banana Pi M1 and power it on. The system will boot into Armbian, and the first login is usually root / 1234. You will be prompted to change the password on first login.

The Banana Pi M1 can use its SATA port to run the operating system directly from a hard drive or SSD, offering higher performance and reliability compared to the SD card. The steps below outline setting up a SATA drive as the main system drive.

1. Prepare the SATA Drive

Connect the SATA drive and format it with ext4 for Linux:

sudo mkfs.ext4 /dev/sda
sudo mount /dev/sda /mnt/sata

2. Copy System Files

Mount the SD card root partition and copy all system files to the SATA drive:

sudo mount /dev/mmcblk0p1 /mnt/sd
sudo rsync -aAXv /mnt/sd/ /mnt/sata/

3. Update fstab

Edit /etc/fstab to mount root and home directories from the SATA drive:

UUID=$(sudo blkid -s UUID -o value /dev/sda1)
/mnt/sata  ext4  defaults  0 1

4. Update Bootloader

Configure the bootloader to use the SATA drive as root. For U-Boot, edit boot.cmd or boot.scr:

setenv rootdev /dev/sda1
saveenv

5. Reboot and Verify

After reboot, verify that the system is running from the SATA drive:

df -h
lsblk

Besides Armbian, the Banana Pi M1 supports other Linux distributions and lightweight systems:

• Debian / Ubuntu Server: Standard ARM images can be adapted for BPi M1, providing familiar package management and server tools.
• Android: Custom Android builds allow using the M1 as a media or gaming device.
• DietPi: Minimal Debian-based OS optimized for low-resource ARM devices.
• OpenMediaVault: For NAS setups, especially when using SATA drives.

Each alternative OS has specific requirements and may need kernel patches to fully support the M1 hardware, especially SATA and Ethernet interfaces.