Skocz do zawartości

Kurs STM32 F1 HAL - #9 - SPI w praktyce, ekspander IO

Komentator

Przez Komentator,
w Artykuły redakcji (blog)

 Udostępnij

Pomocna odpowiedź

  • Popularny post
Rogal Wynalazca

Rogal

  • Popularny post
(edytowany)

Hej,

Wrzucam zadania domowe. W zadaniach 9.1 oraz 9.2 kolejność podłączenia diod do wyjść ekspandera może być trochę nieintuicyjna - są w kolejności 3, 0, 1, 2. We wszystkich zadaniach zdecydowałem się na dodatkowe buforowanie rejestrów OLAT i IODIR ekspandera w pamięci mikrokontrolera. Zapisy do tych buforów jak i bezpośrednio do mniej używanych rejestrów ekspandera zrealizowałem za pomocą przesunięć bitowych trochę tak jak w AVR. 

/*Zadanie domowe 9.1
Podłącz do ekspandera kilka diod świecących np.: 4 i napisz program, który pozwala na włączanie i wyłączanie diod poprzez wysyłanie odpowiednich komend sterujących przez UART (np. 1on, 1off).*/

/*Terminal New Line character has to be set to LF*/

#include "stm32f1xx.h"
#include <string.h>

#define RX_BUFFER_SIZE 10	//String size + 1
#define MCP_IODIR 0x00
#define MCP_IPOL 0x01
#define	MCP_GPINTEN 0x02
#define MCP_DEFVAL 0x03
#define MCP_INTCON 0x04
#define MCP_IOCON 0x05
#define MCP_GPPU 0x06
#define MCP_INTF 0x07
#define MCP_INTCAP 0x08
#define MCP_GPIO 0x09
#define MCP_OLAT 0x0a

#define MCP_GPIO_0 0
#define MCP_GPIO_1 1
#define MCP_GPIO_2 2
#define MCP_GPIO_3 3
#define MCP_GPIO_4 4
#define MCP_GPIO_5 5
#define MCP_GPIO_6 6
#define MCP_GPIO_7 7

SPI_HandleTypeDef spi;
UART_HandleTypeDef uart;

void send_string(char* s){
	HAL_UART_Transmit(&uart, (uint8_t*)s, strlen(s), 1000);
}

void mcp_write_reg(uint8_t addr, uint8_t value){
	uint8_t tx_buff[] = { 0x40, addr, value };
	HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, GPIO_PIN_RESET);
	HAL_SPI_Transmit(&spi, tx_buff, 3, HAL_MAX_DELAY);
	HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, GPIO_PIN_SET);
}
			
