int main(void) {
/* Init system clock for maximum system speed */
TM_RCC_InitSystem();
/* Init HAL layer */
HAL_Init();
/* Init leds */
TM_DISCO_LedInit();
/* Attach EXTI pin, enable both edges because of different boards support */
if (TM_EXTI_Attach(TM_DISCO_BUTTON_PORT, TM_DISCO_BUTTON_PIN, TM_EXTI_Trigger_Rising_Falling) == TM_EXTI_Result_Ok) {
/* Turn on green LED */
TM_DISCO_LedOn(LED_GREEN);
} else {
/* Turn on RED led */
TM_DISCO_LedOn(LED_RED);
}
while (1) {
/* Do nothing, wait user to press button */
}
}
int main(void) {
/* Initialize system */
SystemInit();
/* Initialize LEDS */
TM_DISCO_LedInit();
/* Attach interrupt on pin PA0 = External line 0 */
/* Button connected on discovery boards */
if (TM_EXTI_Attach(GPIOA, GPIO_Pin_0, TM_EXTI_Trigger_Rising) == TM_EXTI_Result_Ok) {
TM_DISCO_LedOn(LED_RED);
}
/* Attach interrupt on pin PC13 = External line 13 */
/* Button connected on nucleo boards */
if (TM_EXTI_Attach(GPIOC, GPIO_Pin_13, TM_EXTI_Trigger_Falling) == TM_EXTI_Result_Ok) {
TM_DISCO_LedOn(LED_GREEN);
}
while (1) {
}
}
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();
/* Check if system reset because of IWDG */
if (TM_IWDG_Init(TM_IWDG_Timeout_4s)) {
/* System reset was done because of IWDG timer */
TM_DISCO_LedOn(LED_RED);
} else {
/* No IWDG */
TM_DISCO_LedOn(LED_GREEN);
}
/* If there is no LED active (F7-Discovery, Nucleo boards), */
/* then system reset occurred because of IWDG */
while (1) {
/* Check for button */
if (TM_DISCO_ButtonPressed()) {
/* Wait till pressed */
/* If pressed more than 4 seconds in a row, system will reset because of IWDG timer */
while (TM_DISCO_ButtonPressed());
}
/* Reset watchdog */
TM_IWDG_Reset();
}
}
int main(void) {
/* Init system clock for maximum system speed */
TM_RCC_InitSystem();
/* Init HAL layer */
HAL_Init();
/* Init leds */
TM_DISCO_LedInit();
/* Try to mount card */
if (f_mount(&FS, "SD:", 1) == FR_OK) {
/* Try to open file */
if ((fres = f_open(&fil, "SD:first_file.txt", FA_OPEN_ALWAYS | FA_READ | FA_WRITE)) == FR_OK) {
/* Read SDCARD size */
TM_FATFS_GetDriveSize("SD:", &CardSize);
/* Format string */
sprintf(buffer, "Total card size: %u kBytes\n", CardSize.Total);
/* Write total card size to file */
f_puts(buffer, &fil);
/* Format string for free card size */
sprintf(buffer, "Free card size: %u kBytes\n", CardSize.Free);
/* Write free card size to file */
f_puts(buffer, &fil);
/* Close file */
f_close(&fil);
/* Turn led ON */
TM_DISCO_LedOn(LED_ALL);
}
/* Unmount SDCARD */
f_mount(NULL, "SD:", 1);
}
/* Do nothing */
while (1) {
}
}
int main(void) {
/* Initialize System */
SystemInit();
/* Initialize leds on board */
TM_DISCO_LedInit();
/* Initialize button on board */
TM_DISCO_ButtonInit();
while(1) {
/* If button pressed */
if (TM_DISCO_ButtonPressed()) {
/* Turn on leds */
TM_DISCO_LedOn(LED_RED | LED_GREEN);
} else {
/* Turn off leds */
TM_DISCO_LedOff(LED_RED | 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 button */
TM_DISCO_ButtonInit();
/* For pinouts, check TM_MPU6050 library */
/* Try to init MPU6050, device address is 0xD0, AD0 pin is set to low */
if (TM_MPU6050_Init(&MPU6050, TM_MPU6050_Device_0, TM_MPU6050_Accelerometer_8G, TM_MPU6050_Gyroscope_250s) == TM_MPU6050_Result_Ok) {
/* Green LED on */
TM_DISCO_LedOn(LED_GREEN);
}
while (1) {
/* Read everything from device */
TM_MPU6050_ReadAll(&MPU6050);
/* Raw data are available for use as needed */
//MPU6050.Accelerometer_X;
//MPU6050.Accelerometer_Y;
//MPU6050.Accelerometer_Z;
//MPU6050.Gyroscope_X;
//MPU6050.Gyroscope_Y;
//MPU6050.Gyroscope_Z;
//MPU6050.Temperature;
/* Delay a little */
Delayms(1);
}
}
int main(void) {
/* Initialize System */
SystemInit();
/* Initialize leds on board */
TM_DISCO_LedInit();
/* Initialize button on board */
TM_DISCO_ButtonInit();
while(1) {
/* If button pressed, do stuff all the time button is pressed */
if (TM_DISCO_ButtonPressed()) {
/* Turn on leds */
TM_DISCO_LedOn(LED_RED | LED_GREEN);
} else {
/* Turn off leds */
TM_DISCO_LedOff(LED_RED | LED_GREEN);
}
/* Do the stuff only once when button is pressed */
if (TM_DISCO_ButtonOnPressed()) {
/* Do here stuff only once */
/* This function will return 0 until you release button and press it again */
/* For example, you can send data here to USART, but only once when button is pressed */
GPIOD->BSRRL = LED_BLUE;
}
/* Do the stuff only once when button is released */
if (TM_DISCO_ButtonOnReleased()) {
/* DO here stuff only once */
/* This function will return 0 until you press button and release it again */
GPIOD->BSRRH = LED_BLUE;
}
}
}
void TM_ILI9341_Init() {
//Initialize pins used
TM_ILI9341_InitPins();
//SPI chip select high
ILI9341_CS_SET;
//Init SPI
TM_SPI_Init(ILI9341_SPI, ILI9341_SPI_PINS);
//Init SDRAM
TM_DISCO_LedInit();
if (!TM_SDRAM_Init()) {
TM_DISCO_LedOn(LED_RED);
}
//Initialize LCD for LTDC
TM_ILI9341_InitLCD();
//Initialize LTDC
TM_LCD9341_InitLTDC();
//Initialize LTDC layers
TM_ILI9341_InitLayers();
//Set cursor X and Y
ILI9341_x = ILI9341_y = 0;
ILI9341_Opts.Width = ILI9341_WIDTH;
ILI9341_Opts.Height = ILI9341_HEIGHT;
ILI9341_Opts.Orientation = TM_ILI9341_Portrait;
ILI9341_Opts.Orient = TM_ILI9341_Orientation_Portrait_1;
ILI9341_Opts.CurrentLayer = 0;
ILI9341_Opts.CurrentLayerOffset = 0;
ILI9341_Opts.Layer1Opacity = 255;
ILI9341_Opts.Layer2Opacity = 0;
TM_ILI9341_SetLayer1();
TM_ILI9341_Fill(ILI9341_COLOR_WHITE);
TM_ILI9341_SetLayer2();
TM_ILI9341_Fill(ILI9341_COLOR_WHITE);
TM_ILI9341_SetLayer1();
}
int main(void) {
/* Initialize system */
SystemInit();
/* Initialize delay */
TM_DELAY_Init();
/* Initialize leds on board */
TM_DISCO_LedInit();
/* Turn on all leds */
TM_DISCO_LedOn(LED_ALL);
/* Delay 2 seconds */
Delayms(2000);
while (1) {
/* Toggle leds */
TM_DISCO_LedToggle(LED_ALL);
/* Wait 500ms */
Delayms(500);
}
}
void TM_SNAKE_Start(void) {
/* Initialize delay */
TM_DELAY_Init();
/* Initialize leds on board */
TM_DISCO_LedInit();
/* Turn off all leds */
TM_DISCO_LedOff(LED_ALL);
/* Initialize True random number generator */
TM_RNG_Init();
/* Initialize ILI9341 LCD */
TM_ILI9341_Init();
TM_ILI9341_Rotate(TM_ILI9341_Orientation_Portrait_2);
/* Initialize USB HID Host for keyboard */
TM_USB_HIDHOST_Init();
/* Set default options */
TM_SNAKE_SetFirstOptions();
/* Set default values */
TM_SNAKE_SetDefaultSnake();
/* Prepare display */
TM_SNAKE_PrepareDisplay();
/* Generate random target */
TM_SNAKE_GenerateTarget();
/* Set time to 0 */
TM_DELAY_SetTime(0);
while (1) {
/* Process USB HID host */
TM_USB_HIDHOST_Process();
/* Check for timeout, move snake here */
if (TM_DELAY_Time() >= Settings.Millis && !Settings.Pause && !GameOver) {
/* Reset time */
TM_DELAY_SetTime(0);
/* Get new direction value */
Snake.Direction = Snake1.Direction;
/* Get last x/y value from snake array = snake head */
Snake_Head[0] = Snake.Snake[Snake.LastIndex][0];
Snake_Head[1] = Snake.Snake[Snake.LastIndex][1];
/* Store last value before update */
Snake_Head_Last[0] = Snake_Head[0];
Snake_Head_Last[1] = Snake_Head[1];
if (!Snake_FirstTime) {
/* Move snake */
switch (Snake.Direction) {
case SNAKE_DIRECTION_LEFT:
Snake_Head[0] -= 1;
break;
case SNAKE_DIRECTION_RIGHT:
Snake_Head[0] += 1;
break;
case SNAKE_DIRECTION_UP:
Snake_Head[1] -= 1;
break;
case SNAKE_DIRECTION_DOWN:
Snake_Head[1] += 1;
break;
default:
break;
}
}
/* Overflow is activated */
if (Settings.Overflow) {
/* Check X */
if (Snake_Head[0] == -1) {
Snake_Head[0] = SNAKE_PIXELS - 1;
} else if (Snake_Head[0] == SNAKE_PIXELS) {
Snake_Head[0] = 0;
}
/* Check Y */
if (Snake_Head[1] == -1) {
Snake_Head[1] = SNAKE_PIXELS - 1;
} else if (Snake_Head[1] == SNAKE_PIXELS) {
Snake_Head[1] = 0;
}
} else {
/* Check walls */
if (
Snake_Head[0] == -1 ||
Snake_Head[0] == SNAKE_PIXELS ||
Snake_Head[1] == -1 ||
Snake_Head[1] == SNAKE_PIXELS
) {
/* We hit the wall somewhere */
GameOver = 1;
}
}
if (!Snake_FirstTime) {
/* Clear first value from array = snake foot */
TM_SNAKE_DeleteFromArray(0, Snake_Foot);
/* Check if snake hit itself */
if (TM_SNAKE_MatchesSnakeLocations(Snake_Head)) {
/* Set gameover flag */
GameOver = 1;
}
}
/* Check if target is reached */
if (
!GameOver &&
Snake_Head[0] == Snake_Food[0] &&
Snake_Head[1] == Snake_Food[1]
) {
/* Add new value to the array, increase snake */
TM_SNAKE_AddToArray(Snake_Head);
/* Increase counter for snake hits */
Snake.Hits++;
/* Generate new target */
TM_SNAKE_GenerateTarget();
}
if (!GameOver) {
if (!Snake_FirstTime) {
/* Add new value to the array = new snake head */
TM_SNAKE_AddToArray(Snake_Head);
}
/* Clear pixel on LCD for foot */
/* First clear foot, maybe is new head on the same position */
TM_SNAKE_DrawPixel(Snake_Foot[0], Snake_Foot[1], 0);
/* Draw pixel on LCD for new head position with head color */
TM_SNAKE_DrawPixel(Snake_Head[0], Snake_Head[1], 3);
/* Draw new pixel for the second pixel after head with new color to delete head color */
TM_SNAKE_DrawPixel(Snake_Head_Last[0], Snake_Head_Last[1], 1);
}
/* Clear flag if needed */
if (Snake_FirstTime) {
Snake_FirstTime = 0;
}
}
if (GameOver) {
/* Check flag */
if (!GameOverDisplay) {
/* Set flag */
GameOverDisplay = 1;
/* Show content to user */
TM_ILI9341_Puts(88, 120, "Game\nOVER", &TM_Font_16x26, ILI9341_COLOR_WHITE, ILI9341_COLOR_BLACK);
TM_ILI9341_Puts(28, 180, "Press 'r' to start again!!", &TM_Font_7x10, ILI9341_COLOR_WHITE, ILI9341_COLOR_BLACK);
}
} else {
/* Clear flag */
GameOverDisplay = 0;
}
/* Check if connected device is keyboard */
if (TM_USB_HIDHOST_Device() == TM_USB_HIDHOST_Result_KeyboardConnected) {
/* Green LED ON */
TM_DISCO_LedOn(LED_GREEN);
/* Read keyboard data */
TM_USB_HIDHOST_ReadKeyboard(&Keyboard);
/* If any buttons active */
if (Keyboard.ButtonStatus == TM_USB_HIDHOST_Button_Pressed) {
/* Check pressed button and do actions */
switch ((uint8_t)Keyboard.Button) {
case SNAKE_KEY_LEFT:
/* Change direction if possible */
if (
Snake.Direction == SNAKE_DIRECTION_UP ||
Snake.Direction == SNAKE_DIRECTION_DOWN ||
Snake.Direction == SNAKE_DIRECTION_LEFT
) {
/* Disable pause mode */
Settings.Pause = 0;
/* Set direction */
Snake1.Direction = SNAKE_DIRECTION_LEFT;
}
break;
case SNAKE_KEY_RIGHT:
/* Change direction if possible */
if (
Snake.Direction == SNAKE_DIRECTION_UP ||
Snake.Direction == SNAKE_DIRECTION_DOWN ||
Snake.Direction == SNAKE_DIRECTION_RIGHT
) {
/* Disable pause mode */
Settings.Pause = 0;
/* Set direction */
Snake1.Direction = SNAKE_DIRECTION_RIGHT;
}
break;
case SNAKE_KEY_UP:
/* Change direction if possible */
if (
Snake.Direction == SNAKE_DIRECTION_LEFT ||
Snake.Direction == SNAKE_DIRECTION_RIGHT ||
Snake.Direction == SNAKE_DIRECTION_UP
) {
/* Disable pause mode */
Settings.Pause = 0;
/* Set direction */
Snake1.Direction = SNAKE_DIRECTION_UP;
}
break;
case SNAKE_KEY_DOWN:
/* Change direction if possible */
if (
Snake.Direction == SNAKE_DIRECTION_LEFT ||
Snake.Direction == SNAKE_DIRECTION_RIGHT ||
Snake.Direction == SNAKE_DIRECTION_DOWN
) {
/* Disable pause mode */
Settings.Pause = 0;
/* Set direction */
Snake1.Direction = SNAKE_DIRECTION_DOWN;
}
break;
case SNAKE_KEY_SPEED_UP:
/* Increase speed if possible */
TM_SNAKE_SpeedUp();
break;
case SNAKE_KEY_SPEED_DOWN:
/* Decrease speed if possible */
TM_SNAKE_SpeedDown();
break;
case SNAKE_KEY_PAUSE:
/* Toggle pause */
if (Settings.Pause) {
Settings.Pause = 0;
} else {
Settings.Pause = 1;
}
break;
case SNAKE_KEY_RESET:
/* Draw snake area */
TM_SNAKE_DrawArea();
/* Set default snake, leave as it was before */
TM_SNAKE_SetDefaultSnake();
/* Generate random target */
TM_SNAKE_GenerateTarget();
/* Disable gameover */
GameOver = 0;
/* Reset first time flag */
Snake_FirstTime = 1;
break;
case SNAKE_KEY_OVERFLOW:
/* Toggle overflow mode */
if (Settings.Overflow) {
Settings.Overflow = 0;
} else {
Settings.Overflow = 1;
}
break;
default:
break;
}
}
} else {
/* Green LED OFF */
TM_DISCO_LedOff(LED_GREEN);
}
/* Update LCD with changed settings */
/* Check overflow */
if (Settings1.Overflow != Settings.Overflow || Settings1.Speed != Settings.Speed) {
/* Save new */
Settings1.Overflow = Settings.Overflow;
/* Save new */
Settings1.Speed = Settings.Speed;
/* Display game mode and speed */
sprintf(Buffer, "Mode:%4d; Speed: %2d/%2d", Settings.Overflow, Settings.Speed, SNAKE_SPEED_MAX);
TM_ILI9341_Puts(10, SNAKE_TEXT_LINE1, Buffer, &TM_Font_7x10, 0x0000, SNAKE_COLOR_MAIN_BCK);
}
/* Check snake hits */
if (Snake1.Hits != Snake.Hits) {
/* Save new */
Snake1.Hits = Snake.Hits;
/* Display Speed */
sprintf(Buffer, "Hits:%4d; Score: %5d", Snake.Hits, (2 - Settings.Overflow) * Snake.Hits * Settings.Speed);
TM_ILI9341_Puts(10, SNAKE_TEXT_LINE2, Buffer, &TM_Font_7x10, 0x0000, SNAKE_COLOR_MAIN_BCK);
}
}
}
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) {
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) {
/* 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 RTC with internal clock if not already */
if (!TM_RTC_Init(TM_RTC_ClockSource_Internal)) {
/* Set default time for RTC */
/* Set date and time if RTC is not initialized already */
TM_RTC_SetDateTimeString("28.02.15.6;23:35:30");
};
/* 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();
/* Initialize ethernet server if you want use it, server port 80 */
TM_ETHERNETSERVER_Enable(80);
/* Set SSI tags, we have 21 SSI tags */
TM_ETHERNETSERVER_SetSSITags(SSI_Tags, 21);
/* Set CGI tags, we have 1 CGI handler, for leds only */
TM_ETHERNETSERVER_SetCGIHandlers(CGI_Handlers, 1);
/* Read RTC clock */
TM_RTC_GetDateTime(&RTC_Data, TM_RTC_Format_BIN);
/* Print current time to USART */
printf("Current date: %02d:%02d:%02d\n", RTC_Data.hours, RTC_Data.minutes, RTC_Data.seconds);
/* Reset watchdog */
TM_WATCHDOG_Reset();
while (1) {
/* Update ethernet, call this as fast as possible */
TM_ETHERNET_Update();
/* If button pressed, toggle server status */
if (TM_DISCO_ButtonOnPressed()) {
/* If server is enabled */
if (TM_ETHERNETSERVER_Enabled()) {
/* Disable it */
TM_ETHERNETSERVER_Disable();
/* Print to user */
printf("Server disabled\n");
} else {
/* Enable it */
TM_ETHERNETSERVER_Enable(80);
/* Print to user */
printf("Server enabled\n");
}
}
/* Reset watchdog */
TM_WATCHDOG_Reset();
}
}
int main(void) {
char buf[40];
uint8_t devices, i, j, count, alarm_count;
uint8_t device[EXPECTING_SENSORS][8];
uint8_t alarm_device[EXPECTING_SENSORS][8];
float temps[EXPECTING_SENSORS];
/* Initialize system */
SystemInit();
/* Initialize delay */
TM_DELAY_Init();
/* Initialize OneWire on pin PD0 */
TM_OneWire_Init();
/* Initialize USART, TX: PB6, RX: PB7 */
TM_USART_Init(USART1, TM_USART_PinsPack_2, 115200);
/* Initialize Leds */
TM_DISCO_LedInit();
/* Turn leds on */
TM_DISCO_LedOn(LED_RED | LED_GREEN);
/* Checks for any device on 1-wire */
devices = TM_OneWire_First();
count = 0;
while (devices) {
count++;
/* Get full ROM value, 8 bytes, give location of first byte where to save */
TM_OneWire_GetFullROM(&device[count - 1][0]);
/* Get next device */
devices = TM_OneWire_Next();
}
/* If any devices on 1wire */
if (count > 0) {
sprintf(buf, "Devices found on 1-wire: %d\n\r", count);
TM_USART_Puts(USART1, buf);
/* Display 64bit rom code for each device */
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");
}
/* Go through all connected devices and set resolution to 12bits */
for (i = 0; i < count; i++) {
TM_DS18B20_SetResolution(&device[i][0], TM_DS18B20_Resolution_12bits);
}
/* Set high temperature alarm on device number 0, 25degrees celcius */
TM_DS18B20_SetAlarmHighTemperature(&device[0][0], 25);
/* Disable alarm temperatures on device number 1 */
TM_DS18B20_DisableAlarmTemperature(&device[1][0]);
while (1) {
/* Start temperature conversion on all bits */
TM_DS18B20_StartAll();
/* Wait until all are done */
while (!TM_DS18B20_AllDone());
/* Read temperature from each device separatelly */
for (i = 0; i < count; i++) {
/* Read temperature from ROM address and store it to temps variable */
TM_DS18B20_Read(&device[i][0], &temps[i]);
/* Print temperature */
sprintf(buf, "Temp %d: %3.5f; ", i, temps[i]);
TM_USART_Puts(USART1, buf);
}
alarm_count = 0;
/* Check if any device has alarm flag set */
while (TM_DS18B20_AlarmSearch()) {
/* Store ROM of device which has alarm flag set */
TM_OneWire_GetFullROM(&alarm_device[alarm_count][0]);
alarm_count++;
}
sprintf(buf, "alarm: %d\n\r", alarm_count);
TM_USART_Puts(USART1, buf);
/* Any device has alarm flag set? */
if (alarm_count > 0) {
TM_USART_Puts(USART1, "THIS DEVICES HAVE ALARM!\n\r ");
/* Show rom of this devices */
for (j = 0; j < alarm_count; j++) {
for (i = 0; i < 8; i++) {
sprintf(buf, "0x%02X ", alarm_device[j][i]);
TM_USART_Puts(USART1, buf);
}
TM_USART_Puts(USART1, "\n\r ");
}
TM_USART_Puts(USART1, "ALARM devices recognized!\n\r");
}
/* Some delay */
Delayms(1000);
}
}
int main(void) {
//TM_STMPE811_TouchData instance
TM_STMPE811_TouchData touchData;
//TM_ILI9341_Button_t instance
TM_ILI9341_Button_t button;
int8_t buttonPressed, button1, button2, button3;
char str[30];
//Initialize system
SystemInit();
//Initialize onboard leds
TM_DISCO_LedInit();
//Initialize LCD
TM_ILI9341_Init();
//Fill LCD with gray color
TM_ILI9341_Fill(ILI9341_COLOR_GRAY);
//Select orientation
TM_ILI9341_Rotate(TM_ILI9341_Orientation_Portrait_2);
//Select touch screen orientation
touchData.orientation = TM_STMPE811_Orientation_Portrait_2;
//Initialize Touch
TM_STMPE811_Init();
//Button 1, default configuration
//Red with black border and black font 11x18
button.x = 10;
button.y = 30;
button.width = 219;
button.height = 50;
button.background = ILI9341_COLOR_RED;
button.borderColor = ILI9341_COLOR_BLACK;
button.label = "Button 1";
button.color = ILI9341_COLOR_BLACK;
button.font = &TM_Font_11x18;
//Add button
button1 = TM_ILI9341_Button_Add(&button);
//Button with custom background and without label
button.x = 10;
button.y = 260;
button.width = 105;
button.height = 50;
button.background = ILI9341_COLOR_GREEN;
button.borderColor = ILI9341_COLOR_BLACK;
button.label = "Button 2";
//Use background image and no label
button.flags = TM_BUTTON_FLAG_NOLABEL | TM_BUTTON_FLAG_IMAGE;
button.color = ILI9341_COLOR_BLACK;
button.font = &TM_Font_11x18;
button.image = buttonBackground; //Variable stored in
//Add button
button2 = TM_ILI9341_Button_Add(&button);
//Button with custom background and with label and without border and 7x10 fontsize
button.x = 125;
button.y = 260;
button.background = ILI9341_COLOR_BLUE2;
button.borderColor = ILI9341_COLOR_BLACK;
button.label = "Button 3";
button.color = ILI9341_COLOR_BLACK;
button.font = &TM_Font_7x10;
button.flags = TM_BUTTON_FLAG_IMAGE | TM_BUTTON_FLAG_NOBORDER; //Use background image, without border
//Add button
button3 = TM_ILI9341_Button_Add(&button);
if (!TM_DISCO_LedIsOn(LED_RED)) {
//If led res is turned off, disable buttons 2 and 3
TM_ILI9341_Button_Disable(button2);
TM_ILI9341_Button_Disable(button3);
TM_ILI9341_Puts(25, 220, "Buttons disabled!", &TM_Font_11x18, ILI9341_COLOR_RED, ILI9341_COLOR_GRAY);
}
//Draw buttons
TM_ILI9341_Button_DrawAll();
//Draw some strings
TM_ILI9341_Puts(45, 245, "LED on LED off", &TM_Font_7x10, ILI9341_COLOR_BLACK, ILI9341_COLOR_GRAY);
TM_ILI9341_Puts(10, 100, "Bottom buttons work\nonly if red led is turned on.\nYou can toggle red\nled with Button 1.", &TM_Font_7x10, ILI9341_COLOR_BLACK, ILI9341_COLOR_GRAY);
while (1) {
if (TM_STMPE811_ReadTouch(&touchData) == TM_STMPE811_State_Pressed) {
buttonPressed = TM_ILI9341_Button_Touch(&touchData);
if (buttonPressed >= 0) {
//Any button pressed
sprintf(str, "Pressed: Button %d", (buttonPressed + 1));
} else {
sprintf(str, "Press the button ");
}
if (buttonPressed == button1) {
//Red button 1 is pressed, toggle led
TM_DISCO_LedToggle(LED_RED);
if (TM_DISCO_LedIsOn(LED_RED)) {
//If led is turned on, enable button 2 and button 3
TM_ILI9341_Button_Enable(button2);
TM_ILI9341_Button_Enable(button3);
TM_ILI9341_Puts(25, 220, "Buttons enabled! ", &TM_Font_11x18, ILI9341_COLOR_GREEN, ILI9341_COLOR_GRAY);
} else {
//otherwise disable both
TM_ILI9341_Button_Disable(button2);
TM_ILI9341_Button_Disable(button3);
TM_ILI9341_Puts(25, 220, "Buttons disabled!", &TM_Font_11x18, ILI9341_COLOR_RED, ILI9341_COLOR_GRAY);
}
} else if (buttonPressed == button2) {
//If button 2 is pressed, turn green led on
TM_DISCO_LedOn(LED_GREEN);
} else if (buttonPressed == button3) {
//if button 3 is pressed, turn green led off
TM_DISCO_LedOff(LED_GREEN);
}
}
TM_ILI9341_Puts(10, 5, str, &TM_Font_11x18, ILI9341_COLOR_GREEN, ILI9341_COLOR_GRAY);
}
}
int main(void) {
/* Init system */
TM_RCC_InitSystem();
/* Init HAL layer */
HAL_Init();
/* Init leds */
TM_DISCO_LedInit();
/* Init delay */
TM_DELAY_Init();
#if defined(STM32F429_DISCOVERY) || defined(STM32F7_DISCOVERY) || defined(STM32F439_EVAL)
/* Init LCD */
TM_LCD_Init();
TM_LCD_SetFont(&TM_Font_7x10);
TM_LCD_SetXY(5, 5);
#if defined(STM32F7_DISCOVERY)
/* Rotate LCD */
TM_LCD_SetOrientation(2);
#endif
#endif
/* Init USB peripheral */
TM_USB_Init();
/* Init HOST on HS mode */
TM_USBH_Init(TM_USB_HS);
/* Init USB CDC DEVICE on FS port */
TM_USBD_CDC_Init(TM_USB_FS);
/* Send debug */
printf("USB FS configured as CDC device!\n");
/* Init USB HOST HID on HS port */
TM_USBH_HID_Init(TM_USB_HS);
/* Send debug */
printf("USB HS configured as HID host!\n");
/* Start USB CDC device */
TM_USBD_Start(TM_USB_FS);
/* Send debug */
printf("USB FS started!\n");
/* Start USB HID host */
TM_USBH_Start(TM_USB_HS);
/* Send debug */
printf("USB HS started!\n");
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_FS);
/* Process USB HID Host */
TM_USBH_Process(TM_USB_HS);
/* Check if CDC device is ready, if drivers are installed if needed */
if (TM_USBD_IsDeviceReady(TM_USB_FS) == TM_USBD_Result_Ok) {
/* Turn ON led */
TM_DISCO_LedOn(LED_GREEN);
/* Print if needed */
if (!FS_Printed) {
printf("FS: CDC ready to use!\n");
FS_Printed = 1;
}
} else {
/* Turn OFF led */
TM_DISCO_LedOff(LED_GREEN);
/* Print if needed */
if (FS_Printed) {
printf("FS: CDC not ready to use!\n");
FS_Printed = 0;
}
}
/* Check if anything received on FS port */
if (TM_USBD_CDC_Getc(TM_USB_FS, &ch)) {
/* One character received */
/* Send it back */
TM_USBD_CDC_Putc(TM_USB_FS, ch);
}
/* Check HS port if anything connected */
if (
TM_USBH_IsConnected(TM_USB_HS) == TM_USBH_Result_Ok &&
TM_USBH_IsDeviceReady(TM_USB_HS) == TM_USBH_Result_Ok
) {
/* Something is connected */
/* Check for HID */
if (TM_USBH_HID_GetConnected(TM_USB_HS) == TM_USBH_HID_Keyboard) {
if (!HS_Printed) {
printf("HS: Keyboard connected!\n");
HS_Printed = 1;
}
} else if (TM_USBH_HID_GetConnected(TM_USB_HS) == TM_USBH_HID_Mouse) {
if (!HS_Printed) {
printf("HS: Mouse connected!\n");
HS_Printed = 1;
}
} else {
/* No HID connected */
if (!HS_Printed) {
printf("HS: Unknown connected!\n");
HS_Printed = 1;
}
}
} else {
/* Device not connected */
if (HS_Printed) {
printf("HS: Device disconnected!\n");
HS_Printed = 0;
}
}
}
}
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");
}
}
}
}
/* Handle CGI request for LEDS */
const char* LEDS_CGI_Handler(int iIndex, int iNumParams, char *pcParam[], char *pcValue[]) {
uint8_t i;
/* This function handles request like one below: */
/* /ledaction.cgi?ledtoggle=1&ledoff=2 */
/* This will toggle LED 1 and turn off LED 2 */
/* Callback */
if (iIndex == 0) {
/* Go through all params */
for (i = 0; i < iNumParams; i++) {
/* If current pair = ledtoggle=someled */
if (strstr(pcParam[i], "ledtoggle")) {
/* Switch first character */
switch (pcValue[i][0]) {
case '1':
TM_DISCO_LedToggle(LED_GREEN);
break;
case '2':
TM_DISCO_LedToggle(LED_ORANGE);
break;
case '3':
TM_DISCO_LedToggle(LED_RED);
break;
case '4':
TM_DISCO_LedToggle(LED_BLUE);
break;
default:
break;
}
} else if (strstr(pcParam[i], "ledon")) {
switch (pcValue[i][0]) {
case '1':
TM_DISCO_LedOn(LED_GREEN);
break;
case '2':
TM_DISCO_LedOn(LED_ORANGE);
break;
case '3':
TM_DISCO_LedOn(LED_RED);
break;
case '4':
TM_DISCO_LedOn(LED_BLUE);
break;
default:
break;
}
} else if (strstr(pcParam[i], "ledoff")) {
switch (pcValue[i][0]) {
case '1':
TM_DISCO_LedOff(LED_GREEN);
break;
case '2':
TM_DISCO_LedOff(LED_ORANGE);
break;
case '3':
TM_DISCO_LedOff(LED_RED);
break;
case '4':
TM_DISCO_LedOff(LED_BLUE);
break;
default:
break;
}
}
}
}
/* Return URL to be used after call */
return "/index.shtml";
}
int main(void) {
/* Init system */
TM_RCC_InitSystem();
/* Init HAL layer */
HAL_Init();
/* Init leds */
TM_DISCO_LedInit();
/* Init delay */
TM_DELAY_Init();
#if defined(STM32F429_DISCOVERY) || defined(STM32F7_DISCOVERY) || defined(STM32F439_EVAL)
/* Init LCD */
TM_LCD_Init();
TM_LCD_SetFont(&TM_Font_7x10);
TM_LCD_SetXY(5, 5);
#if defined(STM32F7_DISCOVERY)
/* Rotate LCD */
TM_LCD_SetOrientation(2);
#endif
#endif
/* Init USB */
TM_USB_Init();
/* Init USB Host, FS and HS modes */
TM_USBH_Init(TM_USB_Both);
/* Enable HID HOST class for USB FS mode */
TM_USBH_HID_Init(TM_USB_FS);
/* Enable MSC HOST class for USB HS mode */
TM_USBH_MSC_Init(TM_USB_HS);
/* Start USB host on FS and HS */
TM_USBH_Start(TM_USB_Both);
while (1) {
/* Process USB host FS and HS modes */
TM_USBH_Process(TM_USB_Both);
/* Check if device connected on FS port */
if (TM_USBH_IsConnected(TM_USB_FS) == TM_USBH_Result_Ok) {
/* Check if any HID devie is connected to FS port */
if (TM_USBH_HID_GetConnected(TM_USB_FS) == TM_USBH_HID_Keyboard) {
/* Keyboard is connected on FS port */
/* If not printed yet */
if (!FS_Printed) {
/* Print to LCD */
printf("USB FS: Keyboard connected! VID: %04X; PID: %04X\n", TM_USBH_GetVID(TM_USB_FS), TM_USBH_GetPID(TM_USB_FS));
/* Set flag */
FS_Printed = 1;
}
/* Read pressed button if any */
if (TM_USBH_HID_GetKeyboard(TM_USB_FS, &KbdInfo) == TM_USBH_HID_Keyboard) {
/* Something pressed on keyboard */
/* Print on LCD if character is valid */
if (KbdInfo.C) {
printf("Character: %c\n", KbdInfo.C);
}
/* Print others */
printf("LS: %d ", KbdInfo.Special.S.LShift);
printf("LC: %d ", KbdInfo.Special.S.LCtrl);
printf("LA: %d ", KbdInfo.Special.S.LAlt);
printf("LG: %d ", KbdInfo.Special.S.LGUI);
printf("\n");
}
} else if (TM_USBH_HID_GetConnected(TM_USB_FS) == TM_USBH_HID_Mouse) {
/* Mouse is connected on FS port */
/* If not printed yet */
if (!FS_Printed) {
/* Print to LCD */
printf("USB FS: Mouse connected! VID: %04X; PID: %04X\n", TM_USBH_GetVID(TM_USB_FS), TM_USBH_GetPID(TM_USB_FS));
/* Turn on green LED */
TM_DISCO_LedOn(LED_GREEN);
/* Set flag */
FS_Printed = 1;
}
/* Read mouse if any */
if (TM_USBH_HID_GetMouse(TM_USB_FS, &MouseInfo) == TM_USBH_HID_Mouse) {
/* Something pressed on keyboard */
printf("Abs X: %d; Abs Y: %d; Rel X: %d; Rel Y %d\n", MouseInfo.AbsoluteX, MouseInfo.AbsoluteY, MouseInfo.RelativeX, MouseInfo.RelativeY);
printf("Btn1: %d; Btn2: %d; Btn3: %d\n", MouseInfo.Buttons[0], MouseInfo.Buttons[1], MouseInfo.Buttons[2]);
}
}
} else if (FS_Printed) {
/* Check if no device connected */
if (TM_USBH_HID_GetConnected(TM_USB_FS) == TM_USBH_HID_None) {
/* Mouse is connected */
/* Print to LCD */
printf("USB FS: Device disconnected\n");
/* Clear flag */
FS_Printed = 0;
/* Turn off green LED */
TM_DISCO_LedOff(LED_GREEN);
}
}
/* Check MSC host on HS port */
if (
TM_USBH_IsConnected(TM_USB_HS) == TM_USBH_Result_Ok && /*!< Check if any device connected to USB HS port */
TM_USBH_MSC_IsConnected(TM_USB_HS) == TM_USBH_Result_Ok && /*!< Device connected to USB port is MSC type */
TM_USBH_MSC_IsReady(TM_USB_HS) == TM_USBH_Result_Ok /*!< Device is ready */
) {
/* Device is connected on HS port */
/* Connected device is MSC type */
/* If not printed already */
if (!HS_Printed) {
/* Print to LCD */
printf("--------------------------\n");
printf("USB HS: USB MSC device connected with VID: %04X; PID: %04X\n", TM_USBH_GetVID(TM_USB_HS), TM_USBH_GetPID(TM_USB_HS));
/* Set flag */
HS_Printed = 1;
}
/* If not mounted already */
if (!mounted) {
/* Try to mount and write using FATFS */
if ((fres = f_mount(&FATFS_USB, "USBHS:", 1)) == FR_OK) {
/* Mounted OK */
printf("USB HS: Mounted OK!\n");
/* Try to open file */
if ((fres = f_open(&fil, "USBHS:usb_hs_file.txt", FA_OPEN_ALWAYS | FA_WRITE | FA_READ)) == FR_OK) {
/* File opened OK */
printf("USB HS: File opened!\n");
/* Go to end of file */
f_lseek(&fil, f_size(&fil));
/* Print string */
if (f_puts("USB HS: File written using USB HS port\n", &fil)) {
/* Written OK */
printf("USB HS: File written OK!\n");
/* Set flag */
mounted = 1;
/* Turn on red LED */
TM_DISCO_LedOn(LED_RED);
} else {
printf("USB HS: File writing error!\n");
}
/* Close file */
f_close(&fil);
printf("USB HS: File closed!\n");
if ((fres = f_open(&fil, "USBHS:usb_hs_file.txt", FA_WRITE | FA_READ)) == FR_OK) {
printf("USB HS: File reopened OK and closed again!\n");
f_close(&fil);
} else {
printf("USB HS: File reopen ERROR! FRES: %d\n", fres);
}
} else {
/* File not opened */
printf("USB HS: Failed to open file!\n");
}
/* Unmount USB */
f_mount(NULL, "USBHS:", 1);
} else {
/* Mounting error! */
printf("USB HS: Failed to mount!\n");
}
}
} else {
/* Clear flag */
mounted = 0;
/* Print disconnection */
if (HS_Printed) {
/* Print to LCD */
printf("USB HS: USB MSC device disconnected!\n");
/* Clear flag */
HS_Printed = 0;
/* Turn off red LED */
TM_DISCO_LedOff(LED_RED);
}
}
}
}
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 FS and HS ports.. */
TM_USBD_CDC_Init(TM_USB_FS);
TM_USBD_CDC_Init(TM_USB_HS);
/* ..or use single call for both modes */
//TM_USBD_CDC_Init(TM_USB_Both);
/* Start USB device mode on FS and HS ports.. */
TM_USBD_Start(TM_USB_FS);
TM_USBD_Start(TM_USB_HS);
/* .. or use single call for both modes */
//TM_USBD_Start(TM_USB_Both);
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_Both);
/* Check if device is ready, if drivers are installed if needed on FS port */
if (TM_USBD_IsDeviceReady(TM_USB_FS) == TM_USBD_Result_Ok) {
TM_DISCO_LedOn(LED_GREEN);
} else {
TM_DISCO_LedOff(LED_GREEN);
}
/* Check if user has changed parameter for COM port */
TM_USBD_CDC_GetSettings(TM_USB_FS, &USB_FS_Settings);
/* Check if updated */
if (USB_FS_Settings.Updated) {
/* Update settings for UART here if needed */
TM_USBD_CDC_Puts(TM_USB_FS, "USB FS settings changed!\n");
}
/* Check if anything received on FS port */
if (TM_USBD_CDC_Getc(TM_USB_FS, &ch)) {
/* One character received */
/* Send it back */
TM_USBD_CDC_Putc(TM_USB_FS, ch);
}
/* 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) {
//TM_DISCO_LedOn(LED_GREEN);
} else {
//TM_DISCO_LedOff(LED_GREEN);
}
/* Check if any string received on HS port */
if (TM_USBD_CDC_Gets(TM_USB_HS, string_array, sizeof(string_array))) {
/* One character received */
/* Send it back */
TM_USBD_CDC_Puts(TM_USB_HS, string_array);
}
}
}
int main(void) {
/* Init system */
TM_RCC_InitSystem();
/* Init HAL layer */
HAL_Init();
/* Timer Init for SysTick */
timer_start();
/* Init leds */
TM_DISCO_LedInit();
/* Init delay */
TM_DELAY_Init();
/* Init USB peripheral */
TM_USB_Init();
/* Init VCP on FS port.. */
TM_USBD_CDC_Init(TM_USB_FS);
/* Start USB device mode on FS port.. */
TM_USBD_Start(TM_USB_FS);
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_FS);
/* Check if device is ready, if drivers are installed if needed on FS port */
if (TM_USBD_IsDeviceReady(TM_USB_FS) == TM_USBD_Result_Ok) {
TM_DISCO_LedOn(LED_GREEN);
} else {
TM_DISCO_LedOff(LED_GREEN);
}
/* Check if user has changed parameter for COM port */
TM_USBD_CDC_GetSettings(TM_USB_FS, &USB_FS_Settings);
/* Check if updated */
if (USB_FS_Settings.Updated) {
/* Update settings for UART here if needed */
TM_USBD_CDC_Puts(TM_USB_FS, "USB FS settings changed!\n");
}
/* Check if anything received on FS port */
if (TM_USBD_CDC_Getc(TM_USB_FS, &ch)) {
/* One character received */
/* Send it back */
/* TM_USBD_CDC_Putc(TM_USB_FS, ch); */
/* Control LEDs based on input (debug) */
switch(ch){
case '1':
TM_DISCO_LedToggle(LED_BLUE);
break;
case '2':
TM_DISCO_LedToggle(LED_ORANGE);
TM_USBD_CDC_Puts(TM_USB_FS, "Toggling Orange LED\n");
break;
case '3':
TM_DISCO_LedToggle(LED_RED);
TM_USBD_CDC_Puts(TM_USB_FS, "Toggling Red LED\n");
break;
case '4':
TM_DISCO_LedToggle(LED_GREEN);
break;
case '5':
/* Transfer Sample Audio */
trace_puts("Sending Audio Sample");
/* For now, send entire sample audio data */
/* TODO get size of sample to be transfered from serial port */
/* at 115k BAUD 800 bytes is sub 10 msec total transfer time */
for(int i = 0; i < SAMPLEAUDIO_SIZE;i++)
{
/* Need to split 16 bit samples into upper and lower bytes */
/* Note that these will need to be reconstructed in the
* processing script. Updated Buffer size to 1024 from 256 in
* USBD_CDC library file for this operation.
*/
/* Send MSB first */
TM_USBD_CDC_Putc(TM_USB_FS, Hi(SampleAudio[i]));
trace_putchar((int)Hi(SampleAudio[i]));
/* Then Send LSB */
TM_USBD_CDC_Putc(TM_USB_FS, Lo(SampleAudio[i]));
trace_putchar((int)Lo(SampleAudio[i]));
}
break;
default:
break;
}
}
//Wait for next system tick
while (g_SysTick_Flag == 0){};
g_SysTick_Flag = 0;
TM_DISCO_LedToggle(LED_BLUE);
}
}
int main(void) {
uint8_t already = 0;
/* Set structs for all examples */
TM_USB_HIDDEVICE_Keyboard_t Keyboard;
TM_USB_HIDDEVICE_Gamepad_t Gamepad1, Gamepad2;
TM_USB_HIDDEVICE_Mouse_t Mouse;
/* Initialize system */
SystemInit();
//Initialize LIS302DL - acceleration sensor;...
//... the board position determines the movement of joystick
LIS302DL_Init1();
/* Initialize leds */
TM_DISCO_LedInit();
/* Initialize button */
TM_DISCO_ButtonInit();
/* Initialize delay */
TM_DELAY_Init();
/* Initialize USB HID Device */
TM_USB_HIDDEVICE_Init();
/* Set default values for mouse struct */
TM_USB_HIDDEVICE_MouseStructInit(&Mouse);
/* Set default values for keyboard struct */
TM_USB_HIDDEVICE_KeyboardStructInit(&Keyboard);
/* Set default values for gamepad structs */
TM_USB_HIDDEVICE_GamepadStructInit(&Gamepad1);
TM_USB_HIDDEVICE_GamepadStructInit(&Gamepad2);
//Variables
const int8_t axis_x_min = 0; //The number represents maximum deflection of left-stick on left; Default: -128 (!The value recommended for Unity game: 0 - Unity can read only not minus numbers of axis!)
const int8_t axis_x_max = 127; //The number represents maximum deflection of left-stick on right; Default: 127
const int8_t axis_x_avg = (axis_x_min + axis_x_max) / 2; //The value presented center position of left stick
const int8_t acc_x_min = -60; //Minimum (approximately) value reading from accelerometer for X-axis
const int8_t acc_x_max = 60; //Maximum (approximately) value reading from accelerometer for X-axis
const int8_t kx = (-axis_x_min + axis_x_max) / (-acc_x_min + acc_x_max); //Thanks to this ratio, can create universal formula on value of gamepad left-axis depends on STM-board position
const int8_t axis_y_min = 0; //The number represents maximum deflection of left-stick on top; Default: -128 (!The value recommended for Unity game: 0 - Unity can read only not minus numbers of axis!)
const int8_t axis_y_max = 127; //The number represents maximum deflection of left-stick on bottom; Default: 127
const int8_t axis_y_avg = (axis_y_min + axis_y_max) / 2; //The value presented center position of left stick
const int8_t acc_y_min = -60; //Minimum (approximately) value reading from accelerometer for Y-axis
const int8_t acc_y_max = 60; //Maximum (approximately) value reading from accelerometer for Y-axis
const int8_t ky = (-axis_y_min + axis_y_max) / (-acc_y_min + acc_y_max); //Thanks to this ratio, can create universal formula on value of gamepad left-axis depends on STM-board position
while (1) {
/* If we are connected and drivers are OK */
if (TM_USB_HIDDEVICE_GetStatus() == TM_USB_HIDDEVICE_Status_Connected) {
/* Turn on green LED */
TM_DISCO_LedOn(LED_GREEN);
/* Simple sketch start */
/* If you pressed button right now and was not already pressed */
if (TM_DISCO_ButtonPressed() && already == 0) { /* Button on press */
already = 1;
/* Gamepad 1 */
/* Simulate button 1 on gamepad 1 */
Gamepad1.Button1 = TM_USB_HIDDEVICE_Button_Pressed;
/* Send report for gamepad 1 */
TM_USB_HIDDEVICE_GamepadSend(TM_USB_HIDDEVICE_Gamepad_Number_1, &Gamepad1);
} else if (!TM_DISCO_ButtonPressed() && already == 1) { /* Button on release */
already = 0;
//I thought the command that is 5 lines below was sufficient but no...
//I released blue button but computer "thought" I still pressed it.
Gamepad1.Button1 = TM_USB_HIDDEVICE_Button_Released; //release button 1
/* Send command to release all buttons on both gamepads */
TM_USB_HIDDEVICE_GamepadReleaseAll(TM_USB_HIDDEVICE_Gamepad_Number_1);
}
// Read the board position on axes
LIS302DL_Read(&acc_x,LIS302DL_OUT_X_ADDR,1);
LIS302DL_Read(&acc_y,LIS302DL_OUT_Y_ADDR,1);
LIS302DL_Read(&acc_z,LIS302DL_OUT_Z_ADDR,1);
//The value on axis depends on board lean
//HERE: Changing orientation of left joystick under the influence of X-axis
/* Simulate left stick rotation */
/* X axis */
if (acc_x > -15 && acc_x < 15) //horizontal position of STM-board
{
Gamepad1.LeftXAxis = axis_x_avg;
}
else
{
if (acc_x >= acc_x_max - 10) //maximum right position --> vertical position of STM-board (USB mini-B on top of board)
{
Gamepad1.LeftXAxis = axis_x_max;
}
else
{
if (acc_x <= acc_x_min + 10) //maximum left position --> vertical position of STM-board (mini-jack out and USB micro-B on top )
{
Gamepad1.LeftXAxis = axis_x_min;
}
else
{
Gamepad1.LeftXAxis = acc_x * kx + axis_x_avg; //universal formula on left-stick position of gamepad depending on STM position
//it seems to be sufficient (without if-conditionals); but using of "if", it ensures more stability
}
}
}
/* Y axis */
if (acc_y > -15 && acc_y < 15) //horizontal position of STM-board
{
Gamepad1.LeftYAxis = axis_y_avg;
}
else
{
if (acc_y >= acc_x_max - 10) //maximum "up" position --> blue button of STM is higher than black reset-button
{
Gamepad1.LeftYAxis = axis_y_min;
}
else
{
if (acc_y <= acc_x_min + 10) //maximum "down" position --> black button of STM is higher than blue button
{
Gamepad1.LeftYAxis = axis_y_max;
}
else
{
Gamepad1.LeftYAxis = acc_y * (-ky) + axis_y_avg; //universal formula on left-stick position of gamepad depending on STM position
//it seems to be sufficient (without if-conditionals); but using of "if", it ensures more stability
}
}
}
TM_USB_HIDDEVICE_GamepadSend(TM_USB_HIDDEVICE_Gamepad_Number_1, &Gamepad1);
/* Simple sketch end */
} else {
/* Turn off green LED */
TM_DISCO_LedOff(LED_GREEN);
}
}
}
int main(void) {
char buffer[50];
uint8_t write = 1;
uint32_t free, total;
/* Initialize system */
SystemInit();
/* Initialize delay functions */
TM_DELAY_Init();
/* Leds init */
TM_DISCO_LedInit();
/* Initialize USB MSC HOST */
TM_USB_MSCHOST_Init();
while (1) {
/* Host Task handler */
/* This have to be called periodically as fast as possible */
TM_USB_MSCHOST_Process();
/* Device is connected and ready to use */
if (TM_USB_MSCHOST_Device() == TM_USB_MSCHOST_Result_Connected) {
/* If we didn't write data already */
if (write) {
/* Try to mount USB device */
/* USB is at 1: */
if ((fres = f_mount(&USB_Fs, "USB:", 1)) == FR_OK) {
TM_DISCO_LedOn(LED_GREEN);
/* Mounted ok */
/* Try to open USB file */
if ((fres = f_open(&USB_Fil, "USB:usb_file.txt", FA_READ | FA_WRITE | FA_OPEN_ALWAYS)) == FR_OK) {
/* We want to write only once */
write = 0;
/* Get total and free space on USB */
TM_FATFS_USBDriveSize(&total, &free);
/* Put data */
f_puts("This is my first file with USB and FatFS\n", &USB_Fil);
f_puts("with USB MSC HOST library from stm32f4-discovery.com\n", &USB_Fil);
f_puts("----------------------------------------------------\n", &USB_Fil);
f_puts("USB total and free space:\n\n", &USB_Fil);
/* Total space */
sprintf(buffer, "Total: %8u kB; %5u MB; %2u GB\n", total, total / 1024, total / 1048576);
f_puts(buffer, &USB_Fil);
/* Free space */
sprintf(buffer, "Free: %8u kB; %5u MB; %2u GB\n", free, free / 1024, free / 1048576);
f_puts(buffer, &USB_Fil);
f_puts("----------------------------------------------------\n", &USB_Fil);
/* Close USB file */
f_close(&USB_Fil);
/* Turn GREEN LED On and RED LED Off */
/* Indicate successful write */
TM_DISCO_LedOn(LED_GREEN);
TM_DISCO_LedOff(LED_RED);
}
}
/* Unmount USB */
f_mount(0, "USB:", 1);
}
} else {
/* Not inserted, turn on RED led */
TM_DISCO_LedOn(LED_RED);
TM_DISCO_LedOff(LED_GREEN);
/* Ready to write next time */
write = 1;
}
}
}
int main(void) {
uint8_t already = 0;
/* Set structs for all examples */
TM_USB_HIDDEVICE_Keyboard_t Keyboard;
TM_USB_HIDDEVICE_Gamepad_t Gamepad1, Gamepad2;
TM_USB_HIDDEVICE_Mouse_t Mouse;
/* Initialize system */
SystemInit();
/* Initialize leds */
TM_DISCO_LedInit();
/* Initialize button */
TM_DISCO_ButtonInit();
/* Initialize delay */
TM_DELAY_Init();
/* Initialize USB HID Device */
TM_USB_HIDDEVICE_Init();
/* Set default values for mouse struct */
TM_USB_HIDDEVICE_MouseStructInit(&Mouse);
/* Set default values for keyboard struct */
TM_USB_HIDDEVICE_KeyboardStructInit(&Keyboard);
/* Set default values for gamepad structs */
TM_USB_HIDDEVICE_GamepadStructInit(&Gamepad1);
TM_USB_HIDDEVICE_GamepadStructInit(&Gamepad2);
while (1) {
/* If we are connected and drivers are OK */
if (TM_USB_HIDDEVICE_GetStatus() == TM_USB_HIDDEVICE_Status_Connected) {
/* Turn on green LED */
TM_DISCO_LedOn(LED_GREEN);
/* Simple sketch start */
/* If you pressed button right now and was not already pressed */
if (TM_DISCO_ButtonPressed() && already == 0) { /* Button on press */
already = 1;
/* Set pressed keys = WIN + R */
Keyboard.L_GUI = TM_USB_HIDDEVICE_Button_Pressed; /* Win button */
Keyboard.Key1 = 0x15; /* R */
/* Result = "Run" command */
/* Send keyboard report */
TM_USB_HIDDEVICE_KeyboardSend(&Keyboard);
} else if (!TM_DISCO_ButtonPressed() && already == 1) { /* Button on release */
already = 0;
/* Release all buttons */
Keyboard.L_GUI = TM_USB_HIDDEVICE_Button_Released; /* No button */
Keyboard.Key1 = 0x00; /* No key */
/* Result = Released everything */
/* Send keyboard report */
TM_USB_HIDDEVICE_KeyboardSend(&Keyboard);
}
/* Simple sketch end */
} else {
/* Turn off green LED */
TM_DISCO_LedOff(LED_GREEN);
}
}
}
int main(void) {
BUTTON_Handle hButton, hB1, hB2, hB3, hB4;
PROGBAR_Handle hProgbar;
uint8_t i;
/* Initialize system */
SystemInit();
/* Initialize delay functions */
TM_DELAY_Init();
/* Initialize LEDs */
TM_DISCO_LedInit();
/* Initialize emWin */
if (TM_EMWIN_Init() != TM_EMWIN_Result_Ok) {
/* Initialization error */
while (1) {
/* Toggle RED led */
TM_DISCO_LedToggle(LED_RED);
/* Delay */
Delayms(100);
}
}
/* Create progress bar at location x = 10, y = 10, length = 219, height = 30 */
hProgbar = PROGBAR_CreateEx(10, 10, 219, 30, 0, WM_CF_SHOW, 0, GUI_ID_PROGBAR0);
/* Set progress bar font */
PROGBAR_SetFont(hProgbar, &GUI_Font8x16);
/* Set progress bar text */
PROGBAR_SetText(hProgbar, "LOADING..Please wait..");
/* Imitate loading */
for (i = 1; i <= 100; i++) {
/* Set bar */
PROGBAR_SetValue(hProgbar, i);
/* Little delay, update value on LCD */
GUI_Delay(20);
}
/* Create button with GUI_ID_OK ID number */
hButton = BUTTON_CreateEx(10, 50, 219, 30, 0, WM_CF_SHOW, 0, GUI_ID_BUTTON0);
/* Set text and font */
BUTTON_SetText(hButton, "Click me to continue..");
BUTTON_SetFont(hButton, &GUI_Font8x15B_ASCII);
/* Execute, show button */
GUI_Exec();
/* Wait till button pressed */
while (1) {
/* Check if button was pressed */
if (GUI_GetKey() == GUI_ID_BUTTON0) {
/* Led Off */
TM_DISCO_LedOff(LED_GREEN);
/* Stop while loop */
break;
}
/* Toggle green led */
TM_DISCO_LedToggle(LED_GREEN);
/* Delay 100ms */
GUI_Delay(100);
}
/* Delete button functionality */
BUTTON_Delete(hButton);
/* Delete button from LCD */
GUI_ClearRect(10, 50, 269, 90);
/* Create buttons for leds control */
hB1 = BUTTON_CreateEx(10, 90, 105, 50, 0, WM_CF_SHOW, 0, GUI_ID_BUTTON1);
hB2 = BUTTON_CreateEx(124, 90, 105, 50, 0, WM_CF_SHOW, 0, GUI_ID_BUTTON2);
hB3 = BUTTON_CreateEx(10, 150, 105, 50, 0, WM_CF_SHOW, 0, GUI_ID_BUTTON3);
hB4 = BUTTON_CreateEx(124, 150, 105, 50, 0, WM_CF_SHOW, 0, GUI_ID_BUTTON4);
/* Set font for buttons */
BUTTON_SetFont(hB1, &GUI_Font13HB_ASCII);
BUTTON_SetFont(hB2, &GUI_Font13HB_ASCII);
BUTTON_SetFont(hB3, &GUI_Font13HB_ASCII);
BUTTON_SetFont(hB4, &GUI_Font13HB_ASCII);
/* Set button text */
BUTTON_SetText(hB1, "GREEN on");
BUTTON_SetText(hB2, "GREEN off");
BUTTON_SetText(hB3, "RED on");
BUTTON_SetText(hB4, "RED off");
/* Button styling */
/* Background color when button is not pressed */
BUTTON_SetBkColor(hB1, BUTTON_CI_UNPRESSED, GUI_DARKGREEN);
/* Background color when button is pressed */
BUTTON_SetBkColor(hB1, BUTTON_CI_PRESSED, GUI_GREEN);
/* Background color when button is not pressed */
BUTTON_SetBkColor(hB3, BUTTON_CI_UNPRESSED, GUI_DARKRED);
/* Background color when button is pressed */
BUTTON_SetBkColor(hB3, BUTTON_CI_PRESSED, GUI_RED);
/* Show buttons */
GUI_Exec();
while (1) {
/* Get pressed key */
switch (GUI_GetKey()) {
case GUI_ID_BUTTON1:
/* Button 1 pressed */
TM_DISCO_LedOn(LED_GREEN);
break;
case GUI_ID_BUTTON2:
/* Button 2 pressed */
TM_DISCO_LedOff(LED_GREEN);
break;
case GUI_ID_BUTTON3:
/* Button 3 pressed */
TM_DISCO_LedOn(LED_RED);
break;
case GUI_ID_BUTTON4:
/* Button 4 pressed */
TM_DISCO_LedOff(LED_RED);
break;
default:
break;
}
}
}
