STM8L–Линии ввода-вывода

Как всегда проще начать с самого простого, а именно с линий ввода-вывода. Умение работать с ними позволит нам помигать светодиодами и опросить состояние кнопки. И в качестве примера работа с ЖКИ индикатором от сотового телефона Нокиа 1100.


Линии ввода-вывода общего назначения
Возможны несколько режимов работы линий ввода-вывода:
image
Структурная схема блока:
image
Согласно структурной схемы для управление режимами работы и ввода-вывода данных используются пять регистров, структура регистров объявлена в библиотечном файле:
/**
  * @brief General Purpose I/Os (GPIO)
  */
typedef struct GPIO_struct
{
  __IO uint8_t ODR; /*!< Output Data Register */
  __IO uint8_t IDR; /*!< Input Data Register */
  __IO uint8_t DDR; /*!< Data Direction Register */
  __IO uint8_t CR1; /*!< Configuration Register 1 */
  __IO uint8_t CR2; /*!< Configuration Register 2 */
}
GPIO_TypeDef;


Базовые адреса для регистров:
#define GPIOA_BASE                  (uint16_t)0x5000
#define GPIOB_BASE                  (uint16_t)0x5005
#define GPIOC_BASE                  (uint16_t)0x500A
#define GPIOD_BASE                  (uint16_t)0x500F
#define GPIOE_BASE                  (uint16_t)0x5014
#define GPIOF_BASE                  (uint16_t)0x5019
#define GPIOG_BASE                  (uint16_t)0x501E
#define GPIOH_BASE                  (uint16_t)0x5023
#define GPIOI_BASE                  (uint16_t)0x5028


Исходя из режимов работы я написал макросы для работы с линиями ввода-вывода:
/*
 *	File:	GPIO.h
 *	Date:	23.01.2011
 */

#ifndef MCU_GPIO_H_
#define MCU_GPIO_H_

// PIN_TEST    A, 3, HIGH, INPUT_FLOATING_WITHOUT_INTERRUPT

#define INPUT_FLOATING_WITHOUT_INTERRUPT		INPUT_FLOATING_WITHOUT_INTERRUPT
#define INPUT_FLOATING_WITH_INTERRUPT		INPUT_FLOATING_WITH_INTERRUPT
#define INPUT_PULL_UP_WITHOUT_INTERRUPT		INPUT_PULL_UP_WITHOUT_INTERRUPT
#define INPUT_PULL_UP_WITH_INTERRUPT			INPUT_PULL_UP_WITH_INTERRUPT
#define OUTPUT_OPEN_DRAIN_NOSPEED_LIMIT		OUTPUT_OPEN_DRAIN_NOSPEED_LIMIT
#define OUTPUT_OPEN_DRAIN_SPEED_LIMIT_10MHZ	OUTPUT_OPEN_DRAIN_SPEED_LIMIT_10MHZ
#define OUTPUT_PUSH_PULL_NOSPEED_LIMIT		OUTPUT_PUSH_PULL_NOSPEED_LIMIT
#define OUTPUT_PUSH_PULL_SPEED_LIMIT_10MHZ	OUTPUT_PUSH_PULL_SPEED_LIMIT_10MHZ

//------------------------------------------------------------------------------
#define GPIO_PIN_CONFIGURATION_OUTPUT_PUSH_PULL_SPEED_LIMIT_10MHZ(PORT, PIN, LEVEL, MODE) \
			{ \
				GPIO##PORT->DDR |= (1 << PIN); \
				GPIO##PORT->CR1 |= (1 << PIN); \
				GPIO##PORT->CR2 |= (1 << PIN); \
			}

#define GPIO_PIN_CONFIGURATION_OUTPUT_PUSH_PULL_NOSPEED_LIMIT(PORT, PIN, LEVEL, MODE) \
			{ \
				GPIO##PORT->DDR |= (1 << PIN); \
				GPIO##PORT->CR1 |= (1 << PIN); \
				GPIO##PORT->CR2 &= (uint8_t)(~(1 << PIN)); \
			}