int main(void){
	SystemCoreClock = 8000000;
	HAL_Init();

	__HAL_RCC_GPIOA_CLK_ENABLE();
	__HAL_RCC_GPIOC_CLK_ENABLE();
	__HAL_RCC_SPI1_CLK_ENABLE();
	__HAL_RCC_USART2_CLK_ENABLE();

	/*PA5 AS SCK + PA7 AS MOSI*/
	GPIO_InitTypeDef inout;
	inout.Pin					=	GPIO_PIN_5 | GPIO_PIN_7;
	inout.Mode					=	GPIO_MODE_AF_PP;
	inout.Pull					=	GPIO_NOPULL;
	inout.Speed					=	GPIO_SPEED_FREQ_HIGH;
	HAL_GPIO_Init(GPIOA, &inout);

	/*PA6 AS MISO*/
	inout.Pin					=	GPIO_PIN_6;
	inout.Mode					=	GPIO_MODE_AF_INPUT;
	HAL_GPIO_Init(GPIOA, &inout);

	/*PC0 AS CS (SS)*/
	inout.Pin					=	GPIO_PIN_0;
	inout.Mode					=	GPIO_MODE_OUTPUT_PP;
	HAL_GPIO_Init(GPIOC, &inout);
	HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, GPIO_PIN_SET);

	/*PIN PA2 AS TX (ALTERNATE)*/
	inout.Mode				=	GPIO_MODE_AF_PP;
	inout.Pin				=	GPIO_PIN_2;
	inout.Pull				=	GPIO_NOPULL;
	inout.Speed				=	GPIO_SPEED_FREQ_LOW;
	HAL_GPIO_Init(GPIOA, &inout);

	/*PIN PA3 AS RX (ALTERNATE)*/
	inout.Mode				=	GPIO_MODE_AF_INPUT;
	inout.Pin				=	GPIO_PIN_3;
	HAL_GPIO_Init(GPIOA, &inout);

	/*UART2 CONFIG*/
	uart.Instance			=	USART2;
	uart.Init.BaudRate		=	115200;
	uart.Init.WordLength	=	UART_WORDLENGTH_8B;
	uart.Init.Parity		=	UART_PARITY_NONE;
	uart.Init.StopBits		=	UART_STOPBITS_1;
	uart.Init.HwFlowCtl		=	UART_HWCONTROL_NONE;
	uart.Init.OverSampling	=	UART_OVERSAMPLING_16;
	uart.Init.Mode			=	UART_MODE_TX_RX;
	HAL_UART_Init(&uart);

	/*SPI CONFIG*/
	spi.Instance				=	SPI1;
	spi.Init.Mode				=	SPI_MODE_MASTER;
	spi.Init.NSS				=	SPI_NSS_SOFT;
	spi.Init.BaudRatePrescaler	=	SPI_BAUDRATEPRESCALER_8;
	spi.Init.Direction			=	SPI_DIRECTION_2LINES;
	spi.Init.CLKPhase			=	SPI_PHASE_1EDGE;
	spi.Init.CLKPolarity		=	SPI_POLARITY_LOW;
	spi.Init.DataSize			=	SPI_DATASIZE_8BIT;
	spi.Init.FirstBit			=	SPI_FIRSTBIT_MSB;
	spi.Init.TIMode				=	SPI_TIMODE_DISABLE;
	spi.Init.CRCCalculation		=	SPI_CRCCALCULATION_DISABLE;
	spi.Init.CRCPolynomial		=	7;
	HAL_SPI_Init(&spi);
	__HAL_SPI_ENABLE(&spi);

	/*VARIABLES*/
	uint8_t EndOfTransmissionFlag = 0;
	char str[RX_BUFFER_SIZE] = "";
	uint8_t i = 0;
	uint8_t mcp_olat_buff = 0;
	uint8_t mcp_iodir_buff = 255;
	memset(str, 0, strlen(str));		//Clearing string buffer

	mcp_iodir_buff &= ~(1<<MCP_GPIO_0) & ~(1<<MCP_GPIO_1) & ~(1<<MCP_GPIO_2) & ~(1<<MCP_GPIO_3);
	mcp_write_reg(MCP_IODIR, mcp_iodir_buff);

	while (1){

		if(__HAL_UART_GET_FLAG(&uart, UART_FLAG_RXNE) == SET){
			HAL_UART_Receive(&uart, (uint8_t*)str + i, 1, 1000);
			send_string(str + i);	//Terminal echo
			if(str[i] == '\n'){
				str[i] = 0;
				i = 0;
				EndOfTransmissionFlag = 1;
			}
			else{
				i++;
			}
		}
		if (EndOfTransmissionFlag == 1) {
			if (strcmp(str, "on 1") == 0) {
				send_string("1 ON\n");
				mcp_olat_buff |= 1<<MCP_GPIO_3;
			}
			if (strcmp(str, "off 1") == 0) {
				send_string("1 OFF\n");
				mcp_olat_buff &= ~(1<<MCP_GPIO_3);
			}
			if (strcmp(str, "on 2") == 0) {
				send_string("2 ON\n");
				mcp_olat_buff |= 1<<MCP_GPIO_0;
			}
			if (strcmp(str, "off 2") == 0) {
				send_string("2 OFF\n");
				mcp_olat_buff &= ~(1<<MCP_GPIO_0);
			}
			if (strcmp(str, "on 3") == 0) {
				send_string("3 ON\n");
				mcp_olat_buff |= 1<<MCP_GPIO_1;
			}
			if (strcmp(str, "off 3") == 0) {
				send_string("3 OFF\n");
				mcp_olat_buff &= ~(1<<MCP_GPIO_1);
			}
			if (strcmp(str, "on 4") == 0) {
				send_string("4 ON\n");
				mcp_olat_buff |= 1<<MCP_GPIO_2;
			}
			if (strcmp(str, "off 4") == 0) {
				send_string("4 OFF\n");
				mcp_olat_buff &= ~(1<<MCP_GPIO_2);
			}
			mcp_write_reg(MCP_OLAT, mcp_olat_buff);
			EndOfTransmissionFlag = 0;
			memset(str, 0, strlen(str));		//Clearing buffer
		}
		if(str[10] != 0){
			i = 0;
			memset(str, 0, strlen(str));		//Clearing buffer
			send_string("\n");
		}
	}
}
/*Zadanie domowe 9.2
Wykorzystaj podłączenie z zadanie 9.1 i stwórz licznik Johnsona. Do układu podłącz dodatkowo potencjometr, którym będzie można regulować prędkość pracy licznika (w tym celu użyj ADC).*/

