ESP-PSRAM64 / ESP-PSRAM64H

import spidev

spi = spidev.SpiDev()
spi.open(0, 0) # Открываем шину 0, устройство 0
spi.max_speed_hz = 10000000 # Начните с 10 МГц для стабильности

# Пример: чтение ID (команда зависит от чипа, обычно 0x9F или 0xAF)
def read_id():
    resp = spi.xfer2([0x9F, 0x00, 0x00, 0x00])
    print(f"ID чипа: {resp}")

read_id()
spi.close()

#include <stdint.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <linux/spi/spidev.h>

#define SPI_DEVICE "/dev/spidev0.0"

int fd;

// Функция для передачи данных по SPI
void spi_transfer(uint8_t *tx, uint8_t *rx, int len) {
    struct spi_ioc_transfer tr = {
        .tx_buf = (unsigned long)tx,
        .rx_buf = (unsigned long)rx,
        .len = len,
        .speed_hz = 10000000, // Частота 10 МГц
        .bits_per_word = 8,
    };

    if (ioctl(fd, SPI_IOC_MESSAGE(1), &tr) < 1) {
        perror("Ошибка передачи SPI");
    }
}

int main() {
    // 1. Открываем SPI устройство
    fd = open(SPI_DEVICE, O_RDWR);
    if (fd < 0) {
        perror("Не удалось открыть SPI");
        return 1;
    }

    // 2. Настройка режима SPI (Mode 0: CPOL=0, CPHA=0)
    uint8_t mode = SPI_MODE_0;
    ioctl(fd, SPI_IOC_WR_MODE, &mode);

    // 3. Команда чтения ID для ESP-PSRAM64H (Команда 0x9F)
    // Формат: [Command] + [3 Address Bytes (dummy)] + [Data]
    uint8_t tx[6] = {0x9F, 0x00, 0x00, 0x00, 0x00, 0x00};
    uint8_t rx[6] = {0};

    printf("Отправка команды чтения ID...\n");
    spi_transfer(tx, rx, 6);

    // Вывод результата (первые 4 байта после команды - это ID)
    printf("Ответ: ");
    for (int i = 1; i < 6; i++) {
        printf("%02X ", rx[i]);
    }
    printf("\n");

    close(fd);
    return 0;
}

#include <stdint.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <linux/spi/spidev.h>

#define SPI_DEVICE "/dev/spidev0.0"
#define SPEED_HZ   10000000  // 10 МГц для стабильности на проводах

int spi_fd;

void spi_transfer(uint8_t *tx, uint8_t *rx, int len) {
    struct spi_ioc_transfer tr = {
        .tx_buf = (unsigned long)tx,
        .rx_buf = (unsigned long)rx,
        .len = len,
        .speed_hz = SPEED_HZ,
        .bits_per_word = 8,
    };
    if (ioctl(spi_fd, SPI_IOC_MESSAGE(1), &tr) < 1) {
        perror("SPI transfer error");
    }
}

// Чтение ID чипа
void read_id() {
    uint8_t tx[6] = {0x9F, 0x00, 0x00, 0x00, 0x00, 0x00};
    uint8_t rx[6] = {0};
    spi_transfer(tx, rx, 6);
    printf("PSRAM ID: %02X %02X %02X (Expected MF: 0x0D)\n", rx[1], rx[2], rx[3]);
}

// Запись байта
void write_byte(uint32_t addr, uint8_t data) {
    uint8_t tx[5];
    tx[0] = 0x02;             // Команда Write
    tx[1] = (addr >> 16) & 0xFF; // MSB адреса
    tx[2] = (addr >> 8) & 0xFF;
    tx[3] = addr & 0xFF;      // LSB адреса
    tx[4] = data;
    spi_transfer(tx, NULL, 5);
}

// Чтение байта
uint8_t read_byte(uint32_t addr) {
    uint8_t tx[5] = {0x03, (addr >> 16) & 0xFF, (addr >> 8) & 0xFF, addr & 0xFF, 0x00};
    uint8_t rx[5] = {0};
    spi_transfer(tx, rx, 5);
    return rx[4];
}

