UNI/O med STM32F7 og FreeRtos

For at kunne kommunikere med en UNI/O eeprom med en STM32F7, som kører FreeRtos, har jeg lavet et lille test program. Jeg har taget udgangspunkt i et eksempel skrevet af Stephen Early (Thanks Steve 🙂 – https://github.com/martmaiste/UNIO/blob/master/UNIO.h )

 

/* Copyright (C) 2011 by Stephen Early <steve@greenend.org.uk>
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
 "Software"), to deal in the Software without restriction, including
 without limitation the rights to use, copy, modify, merge, publish,
 distribute, sublicense, and/or sell copies of the Software, and to
 permit persons to whom the Software is furnished to do so, subject to
 the following conditions:
 The above copyright notice and this permission notice shall be
 included in all copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.  

 Modified to fit to STM32F7 + FreeRtos by Flemming Jahn (flemming@familien-jahn.dk)
 */

#include "stm32f7xx_hal.h"
#include "FreeRTOS.h"
#include "task.h"
#include "../../AppBootShared/Delay.h"
#include "test.h"
#include "Utility/TraceDebug/trace.h"

#define UNIO_STARTHEADER 0x55
#define UNIO_READ        0x03
#define UNIO_CRRD        0x06
#define UNIO_WRITE       0x6c
#define UNIO_WREN        0x96
#define UNIO_WRDI        0x91
#define UNIO_RDSR        0x05
#define UNIO_WRSR        0x6e
#define UNIO_ERAL        0x6d
#define UNIO_SETAL       0x67

// The following are defined in the datasheet as _minimum_ times, in
// microseconds.  There is no maximum.
#define UNIO_TSTBY 600
#define UNIO_TSS    10
#define UNIO_THDR    5

#define UNIO_QUARTER_BIT 10

// Add this to all the times defined above, to be on the safe side!
#define UNIO_FUDGE_FACTOR 0

// For testing we use GPIO PC12
#define GPIO_PIN GPIO_PIN_12
#define GPIO_PIN_NUMBER 12
#define GPIO_PORT GPIOC
#define DEVICE_ADDR 0xA0

static void set_bus(bool state) {
	if (state) {
		HAL_GPIO_WritePin(GPIO_PORT, GPIO_PIN, GPIO_PIN_SET);
	} else {
		HAL_GPIO_WritePin(GPIO_PORT, GPIO_PIN, GPIO_PIN_RESET);
	}
}

// Using HAL_GPIO_Init takes too long time, so we do change of port mode directly (The code is copied from the HAL_GPIO_Iint function)
void confPort(uint32_t outputMode) {
	const auto GPIO_OUTPUT_TYPE = ((uint32_t) 0x00000010U);
	const auto position = GPIO_PIN_NUMBER;
	auto temp = GPIO_PORT->OTYPER;
	temp &= ~(GPIO_OTYPER_OT_0 << position);
	temp |= (((outputMode & GPIO_OUTPUT_TYPE) >> 4) << position);
	GPIO_PORT->OTYPER = temp;
}

void confPortAsOutput() {
	confPort (GPIO_MODE_OUTPUT_PP);
}

void confPortAsInput() {
	confPort (GPIO_MODE_OUTPUT_OD); // We use Open Drain, since that still allows us to read the PIN as an input.
	set_bus(1);
}

#define UNIO_OUTPUT() do {  confPortAsOutput(); } while (0)
#define UNIO_INPUT() do { confPortAsInput(); } while (0)

void initUniio() {
	GPIO_InitTypeDef GPIO_InitStruct;
	GPIO_InitStruct.Pin = GPIO_PIN;
	GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_OD;
	GPIO_InitStruct.Pull = GPIO_NOPULL;
	GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_MEDIUM;
	HAL_GPIO_Init(GPIO_PORT, &GPIO_InitStruct);
	set_bus(1);
}

static bool read_bus(void) {
	return HAL_GPIO_ReadPin(GPIO_PORT, GPIO_PIN);
}

/* If multiple commands are to be issued to a device without a standby
 pulse in between, the bus must be held high for at least UNIO_TSS
 between the end of one command and the start of the next. */
static void unio_inter_command_gap(void) {
	set_bus(1);
	delayMicroseconds(UNIO_TSS + UNIO_FUDGE_FACTOR);
}

/* Send a standby pulse on the bus.  After power-on or brown-out
 reset, the device requires a low-to-high transition on the bus at
 the start of the standby pulse.  To be conservative, we take the
 bus low for UNIO_TSS, then high for UNIO_TSTBY. */
static void unio_standby_pulse(void) {
	UNIO_OUTPUT()
	;
	set_bus(0);
	delayMicroseconds(UNIO_TSS + UNIO_FUDGE_FACTOR);
	set_bus(1);
	delayMicroseconds(UNIO_TSTBY + UNIO_FUDGE_FACTOR);
}

/* While bit-banging, all delays are expressed in terms of quarter
 bits.  We use the same code path for reading and writing.  During a
 write, we perform dummy reads at 1/4 and 3/4 of the way through
 each bit time.  During a read we perform a dummy write at the start
 and 1/2 way through each bit time. */

static volatile bool rwbit(bool w) {
	bool a, b;
	set_bus(!w);
	delayMicroseconds(UNIO_QUARTER_BIT);
	a = read_bus();
	delayMicroseconds(UNIO_QUARTER_BIT);
	set_bus(w);
	delayMicroseconds(UNIO_QUARTER_BIT);
	b = read_bus();
	delayMicroseconds(UNIO_QUARTER_BIT);
// TRACE("test", T_I, "a:%d,b:%d, T:%d", a,b,b&&!a);
	return b && !a;
}

static bool read_bit(void) {
	bool b;
	UNIO_INPUT()
	;
	b = rwbit(1);
	UNIO_OUTPUT()
	;
	return b;
}

static bool send_byte(uint8_t b, bool mak) {
	for (int i = 0; i < 8; i++) {
		rwbit(b & 0x80);
		b <<= 1;
	}
	rwbit(mak);
	return read_bit();
}

static bool read_byte(uint8_t*b, bool mak) {
	uint8_t data = 0;
	UNIO_INPUT()
	;
	for (int i = 0; i < 8; i++) {
		data = (data << 1) | rwbit(1);
	}

	UNIO_OUTPUT()
	;
	*b = data;
	rwbit(mak);
	return read_bit();
}

/* Send data on the bus. If end is true, send NoMAK after the last
 byte; otherwise send MAK. */
static bool unio_send(const uint8_t *data, uint32_t length, bool end) {
	for (uint32_t i = 0; i < length; i++) {
		/* Rules for sending MAK: if it's the last byte and end is true,
		 send NoMAK.  Otherwise send MAK. */
		if (!send_byte(data[i], !(((i + 1) == length) && end)))
			return false;
	}
	return true;
}

/* Read data from the bus.  After reading 'length' bytes, send NoMAK to
 terminate the command. */
static bool unio_read(uint8_t *data, uint32_t length) {
	for (uint32_t i = 0; i < length; i++) {
		if (!read_byte(data + i, !((i + 1) == length)))
			return false;
	}
	return true;
}

/* Send a start header on the bus.  Hold the bus low for UNIO_THDR,
 then transmit UNIO_STARTHEADER.  There is a time slot for SAK after
 this transmission, but we must ignore the value because no slave
 devices will drive the bus; if there is more than one device
 connected then that could cause bus contention. */
static void unio_start_header(void) {
	set_bus(0);
	delayMicroseconds(UNIO_THDR + UNIO_FUDGE_FACTOR);
	send_byte(UNIO_STARTHEADER, true);
}

nanodeUNIO::nanodeUNIO(uint8_t address) {
	addr = address;
	initUniio();
}

#define fail() do { sei(); return false; } while (0)

void sei() {
	taskEXIT_CRITICAL();
}

void cli() {
	taskENTER_CRITICAL();
}

bool nanodeUNIO::read(uint8_t *buffer, uint32_t address, uint32_t length) {
	uint8_t cmd[4];
	cmd[0] = addr;
	cmd[1] = UNIO_READ;
	cmd[2] = (uint8_t)(address >> 8);
	cmd[3] = (uint8_t)(address & 0xff);
	unio_standby_pulse();
	cli();
	unio_start_header();
	if (!unio_send(cmd, 4, false))
		fail()
		;
	if (!unio_read(buffer, length))
		fail()
		;
	sei();
	return true;
}

bool nanodeUNIO::start_write(const uint8_t *buffer, uint32_t address,
		uint32_t length) {
	uint8_t cmd[4];
	if (((address & 0x0f) + length) > 16)
		return false; // would cross page boundary
	cmd[0] = addr;
	cmd[1] = UNIO_WRITE;
	cmd[2] = (uint8_t)(address >> 8);
	cmd[3] = (uint8_t)(address & 0xff);
	unio_standby_pulse();
	cli();
	unio_start_header();
	if (!unio_send(cmd, 4, false))
		fail()
		;
	if (!unio_send(buffer, length, true))
		fail()
		;
	sei();
	return true;
}

bool nanodeUNIO::enable_write(void) {
	uint8_t cmd[2];
	cmd[0] = addr;
	cmd[1] = UNIO_WREN;
	unio_standby_pulse();
	cli();
	unio_start_header();
	if (!unio_send(cmd, 2, true))
		fail()
		;
	sei();
	return true;
}

bool nanodeUNIO::disable_write(void) {
	uint8_t cmd[2];
	cmd[0] = addr;
	cmd[1] = UNIO_WRDI;
	unio_standby_pulse();
	cli();
	unio_start_header();
	if (!unio_send(cmd, 2, true))
		fail()
		;
	sei();
	return true;
}

bool nanodeUNIO::read_status(uint8_t *status) {
	uint8_t cmd[2];
	cmd[0] = addr;
	cmd[1] = UNIO_RDSR;
	unio_standby_pulse();
	cli();
	unio_start_header();
	if (!unio_send(cmd, 2, false))
		fail()
		;
	if (!unio_read(status, 1))
		fail()
		;
	sei();
	return true;
}

bool nanodeUNIO::write_status(uint8_t status) {
	uint8_t cmd[3];
	cmd[0] = addr;
	cmd[1] = UNIO_WRSR;
	cmd[2] = status;
	unio_standby_pulse();
	cli();
	unio_start_header();
	if (!unio_send(cmd, 3, true))
		fail()
		;
	sei();
	return true;
}

bool nanodeUNIO::await_write_complete(void) {
	uint8_t cmd[2];
	uint8_t status;
	cmd[0] = addr;
	cmd[1] = UNIO_RDSR;
	unio_standby_pulse();
	/* Here we issue RDSR commands back-to-back until the WIP bit in the
	 status register is cleared.  Note that this isn't absolutely the
	 most efficient way to monitor this bit; after sending the command
	 we could read as many uint8_ts as we like as long as we send MAK
	 after each uint8_t.  The unio_read() function isn't set up to do
	 this, though, and it's not really performance-critical compared
	 to the eeprom write time! We re-enable interrupts briefly between
	 each command so that any background tasks like updating millis()
	 continue to happen.*/
	do {
		unio_inter_command_gap();
		cli();
		unio_start_header();
		if (!unio_send(cmd, 2, false))
			fail()
			;
		if (!unio_read(&status, 1))
			fail()
			;
		sei();
	} while (status & 0x01);
	return true;
}

bool nanodeUNIO::simple_write(const uint8_t *buffer, uint32_t address,
		uint32_t length) {
	uint32_t wlen;
	while (length > 0) {
		wlen = length;
		if (((address & 0x0f) + wlen) > 16) {
			/* Write would cross a page boundary.  Truncate the write to the
			 page boundary. */
			wlen = 16 - (address & 0x0f);
		}
		if (!enable_write())
			return false;
		if (!start_write(buffer, address, wlen))
			return false;
		if (!await_write_complete())
			return false;
		buffer += wlen;
		address += wlen;
		length -= wlen;
	}
	return true;
}

#include <stdio.h>
#include <string.h>
static const int BUF_SIZE = 32;

char *array_to_str(char * str, uint8_t *array, unsigned int n) {
	int r;
	if (n == 0)
		return 0;
	if (n == 1)
		r = sprintf(str, "0x%X", array[0]);
	else
		r = sprintf(str, "0x%X ", array[0]);
	array_to_str(str + r, array + 1, n - 1);
	return str;
}

void unioTask(void *argument) {
	uint8_t readBuffer[BUF_SIZE];
	nanodeUNIO unio(DEVICE_ADDR);
	unio.read(readBuffer, 0, BUF_SIZE); // Dummy read - Not quite sure why the first read fails
	uint32_t addr = 0;
	auto badCnt = 0; // For counting the number times read didn't work
	auto goodCnt = 0; // For counting the number times read worked
	while (1) {
		memset(readBuffer, 0x0, BUF_SIZE);
		unio.read(readBuffer, addr, BUF_SIZE);

		// Just for testing that we can do many reads. Address 31 contains 0x52 with the CHIP I have used for this testing
		if (readBuffer[31] != 0x52) {
			char outputStr[228];
			TRACE("test", T_I, "BadCnt:%d, GoodCnt:%d, Addr:%d, Data:%s",
					badCnt++, goodCnt, addr,
					array_to_str(outputStr, readBuffer, BUF_SIZE));
			vTaskDelay(100);
		} else {
			goodCnt++;
		}

		vTaskDelay(4);
	}
}

 

Leave a Reply

Your email address will not be published. Required fields are marked *