MaciejZyskowski

Got it! Rozwiazanie jest niesamowicie trywialne. Do funkcji udpecho_raw_recv() nalezy dopisac: pbuf_free(p); Konieczne jest czyszczenie obydwu buforow, zarowno tego nadawczego (ethTxBuffer_p_x) i odbiorczego (p). Moze chociaz komus pomoga moje rozkminy, a tymczasem temat do zamkniecia. :)

Witam serdecznie. Prosze wybaczyc, ze bez pisze bez polskich znakow, ale teraz do rzeczy. Chce nawiazac komunikacje pc - mcu przez Ethernet. Pracuje na Nucleo F746ZG. Stworzylem projekt z pomoca CubeMX (v4.27.0) w ktorym uruchomilem lwIP i podstawowe protokoly (w tym UDP), jako IDE uzywam Eclipse OpenSTM32. Ustalenie IP mikrokontrolera wykonywane jest przez DHCP. Ping oraz echo UDP dziala bez problemu (wyslanie pakietu UDP z dowolnego pc w sieci skutkuje odeslaniem wiadomosci na ten sam adres ip oraz port). Moj problem zaczyna sie wowczas, gdy zmodyfikowalem funkcje udpecho_raw_recv() i chce umiescic inne dane w odsylanym pakiecie. udp_sendto(pcb, p, addr, port); /* dziala jak echo */ udp_sendto(pcb, ethTxBuffer_p_x, addr, port); /* wysyla dane z bufora */ Po przeslaniu zwykle okolo 10 pakietow z pc i uzyskaniu odpowiedzi od mcu z pakietem o innej tresci nagle mikrokontroler przestaje odpowiadac (obrazek screenshot_udp.jpg). Wyglada mi to na problem z buforem pbuf w funkcji udpecho_raw_recv(), lecz nie wiem jak sie za to zabrac. Czy ktos z Was ma moze doswiadczenie z lwIP i moglby mi podpowiedziec co z tym zrobic? Przegladalem wiele stron z podobnymi problemami, ale jednak opisane tam rozwiazania lub rady mi nie pomogly. Z gory dziekuje! Kod wyglada nastepujaco: Zmienne globalne: /* USER CODE BEGIN PV */ /* Private variables ---------------------------------------------------------*/ extern struct netif gnetif; static struct udp_pcb *udpPcb1_p; ip_addr_t ipaddress; static const char clientPacket_c[] = { 0x49, 0x20, 0x6c, 0x69, 0x6b, 0x65, 0x20, 0x63, 0x61, 0x74, 0x73, 0x2e }; static const char reply[] = { 0x67, 0x6f, 0x74, 0x20, 0x69, 0x74, 0x20, 0x62, 0x72, 0x6f }; /* USER CODE END PV */ Funkcje: static void udpecho_raw_recv(void *arg, struct udp_pcb *pcb, struct pbuf *p, struct ip_addr *addr, u16_t port) { static struct pbuf *ethTxBuffer_p_x; ethTxBuffer_p_x = pbuf_alloc(PBUF_TRANSPORT, sizeof(reply), PBUF_RAM); memcpy(ethTxBuffer_p_x->payload, reply, sizeof(reply)); udp_sendto(pcb, ethTxBuffer_p_x, addr, port); pbuf_free(ethTxBuffer_p_x); } /*-----------------------------------------------------------------------------------*/ void udpecho_raw_server_init(u16_t port) { struct udp_pcb *pcb; printf("%s() ..........\n", __func__); pcb = udp_new(); udp_bind(pcb, gnetif.ip_addr.addr, port); /* no need to loop forever */ udp_recv(pcb , udpecho_raw_recv, pcb); } W main() z rzeczy dodanych przeze mnie jest tylko: udpecho_raw_server_init(20); while(1) { MX_LWIP_Process(); }

Cześć! Pochwale się Wam swoim wybitnym osiągnięciem. Funkcja atoi() w moim przypadku nie dawała do końca oczekiwanych rezultatów. Podczas wysłania liczby program zachowywał się jak należy, lecz gdy wysłany został znak informacją zwrotną było STOP. Wystarczy użyć funkcji strtol() i powinno działać normalnie. switch (strtol(&received)) { ... }

