Stufin
Home Quick Cart Profile

UNIHIKER - IoT Python Single Board Computer with Touchscreen

UNIHIKER - IoT Python Single Board Computer with Touchscreen UNIHIKER - IoT Python Single Board Computer with Touchscreen
Buy Now on Stufin

Component Name

UNIHIKER - IoT Python Single Board Computer with Touchscreen

Overview

The UNIHIKER is a compact, single-board computer designed specifically for Internet of Things (IoT) applications. This powerful device integrates a high-performance computing platform, a high-resolution touchscreen display, and a wide range of interfaces, making it an ideal choice for developers, engineers, and hobbyists working on IoT projects.

Functional Description

The UNIHIKER is a versatile single-board computer that can be used for a variety of IoT applications, including

Automation and control systems

Industrial monitoring and control

Smart home devices

Wearable devices

Robotics and machine learning

This device can be programmed using Python, allowing developers to easily create and deploy IoT applications. The UNIHIKER's touchscreen display enables users to create interactive GUIs, making it an excellent choice for human-machine interface (HMI) applications.

Key Features

  • Processing Power: The UNIHIKER is equipped with a high-performance, quad-core processor (Cortex-A7) clocked at 1.2 GHz, providing ample processing power for demanding IoT applications.
  • Memory and Storage: The device comes with 1GB of DDR3 RAM and 8GB of eMMC flash storage, ensuring smooth performance and reliable storage of data.
  • Touchscreen Display: The UNIHIKER features a 5-inch, 800x480-pixel touchscreen display with a capacitive touch interface, providing an intuitive user experience.
  • Networking and Connectivity:

Wi-Fi (2.4 GHz and 5 GHz) for wireless connectivity

Bluetooth 4.0 for low-power wireless communication

Ethernet (RJ45) for wired network connectivity

USB 2.0 (x2) for connecting peripherals and debugging

  • Sensor and Interface Options:

12-bit ADC (x4) for analog signal acquisition

12-bit DAC (x2) for analog signal output

I2C (x2) for connecting sensors and I2C devices

UART (x2) for serial communication

SPI (x1) for connecting SPI devices

GPIO (x16) for digital input/output operations

  • Operating System: The UNIHIKER runs on a Linux-based operating system, providing a stable and flexible platform for IoT development.
  • Power Management: The device has a built-in power management system, which includes a rechargeable battery (Li-ion, 2500mAh) and power-saving features to extend battery life.
  • Physical Dimensions: The UNIHIKER measures 85x60x22 mm, making it a compact and portable solution for IoT applications.

Appendix

Technical Specifications

+ ProcessorQuad-core Cortex-A7, 1.2 GHz
+ Memory1GB DDR3 RAM
+ Storage8GB eMMC flash
+ Operating SystemLinux-based
+ Power Supply5V, 2A
+ Power Consumption<1W (idle), <5W (active)
Software Development Kits (SDKs)The UNIHIKER is supported by a comprehensive SDK, including Python libraries, sample code, and documentation to help developers get started quickly.

Certifications and Compliance

The UNIHIKER meets regulatory requirements, including CE, FCC, and RoHS certifications.

Pin Configuration

  • UNIHIKER - IoT Python Single Board Computer with Touchscreen Pinout Guide
  • The UNIHIKER IoT Python Single Board Computer with Touchscreen features a wide range of pins that enable users to connect various peripherals and devices. This guide provides a comprehensive overview of each pin, its functions, and how to connect them.
  • GPIO Pins
  • 1. GPIO0 (PIN 1)
  • Function: General-purpose input/output pin
  • Mode: Input/output
  • Voltage: 3.3V
  • Notes: Can be used as a digital input or output pin
  • 2. GPIO1 (PIN 2)
  • Function: General-purpose input/output pin
  • Mode: Input/output
  • Voltage: 3.3V
  • Notes: Can be used as a digital input or output pin
  • 3. GPIO2 (PIN 3)
  • Function: General-purpose input/output pin
  • Mode: Input/output
  • Voltage: 3.3V
  • Notes: Can be used as a digital input or output pin
  • 4. GPIO3 (PIN 4)
  • Function: General-purpose input/output pin
  • Mode: Input/output
  • Voltage: 3.3V
  • Notes: Can be used as a digital input or output pin
  • 5. GPIO4 (PIN 5)
  • Function: General-purpose input/output pin
  • Mode: Input/output
  • Voltage: 3.3V
  • Notes: Can be used as a digital input or output pin
  • 6. GPIO5 (PIN 6)
  • Function: General-purpose input/output pin
  • Mode: Input/output
  • Voltage: 3.3V
  • Notes: Can be used as a digital input or output pin
  • UART Pins
  • 7. UART_TX (PIN 7)
  • Function: UART transmit pin
  • Mode: Output
  • Voltage: 3.3V
  • Notes: Connect to the receive pin of a serial device
  • 8. UART_RX (PIN 8)
  • Function: UART receive pin
  • Mode: Input
  • Voltage: 3.3V
  • Notes: Connect to the transmit pin of a serial device
  • I2C Pins
  • 9. I2C_SCL (PIN 9)
  • Function: I2C clock pin
  • Mode: Input/output
  • Voltage: 3.3V
  • Notes: Connect to the clock pin of an I2C device
  • 10. I2C_SDA (PIN 10)
  • Function: I2C data pin
  • Mode: Input/output
  • Voltage: 3.3V
  • Notes: Connect to the data pin of an I2C device
  • SPI Pins
  • 11. SPI_CLK (PIN 11)
  • Function: SPI clock pin
  • Mode: Output
  • Voltage: 3.3V
  • Notes: Connect to the clock pin of an SPI device
  • 12. SPI_MOSI (PIN 12)
  • Function: SPI master output slave input pin
  • Mode: Output
  • Voltage: 3.3V
  • Notes: Connect to the MOSI pin of an SPI device
  • 13. SPI_MISO (PIN 13)
  • Function: SPI master input slave output pin
  • Mode: Input
  • Voltage: 3.3V
  • Notes: Connect to the MISO pin of an SPI device
  • Power Pins
  • 14. VIN (PIN 14)
  • Function: Power input pin
  • Mode: Input
  • Voltage: 5V
  • Notes: Connect to a power source, such as a USB port or a wall adapter
  • 15. GND (PIN 15)
  • Function: Ground pin
  • Mode: Input
  • Voltage: 0V
  • Notes: Connect to the ground pin of a power source or a device
  • Touchscreen Pins
  • 16. T_CLK (PIN 16)
  • Function: Touchscreen clock pin
  • Mode: Output
  • Voltage: 3.3V
  • Notes: Connect to the clock pin of the touchscreen controller
  • 17. T_CS (PIN 17)
  • Function: Touchscreen chip select pin
  • Mode: Output
  • Voltage: 3.3V
  • Notes: Connect to the chip select pin of the touchscreen controller
  • 18. T_MOSI (PIN 18)
  • Function: Touchscreen master output slave input pin
  • Mode: Output
  • Voltage: 3.3V
  • Notes: Connect to the MOSI pin of the touchscreen controller
  • 19. T_MISO (PIN 19)
  • Function: Touchscreen master input slave output pin
  • Mode: Input
  • Voltage: 3.3V
  • Notes: Connect to the MISO pin of the touchscreen controller
  • LED and Button Pins
  • 20. LED_R (PIN 20)
  • Function: Red LED pin
  • Mode: Output
  • Voltage: 3.3V
  • Notes: Connect to a red LED to indicate power or status
  • 21. BTN (PIN 21)
  • Function: Button pin
  • Mode: Input
  • Voltage: 3.3V
  • Notes: Connect to a button or switch to control the board
  • When connecting pins, ensure that the voltage levels and modes match the requirements of the peripheral device or module. Always refer to the datasheet of the specific device or module for specific connection guidelines.
  • Remember to handle the board with care, and avoid shorting pins or applying excessive voltage to avoid damage to the board or connected devices.