#include "stm32f1xx.h"

#define MCP_IODIR 0x00
#define MCP_IPOL 0x01
#define	MCP_GPINTEN 0x02
#define MCP_DEFVAL 0x03
#define MCP_INTCON 0x04
#define MCP_IOCON 0x05
#define MCP_GPPU 0x06
#define MCP_INTF 0x07
#define MCP_INTCAP 0x08
#define MCP_GPIO 0x09
#define MCP_OLAT 0x0a

#define MCP_GPIO_0 0
#define MCP_GPIO_1 1
#define MCP_GPIO_2 2
#define MCP_GPIO_3 3
#define MCP_GPIO_4 4
#define MCP_GPIO_5 5
#define MCP_GPIO_6 6
#define MCP_GPIO_7 7

SPI_HandleTypeDef spi;
ADC_HandleTypeDef adc;

uint32_t read_adc(){
	HAL_ADC_Start(&adc);
	HAL_ADC_PollForConversion(&adc, 1000);
	return HAL_ADC_GetValue(&adc);
}

void mcp_write_reg(uint8_t addr, uint8_t value){
	uint8_t tx_buff[] = { 0x40, addr, value };
	HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, GPIO_PIN_RESET);
	HAL_SPI_Transmit(&spi, tx_buff, 3, HAL_MAX_DELAY);
	HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, GPIO_PIN_SET);
}
			