#define GPIO_PIN_CONFIGURATION_OUTPUT_OPEN_DRAIN_SPEED_LIMIT_10MHZ(PORT, PIN, LEVEL, MODE) \
			{ \
				GPIO##PORT->DDR |= (1 << PIN); \
				GPIO##PORT->CR1 &= (uint8_t)(~(1 << PIN)); \
				GPIO##PORT->CR2 |= (1 << PIN); \
			}

#define GPIO_PIN_CONFIGURATION_OUTPUT_OPEN_DRAIN_NOSPEED_LIMIT(PORT, PIN, LEVEL, MODE) \
			{ \
				GPIO##PORT->DDR |= (1 << PIN); \
				GPIO##PORT->CR1 &= (uint8_t)(~(1 << PIN)); \
				GPIO##PORT->CR2 &= (uint8_t)(~(1 << PIN)); \
			}

#define GPIO_PIN_CONFIGURATION_INPUT_PULL_UP_WITH_INTERRUPT(PORT, PIN, LEVEL, MODE) \
			{ \
				GPIO##PORT->DDR &= (uint8_t)(~(1 << PIN)); \
				GPIO##PORT->CR1 |= (1 << PIN); \
				GPIO##PORT->CR2 |= (1 << PIN); \
			}

#define GPIO_PIN_CONFIGURATION_INPUT_PULL_UP_WITHOUT_INTERRUPT(PORT, PIN, LEVEL, MODE) \
			{ \
				GPIO##PORT->DDR &= (uint8_t)(~(1 << PIN)); \
				GPIO##PORT->CR1 |= (1 << PIN); \
				GPIO##PORT->CR2 &= (uint8_t)(~(1 << PIN)); \
			}

#define GPIO_PIN_CONFIGURATION_INPUT_FLOATING_WITH_INTERRUPT(PORT, PIN, LEVEL, MODE) \
			{ \
				GPIO##PORT->DDR &= (uint8_t)(~(1 << PIN)); \
				GPIO##PORT->CR1 &= (uint8_t)(~(1 << PIN)); \
				GPIO##PORT->CR2 |= (1 << PIN); \
			}

#define GPIO_PIN_CONFIGURATION_INPUT_FLOATING_WITHOUT_INTERRUPT(PORT, PIN, LEVEL, MODE) \
			{ \
				GPIO##PORT->DDR &= (uint8_t)(~(1 << PIN)); \
				GPIO##PORT->CR1 &= (uint8_t)(~(1 << PIN)); \
				GPIO##PORT->CR2 &= (uint8_t)(~(1 << PIN)); \
			}

//------------------------------------------------------------------------------
#define GPIO_PIN_CONFIGURATION(PORT, PIN, LEVEL, MODE) \
			{ \
			  GPIO_PIN_CONFIGURATION_##MODE(PORT, PIN, LEVEL, MODE); \
			}