int main() {
    spi_fd = open(SPI_DEVICE, O_RDWR);
    if (spi_fd < 0) { perror("Can't open SPI device"); return 1; }

    uint8_t mode = SPI_MODE_0;
    ioctl(spi_fd, SPI_IOC_WR_MODE, &mode);

    read_id();

    printf("Writing 0xAB to address 0x000100...\n");
    write_byte(0x000100, 0xAB);

    uint8_t val = read_byte(0x000100);
    printf("Read value: 0x%02X\n", val);

    close(spi_fd);
    return 0;
}

#include <stdint.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <linux/spi/spidev.h>

#define SPI_PATH "/dev/spidev0.0"
#define PSRAM_WRITE 0x02
#define PSRAM_READ  0x03

// Пример структуры, которую мы будем хранить в массиве
typedef struct {
    uint32_t id;
    float temperature;
    uint8_t status;
} SensorData;

int spi_fd;

// Функция для обмена данными по SPI
int psram_transfer(uint8_t *tx, uint8_t *rx, size_t len) {
    struct spi_ioc_transfer tr = {
        .tx_buf = (unsigned long)tx,
        .rx_buf = (unsigned long)rx,
        .len = len,
        .speed_hz = 10000000, // 10 МГц
        .bits_per_word = 8,
    };
    return ioctl(spi_fd, SPI_IOC_MESSAGE(1), &tr);
}

// Запись массива в PSRAM
void psram_write_array(uint32_t addr, void *data, size_t size) {
    size_t total_len = 4 + size; // 1 байт команды + 3 байта адреса + данные
    uint8_t *buffer = malloc(total_len);

    buffer[0] = PSRAM_WRITE;
    buffer[1] = (addr >> 16) & 0xFF;
    buffer[2] = (addr >> 8) & 0xFF;
    buffer[3] = addr & 0xFF;
    memcpy(&buffer[4], data, size);

    psram_transfer(buffer, NULL, total_len);
    free(buffer);
}

// Чтение массива из PSRAM
void psram_read_array(uint32_t addr, void *dest, size_t size) {
    size_t total_len = 4 + size;
    uint8_t *tx = calloc(1, total_len);
    uint8_t *rx = malloc(total_len);

    tx[0] = PSRAM_READ;
    tx[1] = (addr >> 16) & 0xFF;
    tx[2] = (addr >> 8) & 0xFF;
    tx[3] = addr & 0xFF;

    psram_transfer(tx, rx, total_len);
    
    // Данные начинаются после 4-го байта (команда + адрес)
    memcpy(dest, &rx[4], size);

    free(tx);
    free(rx);
}

int main() {
    spi_fd = open(SPI_PATH, O_RDWR);
    if (spi_fd < 0) { perror("SPI open failed"); return 1; }

    // Создаем массив данных
    SensorData my_sensors[3] = {
        {1, 22.5, 0x01},
        {2, 24.1, 0x01},
        {3, 19.8, 0x00}
    };

    uint32_t mem_addr = 0x001000; // Адрес в PSRAM

    // 1. Сохраняем массив
    printf("Сохранение массива структур в PSRAM...\n");
    psram_write_array(mem_addr, my_sensors, sizeof(my_sensors));

    // 2. Читаем массив обратно в новое место
    SensorData read_sensors[3];
    printf("Чтение данных обратно...\n");
    psram_read_array(mem_addr, read_sensors, sizeof(read_sensors));

    // 3. Проверка результата
    for(int i = 0; i < 3; i++) {
        printf("Датчик %d: Температура = %.1f, Статус = %d\n", 
                read_sensors[i].id, read_sensors[i].temperature, read_sensors[i].status);
    }

    close(spi_fd);
    return 0;
}

#!/usr/bin/perl
use strict;
use warnings;
use Device::SPI;

# Настройки устройства
my $dev = Device::SPI->new(device => '/dev/spidev0.0');
$dev->mode(0);             # SPI Mode 0
$dev->speed(10_000_000);   # 10 MHz
$dev->bits_per_word(8);