int main(void){
	SystemCoreClock = 8000000;
	HAL_Init();

	__HAL_RCC_GPIOA_CLK_ENABLE();
	__HAL_RCC_GPIOC_CLK_ENABLE();
	__HAL_RCC_SPI1_CLK_ENABLE();
	__HAL_RCC_ADC1_CLK_ENABLE();

	/*PA5 AS SCK + PA7 AS MOSI*/
	GPIO_InitTypeDef inout;
	inout.Pin						=	GPIO_PIN_5 | GPIO_PIN_7;
	inout.Mode						=	GPIO_MODE_AF_PP;
	inout.Pull						=	GPIO_NOPULL;
	inout.Speed						=	GPIO_SPEED_FREQ_HIGH;
	HAL_GPIO_Init(GPIOA, &inout);

	/*PA6 AS MISO*/
	inout.Pin						=	GPIO_PIN_6;
	inout.Mode						=	GPIO_MODE_AF_INPUT;
	HAL_GPIO_Init(GPIOA, &inout);

	/*PC0 AS CS (SS)*/
	inout.Pin						=	GPIO_PIN_0;
	inout.Mode						=	GPIO_MODE_OUTPUT_PP;
	HAL_GPIO_Init(GPIOC, &inout);
	HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, GPIO_PIN_SET);

	/*PA0 AS ANALOG INPUT*/
	inout.Pin						=	GPIO_PIN_0;
	inout.Mode						=	GPIO_MODE_ANALOG;
	inout.Speed						=	GPIO_SPEED_FREQ_LOW;
	HAL_GPIO_Init(GPIOA, &inout);

	/*SPI CONFIG*/
	spi.Instance					=	SPI1;
	spi.Init.Mode					=	SPI_MODE_MASTER;
	spi.Init.NSS					=	SPI_NSS_SOFT;
	spi.Init.BaudRatePrescaler		=	SPI_BAUDRATEPRESCALER_8;
	spi.Init.Direction				=	SPI_DIRECTION_2LINES;
	spi.Init.CLKPhase				=	SPI_PHASE_1EDGE;
	spi.Init.CLKPolarity			=	SPI_POLARITY_LOW;
	spi.Init.DataSize				=	SPI_DATASIZE_8BIT;
	spi.Init.FirstBit				=	SPI_FIRSTBIT_MSB;
	spi.Init.TIMode					=	SPI_TIMODE_DISABLE;
	spi.Init.CRCCalculation			=	SPI_CRCCALCULATION_DISABLE;
	spi.Init.CRCPolynomial			=	7;
	HAL_SPI_Init(&spi);
	__HAL_SPI_ENABLE(&spi);

	/*ADC CLOCK CONFIG*/
	RCC_PeriphCLKInitTypeDef adc_clk;
	adc_clk.PeriphClockSelection	=	RCC_PERIPHCLK_ADC;
	adc_clk.AdcClockSelection		=	RCC_ADCPCLK2_DIV8;
	HAL_RCCEx_PeriphCLKConfig(&adc_clk);

	/*ADC CONFIG*/
	adc.Instance					=	ADC1;
	adc.Init.ContinuousConvMode		=	DISABLE;
	adc.Init.ExternalTrigConv		=	ADC_SOFTWARE_START;
	adc.Init.DataAlign				=	ADC_DATAALIGN_RIGHT;
	adc.Init.ScanConvMode			=	ADC_SCAN_DISABLE;
	adc.Init.NbrOfConversion		=	1;
	adc.Init.DiscontinuousConvMode	=	DISABLE;
	adc.Init.NbrOfDiscConversion	=	1;
	HAL_ADC_Init(&adc);
	HAL_ADCEx_Calibration_Start(&adc);

	/*ADC MULTIPLEXER CONFIG*/
	ADC_ChannelConfTypeDef adc_ch;
	adc_ch.Channel					=	ADC_CHANNEL_0;
	adc_ch.Rank						=	ADC_REGULAR_RANK_1;
	adc_ch.SamplingTime				=	ADC_SAMPLETIME_239CYCLES_5;
	HAL_ADC_ConfigChannel(&adc, &adc_ch);

	/*VARIABLES*/
	uint8_t mcp_olat_buff = 0;
	uint8_t mcp_iodir_buff = 255;
	uint8_t carry = 0;		//carry flag
	uint32_t period = 0;

	mcp_iodir_buff &= ~(1<<MCP_GPIO_0) & ~(1<<MCP_GPIO_1) & ~(1<<MCP_GPIO_2) & ~(1<<MCP_GPIO_3);
	mcp_write_reg(MCP_IODIR, mcp_iodir_buff);

	while (1){

		if (mcp_olat_buff & (1<<MCP_GPIO_2)){
			carry = 1;
		}
		else {
			carry = 0;
		}

		if (mcp_olat_buff & (1<<MCP_GPIO_1)){
			mcp_olat_buff |= (1<<MCP_GPIO_2);
		}
		else {
			mcp_olat_buff &= ~(1<<MCP_GPIO_2);
		}

		if (mcp_olat_buff & (1<<MCP_GPIO_0)){
			mcp_olat_buff |= (1<<MCP_GPIO_1);
		}
		else {
			mcp_olat_buff &= ~(1<<MCP_GPIO_1);
		}

		if (mcp_olat_buff & (1<<MCP_GPIO_3)){
			mcp_olat_buff |= (1<<MCP_GPIO_0);
		}
		else {
			mcp_olat_buff &= ~(1<<MCP_GPIO_0);
		}

		if (carry == 1){
			mcp_olat_buff &= ~(1<<MCP_GPIO_3);
		}
		else {
			mcp_olat_buff |= (1<<MCP_GPIO_3);
		}

		mcp_write_reg(MCP_OLAT, mcp_olat_buff);
		period = read_adc() / 5;
		if (period < 30){
			period = 30;
		}
		HAL_Delay(period);
	}
}

Zadanie 9.3 zrobiłem nieco inaczej niż MaciejZyskowski. Obyło się bez użycia przerwań a zliczanie zmienia kierunek od razu po zmianie stanu wejścia ekspandera. Przy okazji wyeliminowałem opóźnienia w tym zadaniu. Podobnie można było zrobić w 9.2. 

/*Zadanie domowe 9.3
Skonfiguruj jeden pin ekspandera jako wejście, a pozostałe jako wyjścia, do których podłączone będą diody świecące. Stan diod powinien wizualizować wyjście licznika binarnego, którego kierunek pracy określany ja za pomocą stanu panującego na jedynym wejściu ekspandera.*/