Code Examples

UNIHIKER - IoT Python Single Board Computer with Touchscreen Documentation
Overview
The UNIHIKER is a powerful and versatile IoT single board computer with a built-in touchscreen, ideal for developing interactive IoT projects. It features a high-performance CPU, ample memory, and a range of peripherals, making it suitable for a wide range of applications, from home automation to industrial control systems.
Hardware Specifications
CPU: Quad-core Cortex-A7 processor
 Memory: 1GB RAM, 8GB eMMC storage
 Display: 7-inch touchscreen LCD with 1024x600 resolution
 Peripherals: Wi-Fi, Bluetooth 5.0, Ethernet, USB, UART, I2C, I2S, and SPI
 Operating System: Python-based Linux distribution
Getting Started
To get started with the UNIHIKER, follow these steps:
1. Connect the power adapter to the board and turn it on.
2. Connect to the board using a USB cable and a serial terminal software (e.g., PuTTY).
3. Install the Python development environment by running the command `sudo apt-get install python3-pip` (if not already installed).
Code Examples
### Example 1: Basic Touchscreen Interface
This example demonstrates how to create a basic touchscreen interface using the UNIHIKER's built-in LCD display.
```python
import touchscreen
# Initialize the touchscreen
ts = touchscreen.Touchscreen()
# Create a button on the screen
button = ts.create_button(100, 100, 200, 200, "Hello, World!")
button.set_callback(lambda: print("Button pressed!"))
# Start the touchscreen event loop
ts.start()
```
This code initializes the touchscreen, creates a button with a callback function, and starts the touchscreen event loop. When the button is pressed, the callback function will print "Button pressed!" to the console.
### Example 2: WiFi Connectivity and Data Transmission
This example demonstrates how to connect to a WiFi network and transmit data using the UNIHIKER's WiFi module.
```python
import network
import socket
# Connect to a WiFi network
wifi = network.WiFi()
wifi.connect("your_wifi_ssid", "your_wifi_password")
# Create a socket object
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# Connect to a remote server
sock.connect(("example.com", 8080))
# Send data to the server
sock.send(b"Hello, server!")
# Receive data from the server
data = sock.recv(1024)
print(data.decode())
# Close the socket
sock.close()
```
This code connects to a WiFi network, creates a socket object, connects to a remote server, sends data to the server, receives data from the server, and closes the socket.
### Example 3: Reading Sensor Data with I2C
This example demonstrates how to read data from an I2C sensor connected to the UNIHIKER's I2C interface.
```python
import i2c
# Initialize the I2C bus
i2c_bus = i2c.I2CBus(0)
# Define the sensor address and register
sensor_addr = 0x1A
register_addr = 0x00
# Read data from the sensor
data = i2c_bus.read_bytes(sensor_addr, register_addr, 2)
# Print the sensor data
print("Sensor data:", data)
```
This code initializes the I2C bus, defines the sensor address and register, reads data from the sensor, and prints the sensor data to the console.
These examples demonstrate the basic functionality of the UNIHIKER and its touchscreen, WiFi, and I2C interfaces. For more advanced projects, refer to the UNIHIKER's detailed documentation and Python library reference.