//------------------------------------------------------------------------------
#define GPIO_PIN_OFF_HIGH(PORT, PIN, LEVEL, MODE) \
			{ GPIO##PORT->ODR &= (uint8_t)((uint8_t)(~(1 << PIN))); }

#define GPIO_PIN_OFF_LOW(PORT, PIN, LEVEL, MODE) \
			{ GPIO##PORT->ODR |= (1 << PIN); }

#define GPIO_PIN_OFF(PORT, PIN, LEVEL, MODE) \
			{ GPIO_PIN_OFF_##LEVEL(PORT, PIN, LEVEL, MODE) }

//-----------------------------------------------------------------------------
#define GPIO_PIN_ON_HIGH(PORT, PIN, LEVEL, MODE) \
			{ GPIO##PORT->ODR |= (1 << PIN); }

#define GPIO_PIN_ON_LOW(PORT, PIN, LEVEL, MODE) \
			{ GPIO##PORT->ODR &= (uint8_t)(~(1 << PIN)); }

#define GPIO_PIN_ON(PORT, PIN, LEVEL, MODE) \
			{ GPIO_PIN_ON_##LEVEL(PORT, PIN, LEVEL, MODE) }

//-----------------------------------------------------------------------------
#define GPIO_PIN_SIGNAL_HIGH(PORT, PIN, LEVEL, MODE) \
			( (GPIO##PORT->IDR & (1 << PIN)) == (1 << PIN) )

#define GPIO_PIN_SIGNAL_LOW(PORT, PIN, LEVEL, MODE) \
		( (GPIO##PORT->IDR & (1 << PIN)) != (1 << PIN) )

#define GPIO_PIN_SIGNAL(PORT, PIN, LEVEL, MODE) \
			( GPIO_PIN_SIGNAL_##LEVEL(PORT, PIN, LEVEL, MODE) )

//-----------------------------------------------------------------------------
#define PIN_CONFIGURATION(PIN_DESCRIPTION) GPIO_PIN_CONFIGURATION(PIN_DESCRIPTION)
#define PIN_ON(PIN_DESCRIPTION) GPIO_PIN_ON(PIN_DESCRIPTION)
#define PIN_OFF(PIN_DESCRIPTION) GPIO_PIN_OFF(PIN_DESCRIPTION)
#define PIN_SIGNAL(PIN_DESCRIPTION) GPIO_PIN_SIGNAL(PIN_DESCRIPTION)

#endif /* MCU_GPIO_H_ */


Примечание: в самом начале объявлены режимы работы, они необходимы всего лишь для авто завершения кода.
Работать с ними очень просто достаточно объявить линию с выбранным режимом работы, например для управления зеленым светодиодом установленном на плате можно сделать вот так:
#define LED_GREEN    			E, 7, HIGH, OUTPUT_PUSH_PULL_SPEED_LIMIT_10MHZ



Далее в программе сконфигурировать и помигать ;):
int main(void)
{
	PIN_CONFIGURATION(LED_GREEN);

	while (1)
	{
		PIN_ON(LED_GREEN);
		delay_ms(100);

		PIN_OFF(LED_GREEN);
		delay_ms(100);
	}

	return 0;
}




ЖКИ от Нокиа 1100
Я давно искал небольшой черное-белый индикатор от мобильника к контроллеру которого можно свободно припаять проводники и нашел его, это ЖКИ от Nokia 1100. Недорогой и можно свободно купить в любой мастерской сотовых или в магазине запчастей.
011
Шуршание по просторам интернета показало что контроллер у ЖКИ PCF8814, согласно документации вроде не такой уж и сложный, но вот почему-то в сети я нашел только один источник (точнее много, но все они указывали на один http://www.sunbizhosting.com/~spiral/1100/). В первоисточнике использовался PIC. Да и как-то не стильно написано ;) убрал лишнее, добавил нужное и вот, что вышло у меня:
/*
 *	File:	lcd_nokia_1100.c
 *	Date:	17.01.2011
 */

#include "main.h"

const uint8_t lcd_nokia1100_decode[] =
{ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E',
		'F' };

const uint8_t lcd_nokia1100_font_5x8[96][5] =
{
	{ 0x00, 0x00, 0x00, 0x00, 0x00 },// (space)
	{ 0x00, 0x00, 0x5F, 0x00, 0x00 },// !
	{ 0x00, 0x07, 0x00, 0x07, 0x00 },// "
	{ 0x14, 0x7F, 0x14, 0x7F, 0x14 },// #
	{ 0x24, 0x2A, 0x7F, 0x2A, 0x12 },// $
	{ 0x23, 0x13, 0x08, 0x64, 0x62 },// %
	{ 0x36, 0x49, 0x55, 0x22, 0x50 },// &
	{ 0x00, 0x05, 0x03, 0x00, 0x00 },// '
	{ 0x00, 0x1C, 0x22, 0x41, 0x00 },// (
	{ 0x00, 0x41, 0x22, 0x1C, 0x00 },// )
	{ 0x08, 0x2A, 0x1C, 0x2A, 0x08 },// *
	{ 0x08, 0x08, 0x3E, 0x08, 0x08 },// +
	{ 0x00, 0x50, 0x30, 0x00, 0x00 },// ,
	{ 0x08, 0x08, 0x08, 0x08, 0x08 },// -
	{ 0x00, 0x30, 0x30, 0x00, 0x00 },// .
	{ 0x20, 0x10, 0x08, 0x04, 0x02 },// /
	{ 0x3E, 0x51, 0x49, 0x45, 0x3E },// 0
	{ 0x00, 0x42, 0x7F, 0x40, 0x00 },// 1
	{ 0x42, 0x61, 0x51, 0x49, 0x46 },// 2
	{ 0x21, 0x41, 0x45, 0x4B, 0x31 },// 3
	{ 0x18, 0x14, 0x12, 0x7F, 0x10 },// 4
	{ 0x27, 0x45, 0x45, 0x45, 0x39 },// 5
	{ 0x3C, 0x4A, 0x49, 0x49, 0x30 },// 6
	{ 0x01, 0x71, 0x09, 0x05, 0x03 },// 7
	{ 0x36, 0x49, 0x49, 0x49, 0x36 },// 8
	{ 0x06, 0x49, 0x49, 0x29, 0x1E },// 9
	{ 0x00, 0x36, 0x36, 0x00, 0x00 },// :
	{ 0x00, 0x56, 0x36, 0x00, 0x00 },// ;
	{ 0x00, 0x08, 0x14, 0x22, 0x41 },// <
	{ 0x14, 0x14, 0x14, 0x14, 0x14 },// =
	{ 0x41, 0x22, 0x14, 0x08, 0x00 },// >
	{ 0x02, 0x01, 0x51, 0x09, 0x06 },// ?
	{ 0x32, 0x49, 0x79, 0x41, 0x3E },// @
	{ 0x7E, 0x11, 0x11, 0x11, 0x7E },// A
	{ 0x7F, 0x49, 0x49, 0x49, 0x36 },// B
	{ 0x3E, 0x41, 0x41, 0x41, 0x22 },// C
	{ 0x7F, 0x41, 0x41, 0x22, 0x1C },// D
	{ 0x7F, 0x49, 0x49, 0x49, 0x41 },// E
	{ 0x7F, 0x09, 0x09, 0x01, 0x01 },// F
	{ 0x3E, 0x41, 0x41, 0x51, 0x32 },// G
	{ 0x7F, 0x08, 0x08, 0x08, 0x7F },// H
	{ 0x00, 0x41, 0x7F, 0x41, 0x00 },// I
	{ 0x20, 0x40, 0x41, 0x3F, 0x01 },// J
	{ 0x7F, 0x08, 0x14, 0x22, 0x41 },// K
	{ 0x7F, 0x40, 0x40, 0x40, 0x40 },// L
	{ 0x7F, 0x02, 0x04, 0x02, 0x7F },// M
	{ 0x7F, 0x04, 0x08, 0x10, 0x7F },// N
	{ 0x3E, 0x41, 0x41, 0x41, 0x3E },// O
	{ 0x7F, 0x09, 0x09, 0x09, 0x06 },// P
	{ 0x3E, 0x41, 0x51, 0x21, 0x5E },// Q
	{ 0x7F, 0x09, 0x19, 0x29, 0x46 },// R
	{ 0x46, 0x49, 0x49, 0x49, 0x31 },// S
	{ 0x01, 0x01, 0x7F, 0x01, 0x01 },// T
	{ 0x3F, 0x40, 0x40, 0x40, 0x3F },// U
	{ 0x1F, 0x20, 0x40, 0x20, 0x1F },// V
	{ 0x7F, 0x20, 0x18, 0x20, 0x7F },// W
	{ 0x63, 0x14, 0x08, 0x14, 0x63 },// X
	{ 0x03, 0x04, 0x78, 0x04, 0x03 },// Y
	{ 0x61, 0x51, 0x49, 0x45, 0x43 },// Z
	{ 0x00, 0x00, 0x7F, 0x41, 0x41 },// [
	{ 0x02, 0x04, 0x08, 0x10, 0x20 },// "\"
	{ 0x41, 0x41, 0x7F, 0x00, 0x00 },// ]
	{ 0x04, 0x02, 0x01, 0x02, 0x04 },// ^
	{ 0x40, 0x40, 0x40, 0x40, 0x40 },// _
	{ 0x00, 0x01, 0x02, 0x04, 0x00 },// `
	{ 0x20, 0x54, 0x54, 0x54, 0x78 },// a
	{ 0x7F, 0x48, 0x44, 0x44, 0x38 },// b
	{ 0x38, 0x44, 0x44, 0x44, 0x20 },// c
	{ 0x38, 0x44, 0x44, 0x48, 0x7F },// d
	{ 0x38, 0x54, 0x54, 0x54, 0x18 },// e
	{ 0x08, 0x7E, 0x09, 0x01, 0x02 },// f
	{ 0x08, 0x14, 0x54, 0x54, 0x3C },// g
	{ 0x7F, 0x08, 0x04, 0x04, 0x78 },// h
	{ 0x00, 0x44, 0x7D, 0x40, 0x00 },// i
	{ 0x20, 0x40, 0x44, 0x3D, 0x00 },// j
	{ 0x00, 0x7F, 0x10, 0x28, 0x44 },// k
	{ 0x00, 0x41, 0x7F, 0x40, 0x00 },// l
	{ 0x7C, 0x04, 0x18, 0x04, 0x78 },// m
	{ 0x7C, 0x08, 0x04, 0x04, 0x78 },// n
	{ 0x38, 0x44, 0x44, 0x44, 0x38 },// o
	{ 0x7C, 0x14, 0x14, 0x14, 0x08 },// p
	{ 0x08, 0x14, 0x14, 0x18, 0x7C },// q
	{ 0x7C, 0x08, 0x04, 0x04, 0x08 },// r
	{ 0x48, 0x54, 0x54, 0x54, 0x20 },// s
	{ 0x04, 0x3F, 0x44, 0x40, 0x20 },// t
	{ 0x3C, 0x40, 0x40, 0x20, 0x7C },// u
	{ 0x1C, 0x20, 0x40, 0x20, 0x1C },// v
	{ 0x3C, 0x40, 0x30, 0x40, 0x3C },// w
	{ 0x44, 0x28, 0x10, 0x28, 0x44 },// x
	{ 0x0C, 0x50, 0x50, 0x50, 0x3C },// y
	{ 0x44, 0x64, 0x54, 0x4C, 0x44 },// z
	{ 0x00, 0x08, 0x36, 0x41, 0x00 },// {
	{ 0x00, 0x00, 0x7F, 0x00, 0x00 },// |
	{ 0x00, 0x41, 0x36, 0x08, 0x00 },// }
	{ 0x08, 0x08, 0x2A, 0x1C, 0x08 },// ->
	{ 0x08, 0x1C, 0x2A, 0x08, 0x08 } // <-
};

enum
{
	LCD_NOKIA1100_SET_X_ADDRESS_LOWER_4BITS = 0x00,
	LCD_NOKIA1100_SET_X_ADDRESS_UPPER_3BITS = 0x10,
	LCD_NOKIA1100_SET_Y_ADDRESS = 0xB0,
	LCD_NOKIA1100_SET_START_ROW_ADDRESS_6BITS = 0x40,
	LCD_NOKIA1100_DIPLAY_OFF = 0xAE,
	LCD_NOKIA1100_DIPLAY_ON = 0xAF,
	LCD_NOKIA1100_PIXELS_ALL_OFF = 0xA4,
	LCD_NOKIA1100_PIXELS_ALL_ON = 0xA5,
	LCD_NOKIA1100_DISPLAY_INVERSE_ON = 0xA7,
	LCD_NOKIA1100_DISPLAY_INVERSE_OFF = 0xA6,
	LCD_NOKIA1100_CHARGE_PUMP_ON = 0x2F,
	LCD_NOKIA1100_CHARGE_PUMP_OFF = 0x28
} lcd_nokia1100_command;

//-----------------------------------------------------------------------------
void lcd_nokia1100_write(uint8_t data)
{
	uint8_t bit_number;

	for (bit_number = 8; bit_number-- > 0;)
	{
		PIN_OFF(LCD_NOKIA_1100_SCLK);

		if (data & 0x80)
		{
			PIN_ON(LCD_NOKIA_1100_SDA);
		}
		else
		{
			PIN_OFF(LCD_NOKIA_1100_SDA);
		}

		PIN_ON(LCD_NOKIA_1100_SCLK);

		data <<= 1;
	}
}

//-----------------------------------------------------------------------------
void lcd_nokia1100_write_command(uint8_t data)
{
	PIN_ON(LCD_NOKIA_1100_CS);

	PIN_OFF(LCD_NOKIA_1100_SCLK);
	PIN_OFF(LCD_NOKIA_1100_SDA);
	PIN_ON(LCD_NOKIA_1100_SCLK);

	lcd_nokia1100_write(data);

	PIN_OFF(LCD_NOKIA_1100_CS);
}

//-----------------------------------------------------------------------------
void lcd_nokia1100_write_data(uint8_t data)
{
	PIN_ON(LCD_NOKIA_1100_CS);

	PIN_OFF(LCD_NOKIA_1100_SCLK);
	PIN_ON(LCD_NOKIA_1100_SDA);
	PIN_ON(LCD_NOKIA_1100_SCLK);

	lcd_nokia1100_write(data);

	PIN_OFF(LCD_NOKIA_1100_CS);
}

//-----------------------------------------------------------------------------
void lcd_nokia1100_clear(void)
{
	uint8_t i;

	lcd_nokia1100_write_command(LCD_NOKIA1100_SET_START_ROW_ADDRESS_6BITS);
	lcd_nokia1100_write_command(LCD_NOKIA1100_SET_X_ADDRESS_UPPER_3BITS | 0x0);
	lcd_nokia1100_write_command(LCD_NOKIA1100_SET_X_ADDRESS_LOWER_4BITS | 0x0);
	lcd_nokia1100_write_command(LCD_NOKIA1100_SET_Y_ADDRESS | 0x0);
	lcd_nokia1100_write_command(LCD_NOKIA1100_DIPLAY_OFF);

	for (i = 0; i < 216; i++)
	{
		lcd_nokia1100_write_data(0x00);
		lcd_nokia1100_write_data(0x00);
		lcd_nokia1100_write_data(0x00);
		lcd_nokia1100_write_data(0x00);
	}

	lcd_nokia1100_write_command(LCD_NOKIA1100_DIPLAY_ON);
}

//-----------------------------------------------------------------------------
void lcd_nokia1100_set_position(uint8_t row, uint8_t column)
{
	column *= 6;

	lcd_nokia1100_write_command(LCD_NOKIA1100_SET_Y_ADDRESS | (uint8_t)(row & 0x0F));
	lcd_nokia1100_write_command(LCD_NOKIA1100_SET_X_ADDRESS_UPPER_3BITS
			| ((column >> 4) & 0x07));
	lcd_nokia1100_write_command(LCD_NOKIA1100_SET_X_ADDRESS_LOWER_4BITS
			| (column & 0x0F));
}

//-----------------------------------------------------------------------------
void lcd_nokia1100_print_char(uint8_t simbol)
{
	uint8_t line_number;

	for (line_number = 0; line_number < 5; line_number++)
	{
		lcd_nokia1100_write_data(
				lcd_nokia1100_font_5x8[simbol - 32][line_number]);
	}

	lcd_nokia1100_write_data(0x00);
}

//-----------------------------------------------------------------------------
void lcd_nokia1100_print_string(uint8_t * string)
{
	lcd_nokia1100_write_command(LCD_NOKIA1100_DIPLAY_OFF);

	while (*string)
	{
		lcd_nokia1100_print_char(*string++);
	}

	lcd_nokia1100_write_command(LCD_NOKIA1100_DIPLAY_ON);
}

//-----------------------------------------------------------------------------
void lcd_nokia1100_print_hex_xx(uint8_t data)
{
	lcd_nokia1100_print_char(lcd_nokia1100_decode[(data >> 4) & 0x0F]);
	lcd_nokia1100_print_char(lcd_nokia1100_decode[data & 0x0F]);
}

//-----------------------------------------------------------------------------
void lcd_nokia1100_print_dec_xxx(uint8_t data)
{
	lcd_nokia1100_print_char(lcd_nokia1100_decode[(data / 100) & 0x0F]);
	lcd_nokia1100_print_char(lcd_nokia1100_decode[((data % 100) / 10) & 0x0F]);
	lcd_nokia1100_print_char(lcd_nokia1100_decode[((data % 100) % 10) & 0x0F]);
}

//-----------------------------------------------------------------------------
void lcd_nokia1100_print_dec_xx(uint8_t data)
{
	lcd_nokia1100_print_char(lcd_nokia1100_decode[((data % 100) / 10) & 0x0F]);
	lcd_nokia1100_print_char(lcd_nokia1100_decode[((data % 100) % 10) & 0x0F]);
}

//-----------------------------------------------------------------------------
void lcd_nokia1100_init(void)
{
	PIN_CONFIGURATION(LCD_NOKIA_1100_CS);
	PIN_CONFIGURATION(LCD_NOKIA_1100_RST);
	PIN_CONFIGURATION(LCD_NOKIA_1100_SCLK);
	PIN_CONFIGURATION(LCD_NOKIA_1100_SDA);

	PIN_ON(LCD_NOKIA_1100_RST);
	delay_ms(5);
	PIN_OFF(LCD_NOKIA_1100_RST);

	lcd_nokia1100_write_command(LCD_NOKIA1100_PIXELS_ALL_OFF);
	lcd_nokia1100_write_command(LCD_NOKIA1100_CHARGE_PUMP_ON);

	lcd_nokia1100_clear();
}


И маленький пример:
/*
 *	File:	main.c
 *	Date:	23.01.2011
 */

#include "main.h"

//-----------------------------------------------------------------------------
void delay_ms(uint16_t time)
{
	volatile uint32_t i;

	while (time-- > 0)
	{
		i = 100;
		while (i-- > 0)
		{
		}
	}
}

//-----------------------------------------------------------------------------
int main(void)
{
	PIN_CONFIGURATION(LED_GREEN);

	lcd_nokia1100_init();
	lcd_nokia1100_set_position(7, 0);
	lcd_nokia1100_print_string("ZiBlog.ru @ 2011");
	lcd_nokia1100_set_position(0, 0);
	lcd_nokia1100_print_string("STM8L-Discovery");
	lcd_nokia1100_set_position(4, 1);
	lcd_nokia1100_print_string("LCD Nokia 1100");

	while (1)
	{
		PIN_ON(LED_GREEN);
		delay_ms(1000);

		PIN_OFF(LED_GREEN);
		delay_ms(1000);
	}

	return 0;
}


В результате получим на экране вот такую картинку:
008
  • +4
  • 07 марта 2011, 20:50
  • ZiB

Комментарии (36)

RSS свернуть / развернуть
На STM32F система GPIO похожа.
P.S. INTERRUPT, а не ITERRUPT.
P.P.S. Стоит добавить про ЖК в теги.
0
  • avatar
  • Vga
  • 08 марта 2011, 07:15
Ага есть такое, вначале я под них писал, потом просто поправил под стм8.
На счет орфографии согласен, это у меня основная проблема часто теряю буквы :)
0
Спасибо за статьи о STM8! Надеюсь будет продолжение!
0
Они есть у меня на сайте но вот копи пастить на прямую не получается, я привык писать по средством Windows Live Writer, не думаюешь о тегах и прочих токостях html, а тут все ручками нужно делать…
0
Лайв врайтер он же сам тэги подставляет. Потом только скопировать готовый хтмл код.

А у меня его к сайту так и не удалось прикрутить. ЧТо то работало, но работало как то криво :/
0
Я много чего перепробовал, но «визуально» только он нормально работает, особенно вставка рисунков, кода и файлов радует. Напрямую не получиться скопировать из-за различия тегов и форматирование кода, в частности: таблицы ни как не перевариваются у тебя, выравнивание текста не работает, с подсветкой кода пока не понятно как, окно редактивароние можно было и по больше сделать, предпросмотр снизу записи или в отдельном окне…
0
брр. не люблю WLW.
0
к сожалению лучше ни чего пока не нашел, можешь предложить?
0
для чего, для сайта? в чем преимущества WLW?
0
да, для сайта.
мне бы хотелось иметь:
1) возможность писать оффлайн
2) загружать статьи с сайта и на сайт
3) «писать», а не заниматься html-ом
4) вставка кода, рисунков, ссылок + автоматическая загрузка на сервер
5) автоформатирование рисунков + автоводяной знак
то что на вскидку вспомнилось, все то WLW предоставляет с лихвой, аналогов пока не видел.
пс нужно будет как нибудь чиркнуть о нем :)
0
Спасибо за статью по STM8.
Такой нубский вопрос: а деление есть в STM8? Уж очень интерестно во что компилятор превратит во эти строки:
0
Пардон, отправилось раньше:
lcd_nokia1100_print_char(lcd_nokia1100_decode[((data % 100) / 10) & 0x0F]);
0
Деление есть, но компилятор пока всё оптимально делает (мое мнение).
Если делить два беззнаковых 16 битных числа, то это буквально несколько команд, но при делении восьми битных команд, то он использует свою либу которая хоть и использует аппараное деление но имеет достаточно большой объем.
— unsigned int t_div1;
unsigned int t_div2;
t_div2 = t_div1 / 10;
20 тактов
— unsigned char t_div1;
unsigned int t_div2;
t_div2 = t_div1 / 10;
41 такт
— unsigned char t_div1;
unsigned char t_div2;
t_div2 = t_div1 / 10;
41 такт
— signed char t_div1;
signed char t_div2;
t_div2 = t_div1 / 10;
44 такта
— signed int t_div1;
signed int t_div2;
t_div2 = t_div1 / 10;
44 такта
— как-то так…
0
вот блин кавычки забыл:
«оптимально» :)
0
а и unsigned long 132 такта, signed long 137 тактов
0
Спасибо за столь ценные сведения, а то лишний раз поперся бы ещё свои велосипеды деления строить.
0
не за что :)
Хотя тема не очень, судя по логам у меня на сайте людям больше по душе STM32.
Мне больше интресна из-за малого потребления серии STM8L.
0
Ну армы само-собой интерестно, только я LPC мучаю. Ну я stm8l рассматриваю как замену аврам, где не нужна большая вычислительная мощность и нужна низкая стоимость. Что особенно хорошо, так возможность батарейного питания.
0
ZiB,

Нельзя ли схему подключения добавить?
… и особенно c распиновкой ЛСД от 1100.

Пытался делать тоже самое, через прерывания от T4.
0
см. внизу страницы
ziblog.ru/2011/01/25/stm8l-ndash-linii-vvoda-vyivoda/
0
Код работы с экраном одному мне напоминает софтовый i2c?
0
  • avatar
  • crab
  • 28 марта 2012, 15:11
Нет, вас двое. Остальным он напоминает SPI. :)
0
Нет, я к тому, что на этом контроллере емнимс i2c есть железный.
0
Присмотрелся внимательнее. Чооорт, туплю, прошу прощения =_=.
0
Да не за что :)
Диспов с i2c интерфейсом довольно мало. только у старых сименсов/моторолок.
0
Не совсем понял, а у вас VDD и VDDI наглухо запаяны вместе?
И никаких внешних компонентов не требует? А то 3310 требует конденсатора внешнего.
0
Да, все верно.
Вот посмотрите ещё
ziblog.ru/2011/06/19/soglasovanie-urovney/
0
Отлично. Я как раз вчера купил себе таких дисплейчиков. А то 3310, во-певых, требует лишний внешний компонент (кондер), а во вторых имеет на 1 линию больше (D/C). Плюс, тут еще и подстветка. Одни преимущества кругом ))
0
А еще разрешение больше. Вот )))
0
Ещё бы от 3,3 работали стабильно (
0
Не понял?! Он требует питалово выше чем 3.3?
0
Мои требуют 2,9 вольта
при 3,3 сгорают, говорят потому что «КИТАЙ»…
0
Ааа, ну меньше — не больше. Через диод запитать и порядок. Хотя согласен, что сгорание от лишних 0,4В это нехорошо.
0
Но спасибо, что предупредили, а то я же 3.3В и собирался подавать на них.
0
Я поэтому и скинул линк на эту тему )
0
Надо глянуть тогда ))) А то я подумал, что это очередной 5=>3.3 конвертер. А оно вот как вышло на самом деле )))
0
Только зарегистрированные и авторизованные пользователи могут оставлять комментарии.