#include "stm32f1xx.h"

#define MCP_IODIR 0x00
#define MCP_IPOL 0x01
#define	MCP_GPINTEN 0x02
#define MCP_DEFVAL 0x03
#define MCP_INTCON 0x04
#define MCP_IOCON 0x05
#define MCP_GPPU 0x06
#define MCP_INTF 0x07
#define MCP_INTCAP 0x08
#define MCP_GPIO 0x09
#define MCP_OLAT 0x0a

#define MCP_GPIO_0 0
#define MCP_GPIO_1 1
#define MCP_GPIO_2 2
#define MCP_GPIO_3 3
#define MCP_GPIO_4 4
#define MCP_GPIO_5 5
#define MCP_GPIO_6 6
#define MCP_GPIO_7 7

#define PERIOD 100

SPI_HandleTypeDef spi;

void mcp_write_reg(uint8_t addr, uint8_t value){
	uint8_t tx_buff[] = { 0x40, addr, value };
	HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, GPIO_PIN_RESET);
	HAL_SPI_Transmit(&spi, tx_buff, 3, HAL_MAX_DELAY);
	HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, GPIO_PIN_SET);
}

uint8_t mcp_read_reg(uint8_t addr){
	uint8_t rx_buff[3];
	uint8_t tx_buff[] = { 0x41, addr, 0xff };
	HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, GPIO_PIN_RESET);
	HAL_SPI_TransmitReceive(&spi, tx_buff, rx_buff, 3, HAL_MAX_DELAY);
	HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, GPIO_PIN_SET);
	return rx_buff[2];
}
			
int main(void){
	SystemCoreClock = 8000000;
	HAL_Init();

	__HAL_RCC_GPIOA_CLK_ENABLE();
	__HAL_RCC_GPIOC_CLK_ENABLE();
	__HAL_RCC_SPI1_CLK_ENABLE();

	/*PA5 AS SCK + PA7 AS MOSI*/
	GPIO_InitTypeDef inout;
	inout.Pin						=	GPIO_PIN_5 | GPIO_PIN_7;
	inout.Mode						=	GPIO_MODE_AF_PP;
	inout.Pull						=	GPIO_NOPULL;
	inout.Speed						=	GPIO_SPEED_FREQ_HIGH;
	HAL_GPIO_Init(GPIOA, &inout);

	/*PA6 AS MISO*/
	inout.Pin						=	GPIO_PIN_6;
	inout.Mode						=	GPIO_MODE_AF_INPUT;
	HAL_GPIO_Init(GPIOA, &inout);

	/*PC0 AS CS (SS)*/
	inout.Pin						=	GPIO_PIN_0;
	inout.Mode						=	GPIO_MODE_OUTPUT_PP;
	HAL_GPIO_Init(GPIOC, &inout);
	HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, GPIO_PIN_SET);

	/*SPI CONFIG*/
	spi.Instance					=	SPI1;
	spi.Init.Mode					=	SPI_MODE_MASTER;
	spi.Init.NSS					=	SPI_NSS_SOFT;
	spi.Init.BaudRatePrescaler		=	SPI_BAUDRATEPRESCALER_8;
	spi.Init.Direction				=	SPI_DIRECTION_2LINES;
	spi.Init.CLKPhase				=	SPI_PHASE_1EDGE;
	spi.Init.CLKPolarity			=	SPI_POLARITY_LOW;
	spi.Init.DataSize				=	SPI_DATASIZE_8BIT;
	spi.Init.FirstBit				=	SPI_FIRSTBIT_MSB;
	spi.Init.TIMode					=	SPI_TIMODE_DISABLE;
	spi.Init.CRCCalculation			=	SPI_CRCCALCULATION_DISABLE;
	spi.Init.CRCPolynomial			=	7;
	HAL_SPI_Init(&spi);
	__HAL_SPI_ENABLE(&spi);

	/*VARIABLES*/
	uint8_t mcp_olat_buff = 0;
	uint8_t mcp_iodir_buff = 255;
	uint32_t last_incremented = 0;

	mcp_iodir_buff &= ~(1<<MCP_GPIO_0) & ~(1<<MCP_GPIO_1) & ~(1<<MCP_GPIO_2) & ~(1<<MCP_GPIO_3) & ~(1<<MCP_GPIO_4) & ~(1<<MCP_GPIO_5) & ~(1<<MCP_GPIO_6);
	mcp_write_reg(MCP_IODIR, mcp_iodir_buff);
	mcp_write_reg(MCP_GPPU, (1<<MCP_GPIO_7));

	while (1){
		if(last_incremented + PERIOD <= HAL_GetTick()){
			last_incremented = HAL_GetTick();
			if((mcp_read_reg(MCP_GPIO) & (1<<MCP_GPIO_7)) == 0){
				if(mcp_olat_buff == 0){
					continue;
				}
				else {
					mcp_olat_buff -= 1;
				}
			}
			else {
				if(mcp_olat_buff == 127){
					continue;
				}
				else{
					mcp_olat_buff += 1;
				}
			}
		}
		mcp_write_reg(MCP_OLAT, mcp_olat_buff);
	}
}

 