Jasne, mi też niezbyt podoba się ten cały bałagan w kodzie oraz niepewność co CubeMX tam poustawiał, sam jeszcze nie jestem do niego przekonany. W pracy raczej nie mam przymusu z nim pracować, tzn. przekonam się niedługo. Najważniejsze, aby działało. ;d

@Treker Dziękuję za odpowiedź! Nie brzmi to zbyt dobrze, a dodatkowo w pracy mam używać CubeMX... :< W wolnej chwili przetestuję jak zachowują się starsze wersje (v 4.X) CubeMX.

Cześć. Mam problem z CubeMX. Robiłem zadania dodatkowe i wszystko szło dobrze, aż do momentu kiedy zacząłem robić zadanie trzecie "Jeżeli temperatura mikrokontrolera wzrośnie powyżej 30°, powinien włączyć się alarm. Jest on sygnalizowany miganiem wszystkich diod z częstotliwością 3Hz.". Włączyłem "Temperature Sensor Channel" i ustawiłem jako rank 3 itd. Problem w tym, że po wygenerowaniu kodu program przestał się kompilować i wyrzuca błędy w dziwnych miejscach (widoczne na załączniku "wlasna_praca_domowa.PNG). Zacząłem zmieniać ustawienia i szukać błędu, przywrócić stan z poprzedniego zadania kiedy działało, ale nic nie pomogło. Pobrałem projekt CubeMX z kursu i już po wygenerowaniu kodu, bez żadnej ingerencji są błędy ("homework2.PNG"). Sam nie wiem jak się już za to zabrać. Może trzeba zmodyfikować ustawienia kompilatora w Open STM32 Eclipse? Dzięki! - homework2.png - wlasna_praca_domowa.png

Witam. Skończyłem obydwa kursy F1 stdperiph i HAL, właśnie zabieram się za F4. Osobiście bardzo chętnie wziął udział w kursie dotyczących układów ARM Cortex M7, proponując przy tym płytkę STM32 NUCLEO-F767ZI. Chciałbym przykładowo zobaczyć lekcję w której konfiguruje się protokół IP do wysyłania pakietów przez ethernet. Jestem bardzo zadowolony z Waszych kursów, świetna robota! Jeżeli powstanie kolejny, możecie na mnie liczyć.

Dokładnie to mam na myśli. Obecnie zmiana "kierunku" pracy licznika może obyć się dopiero po zakończeniu pętli. Chciałbym, żeby mogła nastąpić natychmiast po zmianie stanu pinu wejściowego.

Cześć! Zrobiłem zadanie 9.3 Oto mój kod (działa na 4 diodach, bo ciasno mi było montować wszystkie... ;p): /** ****************************************************************************** * @file main.c * @author Ac6 * @version V1.0 * @date 01-December-2013 * @brief Default main function. ****************************************************************************** */ #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 SPI_HandleTypeDef spi; void mcp_write_reg(uint8_t addr, uint8_t value) { uint8_t tx_buf[] = {0x40, addr, value}; HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, GPIO_PIN_RESET); HAL_SPI_Transmit(&spi, tx_buf, 3, HAL_MAX_DELAY); HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, GPIO_PIN_SET); } uint8_t mcp_read_reg(uint8_t addr) { uint8_t tx_buf[] = {0x41, addr, 0xff}; uint8_t rx_buf[3]; HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, GPIO_PIN_RESET); HAL_SPI_TransmitReceive(&spi, tx_buf, rx_buf, 3, HAL_MAX_DELAY); HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, GPIO_PIN_SET); return rx_buf[2]; } int main(void) { SystemCoreClock = 8000000; HAL_Init(); __HAL_RCC_GPIOA_CLK_ENABLE(); __HAL_RCC_GPIOC_CLK_ENABLE(); __HAL_RCC_SPI1_CLK_ENABLE(); /* SPI I/O config */ /* SCK & MOSI */ GPIO_InitTypeDef gpio; gpio.Mode = GPIO_MODE_AF_PP; gpio.Pin = GPIO_PIN_5 | GPIO_PIN_7; gpio.Pull = GPIO_NOPULL; gpio.Speed = GPIO_SPEED_FREQ_HIGH; HAL_GPIO_Init(GPIOA, &gpio); /* MISO */ gpio.Mode = GPIO_MODE_AF_INPUT; gpio.Pin = GPIO_PIN_6; HAL_GPIO_Init(GPIOA, &gpio); /* CS */ gpio.Mode = GPIO_MODE_OUTPUT_PP; gpio.Pin = GPIO_PIN_0; HAL_GPIO_Init(GPIOC, &gpio); HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, GPIO_PIN_SET); /* idle state of the conection with slave */ spi.Instance = SPI1; spi.Init.Mode = SPI_MODE_MASTER; spi.Init.NSS = SPI_NSS_SOFT; spi.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_8; /* 1MHz */ 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); mcp_write_reg(MCP_IODIR, ~0x0F); mcp_write_reg(MCP_GPPU, 0x10); while(1) { if ((mcp_read_reg(MCP_GPIO) & 0x10) == 0) { for (int i = 0x00; i<=0x0F; ++i) { mcp_write_reg(MCP_OLAT, i); HAL_Delay(1000); } } else { for (int i = 0x0F; i>=0x00; --i) { mcp_write_reg(MCP_OLAT, i); HAL_Delay(1000); } } } } Niby działa, ale nie jest to najwspanialsze rozwiązanie, gdyż odczyt stanu pinu ekspandera odbywa się po skończeniu pętli. Chciałbym użyć przerwań, aby wykrywać zmianę stanu tego pinu, lecz nie wiem jak się za to zabrać. :< Czy moglibyście mi pomóc? Dać jakieś wskazówki?

Usunąłem i napis został wyświetlony, lecz po wykonaniu kolejnych komend dalej nie działa printf. /** ****************************************************************************** * @file main.c * @author Ac6 * @version V1.0 * @date 01-December-2013 * @brief Default main function. ****************************************************************************** */ #include "stm32f10x.h" #include "stdio.h" #include "delay.h" void send_char(char c) { while (USART_GetFlagStatus(USART2, USART_FLAG_TXE) == RESET); USART_SendData(USART2, c); } int __io_putchar(int c) { if (c=='\n') send_char('\r'); send_char(c); return c; } void eeprom_set_addr(uint32_t addr) { I2C_GenerateSTART(I2C1, ENABLE); while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT) != SUCCESS); I2C_Send7bitAddress(I2C1, 0xa0, I2C_Direction_Transmitter); while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED) != SUCCESS); I2C_SendData(I2C1, addr); while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTING) != SUCCESS); } void eeprom_write(uint32_t addr, const void* data, int size) { int i; const uint8_t* buffer = (uint8_t*)data; eeprom_set_addr(addr); for (i=0; i<size; i++) { I2C_SendData(I2C1, buffer[i]); while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTING) != SUCCESS); } I2C_GenerateSTOP(I2C1, ENABLE); } void eeprom_read(uint32_t addr, void* data, int size) { int i; uint8_t* buffer = (uint8_t*)data; eeprom_set_addr(addr); I2C_GenerateSTART(I2C1, ENABLE); while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT) != SUCCESS); I2C_AcknowledgeConfig(I2C1, ENABLE); I2C_Send7bitAddress(I2C1, 0xa0, I2C_Direction_Receiver); while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED) != SUCCESS); for (i=0; i<size-1; i++) { while(I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_RECEIVED) != SUCCESS); buffer[i] = I2C_ReceiveData(I2C1); } I2C_AcknowledgeConfig(I2C1, DISABLE); I2C_GenerateSTOP(I2C1, ENABLE); while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_RECEIVED) != SUCCESS); buffer[i] = I2C_ReceiveData(I2C1); } int main(void) { uint32_t counter = 0; RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE); RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1, ENABLE); RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB | RCC_APB2Periph_GPIOC | RCC_APB2Periph_GPIOD, ENABLE); RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE); GPIO_InitTypeDef gpio; GPIO_StructInit(&gpio); gpio.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7; //SCL, SDA gpio.GPIO_Mode = GPIO_Mode_AF_OD; gpio.GPIO_Speed = GPIO_Speed_50MHz; GPIO_Init(GPIOB, &gpio); GPIO_StructInit(&gpio); gpio.GPIO_Pin = GPIO_Pin_2; gpio.GPIO_Mode = GPIO_Mode_AF_PP; GPIO_Init(GPIOA, &gpio); gpio.GPIO_Pin = GPIO_Pin_3; gpio.GPIO_Mode = GPIO_Mode_IN_FLOATING; GPIO_Init(GPIOA, &gpio); USART_InitTypeDef uart; USART_StructInit(&uart); uart.USART_BaudRate = 115200; USART_Init(USART2, &uart); USART_Cmd(USART2, ENABLE); I2C_InitTypeDef i2c; I2C_StructInit(&i2c); i2c.I2C_Mode = I2C_Mode_I2C; i2c.I2C_Ack = I2C_Ack_Enable; i2c.I2C_ClockSpeed = 100000; I2C_Init(I2C1, &i2c); I2C_Cmd(I2C1, ENABLE); eeprom_read(0x10, &counter, sizeof(counter)); counter++; printf("Uruchomienie numer %ld\n", counter); // wyświetla eeprom_write(0x10, &counter, sizeof(counter)); I2C_GenerateSTART(I2C1, ENABLE); while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT) != SUCCESS); I2C_AcknowledgeConfig(I2C1, ENABLE); I2C_Send7bitAddress(I2C1, 0xa0, I2C_Direction_Receiver); while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED) != SUCCESS); while(I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_RECEIVED) != SUCCESS); uint8_t data1 = I2C_ReceiveData(I2C1); I2C_AcknowledgeConfig(I2C1, DISABLE); I2C_GenerateSTOP(I2C1, ENABLE); while(I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_RECEIVED) != SUCCESS); uint8_t data2 = I2C_ReceiveData(I2C1); printf("data1: %x/n", data1); printf("data2: %x/n", data2); printf("cokolwiek\n"); //nie wyświetla while(1) { } }

/** ****************************************************************************** * @file main.c * @author Ac6 * @version V1.0 * @date 01-December-2013 * @brief Default main function. ****************************************************************************** */ #include "stm32f10x.h" #include "stdio.h" #include "delay.h" void send_char(char c) { while (USART_GetFlagStatus(USART2, USART_FLAG_TXE) == RESET); USART_SendData(USART2, c); } int __io_putchar(int c) { if (c=='\n') send_char('\r'); send_char(c); return c; } void eeprom_set_addr(uint32_t addr) { I2C_GenerateSTART(I2C1, ENABLE); while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT) != SUCCESS); I2C_Send7bitAddress(I2C1, 0xa0, I2C_Direction_Transmitter); while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED) != SUCCESS); I2C_SendData(I2C1, addr); while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTING) != SUCCESS); } void eeprom_write(uint32_t addr, const void* data, int size) { int i; const uint8_t* buffer = (uint8_t*)data; eeprom_set_addr(addr); for (i=0; i<size; i++) { I2C_SendData(I2C1, buffer[i]); while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTING) != SUCCESS); } I2C_GenerateSTOP(I2C1, ENABLE); } void eeprom_read(uint32_t addr, void* data, int size) { int i; uint8_t* buffer = (uint8_t*)data; eeprom_set_addr(addr); I2C_GenerateSTART(I2C1, ENABLE); while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT) != SUCCESS); I2C_AcknowledgeConfig(I2C1, ENABLE); I2C_Send7bitAddress(I2C1, 0xa0, I2C_Direction_Receiver); while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED) != SUCCESS); for (i=0; i<size-1; i++) { while(I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_RECEIVED) != SUCCESS); buffer[i] = I2C_ReceiveData(I2C1); } I2C_AcknowledgeConfig(I2C1, DISABLE); I2C_GenerateSTOP(I2C1, ENABLE); while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_RECEIVED) != SUCCESS); buffer[i] = I2C_ReceiveData(I2C1); } int main(void) { uint32_t counter = 0; RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE); RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1, ENABLE); RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB | RCC_APB2Periph_GPIOC | RCC_APB2Periph_GPIOD, ENABLE); RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE); GPIO_InitTypeDef gpio; GPIO_StructInit(&gpio); gpio.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7; //SCL, SDA gpio.GPIO_Mode = GPIO_Mode_AF_OD; gpio.GPIO_Speed = GPIO_Speed_50MHz; GPIO_Init(GPIOB, &gpio); GPIO_StructInit(&gpio); gpio.GPIO_Pin = GPIO_Pin_2; gpio.GPIO_Mode = GPIO_Mode_AF_PP; GPIO_Init(GPIOA, &gpio); gpio.GPIO_Pin = GPIO_Pin_3; gpio.GPIO_Mode = GPIO_Mode_IN_FLOATING; GPIO_Init(GPIOA, &gpio); USART_InitTypeDef uart; USART_StructInit(&uart); uart.USART_BaudRate = 115200; USART_Init(USART2, &uart); USART_Cmd(USART2, ENABLE); I2C_InitTypeDef i2c; I2C_StructInit(&i2c); i2c.I2C_Mode = I2C_Mode_I2C; i2c.I2C_Ack = I2C_Ack_Enable; i2c.I2C_ClockSpeed = 100000; I2C_Init(I2C1, &i2c); I2C_Cmd(I2C1, ENABLE); eeprom_read(0x10, &counter, sizeof(counter)); counter++; printf("Uruchomienie numer %ld\n", counter); // wyświetla eeprom_write(0x10, &counter, sizeof(counter)); eeprom_set_addr(0x00); printf("cokolwiek\n"); //już nie wyświetla I2C_GenerateSTART(I2C1, ENABLE); while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT) != SUCCESS); I2C_AcknowledgeConfig(I2C1, ENABLE); I2C_Send7bitAddress(I2C1, 0xa0, I2C_Direction_Receiver); while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED) != SUCCESS); while(I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_RECEIVED) != SUCCESS); uint8_t data1 = I2C_ReceiveData(I2C1); I2C_AcknowledgeConfig(I2C1, DISABLE); I2C_GenerateSTOP(I2C1, ENABLE); while(I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_RECEIVED) != SUCCESS); uint8_t data2 = I2C_ReceiveData(I2C1); printf("data1: %x/n", data1); //chcę aby wypisywało wartość przez uart printf("data2: %x/n", data2); while(1) { } } Proszę.

Hej. Uznałem, że zrobię sobie "własną" pracę domową i postanowiłem wyświetlić zawartość pamięci pod podanym adresem w terminalu. Problem polega na tym, że po wykonaniu funkcji jak na przykład eeprom_set_addr(0x00); niemożliwe staje się wyświetlenie czegokolwiek z użyciem funkcji printf. Wygląda jakby nagle funkcja wyświetlająca napisy przestawała działać. Program kompiluje się, oraz napis z liczbą uruchomienia MCU działa poprawnie. Macie jakieś pomysły? printf("Uruchomienie numer %ld\n", counter); // wyświetla eeprom_write(0x10, &counter, sizeof(counter)); eeprom_set_addr(0x00); printf("cokolwiek\n"); //już nie wyświetla

Cześć. Czy moglibyście wyjaśnić mi jak działa funkcja lcd_draw_text? void lcd_draw_text(int row, int col, const char* text) { int i; uint8_t* pbuf = &lcd_buffer[row * 84 + col]; while ((*text) && (pbuf < &lcd_buffer[LCD_BUFFER_SIZE - 6])) { int ch = *text++; const uint8_t* font = &font_ASCII[ch - ' '][0]; for (i = 0; i < 5; i++) { *pbuf++ = *font++; } *pbuf++ = 0; } } Podczas wywołania funkcji w następujący sposób lcd_draw_text(0, 0, "c"); na wyświetlaczu pojawia się litera c w pożądanym miejscu. Natomiast jeżeli chcę "wrzucić" w miejsce "c" jakąkolwiek zmienną char w rezultacie dostaje szlaczki. Przykładowo: char x = "c"; lcd_draw_text(0, 0, x); Trochę się tutaj zagubiłem i owszem, robię właśnie zadanie 10.2.

Tak, zrobiłem zadanie 9.1 i 9.2. Zmieniłem wejście na inny port, przykładowo dla GP7 zrobiłem to poprzez modyfikacje rejestru w funkcji read: mcp_read_reg(MCP_GPIO) & 0x40 Zauważyłem, że jeżeli zmienię Ifa tak, aby dioda włączona była bez zwierania przewodu do masy ta dioda nie włącza się. Nie dotykając układu, po załadowaniu kodu np. z zadania 9.2 wszystkie diody świecą normalnie. Podłączenie samego SPI uważam, że jest okej, ponieważ jak inaczej miałyby mi działać poprzednie zadania? while (1) { if ((mcp_read_reg(MCP_GPIO) & 0x40) == 0) { mcp_write_reg(MCP_OLAT, 0x00); } else { mcp_write_reg(MCP_OLAT, 0x01); } } I tak dzięki za pomoc, może sam później jeszcze na coś wpadnę. Tymczasem idę dalej z kursem.

#include "stm32f10x.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 uint8_t spi_sendrecv(uint8_t byte) { // poczekaj az bufor nadawczy bedzie wolny while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET); SPI_I2S_SendData(SPI1, byte); // poczekaj na dane w buforze odbiorczym while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET); return SPI_I2S_ReceiveData(SPI1); } void mcp_write_reg(uint8_t addr, uint8_t value) { GPIO_ResetBits(GPIOC, GPIO_Pin_0); spi_sendrecv(0x40); spi_sendrecv(addr); spi_sendrecv(value); GPIO_SetBits(GPIOC, GPIO_Pin_0); } uint8_t mcp_read_reg(uint8_t addr) { GPIO_ResetBits(GPIOC, GPIO_Pin_0); spi_sendrecv(0x41); spi_sendrecv(addr); uint8_t value = spi_sendrecv(0xff); GPIO_SetBits(GPIOC, GPIO_Pin_0); return value; } int main(void) { GPIO_InitTypeDef gpio; SPI_InitTypeDef spi; RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB | RCC_APB2Periph_GPIOC | RCC_APB2Periph_GPIOD, ENABLE); RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE); RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE); GPIO_StructInit(&gpio); gpio.GPIO_Pin = GPIO_Pin_5|GPIO_Pin_7; // SCK, MOSI gpio.GPIO_Mode = GPIO_Mode_AF_PP; gpio.GPIO_Speed = GPIO_Speed_50MHz; GPIO_Init(GPIOA, &gpio); gpio.GPIO_Pin = GPIO_Pin_6; // MISO gpio.GPIO_Mode = GPIO_Mode_IN_FLOATING; GPIO_Init(GPIOA, &gpio); gpio.GPIO_Pin = GPIO_Pin_0; // CS gpio.GPIO_Mode = GPIO_Mode_Out_PP; GPIO_Init(GPIOC, &gpio); GPIO_SetBits(GPIOC, GPIO_Pin_0); SPI_StructInit(&spi); spi.SPI_Mode = SPI_Mode_Master; spi.SPI_NSS = SPI_NSS_Soft; spi.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_16; SPI_Init(SPI1, &spi); SPI_Cmd(SPI1, ENABLE); mcp_write_reg(MCP_IODIR, ~0x01); mcp_write_reg(MCP_GPPU, 0x02); while (1) { if ((mcp_read_reg(MCP_GPIO) & 0x02) == 0) { mcp_write_reg(MCP_OLAT, 0x01); } else { mcp_write_reg(MCP_OLAT, 0x00); } } } Oto kod, po prostu skopiowany. Poprzedni, z migającym ledem działał poprawnie. Jako przełącznika używam przewodu, który zwieram do masy, albo jest niepodłączony. Podsyłam zdjęcie podłączenia. Profesjonalnie, wiem. Podkreśliłem podłączenie LED-a, pozostałe są do innego ćwiczenia. Do pinu 2 expandera podłączony jest omówiony wcześniej przewód.