# 1. Чтение ID чипа (Команда 0x9F)
# Формат: CMD(1) + Dummy(2) + ID(3) = 6 байт
sub read_id {
    my $tx = pack('C*', 0x9F, 0x00, 0x00, 0x00, 0x00, 0x00);
    my $rx = $dev->transfer($tx);
    my @bytes = unpack('C*', $rx);
   
    printf("Device ID: %02X %02X %02X (Expected MF: 0x0D)\n",
           $bytes[3], $bytes[4], $bytes[5]);
}

# 2. Запись байта (Команда 0x02)
# Формат: CMD(1) + ADDR(3) + DATA(1)
sub write_byte {
    my ($addr, $data) = @_;
    my $tx = pack('C*',
        0x02,
        ($addr >> 16) & 0xFF,
        ($addr >> 8) & 0xFF,
        $addr & 0xFF,
        $data
    );
    $dev->transfer($tx);
}

# 3. Чтение байта (Команда 0x03)
# Формат: CMD(1) + ADDR(3) + DATA(1) = 5 байт
sub read_byte {
    my ($addr) = @_;
    my $tx = pack('C*',
        0x03,
        ($addr >> 16) & 0xFF,
        ($addr >> 8) & 0xFF,
        $addr & 0xFF,
        0x00
    );
    my $rx = $dev->transfer($tx);
    my @bytes = unpack('C*', $rx);
    return $bytes[4];
}

# Основной цикл
print "Starting PSRAM test...\n";

read_id();

my $test_addr = 0x000123;
my $test_val  = 0x77;

print "Writing $test_val to address $test_addr...\n";
write_byte($test_addr, $test_val);

my $result = read_byte($test_addr);
printf("Read value: %02X\n", $result);

if ($result == $test_val) {
    print "Success!\n";
} else {
    print "Error: Data mismatch.\n";
}

#!/usr/bin/perl
use strict;
use warnings;
use Device::SPI;

# Класс-обертка для PSRAM
package ESP_PSRAM;
sub new {
    my ($class, $dev) = @_;
    my $spi = Device::SPI->new(
        device => $dev,
        mode   => 0,
        speed  => 12000000, # 12 МГц
    );
    return bless { spi => $spi }, $class;
}

# Запись строки или буфера в память
sub write_block {
    my ($self, $addr, $data) = @_;
    my @payload = unpack("C*", $data); # Превращаем строку в массив байтов
    
    # Команда 0x02 + 24-битный адрес
    my @header = (
        0x02,
        ($addr >> 16) & 0xFF,
        ($addr >> 8)  & 0xFF,
        $addr & 0xFF
    );
    
    $self->{spi}->transfer([@header, @payload]);
    return length($data);
}

# Чтение блока данных заданной длины
sub read_block {
    my ($self, $addr, $len) = @_;
    
    # Команда 0x03 + 24-битный адрес + пустые байты для заполнения ответом
    my @tx = (
        0x03,
        ($addr >> 16) & 0xFF,
        ($addr >> 8)  & 0xFF,
        $addr & 0xFF,
        (0x00) x $len
    );
    
    my $rx_ref = $self->{spi}->transfer(\@tx);
    
    # Извлекаем только те байты, что пришли после команды и адреса (индексы 4+)
    my @data_bytes = @$rx_ref[4 .. $#$rx_ref];
    return pack("C*", @data_bytes); # Собираем обратно в строку
}

package main;

# Инициализация
my $psram = ESP_PSRAM->new('/dev/spidev0.0');

print "--- Тест ESP-PSRAM64H в 2026 году ---\n";

# 1. Запись текстового сообщения
my $message = "Привет от Raspberry Pi 3 через Perl SPI!";
my $start_address = 0x1000; # Записываем по адресу 4096

print "Запись данных...\n";
$psram->write_block($start_address, $message);

# 2. Чтение сообщения обратно
print "Чтение данных...\n";
my $result = $psram->read_block($start_address, length($message));

print "Результат из памяти: '$result'\n";

# 3. Тест на целостность
if ($message eq $result) {
    print "Успех: Данные идентичны.\n";
} else {
    print "Ошибка: Данные повреждены.\n";
}