Edytowano przez Rogal
  • Lubię! 3
  • 5 miesiące później...
Emerid Starszy odkrywca

Emerid

W którym pliku mogę znaleźć rozpiskę pinów przypisanych do danych modułów (SPI1, ADC1, GPIOA, itp.)? Do tej pory korzystałem z obrazka znalezionego na internecie, ale jednak chciałbym jakieś bardziej wiarygodnie źródło.

Emerid Starszy odkrywca

Emerid

@Gieneq Na stronach 28-33 faktycznie jest opis pinów, ale nie widzę informacji, jak powiązać to z rozmieszczeniem na płytce Nucleo. Chodzi mi o coś podobnego do poniższego rysunku, ale z oficjalnych dokumentów.
 

STM32F103RB_Pinout.gif.f64b74ff4321e7df4d3da6452a96b3dd.gif

Emerid Starszy odkrywca

Emerid

(edytowany)

Moje przemyślenia, którymi podzielę się dla potomnych początkujących:

  1. A1, A2 - bity adresu MCP ustawiane napięciowo przy układzie scalonym (w naszym przypadku wiszą w powietrzu, czyli bardziej 0 niż 1, czyli adres : 00)
  2. SPI Control byte (device Opcode), czyli nawiązanie komunikacji z urządzeniem to: 0100 0(A1)(A2)(R/W) - W bicie kontrolnym na dwóch bitach ustawiamy adres A1,A2 urządzenia / R=1 w przypadku odczytu z MCP,  W=0 w przypadku wysyłania informacji do MCP)
  3. Chcąc skomunikować się z MCP wysyłam (Control bit - adres urządzenia oraz kierunek transmisji , adres rejestru, wartość), gdzie adresy rejestrów i bity odpowiadające za poszczególne funkcje opisane są w tabeli poniżej
    image.thumb.png.d5cc17104c70fd3231927fa89b5a2797.png
  4. Chcąc zaprogramować piny jako wyjście musimy ustawić odpowiadające bity w IODIR na 0
    - 1111 1110 = ~0x01 - MCP_PIN_0_OUTPUT
    - 1111 1011 = ~0x04 - MCP_PIN_2_OUTPUT
    - 1101 1011 = ~0x24 - MCP_PIN_5_OUTPUT | MCP_PIN_2_OUTPUT
    - 0101 1011 = ~0xa4 - MCP_PIN_7_SET | MCP_PIN_5_OUTPUT | MCP_PIN_2_OUTPUT
  5. Wyjście pinów MCP ustawiać możemy poprzez wartości wysyłane do rejestru OLAT 
    - 0000 0001  = 0x01 - MCP_PIN_0_SET
    - 0000 0100 =  0x04 - MCP_PIN_2_SET
    - 0010 0100 =  0x24 - MCP_PIN_5_SET | MCP_PIN_2_SET
    - 1010 0100 =  0xa4 - MCP_PIN_7_SET | MCP_PIN_5_SET | MCP_PIN_2_SET
Edytowano przez Emerid
  • Lubię! 1

Bądź aktywny - zaloguj się lub utwórz konto!

Tylko zarejestrowani użytkownicy mogą komentować zawartość tej strony

Utwórz konto w ~20 sekund!

Zarejestruj nowe konto, to proste!

Zarejestruj się »

Zaloguj się

Posiadasz własne konto? Użyj go!

Zaloguj się »
 Udostępnij
Przejdź do listy tematów
×
×
  • Utwórz nowe...