int main(void) { SystemInit(); // initialize MCU clocks and registers TM_DELAY_Init(); // initialize Delay library TM_DELAY_SetTime(0); // Reset couter for systime Laser_GPIO_Conf(); // configure GPIO for laser control (to be able to enable/disable lasers via software TM_BKPSRAM_Init(); // initialize BKP RAM access library Laser_Update(); // load laser statuses saved in BKP RAM TM_USART_Init(OUTPUT_USART, OUTPUT_USART_PINS, OUTPUT_USART_SPEED); // initialize UART used for collected Data output TM_USART_Init(MENU_USART, MENU_USART_PINS, MENU_USART_SPEED); // initialize UART used for configuration TM_RTC_Init(TM_RTC_ClockSource_External); // initialize RTC library TM_GPIO_Init(GPIOD, GPIO_Pin_8, TM_GPIO_Mode_OUT, TM_GPIO_OType_PP, TM_GPIO_PuPd_NOPULL, TM_GPIO_Speed_Low); // configure GPIO for GSM status indication (RED LED) TM_GPIO_Init(GPIOD, GPIO_Pin_9, TM_GPIO_Mode_OUT, TM_GPIO_OType_PP, TM_GPIO_PuPd_NOPULL, TM_GPIO_Speed_Low); // configure GPIO for GSM status indication (GREEN LED) Laser_ADC_Init(); // initialize ADC peripherals Menu_Init(); // initialize CLI library sfpInit(); // configure GPIO for SFP modules gsm_Init(); // initialize GSM module /* configure and initialize Ethernet hardware and LwIP stack */ ETH_BSP_Config(); // configure ETH GPIOs printf("Ethernet MAC and PHY configured successfully!\n"); LwIP_Init(); // start LwIP stack printf("LwIP stack initialized successfully!\n"); UDP_Server_Init(); // start UDP Server printf("UDP Server initialized successfully!\n"); //start periodic tasks /* GSM Status update "task" */ GSM_Status_Update_Timer = TM_DELAY_TimerCreate(GSM_CHECK_INTERVAL, 1, 1, GSM_Status_Update_Timer_Task, NULL); printf("GSM status check task created!\n"); /* Print results from remote devices "task" */ Print_Results_Timer = TM_DELAY_TimerCreate(DATA_OUT_INTERVAL, 1, 1, Print_Results_Timer_Task, NULL); printf("Print collected data task created!\n"); /* LaserLock status update "task" */ LaserLock_Timer = TM_DELAY_TimerCreate(1000, 1, 1, LaserLock_Timer_Task, NULL); printf("Laser lock check task created!\n"); while (1) { /* CLI menu update */ Menu_Update(); /* check if any packet received */ if (ETH_CheckFrameReceived()) { /* process received ethernet packet */ LwIP_Pkt_Handle(); } /* handle periodic timers for LwIP */ LwIP_Periodic_Handle(LocalTime); /* update laser statuses */ Laser_Update(); /* remove SMS messages which were read by system */ delete_read_gsm_messages(); } }
int main(void) { /* RCC clocks typedef */ RCC_ClocksTypeDef RCC_Clocks; /* RCC PLL structure */ TM_RCC_PLL_t PLL; /* Initialize system */ SystemInit(); /* Initialize delay, systick has interrupts every 1ms by default */ TM_DELAY_Init(); /* Init USART2, TX: PA2, RX: PA3, 921600 baud */ TM_USART_Init(USART2, TM_USART_PinsPack_1, 921600); /* Get current system clock */ RCC_GetClocksFreq(&RCC_Clocks); /* Print current system clock */ printf("System core clock: %d\n", RCC_Clocks.SYSCLK_Frequency); /* Read PLL settings */ TM_RCC_GetPLL(&PLL); /* Set PLL N to some random value */ PLL.PLLN = 200; /* Change PLL settings */ TM_RCC_SetPLL(&PLL); /* Send something over USART */ printf("This will not be seen correct on USART\n"); /* Reinit everything with new clock */ /* You have to reinit everything what depends on system CLOCK */ /* Like timer prescalers, usarts, i2c, etc */ /* Set new systick preload value */ TM_DELAY_Init(); /* Set new prescalers for USART settings */ TM_USART_Init(USART2, TM_USART_PinsPack_1, 921600); /* Get current system clock */ RCC_GetClocksFreq(&RCC_Clocks); /* Print current system clock */ /* This will be seen on console with new settings */ printf("System core clock after PLL change: %d\n", RCC_Clocks.SYSCLK_Frequency); while (1) { } }
int main(void) { /* Init system */ TM_RCC_InitSystem(); /* Init HAL layer */ HAL_Init(); /* Init leds */ TM_DISCO_LedInit(); /* Init delay */ TM_DELAY_Init(); /* Init USB peripheral */ TM_USB_Init(); /* Init VCP on HS port */ TM_USBD_CDC_Init(TM_USB_HS); /* Start USB device mode on HS port */ TM_USBD_Start(TM_USB_HS); while (1) { /* Process USB CDC device, send remaining data if needed */ /* It is better if you call this in periodic timer, like each ms in SYSTICK handler */ TM_USBD_CDC_Process(TM_USB_HS); /* Check if device is ready, if drivers are installed if needed on HS port */ if (TM_USBD_IsDeviceReady(TM_USB_HS) == TM_USBD_Result_Ok) { /* Turn on green LED */ TM_DISCO_LedOn(LED_GREEN); /* Check if user has changed parameters for COM port */ TM_USBD_CDC_GetSettings(TM_USB_HS, &USB_Settings); /* Check if settings updated from user terminal */ if (USB_Settings.Updated) { /* Reinit USART, only baudrate works in this example */ TM_USART_Init(USART6, TM_USART_PinsPack_1, USB_Settings.Baudrate); } /* Check if anything received on HS port from user */ while (TM_USBD_CDC_Getc(TM_USB_HS, &ch)) { /* One character received */ /* Send character to USART */ TM_USART_Putc(USART6, ch); } /* CHeck if any character received from USART */ while (!TM_USART_BufferEmpty(USART6)) { /* Send data over USB CDC */ TM_USBD_CDC_Putc(TM_USB_HS, TM_USART_Getc(USART6)); } } else { /* Turn off green LED */ TM_DISCO_LedOff(LED_GREEN); } } }
int main(void) { /* Init system clock for maximum system speed */ TM_RCC_InitSystem(); /* Init HAL layer */ HAL_Init(); /* Init leds */ TM_DISCO_LedInit(); /* Init USART, TX: PC6, RX: PC7, 921600 bauds */ TM_USART_Init(USART2, TM_USART_PinsPack_1, 115200); /* Put test string */ TM_USART_Puts(USART2, "Hello world\n"); while (1) { /* Check if we have string "OK" in USART6 buffer */ if (TM_USART_FindString(USART2, "OK")) { /* Send data back from buffer */ while (!TM_USART_BufferEmpty(USART2)) { /* Send to computer */ TM_USART_Putc(USART2, TM_USART_Getc(USART6)); } } } }
int main(void) { /* Init system clock for maximum system speed */ TM_RCC_InitSystem(); /* Init HAL layer */ HAL_Init(); /* Init leds */ TM_DISCO_LedInit(); /* Init button */ TM_DISCO_ButtonInit(); /* Init USART, Pins not initialized yet, 921600 bauds */ TM_USART_Init(USART6, TM_USART_PinsPack_Custom, 921600); /* Put test string */ TM_USART_Puts(USART6, "Hello world\n"); while (1) { /* Check if anything received */ while (!TM_USART_BufferEmpty(USART6)) { /* Send data back from buffer */ TM_USART_Putc(USART6, TM_USART_Getc(USART6)); } } }
uint8_t ESP8266_LL_USARTInit(uint32_t baudrate) { /* Init USART */ TM_USART_Init(ESP8266_USART, ESP8266_USART_PP, baudrate); /* Return 0 = Successful */ return 0; }
int main(void) { /* Initialize system */ SystemInit(); /* Init USART2 on pins TX = PA2, RX = PA3 */ /* This pins are used on Nucleo boards for USB to UART via ST-Link */ TM_USART_Init(USART2, TM_USART_PinsPack_1, 115200); /* Say string without DMA */ TM_USART_Puts(USART2, "Hello via USART2 without DMA\n"); /* Init TX DMA for USART2 */ TM_USART_DMA_Init(USART2); /* Send data with DMA */ TM_USART_DMA_Send(USART2, (uint8_t *)USART_Buffer, strlen(USART_Buffer)); /* Wait till DMA works */ /* You can do other stuff here instead of waiting for DMA to end */ while (TM_USART_DMA_Sending(USART2)); while (1) { /* If any string arrived over USART */ /* Expecting "\n" at the end of string from USART terminal or any other source */ if (TM_USART_Gets(USART2, USART_Buffer, sizeof(USART_Buffer))) { /* Send it back over DMA */ TM_USART_DMA_Send(USART2, (uint8_t *)USART_Buffer, strlen(USART_Buffer)); /* Wait till DMA works */ /* You can do other stuff here instead of waiting for DMA to end */ while (TM_USART_DMA_Sending(USART2)); } } }
int main(void) { char str[15]; //Initialize system SystemInit(); //Initialize Delay library TM_DELAY_Init(); //Initialize USART1-> TX: PA9, RX: PA10 TM_USART_Init(USART1, TM_USART_PinsPack_1, 9600); TM_USART_Puts(USART1, "ADC example"); //Initialize ADC1 on channel 0, this is pin PA0 TM_ADC_Init(ADC1, ADC_Channel_0); //Initialize ADC1 on channel 3, this is pin PA3 TM_ADC_Init(ADC1, ADC_Channel_3); while (1) { // Read ADC1 Channel0 Read ADC1 Channel3 sprintf(str, "%d: %d\n\r", TM_ADC_Read(ADC1, ADC_Channel_0), TM_ADC_Read(ADC1, ADC_Channel_3)); TM_USART_Puts(USART1, str); Delayms(100); } }
int main(void) { /* Init system clock for maximum system speed */ TM_RCC_InitSystem(); /* Init HAL layer */ HAL_Init(); /* Init leds */ TM_DISCO_LedInit(); /* Init button */ TM_DISCO_ButtonInit(); /* Initialize USART, TX: PB6, RX: PB7 */ TM_USART_Init(USART1, TM_USART_PinsPack_2, 115200); /* Initialize NRF24L01+ on channel 15 and 32bytes of payload */ /* By default 2Mbps data rate and 0dBm output power */ /* NRF24L01 goes to RX mode by default */ TM_NRF24L01_Init(15, 32); /* Set RF settings, Data rate to 2Mbps, Output power to -18dBm */ TM_NRF24L01_SetRF(TM_NRF24L01_DataRate_2M, TM_NRF24L01_OutputPower_M18dBm); /* Set my address, 5 bytes */ TM_NRF24L01_SetMyAddress(MyAddress); /* Set TX address, 5 bytes */ TM_NRF24L01_SetTxAddress(TxAddress); while (1) { /* If data is ready on NRF24L01+ */ if (TM_NRF24L01_DataReady()) { /* Get data from NRF24L01+ */ TM_NRF24L01_GetData(dataIn); /* Start send */ TM_DISCO_LedOn(LED_GREEN); /* Send it back, automatically goes to TX mode */ TM_NRF24L01_Transmit(dataIn); /* Wait for data to be sent */ do { /* Wait till sending */ transmissionStatus = TM_NRF24L01_GetTransmissionStatus(); } while (transmissionStatus == TM_NRF24L01_Transmit_Status_Sending); /* Send done */ TM_DISCO_LedOff(LED_GREEN); /* Go back to RX mode */ TM_NRF24L01_PowerUpRx(); } } }
int main(void) { uint16_t i, strposition; /* Init system clock for maximum system speed */ TM_RCC_InitSystem(); /* Init HAL layer */ HAL_Init(); /* Init USART6, TX: PC6, RX: PC7, 921600 bauds */ TM_USART_Init(USART6, TM_USART_PinsPack_1, 921600); /* Create string with 10 predefined locations for strings */ String = TM_STRING_Create(10); /* Add string to memory, allocated memory will be set depending on string length */ TM_STRING_AddString(String, "First string"); /* Add another string to memory, allocated memory will be set depending on string length */ TM_STRING_AddString(String, "Second string"); /* Send strings over USART */ for (i = 0; i < String->Count; i++) { /* Print string to user */ printf("%s\n", String->Strings[i]); } /* Add some strings */ TM_STRING_AddString(String, "Third string"); strposition = TM_STRING_AddString(String, "Forth string"); TM_STRING_AddString(String, "Fifth string"); /* Modify string number 4 */ TM_STRING_ReplaceString(String, strposition, "Updated string"); /* Send strings over USART */ for (i = 0; i < String->Count; i++) { /* Print string to user */ printf("%s\n", String->Strings[i]); } /* Delete string on position 1 = "Second string" */ TM_STRING_DeleteString(String, 1); /* Free entire string memory with all strings */ TM_STRING_FreeAll(String); while (1) { /* Do nothing */ } }
int main(void){ SystemInit(); TM_DELAY_Init(); TM_ILI9341_Init(); TM_ILI9341_SetLayer1(); /* Initialize USART2 at 115200 baud, TX: PD5, RX: PD6 */ TM_USART_Init(USART2, TM_USART_PinsPack_2, 115200); uint8_t wacc = 0x3A; // 0xA6 uint8_t racc = 0x3B; // 0xA7 // 0x2D POWER_CTL: Power-saving features control TM_I2C_Write(I2C2, wacc, 0x2D, 0x08); // 0x31 DATA_FORMAT: Data format control //TM_I2C_Write(I2C1, wacc, 0x31, 0x0B); // FULL_RES and +- 16g TM_I2C_Write(I2C2, wacc, 0x31, 0x01); // fixed resolution and +- 4g // 0x2C BW_RATE: Data rate and power mode control TM_I2C_Write(I2C2, wacc, 0x2C, 0x0A); char str[16] = {0}; sprintf(str, "delay = 100"); TM_USART_Puts(USART2, str); while(1){ TM_ILI9341_Fill(ILI9341_COLOR_WHITE); TM_ILI9341_Puts(30, 30, str, &TM_Font_11x18, ILI9341_COLOR_WHITE, ILI9341_COLOR_BLUE2); uint8_t buff[6] = {0}; int16_t tri[3] = {0}; TM_I2C_ReadMulti(I2C2, racc, 0x32, buff, 6); // original read digit tri[0] = (int16_t) ((uint16_t)buff[1] << 8 | (uint16_t)buff[0]); tri[1] = (int16_t) ((uint16_t)buff[3] << 8 | (uint16_t)buff[2]); tri[2] = (int16_t) ((uint16_t)buff[5] << 8 | (uint16_t)buff[4]); float ftri[3] = {0}, divisor = 128.0f; ftri[0] = (float) tri[0] / divisor; ftri[1] = (float) tri[1] / divisor; ftri[2] = (float) tri[2] / divisor; sprintf(str, "%.3f,%.3f,%.3f\n\r", ftri[0], ftri[1], ftri[2]); TM_USART_Puts(USART2, str); TM_ILI9341_Puts(30, 50, str, &TM_Font_11x18, ILI9341_COLOR_BLACK, ILI9341_COLOR_WHITE); Delayms(100); } }
int main(void) { char buf[30]; uint8_t devices, i, j, count, device[2][8]; /* Initialize system */ SystemInit(); /* Initialize delay */ TM_DELAY_Init(); /* Initialize One Wire on pin PD0 */ TM_OneWire_Init(); /* Initialize USART, TX: PB6, RX: PB7 */ TM_USART_Init(USART1, TM_USART_PinsPack_2, 115200); /* Checks for any device on 1-wire */ devices = TM_OneWire_First(); count = 0; while (devices) { count++; for (i = 0; i < 8; i++) { device[count - 1][i] = TM_OneWire_GetROM(i); } /* Check for new device */ devices = TM_OneWire_Next(); } /* If any devices on 1-wire */ if (count > 0) { sprintf(buf, "Devices found on 1-wire: %d\n\r", count); TM_USART_Puts(USART1, buf); /* Display 64bit rom code */ for (j = 0; j < count; j++) { for (i = 0; i < 8; i++) { sprintf(buf, "0x%02X ", device[j][i]); TM_USART_Puts(USART1, buf); } TM_USART_Puts(USART1, "\n\r"); } } else { TM_USART_Puts(USART1, "No devices on OneWire.\n\r"); } while (1) { } }
int main(void) { /* Initialize system */ SystemInit(); /* Initialize delay */ TM_DELAY_Init(); /* Initiaize button */ TM_DISCO_ButtonInit(); /* Initialize Leds */ TM_DISCO_LedInit(); /* Initialize USART, TX: PB10, RX: PB11 */ TM_USART_Init(USART3, TM_USART_PinsPack_1, 115200); /* Initialize RTC with internal 32768Hz clock */ /* It's not very accurate */ if (!TM_RTC_Init(TM_RTC_ClockSource_Internal)) { /* RTC was first time initialized */ /* Do your stuff here */ /* eg. set default time */ } /* Set wakeup interrupt every 125 ms */ TM_RTC_Interrupts(TM_RTC_Int_125ms); while (1) { /* If button pressed */ if (TM_DISCO_ButtonPressed()) { /* Subseconds are ignored when writing new time */ datatime.hours = 0; datatime.minutes = 59; datatime.seconds = 55; datatime.year = 14; datatime.month = 6; datatime.date = 30; datatime.day = 6; /* Set new time */ TM_RTC_SetDateTime(&datatime, TM_RTC_Format_BIN); } } }
int main(void) { __IO uint32_t i; /* CPU load structure */ TM_CPULOAD_t CPU_LOAD; /* Init CPU load monitor */ TM_CPULOAD_Init(&CPU_LOAD); /* Initialize system */ SystemInit(); /* Initialize delay */ TM_DELAY_Init(); /* Initialize leds on board */ TM_DISCO_LedInit(); /* Init button */ TM_DISCO_ButtonInit(); /* Init USART2, TX: PA2, RX: PA3, 921600 bauds */ TM_USART_Init(USART2, TM_USART_PinsPack_1, 921600); while (1) { /* Check if CPU LOAD variable is updated */ if (CPU_LOAD.Updated) { /* Print to user */ printf("W: %u; S: %u; Load: %5.2f\n", CPU_LOAD.WCNT, CPU_LOAD.SCNT, CPU_LOAD.Load); } /* Toggle leds */ TM_DISCO_LedToggle(LED_ALL); /* If button pressed, do some useless counting */ if (TM_DISCO_ButtonPressed()) { /* Count something to waste some time before entering to sleep mode */ i = 0; while (i++ < 0x1FFF); } /* Go low power mode, sleep mode until interrupt, measure CPU load */ TM_CPULOAD_GoToSleepMode(&CPU_LOAD, TM_LOWPOWERMODE_SleepUntilInterrupt); } }
int main(void) { /* Init system clock for maximum system speed */ TM_RCC_InitSystem(); /* Init HAL layer */ HAL_Init(); /* Initialize delay */ TM_DELAY_Init(); /* Initialize leds on board */ TM_DISCO_LedInit(); /* Init button */ TM_DISCO_ButtonInit(); /* Init USART6, TX: PC6, 921600 baud */ TM_USART_Init(USART6, TM_USART_PinsPack_1, 921600); /* Get system reset source and clear flags after read */ printf("System reset source: %d\n", (uint8_t)TM_GENERAL_GetResetSource(1)); /* Get system reset source and clear flags after read */ /* You should see number which corresponds to "None", because we cleared flags in statement above */ printf("System reset source: %d\n", (uint8_t)TM_GENERAL_GetResetSource(1)); /* Get system core and PCLK1 (Peripheral Clock 1, APB1) clocks */ printf("System core clock: %u Hz; PCLK1 clock: %u Hz\n", TM_GENERAL_GetClockSpeed(TM_GENERAL_Clock_SYSCLK), TM_GENERAL_GetClockSpeed(TM_GENERAL_Clock_PCLK1) ); while (1) { /* If button pressed */ if (TM_DISCO_ButtonOnPressed()) { /* Send to USER */ printf("Software reset will happen in a moment\n"); /* Wait a little */ Delayms(500); /* Perform system software reset */ TM_GENERAL_SystemReset(); } } }
int main(void) { TM_RCC_InitSystem(); /* Init system */ HAL_Init(); /* Init HAL layer */ TM_DISCO_LedInit(); /* Init leds */ TM_DISCO_ButtonInit(); /* Init button */ TM_DELAY_Init(); /* Init delay */ TM_USART_Init(DEBUG_USART, DEBUG_USART_PP, 921600); /* Init USART for debug purpose */ /* Print first screen message */ printf("ESP8266 commands parser; Compiled: %s %s\r\n", __DATE__, __TIME__); /* Initialize threads */ ESP_Update_ThreadId = osThreadCreate(osThread(ESP_Update), NULL); ESP_Main_ThreadId = osThreadCreate(osThread(ESP_Main), NULL); /* Start kernel */ osKernelStart(); while (1) { } }
int main(void) { uint8_t c; //Initialize system SystemInit(); TM_DELAY_Init(); //Initialize USART1 at 9600 baud, TX: PA9, RX: PA10 TM_USART_Init(USART1, TM_USART_PinsPack_1, 9600); //Put string to terminal TM_USART_Puts(USART1, "Hello world\n\r"); while (1) { //Get character from internal buffer c = TM_USART_Getc(USART1); if (c) { //If anything received, put it back to terminal TM_USART_Putc(USART1, c); } } }
int main(void) { /* Init system clock for maximum system speed */ TM_RCC_InitSystem(); /* Init HAL layer */ HAL_Init(); /* Init USART, check USART lib description for pinout */ TM_USART_Init(USART, TM_USART_PinsPack_1, 921600); /* Say string without DMA */ TM_USART_Puts(USART, "Hello via USART without DMA\n"); /* Init TX DMA for USART */ TM_USART_DMA_Init(USART); /* Enable interrupts for TX DMA */ TM_USART_DMA_EnableInterrupts(USART); /* Send data with DMA */ TM_USART_DMA_Send(USART, (uint8_t *)USART_Buffer, strlen(USART_Buffer)); /* Wait till DMA works */ /* You can do other stuff here instead of waiting for DMA to end */ while (TM_USART_DMA_Transmitting(USART)); while (1) { /* If any string arrived over USART */ /* Expecting "\n" at the end of string from USART terminal or any other source */ if (TM_USART_Gets(USART, USART_Buffer, sizeof(USART_Buffer))) { /* Send it back over DMA */ TM_USART_DMA_Send(USART, (uint8_t *)USART_Buffer, strlen(USART_Buffer)); /* Wait till DMA works */ /* You can do other stuff here instead of waiting for DMA to end */ while (TM_USART_DMA_Transmitting(USART)); } } }
int main(void) { char buffer[20]; /* Initialize system */ SystemInit(); /* Initialize delay */ TM_DELAY_Init(); /* Initialize USART1, TX: PB6 */ TM_USART_Init(USART1, TM_USART_PinsPack_2, 115200); /* Initialize random number generator */ TM_RNG_Init(); while (1) { /* Get number */ sprintf(buffer, "Number: %u\n", TM_RNG_Get()); /* Put to USART */ TM_USART_Puts(USART1, buffer); Delayms(1000); } }
/* Public */ void TM_GPS_Init(TM_GPS_Data_t* GPS_Data, uint32_t baudrate) { /* Initialize USART */ TM_USART_Init(GPS_USART, GPS_USART_PINSPACK, baudrate); /* Set first-time variable */ TM_GPS_FirstTime = 1; /* Clear all flags */ TM_GPS_INT_ClearFlags(); /* Set flags used */ #ifndef GPS_DISABLE_GPGGA TM_GPS_Flags_OK |= GPS_FLAG_LATITUDE; TM_GPS_Flags_OK |= GPS_FLAG_NS; TM_GPS_Flags_OK |= GPS_FLAG_LONGITUDE; TM_GPS_Flags_OK |= GPS_FLAG_EW; TM_GPS_Flags_OK |= GPS_FLAG_SATS; TM_GPS_Flags_OK |= GPS_FLAG_FIX; TM_GPS_Flags_OK |= GPS_FLAG_ALTITUDE; TM_GPS_Flags_OK |= GPS_FLAG_TIME; #endif #ifndef GPS_DISABLE_GPRMC TM_GPS_Flags_OK |= GPS_FLAG_SPEED; TM_GPS_Flags_OK |= GPS_FLAG_DATE; TM_GPS_Flags_OK |= GPS_FLAG_VALIDITY; TM_GPS_Flags_OK |= GPS_FLAG_DIRECTION; #endif #ifndef GPS_DISABLE_GPGSA TM_GPS_Flags_OK |= GPS_FLAG_HDOP; TM_GPS_Flags_OK |= GPS_FLAG_VDOP; TM_GPS_Flags_OK |= GPS_FLAG_PDOP; TM_GPS_Flags_OK |= GPS_FLAG_FIXMODE; TM_GPS_Flags_OK |= GPS_FLAG_SATS1_12; #endif #ifndef GPS_DISABLE_GPGSV TM_GPS_Flags_OK |= GPS_FLAG_SATSINVIEW; #endif }
void USART_Config() { TM_USART_Init(USART1, TM_USART_PinsPack_1, 115200); TM_USART_SetCustomStringEndCharacter(USART1, '\r'); TM_USART_Init(USART3, TM_USART_PinsPack_1, 115200); TM_USART_SetCustomStringEndCharacter(USART3, '\r'); }
int main(void) { TM_NRF24L01_Transmit_Status_t transmissionStatus; char str[40]; //Initialize system SystemInit(); //Initialize system and Delay functions TM_DELAY_Init(); //Initialize onboard leds TM_DISCO_LedInit(); //Initialize USART, TX: PB6, RX: PB7 TM_USART_Init(USART1, TM_USART_PinsPack_2, 115200); //Initialize NRF24L01+ on channel 15 and 32bytes of payload //By default 2Mbps data rate and 0dBm output power //NRF24L01 goes to RX mode by default TM_NRF24L01_Init(15, 32); //Set 2MBps data rate and -18dBm output power TM_NRF24L01_SetRF(TM_NRF24L01_DataRate_2M, TM_NRF24L01_OutputPower_M18dBm); //Set my address, 5 bytes TM_NRF24L01_SetMyAddress(MyAddress); //Set TX address, 5 bytes TM_NRF24L01_SetTxAddress(TxAddress); //Reset counter TM_DELAY_SetTime(0); while (1) { //Every 2 seconds if (TM_DELAY_Time() > 2000000) { //Fill data with something sprintf((char *)dataOut, "abcdefghijklmnoszxABCDEFCBDA"); //Display on USART TM_USART_Puts(USART1, "pinging: "); //Reset time, start counting microseconds TM_DELAY_SetTime(0); //Transmit data, goes automatically to TX mode TM_NRF24L01_Transmit(dataOut); TM_DISCO_LedOn(LED_PIN); //Wait for data to be sent do { transmissionStatus = TM_NRF24L01_GetTransmissionStatus(); } while (transmissionStatus == TM_NRF24L01_Transmit_Status_Sending); TM_DISCO_LedOff(LED_PIN); //Go back to RX mode TM_NRF24L01_PowerUpRx(); //Wait received data, wait max 100ms, if time is larger, than data was probably lost while (!TM_NRF24L01_DataReady() && TM_DELAY_Time() < 100000); //Format time sprintf(str, "%d us", TM_DELAY_Time()); //Show ping time TM_USART_Puts(USART1, str); //Get data from NRF2L01+ TM_NRF24L01_GetData(dataIn); //Check transmit status if (transmissionStatus == TM_NRF24L01_Transmit_Status_Ok) { //Transmit went OK TM_USART_Puts(USART1, ": OK\n\r"); } else if (transmissionStatus == TM_NRF24L01_Transmit_Status_Lost) { //Message was LOST TM_USART_Puts(USART1, ": LOST\n\r"); } else { //This should never happen TM_USART_Puts(USART1, ": SENDING\n\r"); } } } }
int main(void) { char buffer[50]; /* Working structure */ TM_BMP180_t BMP180_Data; /* Initialize system */ SystemInit(); /* Initialize delay */ TM_DELAY_Init(); /* Initialize USART1, 11500baud, TX: PB6 */ TM_USART_Init(USART1, TM_USART_PinsPack_2, 115200); /* Initialize BMP180 pressure sensor */ if (TM_BMP180_Init(&BMP180_Data) == TM_BMP180_Result_Ok) { /* Init OK */ TM_USART_Puts(USART1, "BMP180 configured and ready to use\n\n"); } else { /* Device error */ TM_USART_Puts(USART1, "BMP180 error\n\n"); while (1); } /* Imagine, we are at 1000 meters above the sea */ /* And we read pressure of 95000 pascals */ /* Pressure right on the sea is */ sprintf(buffer, "Pressure right above the sea: %d pascals\n", TM_BMP180_GetPressureAtSeaLevel(95000, 1000)); TM_USART_Puts(USART1, buffer); sprintf(buffer, "Data were calculated from pressure %d pascals at know altitude %d meters\n\n\n", 95000, 1000); TM_USART_Puts(USART1, buffer); while (1) { /* Start temperature conversion */ TM_BMP180_StartTemperature(&BMP180_Data); /* Wait delay in microseconds */ /* You can do other things here instead of delay */ Delay(BMP180_Data.Delay); /* Read temperature first */ TM_BMP180_ReadTemperature(&BMP180_Data); /* Start pressure conversion at ultra high resolution */ TM_BMP180_StartPressure(&BMP180_Data, TM_BMP180_Oversampling_UltraHighResolution); /* Wait delay in microseconds */ /* You can do other things here instead of delay */ Delay(BMP180_Data.Delay); /* Read pressure value */ TM_BMP180_ReadPressure(&BMP180_Data); /* Format data and print to USART */ sprintf(buffer, "Temp: %2.3f degrees\nPressure: %6d Pascals\nAltitude at current pressure: %3.2f meters\n\n", BMP180_Data.Temperature, BMP180_Data.Pressure, BMP180_Data.Altitude ); /* Send to USART */ TM_USART_Puts(USART1, buffer); /* Some delay */ Delayms(1000); } }
int main(void) { uint8_t i; float temp; /* Initialize system */ SystemInit(); /* Delay init */ TM_DELAY_Init(); /* Initialize GPS on 115200 baudrate */ TM_GPS_Init(&GPS_Data, 115200); /* Initialize USART2 for debug */ /* TX = PA2 */ TM_USART_Init(USART2, TM_USART_PinsPack_1, 115200); /* Version 1.1 added */ /* Set two test coordinates */ GPS_Distance.Latitude1 = 48.300215; GPS_Distance.Longitude1 = -122.285903; GPS_Distance.Latitude2 = 45.907813; GPS_Distance.Longitude2 = 56.659407; /* Calculate distance and bearing between 2 points */ TM_GPS_DistanceBetween(&GPS_Distance); /* Convert float number */ TM_GPS_ConvertFloat(GPS_Distance.Distance, &GPS_Float, 6); printf("Distance is: %d.%06d meters\n", GPS_Float.Integer, GPS_Float.Decimal); TM_GPS_ConvertFloat(GPS_Distance.Bearing, &GPS_Float, 6); printf("Bearing is: %d.%06d degrees\n\n", GPS_Float.Integer, GPS_Float.Decimal); /* Reset counter */ TM_DELAY_SetTime(0); while (1) { /* Update GPR data */ /* Call this as faster as possible */ result = TM_GPS_Update(&GPS_Data); /* If we have any unread data */ if (result == TM_GPS_Result_NewData) { /* We received new packet of useful data from GPS */ current = TM_GPS_Result_NewData; /* Is GPS signal valid? */ if (GPS_Data.Validity) { /* If you want to make a GPS tracker, now is the time to save your data on SD card */ /* We have valid GPS signal */ printf("New received data have valid GPS signal\n"); printf("---------------------------------------\n"); #ifndef GPS_DISABLE_GPGGA /* GPGGA data */ printf("GPGGA statement:\n"); /* Latitude */ /* Convert float to integer and decimal part, with 6 decimal places */ TM_GPS_ConvertFloat(GPS_Data.Latitude, &GPS_Float, 6); printf(" - Latitude: %d.%d\n", GPS_Float.Integer, GPS_Float.Decimal); /* Longitude */ /* Convert float to integer and decimal part, with 6 decimal places */ TM_GPS_ConvertFloat(GPS_Data.Longitude, &GPS_Float, 6); printf(" - Longitude: %d.%d\n", GPS_Float.Integer, GPS_Float.Decimal); /* Satellites in use */ printf(" - Sats in use: %02d\n", GPS_Data.Satellites); /* Current time */ printf(" - UTC Time: %02d.%02d.%02d:%02d\n", GPS_Data.Time.Hours, GPS_Data.Time.Minutes, GPS_Data.Time.Seconds, GPS_Data.Time.Hundredths); /* Fix: 0 = invalid, 1 = GPS, 2 = DGPS */ printf(" - Fix: %d\n", GPS_Data.Fix); /* Altitude */ /* Convert float to integer and decimal part, with 6 decimal places */ TM_GPS_ConvertFloat(GPS_Data.Altitude, &GPS_Float, 6); printf(" - Altitude: %3d.%06d\n", GPS_Float.Integer, GPS_Float.Decimal); #endif #ifndef GPS_DISABLE_GPRMC /* GPRMC data */ printf("GPRMC statement:\n"); /* Current date */ printf(" - Date: %02d.%02d.%04d\n", GPS_Data.Date.Date, GPS_Data.Date.Month, GPS_Data.Date.Year + 2000); /* Current speed in knots */ TM_GPS_ConvertFloat(GPS_Data.Speed, &GPS_Float, 6); printf(" - Speed in knots: %d.%06d\n", GPS_Float.Integer, GPS_Float.Decimal); /* Current speed in km/h */ temp = TM_GPS_ConvertSpeed(GPS_Data.Speed, TM_GPS_Speed_KilometerPerHour); TM_GPS_ConvertFloat(temp, &GPS_Float, 6); printf(" - Speed in km/h: %d.%06d\n", GPS_Float.Integer, GPS_Float.Decimal); TM_GPS_ConvertFloat(GPS_Data.Direction, &GPS_Float, 3); printf(" - Direction: %3d.%03d\n", GPS_Float.Integer, GPS_Float.Decimal); #endif #ifndef GPS_DISABLE_GPGSA /* GPGSA data */ printf("GPGSA statement:\n"); /* Horizontal dilution of precision */ TM_GPS_ConvertFloat(GPS_Data.HDOP, &GPS_Float, 2); printf(" - HDOP: %2d.%02d\n", GPS_Float.Integer, GPS_Float.Decimal); /* Vertical dilution of precision */ TM_GPS_ConvertFloat(GPS_Data.VDOP, &GPS_Float, 2); printf(" - VDOP: %2d.%02d\n", GPS_Float.Integer, GPS_Float.Decimal); /* Position dilution of precision */ TM_GPS_ConvertFloat(GPS_Data.PDOP, &GPS_Float, 2); printf(" - PDOP: %2d.%02d\n", GPS_Float.Integer, GPS_Float.Decimal); /* Current fix mode in use */ printf(" - Fix mode: %d\n", GPS_Data.FixMode); /* Display IDs of satellites in use */ printf(" - ID's of used satellites: "); for (i = 0; i < GPS_Data.Satellites; i++) { printf("%d,", GPS_Data.SatelliteIDs[i]); } printf("\n"); #endif #ifndef GPS_DISABLE_GPGSV /* GPGSV data */ printf("GPGSV statement:\n"); /* Satellites in view */ printf(" - Satellites in view: %d\n", GPS_Data.SatellitesInView); /* Print satellites description */ for (i = 0; i < GPS_Data.SatellitesInView; i++) { printf(" - S: %02d, A: %03d, E: %02d, SNR: %02d\n", GPS_Data.SatDesc[i].ID, GPS_Data.SatDesc[i].Azimuth, GPS_Data.SatDesc[i].Elevation, GPS_Data.SatDesc[i].SNR ); } #endif printf("---------------------------------------\n"); } else { /* GPS signal is not valid */ printf("New received data haven't valid GPS signal!\n"); } } else if (result == TM_GPS_Result_FirstDataWaiting && current != TM_GPS_Result_FirstDataWaiting) { current = TM_GPS_Result_FirstDataWaiting; printf("Waiting first data from GPS!\n"); } else if (result == TM_GPS_Result_OldData && current != TM_GPS_Result_OldData) { current = TM_GPS_Result_OldData; /* We already read data, nothing new was received from GPS */ } } }
int main(void) { int accelData[3]; int analogData[BUFFER]; int i=0; for(i=0;i<BUFFER;i++){ analogData[i]=0; } int a = 0; int analogIn = 0; int analogMin, analogMax; /* Initialize system */ SystemInit(); /* Initialize delay */ //TM_DELAY_Init(); /* Initialize PG13 (GREEN LED) and PG14 (RED LED) */ TM_GPIO_Init(GPIOG, GPIO_PIN_13 | GPIO_PIN_14, TM_GPIO_Mode_OUT, TM_GPIO_OType_PP, TM_GPIO_PuPd_NOPULL, TM_GPIO_Speed_Fast); TM_GPIO_SetPinValue(GPIOG, GPIO_PIN_14, 1); // Red: ON #ifdef ENABLE_USART /* Initialize USART1 at 115200 baud, TX: PA10, RX: PA9 */ TM_USART_Init(USART1, TM_USART_PinsPack_1, 115200); #endif #ifdef ENABLE_VCP /* Initialize USB Virtual Comm Port */ TM_USB_VCP_Result status = TM_USB_VCP_NOT_CONNECTED; while (TM_USB_VCP_GetStatus() != TM_USB_VCP_CONNECTED) { TM_USB_VCP_Init(); TM_GPIO_TogglePinValue(GPIOG, GPIO_PIN_14); Delay(500000); } SendString("USB VCP initialized and connected\n"); TM_GPIO_TogglePinValue(GPIOG, GPIO_PIN_14 | GPIO_PIN_13); // Red: OFF, Gr: ON #endif #ifdef ENABLE_MMA /* Initialize MMA845X */ uint8_t mma_status = MMA845X_Initialize(MMA_RANGE_4G); if (mma_status == MMA_OK) { SendString("MMA initialized\n"); } else { SendString("MMA initialization failed, error code: "); // Add 48 to the byte value to have character representation, (48 = '0') SendChar('0'+mma_status); SendChar('\n'); } #endif /* Initialize Display */ TM_ILI9341_Init(); TM_ILI9341_Rotate(TM_ILI9341_Orientation_Portrait_1); TM_ILI9341_SetLayer1(); TM_ILI9341_Fill(ILI9341_COLOR_BLACK); /* Fill data on layer 1 */ /* Initialize ADC1 */ TM_ADC_Init(CURRENT_ADC, CURRENT_CH); /* Initialize PE2 and PE3 for digital output (Motor direction) */ TM_GPIO_Init(GPIOE, GPIO_PIN_2 | GPIO_PIN_3, TM_GPIO_Mode_OUT, TM_GPIO_OType_PP, TM_GPIO_PuPd_NOPULL, TM_GPIO_Speed_Fast); // Set them to HIGH/LOW TM_GPIO_SetPinHigh(GPIOE, GPIO_PIN_3); TM_GPIO_SetPinLow(GPIOE, GPIO_PIN_2); #ifdef ENABLE_PWM /* Set up PE5 (in front of PE4) for PWM (TIM9 CH1 PP2) (Motor speed control) */ TM_PWM_TIM_t TIM9_Data; // Set PWM to 1kHz frequency on timer TIM4, 1 kHz = 1ms = 1000us TM_PWM_InitTimer(TIM9, &TIM9_Data, 1000); // Initialize PWM on TIM9, Channel 1 and PinsPack 2 = PE5 TM_PWM_InitChannel(&TIM9_Data, TM_PWM_Channel_1, TM_PWM_PinsPack_2); // Set channel 1 value, 50% duty cycle TM_PWM_SetChannelPercent(&TIM9_Data, TM_PWM_Channel_1, 50); #endif /* Initialize DAC channel 2, pin PA5 (Shaker control) */ //TM_DAC_Init(TM_DAC2); /* Set 12bit analog value of 2047/4096 * 3.3V */ //TM_DAC_SetValue(TM_DAC2, 4096); #ifdef ENABLE_DAC // DAC PIN PA5 /* Initialize DAC1, use TIM4 for signal generation */ TM_DAC_SIGNAL_Init(TM_DAC2, TIM4); /* Output predefined triangle signal with frequency of 5kHz */ TM_DAC_SIGNAL_SetSignal(TM_DAC2, TM_DAC_SIGNAL_Signal_Sinus, 50); #endif /* MAIN LOOP */ while (1) { // Read acceleration data #ifdef ENABLE_MMA MMA845X_ReadAcceleration(accelData); #endif // Read analog input analogData[a] = TM_ADC_Read(CURRENT_ADC, CURRENT_CH); a++; if(a==BUFFER) {a=0;} // Analog average analogIn=0; analogMax=0; analogMin=4096; for(i=0;i<BUFFER;i++){ if(analogData[i] > analogMax) { analogMax = analogData[i]; } if(analogData[i] < analogMin) { analogMin = analogData[i]; } analogIn+=analogData[i]; } analogIn/=BUFFER; // Print graphs printGraphsLCD(accelData, analogData[a], analogIn, analogMin, analogMax); // Toggle Green led TM_GPIO_TogglePinValue(GPIOG, GPIO_PIN_13); } }
int main(void) { uint8_t i; /* Initialize system */ SystemInit(); /* Delay init */ TM_DELAY_Init(); /* Initialize GPS on 115200 baudrate */ TM_GPS_Init(&GPS_Data, 115200); /* Initialize USART2 for debug */ /* TX = PA2 */ TM_USART_Init(USART2, TM_USART_PinsPack_1, 115200); /* Register custom GPGxx statements */ /* $GPRMC statement, term number 7 = Speed over ground in knots */ GPRMC = TM_GPS_AddCustom(&GPS_Data, "$GPRMC", 7); /* $GPGLL statement, term number 1 = Current latitude */ GPGLL = TM_GPS_AddCustom(&GPS_Data, "$GPGLL", 1); /* $GPGSA statement, term number 1 = M = Manual, forced to operate in 2D or 3D A=Automatic, 3D/2D */ GPGSA = TM_GPS_AddCustom(&GPS_Data, "$GPGSA", 1); /* Add here more custom tags you want */ /* ... */ /* Reset counter */ TM_DELAY_SetTime(0); while (1) { /* Update GPR data */ /* Call this as faster as possible */ result = TM_GPS_Update(&GPS_Data); /* If we have any unread data */ if (result == TM_GPS_Result_NewData) { /* We received new packet of useful data from GPS */ current = TM_GPS_Result_NewData; /* Is GPS signal valid? */ if (GPS_Data.Validity) { /* If you want to make a GPS tracker, now is the time to save your data on SD card */ /* We have valid GPS signal */ printf("New received data have valid GPS signal\n"); printf("---------------------------------------\n"); /* We have all data from GPS_Data structure valid, you can do here what you want */ /* We will in this example show only custom data to user */ /* Print custom statements */ printf("Custom statements defined by user:\n"); /* Go through all custom statements */ for (i = 0; i < GPS_Data.CustomStatementsCount; i++) { printf(" - Statement: %s; TermNumber: %d; Value: %s\n", GPS_Data.CustomStatements[i]->Statement, /*!< Statement value */ GPS_Data.CustomStatements[i]->TermNumber, /*!< Term number */ GPS_Data.CustomStatements[i]->Value /*!< Value from GPS receiver */ ); } /* You can do it this way too for all your custom statements separatelly */ printf(" - Statement2: %s; TermNumber: %d; Value: %s\n", GPRMC->Statement, GPRMC->TermNumber, GPRMC->Value ); printf("---------------------------------------\n"); } else { /* GPS signal is not valid */ printf("New received data haven't valid GPS signal!\n"); } } else if (result == TM_GPS_Result_FirstDataWaiting && current != TM_GPS_Result_FirstDataWaiting) { current = TM_GPS_Result_FirstDataWaiting; printf("Waiting first data from GPS!\n"); } else if (result == TM_GPS_Result_OldData && current != TM_GPS_Result_OldData) { current = TM_GPS_Result_OldData; /* We already read data, nothing new was received from GPS */ } } }
int main(void) { TM_KEYPAD_Button_t Keypad_Button; char buff[20]; /* Initialize system */ SystemInit(); /* Initialize leds */ TM_DISCO_LedInit(); /* Initialize USART 1, TX: PB6 */ TM_USART_Init(USART1, TM_USART_PinsPack_2, 115200); /* Initialize matrix keyboard */ TM_KEYPAD_Init(TM_KEYPAD_Type_Large); while (1) { /* Read keyboard data */ Keypad_Button = TM_KEYPAD_Read(); /* Keypad was pressed */ if (Keypad_Button != TM_KEYPAD_Button_NOPRESSED) {/* Keypad is pressed */ switch (Keypad_Button) { case TM_KEYPAD_Button_0: /* Button 0 pressed */ TM_DISCO_LedToggle(LED_GREEN | LED_RED | LED_BLUE | LED_ORANGE); break; case TM_KEYPAD_Button_1: /* Button 1 pressed */ TM_DISCO_LedOn(LED_GREEN); break; case TM_KEYPAD_Button_2: /* Button 2 pressed */ TM_DISCO_LedOff(LED_GREEN); break; case TM_KEYPAD_Button_3: /* Button 3 pressed */ TM_DISCO_LedOn(LED_RED); break; case TM_KEYPAD_Button_4: /* Button 4 pressed */ TM_DISCO_LedOff(LED_RED); break; case TM_KEYPAD_Button_5: /* Button 5 pressed */ TM_DISCO_LedOn(LED_ORANGE); break; case TM_KEYPAD_Button_6: /* Button 6 pressed */ TM_DISCO_LedOff(LED_ORANGE); break; case TM_KEYPAD_Button_7: /* Button 7 pressed */ TM_DISCO_LedOn(LED_BLUE); break; case TM_KEYPAD_Button_8: /* Button 8 pressed */ TM_DISCO_LedOff(LED_BLUE); break; case TM_KEYPAD_Button_9: /* Button 9 pressed */ /* Do your stuff here */ break; case TM_KEYPAD_Button_STAR: /* Button STAR pressed */ TM_DISCO_LedOn(LED_GREEN | LED_RED | LED_BLUE | LED_ORANGE); break; case TM_KEYPAD_Button_HASH: /* Button HASH pressed */ TM_DISCO_LedOff(LED_GREEN | LED_RED | LED_BLUE | LED_ORANGE); break; case TM_KEYPAD_Button_A: /* Button A pressed, only on large keyboard */ /* Do your stuff here */ break; case TM_KEYPAD_Button_B: /* Button B pressed, only on large keyboard */ /* Do your stuff here */ break; case TM_KEYPAD_Button_C: /* Button C pressed, only on large keyboard */ /* Do your stuff here */ break; case TM_KEYPAD_Button_D: /* Button D pressed, only on large keyboard */ /* Do your stuff here */ break; default: break; } sprintf(buff, "Pressed: %u us\n", (uint8_t)Keypad_Button); TM_USART_Puts(USART1, buff); } } }
int main(void) { char str[100]; // char buffer1[100]; // /* Free and total space */ // uint32_t total, free; /* Initialize system */ SystemInit(); /* Initialize delays */ TM_DELAY_Init(); /* Enable watchdog, 4 seconds before timeout */ if (TM_WATCHDOG_Init(TM_WATCHDOG_Timeout_8s)) { /* Report to user */ //printf("Reset occured because of Watchdog\n"); } /* Reset counter to 0 */ TM_DELAY_SetTime(0); /* init DTMF*/ TM_GPIO_Init(DTMF_BIT0_PORT, DTMF_BIT0_PIN, TM_GPIO_Mode_IN, TM_GPIO_OType_PP, TM_GPIO_PuPd_NOPULL, TM_GPIO_Speed_Low); TM_GPIO_Init(DTMF_BIT1_PORT, DTMF_BIT1_PIN, TM_GPIO_Mode_IN, TM_GPIO_OType_PP, TM_GPIO_PuPd_NOPULL, TM_GPIO_Speed_Low); TM_GPIO_Init(DTMF_BIT2_PORT, DTMF_BIT2_PIN, TM_GPIO_Mode_IN, TM_GPIO_OType_PP, TM_GPIO_PuPd_NOPULL, TM_GPIO_Speed_Low); TM_GPIO_Init(DTMF_BIT3_PORT, DTMF_BIT3_PIN, TM_GPIO_Mode_IN, TM_GPIO_OType_PP, TM_GPIO_PuPd_NOPULL, TM_GPIO_Speed_Low); /* DTMF*/ if (TM_EXTI_Attach(DFMF_BIT4_PORT, DTMF_BIT4_PIN, TM_EXTI_Trigger_Rising) == TM_EXTI_Result_Ok) { TM_USART_Puts(USART3, "khoi tao ngat DFMF_BIT4\n"); } /*init interrup INPUT*/ if (TM_EXTI_Attach(W1_D0_PORT, W1_D0_PIN, TM_EXTI_Trigger_Rising) == TM_EXTI_Result_Ok) { TM_USART_Puts(USART3, "khoi tao ngat W1_D0\n"); } if (TM_EXTI_Attach(W1_D1_PORT, W1_D1_PIN, TM_EXTI_Trigger_Rising) == TM_EXTI_Result_Ok) { TM_USART_Puts(USART3, "khoi tao ngat W1_D1\n"); } if (TM_EXTI_Attach(W2_D1_PORT, W2_D1_PIN, TM_EXTI_Trigger_Falling) == TM_EXTI_Result_Ok) { TM_USART_Puts(USART3, "khoi tao ngat W2_D1\n"); } if (TM_EXTI_Attach(W2_D0_PORT, W2_D0_PIN, TM_EXTI_Trigger_Falling) == TM_EXTI_Result_Ok) { TM_USART_Puts(USART3, "khoi tao ngat W2_D0\n"); // W2D0 } /*init SWADD*/ TM_GPIO_Init(ADD_BIT0_PORT, ADD_BIT0_PIN, TM_GPIO_Mode_IN, TM_GPIO_OType_PP, TM_GPIO_PuPd_UP, TM_GPIO_Speed_Medium); TM_GPIO_Init(ADD_BIT1_PORT, ADD_BIT1_PIN, TM_GPIO_Mode_IN, TM_GPIO_OType_PP, TM_GPIO_PuPd_UP, TM_GPIO_Speed_Medium); TM_GPIO_Init(ADD_BIT2_PORT, ADD_BIT2_PIN, TM_GPIO_Mode_IN, TM_GPIO_OType_PP, TM_GPIO_PuPd_UP, TM_GPIO_Speed_Medium); TM_GPIO_Init(ADD_BIT3_PORT, ADD_BIT3_PIN, TM_GPIO_Mode_IN, TM_GPIO_OType_PP, TM_GPIO_PuPd_UP, TM_GPIO_Speed_Medium); TM_GPIO_Init(ADD_BIT4_PORT, ADD_BIT4_PIN, TM_GPIO_Mode_IN, TM_GPIO_OType_PP, TM_GPIO_PuPd_UP, TM_GPIO_Speed_Medium); TM_GPIO_Init(ADD_BIT5_PORT, ADD_BIT5_PIN, TM_GPIO_Mode_IN, TM_GPIO_OType_PP, TM_GPIO_PuPd_UP, TM_GPIO_Speed_Medium); TM_GPIO_Init(ADD_BIT6_PORT, ADD_BIT6_PIN, TM_GPIO_Mode_IN, TM_GPIO_OType_PP, TM_GPIO_PuPd_UP, TM_GPIO_Speed_Medium); TM_GPIO_Init(ADD_BIT7_PORT, ADD_BIT7_PIN, TM_GPIO_Mode_IN, TM_GPIO_OType_PP, TM_GPIO_PuPd_UP, TM_GPIO_Speed_Medium); /* init OUTPUT*/ TM_GPIO_Init(RELAY_DK1_PORT, RELAY_DK1_PIN, TM_GPIO_Mode_OUT, TM_GPIO_OType_PP, TM_GPIO_PuPd_NOPULL, TM_GPIO_Speed_High); TM_GPIO_Init(RELAY_DK2_PORT, RELAY_DK2_PIN, TM_GPIO_Mode_OUT, TM_GPIO_OType_PP, TM_GPIO_PuPd_NOPULL, TM_GPIO_Speed_High); TM_GPIO_Init(RELAY_DK3_PORT, RELAY_DK3_PIN, TM_GPIO_Mode_OUT, TM_GPIO_OType_PP, TM_GPIO_PuPd_NOPULL, TM_GPIO_Speed_High); TM_GPIO_Init(RELAY_DK4_PORT, RELAY_DK4_PIN, TM_GPIO_Mode_OUT, TM_GPIO_OType_PP, TM_GPIO_PuPd_NOPULL, TM_GPIO_Speed_High); /* Initialize USART6 at 115200 baud, TX: PC6, RX: PC7 , COM 1 - RFID1 gan cong tac nguon*/ TM_USART_Init(USART6, TM_USART_PinsPack_1, 115200); /* Initialize USART3 at 115200 baud, TX: PD8, RX: PD9 , COM 2 -RFID 2 gan ethernet*/ TM_USART_Init(USART3, TM_USART_PinsPack_3, 115200); /* Initialize USART1 at 115200 baud, TX: PA9, RX: PA10, CONG 485 */ TM_USART_Init(USART1, TM_USART_PinsPack_1, 9600); /* Initialize USART2, with custom pins */ // COM 3 extension PC //TM_USART_Init(USART2, TM_USART_PinsPack_Custom,9600); TM_USART_Init(USART2, TM_USART_PinsPack_2,9600); /* int DIR 485 set = send , reset = recvice*/ TM_GPIO_Init(CCU_DIR_PORT, CCU_DIR_PIN, TM_GPIO_Mode_OUT, TM_GPIO_OType_PP, TM_GPIO_PuPd_UP, TM_GPIO_Speed_High); TM_GPIO_SetPinHigh(CCU_DIR_PORT,CCU_DIR_PIN); /* Init 2 custom timers */ /* Timer1 has reload value each 500ms, enabled auto reload feature and timer is enabled */ CustomTimer1 = TM_DELAY_TimerCreate(500, 1, 1, CustomTIMER1_Task, NULL); /* Timer1 has reload value each 1000ms, enabled auto reload feature and timer is enabled */ CustomTimer2 = TM_DELAY_TimerCreate(100, 1, 1, CustomTIMER2_Task, NULL); /* Init LCD*/ TM_GPIO_Init(HD44780_RW_PORT, HD44780_RW_PIN, TM_GPIO_Mode_OUT, TM_GPIO_OType_PP, TM_GPIO_PuPd_NOPULL, TM_GPIO_Speed_High); TM_GPIO_SetPinLow(HD44780_RW_PORT,HD44780_RW_PIN); read_sw_add(); timeout = value_dip; memset(str,'\0',0); //Initialize LCD 20 cols x 4 rows TM_HD44780_Init(16, 4); //Save custom character on location 0 in LCD TM_HD44780_CreateChar(0, &customChar[0]); //Put string to LCD TM_HD44780_Puts(0, 0, "STM32F407VET\n\rCreartbyR&D-TIS"); /* 0 dong 1, 1 dong 2*/ TM_HD44780_Puts(0, 2, "Welcome"); Delayms(1000); TM_HD44780_Clear(); sprintf(str,"Timer out %d", timeout); TM_HD44780_Puts(0, 0,str); Delayms(1000); TM_HD44780_Clear(); TM_HD44780_Puts(0, 0,"----TIS8 PRO----"); //TM_USART_Puts(USART3, "Welcome2"); /*creat by duc*/ TM_WATCHDOG_Reset(); // TM_USART_BufferEmpty(USART3); // TM_USART_BufferEmpty(USART6); flag_RFID2=0; flag_RFID1=0; /*end by duc*/ while (1) { /*process 485*/ if(flag_485){ flag_485=0; if(LEDStatus==0) TM_USART_Puts(USART1, "/LED000>\r\n"); if(LEDStatus==1) TM_USART_Puts(USART1, "/LED001>\r\n"); if(LEDStatus==2) TM_USART_Puts(USART1, "/LED002>\r\n"); } /* xu li W1D0 - dk1*/ if(flag_W1D0){ turn_on_dk1(); //flag_W1D0=0; } /* xu li W1D1 - dk2*/ if(flag_W1D1){ turn_on_dk2(); //flag_W1D1=0; } //TM_WATCHDOG_Reset(); // /*end*/ if(Process!=1) TM_HD44780_Puts(0, 2,"Wait for Card"); /* 0 dong 1, 1 dong 2*/ if(flag_RFID1==1) { Process=1; IDCAR1[0]=BufferCom1[4]; IDCAR1[1]=BufferCom1[5]; IDCAR1[2]=BufferCom1[6]; IDCAR1[3]=BufferCom1[7]; IDCAR1[4]=BufferCom1[8]; IDCAR1[5]=BufferCom1[9]; IDCAR1[6]=BufferCom1[10]; if(BufferCom1[1]==0x08) { sprintf(UID1,"%02x %02x %02x %02x,1",IDCAR1[0],IDCAR1[1],IDCAR1[2],IDCAR1[3]); } if(BufferCom1[1]==0x0B) { sprintf(UID1,"%02x %02x %02x %02x %02x %02x %02x,1",IDCAR1[0],IDCAR1[1],IDCAR1[2],IDCAR1[3],IDCAR1[4],IDCAR1[5],IDCAR1[6]); } TM_HD44780_Puts(0, 2,"Waiting PC..."); /* 0 dong 1, 1 dong 2*/ if(check_vip(UID1)){ flag_PC=1; flag_R11=1; timerdk1 =0; Process=0; } else{ if(Process)TM_USART_Puts(USART2,UID1); } WaitPC(200); flag_RFID1=0; if(flag_PC) { TM_HD44780_Puts(0, 2,"Door opened.."); /* 0 dong 1, 1 dong 2*/ flag_PC=0; ProcessAction(); } else Process=0; flag_RFID1=0; } if(flag_RFID2==1) { Process=1; IDCAR2[0]=BufferCom2[4]; IDCAR2[1]=BufferCom2[5]; IDCAR2[2]=BufferCom2[6]; IDCAR2[3]=BufferCom2[7]; IDCAR2[4]=BufferCom2[8]; IDCAR2[5]=BufferCom2[9]; IDCAR2[6]=BufferCom2[10]; if(BufferCom2[1]==0x08) { sprintf(UID2,"%02x %02x %02x %02x ,2",IDCAR2[0],IDCAR2[1],IDCAR2[2],IDCAR2[3]); } if(BufferCom2[1]==0x0B) { sprintf(UID2,"%02x %02x %02x %02x %02x %02x %02x ,2",IDCAR2[0],IDCAR2[1],IDCAR2[2],IDCAR2[3],IDCAR2[4],IDCAR2[5],IDCAR2[6]); } TM_HD44780_Puts(0, 2,"Waiting PC..."); /* 0 dong 1, 1 dong 2*/ if(check_vip(UID2)){ flag_PC=1; flag_R31=1; timerdk2 =0; Process=0; } else{ if(Process)TM_USART_Puts(USART2,UID2);} WaitPC(200); flag_RFID2=0; if(flag_PC) { TM_HD44780_Puts(0, 2,"Door opened.."); /* 0 dong 1, 1 dong 2*/ flag_PC=0; ProcessAction(); } else Process=0; flag_RFID2=0; } /**/ timer_dk1 = timerdk1/2; if (timer_dk1 >= timeout){ turn_off_dk1(); flag_R11 =0; flag_W1D0=0; timerdk1=0; timer_dk1=0; flag_RFID1=0; flag_RFID2=0; Process=0; // if(LEDStatus==0) TM_USART_Puts(USART3, "/LED000>\r\n"); } timer_dk2 = timerdk2/2; if (timer_dk2 >= timeout){ turn_off_dk2(); //flag_R21 =0; flag_R31 =0; flag_W1D1=0; timerdk2=0; timer_dk2=0; //flag_RFID1=0; Process=0; // if(LEDStatus==0) TM_USART_Puts(USART3, "/LED000>\r\n"); } timer_dk3 = timerdk3; if (timer_dk3 >= 1){ turn_off_dk3(); flag_R12 =0; timerdk3=0; timer_dk3=0; } timer_dk4 = timerdk4; if (timer_dk4 >= 1){ turn_off_dk4(); flag_R22 =0; timer_dk4=0; timerdk4=0; } TM_WATCHDOG_Reset(); } }
int main(void) { /* Initialize system */ SystemInit(); /* Init USART6, TX: PC6 for debug */ TM_USART_Init(USART6, TM_USART_PinsPack_1, 115200); /* Enable watchdog, 4 seconds before timeout */ if (TM_WATCHDOG_Init(TM_WATCHDOG_Timeout_4s)) { /* Report to user */ printf("Reset occured because of Watchdog\n"); } /* Initialize delay */ TM_DELAY_Init(); /* Initialize leds on board */ TM_DISCO_LedInit(); /* Initialize button */ TM_DISCO_ButtonInit(); /* Display to user */ printf("Program starting..\n"); /* Initialize ethernet peripheral */ /* All parameters NULL, default options for MAC, static IP, gateway and netmask will be used */ /* They are defined in tm_stm32f4_ethernet.h file */ if (TM_ETHERNET_Init(NULL, NULL, NULL, NULL) == TM_ETHERNET_Result_Ok) { /* Successfully initialized */ TM_DISCO_LedOn(LED_GREEN); } else { /* Unsuccessfull communication */ TM_DISCO_LedOn(LED_RED); } /* Reset watchdog */ TM_WATCHDOG_Reset(); while (1) { /* Update ethernet, call this as fast as possible */ TM_ETHERNET_Update(); /* If DNS is not working and we don't have IP yet */ if (MyDNS.Working == 0 && MyDNS.HaveIP == 0) { /* Try to start DNS */ /* It will return error in case Ethernet is not ready yet so you have to try more than one time */ if (TM_ETHERNETDNS_GetHostByName("stm32f4-discovery.com") == TM_ETHERNET_Result_Ok) { /* We started with working */ MyDNS.Working = 1; } } /* On button pressed, make a new connection and if we have IP known */ if (TM_DISCO_ButtonOnPressed() && MyDNS.HaveIP) { /* Try to make a new connection, port 80 */ if (TM_ETHERNETCLIENT_Connect("stm32f4-discovery.com", MyDNS.ip[0], MyDNS.ip[1], MyDNS.ip[2], MyDNS.ip[3], 80, &requests_count) != TM_ETHERNET_Result_Ok) { /* Print to user */ printf("Can not make a new connection!\n"); } } /* Reset watchdog */ TM_WATCHDOG_Reset(); } }
int main(void) { /* Init system */ TM_RCC_InitSystem(); /* Init HAL layer */ HAL_Init(); /* Init leds */ TM_DISCO_LedInit(); /* Init button */ TM_DISCO_ButtonInit(); /* Init delay */ TM_DELAY_Init(); /* Init debug USART */ TM_USART_Init(USART2, TM_USART_PinsPack_1, 921600); /* Display message */ printf("ESP8266 AT commands parser\r\n"); /* Init ESP module */ while (ESP8266_Init(&ESP8266, 115200) != ESP_OK) { printf("Problems with initializing module!\r\n"); } /* Set mode to STA+AP */ while (ESP8266_SetMode(&ESP8266, ESP8266_Mode_STA_AP) != ESP_OK); /* Enable server on port 80 */ while (ESP8266_ServerEnable(&ESP8266, 80) != ESP_OK); /* Module is connected OK */ printf("Initialization finished!\r\n"); /* Disconnect from wifi if connected */ ESP8266_WifiDisconnect(&ESP8266); #if ESP8266_USE_APSEARCH /* Get a list of all stations */ ESP8266_ListWifiStations(&ESP8266); #endif /* Wait till finishes */ ESP8266_WaitReady(&ESP8266); /* Connect to wifi and save settings */ ESP8266_WifiConnect(&ESP8266, "YOUR SSID", "SSID PASSWORD"); /* Wait till finish */ ESP8266_WaitReady(&ESP8266); /* Get connected devices */ ESP8266_WifiGetConnected(&ESP8266); while (1) { /* Update ESP module */ ESP8266_Update(&ESP8266); /* Check for button */ if (TM_DISCO_ButtonOnPressed()) { /* Starting with connection to web */ while (ESP8266_StartClientConnection(&ESP8266, "stm32f4_discovery", "stm32f4-discovery.com", 80, NULL)); } } }