I have written some code that must turn on leds one by another (in a round) by each click of the button, but sometimes with one click of the button lights not the next led but one random from four leds. It's something like one or more leds skips its turn. I think the problem is caused by wrong setup of clock rate or wrong setup of Rising/Falling EXTI trigers.
Board: STM32DISCOVERY
periph.h
#ifndef PERIPH_H
#define PERIPH_H
#include "stm32f4xx_gpio.h"
#include "stm32f4xx_rcc.h"
#include "misc.h"
#include "stm32f4xx_exti.h"
#include "stm32f4xx_syscfg.h"
void Initialize_GPIO_LEDS(void);
void Initialize_GPIO_Button(void);
void Initialize_EXTI0_PA(void);
void Initialize_NVIC(void);
typedef enum
{
GPIO_LED_Green = GPIO_Pin_12,
GPIO_LED_Yellow = GPIO_Pin_13,
GPIO_LED_Red = GPIO_Pin_14,
GPIO_LED_Blue = GPIO_Pin_15
}GPIO_LED_TypeDef;
void GPIO_LED_On(GPIO_LED_TypeDef GPIO_LED_x);
void GPIO_LED_Off(GPIO_LED_TypeDef GPIO_LED_x);
void GPIO_LED_All_On(void);
void GPIO_LED_All_Off(void);
#endif /* PERIPH_H */
periph.c
#include "periph.h"
GPIO_InitTypeDef GPIO_LEDS;
GPIO_InitTypeDef GPIO_Button;
EXTI_InitTypeDef EXTI0_PA;
NVIC_InitTypeDef NVIC_Struct;
void Initialize_GPIO_LEDS(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);
GPIO_LEDS.GPIO_Pin = GPIO_Pin_15 | GPIO_Pin_14 | GPIO_Pin_13 | GPIO_Pin_12;
GPIO_LEDS.GPIO_Mode = GPIO_Mode_OUT;
GPIO_LEDS.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_LEDS.GPIO_OType = GPIO_OType_PP;
GPIO_LEDS.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(GPIOD, &GPIO_LEDS);
}
void Initialize_GPIO_Button(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
GPIO_Button.GPIO_Pin = GPIO_Pin_0;
GPIO_Button.GPIO_Mode = GPIO_Mode_IN;
GPIO_Button.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_Button.GPIO_OType = GPIO_OType_PP;
GPIO_Button.GPIO_PuPd = GPIO_PuPd_DOWN;
GPIO_Init(GPIOA, &GPIO_Button);
}
void Initialize_EXTI0_PA(void)
{
EXTI0_PA.EXTI_Line = EXTI_Line0;
EXTI0_PA.EXTI_Mode = EXTI_Mode_Interrupt;
EXTI0_PA.EXTI_Trigger = EXTI_Trigger_Rising;
EXTI0_PA.EXTI_LineCmd = ENABLE;
EXTI_Init(&EXTI0_PA);
}
void Initialize_NVIC(void)
{
NVIC_Struct.NVIC_IRQChannel = EXTI0_IRQn;
NVIC_Struct.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_Struct);
}
void GPIO_LED_On(GPIO_LED_TypeDef GPIO_LED_x)
{
GPIO_SetBits(GPIOD, GPIO_LED_x);
}
void GPIO_LED_Off(GPIO_LED_TypeDef GPIO_LED_x)
{
GPIO_ResetBits(GPIOD, GPIO_LED_x);
}
void GPIO_LED_All_On(void)
{
GPIO_SetBits(GPIOD, GPIO_LED_Green | GPIO_LED_Yellow | GPIO_LED_Red | GPIO_LED_Blue);
}
void GPIO_LED_All_Off(void)
{
GPIO_ResetBits(GPIOD, GPIO_LED_Green | GPIO_LED_Yellow | GPIO_LED_Red | GPIO_LED_Blue);
}
main.c
#include "cmsis_os.h"
#include "periph.h"
uint8_t led_num = 0;
void EXTI0_IRQHandler(void)
{
if (EXTI_GetITStatus(EXTI_Line0) != RESET)
{
if (GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_0))
{
led_num++;
if (led_num == 4) led_num = 0;
}
EXTI_ClearITPendingBit(EXTI_Line0);
}
}
int main (void)
{
Initialize_GPIO_LEDS();
Initialize_GPIO_Button();
SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOA, EXTI_PinSource0);
Initialize_EXTI0_PA();
Initialize_NVIC();
while(1)
{
switch(led_num)
{
case 0 : GPIO_LED_On(GPIO_LED_Green); break;
case 1 : GPIO_LED_On(GPIO_LED_Yellow); break;
case 2 : GPIO_LED_On(GPIO_LED_Red); break;
case 3 : GPIO_LED_On(GPIO_LED_Blue); break;
}
GPIO_LED_All_Off();
}
}
It's probably due to debouncing (or the lack thereof).
See http://www.labbookpages.co.uk/electronics/debounce.html for a short primer on how to solve this.
See also http://www.emcu.it/STM32/STM32Discovery-Debounce/STM32Discovery-InputWithDebounce_Output_UART_SPI_SysTick.html for something specifically about the STM32Discovery.
All this was found via google.
Related
i'm new to vulkan.
when i call vkCreateInstance() , it crash , but i can't figure out what's the problem.
vkenumerateExtensionProperties return 0 extensoin count,and only VKLayer_LUNARG_api_dump found , it is weird .
core code are following , irrelevant code are removed.
Instance_Vulkan
#pragma once
#ifndef INSTANCE_VULKAN_HPP
#define INSTANCE_VULKAN_HPP
#include <vulkan/vulkan.h>
#include <vector>
#include <string>
#include <exception>
#include <iostream>
using namespace std;
namespace LB
{
class Instance_Vulkan
{
public:
bool isCreated = false;
VkInstance instance;
VkInstanceCreateInfo createInfo;
std::vector<const char*> extensions;
std::vector<const char*> layers;
Instance_Vulkan()
{
createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
createInfo.flags = 0;
createInfo.pNext = NULL;
createInfo.pApplicationInfo = NULL;
createInfo.enabledLayerCount = 0;
createInfo.ppEnabledLayerNames = NULL;
createInfo.enabledExtensionCount = 0;
createInfo.ppEnabledExtensionNames = NULL;
}
VkResult creat(const VkAllocationCallbacks* pAllocator=NULL)
{
if (isCreated)
return VK_SUCCESS;
else
{
VkResult result;
createInfo.enabledExtensionCount = static_cast<uint32_t>(extensions.size());
if(createInfo.enabledExtensionCount)
createInfo.ppEnabledExtensionNames = extensions.data();
createInfo.enabledLayerCount = static_cast<uint32_t>(layers.size());
if(createInfo.enabledLayerCount)
createInfo.ppEnabledLayerNames = layers.data();
if((result = vkCreateInstance(&createInfo, nullptr, &instance))!=VK_SUCCESS)
cout << "Error: fail to create Vulkan Instance ! " << endl;
if (result == VK_SUCCESS)
isCreated = true;
return result;
}
}
void destroy()
{
if (isCreated)
vkDestroyInstance(instance,nullptr);
isCreated = false;
}
};
}
#endif // !INSTANCE_VULKAN_HPP
following code invoke above class
#pragma once
#ifndef APPLICATION_HPP
#define APPLICATION_HPP
#include<vulkan/vulkan.h>
#include <iostream>
#include <stdexcept>
#include <cstdlib>
#define GLFW_INCLUDE_VULKAN
#include <GLFW/glfw3.h>
#include "Item.hpp"
#include"Window.hpp"
#include "Instance_Vulkan.hpp"
using namespace std;
namespace LB
{
class Application
{
public:
bool shouldClose = false;
virtual void mainLoop()
{
}
void init()
{
glfwInit();
glfwWindowHint(GLFW_CLIENT_API,GLFW_NO_API);
glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE);
initVulkan();
}
void initVulkan()
{
// set the application info
VkApplicationInfo appInfo = {};
appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
appInfo.pApplicationName = "Hellp Triangle";
appInfo.applicationVersion = VK_MAKE_VERSION(1, 0, 0);
appInfo.pEngineName= "No Engine";
appInfo.engineVersion = VK_MAKE_VERSION(1, 0, 0);
appInfo.apiVersion = VK_API_VERSION_1_0;
appInfo.pNext = NULL;
// set papplicatoinInfo
instance.createInfo.pApplicationInfo = &appInfo;
if (instance.creat()!= VK_SUCCESS)
throw std::runtime_error("Error: fail to create vulkan instance ");
}
void cleanUp()
{
glfwTerminate();
instance.destroy();
}
int run(int argc=0,char* argv[]=0)
{
init();
try {
for (;!shouldClose;)
mainLoop();
}
catch (const std::exception e)
{
std::cerr << e.what() << std::endl;
return EXIT_FAILURE;
}
cleanUp();
return EXIT_SUCCESS;
}
private:
Instance_Vulkan instance;
};
}
#endif
there are main function
#include "pch.h"
#define GLFW_INCLUDE_VULKAN
#include <GLFW/glfw3.h>
#include "Application.hpp"
#include <iostream>
#include <cstdlib>
using namespace LB;
using namespace std;
int main()
{
Application app;
return app.run();
}
when i run the code,it crash
'result image'
My Environment:
Win10 debug 64bit
vs2017
Gtx 940m driver: 416.94
i install lunarg sdk 1.1.85.0 , run the cube.exe and also compile the demo successfully
I want to implement module, which when is called to work changes signal x the way below:
1 clk pos.edge : x = 0 // 1st phase
2 clk pos.edge : x = 0 // 2nd phase
3 clk pos.edge : x = 1 // 3rd phase
And then stops until called again.
I have function foo() in my module, which is called from main and allows thread work_foo() to execute on the posedge of clock.
I tried to do it this way (with wait()), and in some simple test it gives right wave, but it is an inappropriate way: my_module.h:
#include "systemc.h"
SC_MODULE (my_module)
{
sc_in <bool> clk;
sc_out <sc_logic> x;
sc_signal <bool> valid;
void foo()
{
valid = 1;
return;
}
void work_foo()
{
while (true)
{
if (valid == 1)
{ // foo() was called
if (phase == 0)
{
x = SC_LOGIC_0;
wait(); // waiting for the next tick
x = SC_LOGIC_0;
wait(); // waiting for the next tick
x = SC_LOGIC_1;
wait(); // waiting for the next tick
}
else
{
valid=0;
wait();
}
}
}
SC_HAS_PROCESS(my_module);
my_module(sc_module_name name):
sc_module(name),
clk("clk"), x("x"), valid("valid")
{
SC_THREAD(work_foo);
//dont_initialize();
sensitive<<clk.pos();
valid=0;
}
};
main.cpp:
#include "systemc.h"
#include "my_module.h"
int sc_main (int argc, char* argv[])
{
sc_clock clock("clock", 10, SC_NS);
sc_signal<sc_logic > x;
my_module mm("my_mod");
mm.clk(clock);
mm.x(x);
mm.foo ();
sc_start(200, SC_NS);
sc_stop();
return 0;
}
And now I'm trying to implement it another way. I was advised to use additional sc_signal (or variable) in my module, which indicates the incrementing number of the phase. The problem is what this gets looped at the very start. How can I solve this?
#include "systemc.h"
SC_MODULE (my_module)
{
sc_in <bool> clk;
sc_out <sc_logic> x;
sc_signal <bool> valid;
sc_signal <uint> phase;
void foo()
{
valid = 1;
return;
}
void work_foo()
{
while (true)
{
if (valid == 1)
{
if (phase == 0)
{
x = SC_LOGIC_0;
phase=phase+1;
}
else if (phase == 1)
{
x = SC_LOGIC_0;
phase=phase+1;
}
else if (phase == 2)
{
x = SC_LOGIC_1;
phase=phase+1;
}
}
else
{
phase=0;
valid=0;
wait();
}
}
}
SC_HAS_PROCESS(my_module);
my_module(sc_module_name name):
sc_module(name),
clk("clk"), x("x"), valid("valid")
{
SC_THREAD(work_foo);
//dont_initialize();
sensitive<<clk.pos();
valid=0;
phase=0;
}
};
I'm using RAD Studio 10.2 with two instances of TIdUDPServer from Indy 10.
I run my program on Windows 10 and check the counters of sent and received packages, but there are no packages received. At the same time, I see through Wireshark that they come to the PC, but the second TIdUDPServer does not receive the packages. Why?
Here is my code:
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
typedef struct {
char Data[10000];
} struct_Buffer;
int i = 0;
int n = 0;
int k = 0;
int TxSize = 1400;
char TxData;
struct_Buffer TxBuffer;
AnsiString ServerIP1 = "192.168.10.1";
AnsiString ServerIP2 = "192.168.10.2";
TBytes Buffer;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------------
class TMyQueueProc1 : public TCppInterfacedObject<TThreadProcedure>
{
private:
int m_counter;
TIdBytes m_bytes;
public:
TMyQueueProc1(int ACounter, const TIdBytes &AData) : m_counter(ACounter), m_bytes(AData) {}
INTFOBJECT_IMPL_IUNKNOWN(TInterfacedObject);
void __fastcall Invoke()
{
Form1->Label1->Caption = "Rx " + IntToStr(m_counter);
}
};
void __fastcall TForm1::FormCreate(TObject *Sender)
{
try {
TIdSocketHandle *SocketHandle_Server = Form1->IdUDPServer1->Bindings->Add();
SocketHandle_Server->IP = ServerIP1;
SocketHandle_Server->Port = 4004;
Form1->IdUDPServer1->Active = true;
}
catch(Exception *ex) {
ShowMessage("IdUDPServer1 start error!");
}
try {
TIdSocketHandle *SocketHandle_Echo = Form1->IdUDPServer2->Bindings->Add();
SocketHandle_Echo->IP = ServerIP2;
SocketHandle_Echo->Port = 4004;
Form1->IdUDPServer2->Active = true;
}
catch(Exception *ex) {
ShowMessage("IdUDPServer2 start error!");
}
Timer1->Interval = 100;
Timer1->Enabled = true;
Label3->Caption = "IdUPDServer1: " + ServerIP1;
Label4->Caption = "IdUDPServer2: " + ServerIP2;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Timer1Timer(TObject *Sender)
{
TxData++;
if (TxData == 255) TxData = 0;
for (k = 0; k < TxSize; k++) TxBuffer.Data[k] = TxData;
Buffer = RawToBytes(&TxBuffer.Data[0], TxSize);
Form1->IdUDPServer1->SendBuffer(ServerIP2, 4004, Buffer);
n++;
Label2->Caption = "Tx " + IntToStr(n);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::IdUDPServer2UDPRead(TIdUDPListenerThread *AThread, const TIdBytes AData,
TIdSocketHandle *ABinding)
{
i++;
TThread::Queue(NULL, _di_TThreadProcedure(new TMyQueueProc1(i, AData)));
}
//---------------------------------------------------------------------------
I'm having an error doing the Update when checking if(Game::vector.at(i).alivez()), the error is C2280.
The error says: "Enemy &Enemy::operator =(const Enemy &)': attempting to reference a deleted function. Project: Avoidance Game File:xutility
Game.cpp:
void Game::Init()
{
int i = 0;
while(i< Game::Enemies)
{
srand(time(NULL));
Game::vector.push_back(Enemy(0, (rand()% (int)Console::WindowWidth), (rand() % (int)Console::WindowHeight), rand()%1500/1000.0f));
i++;
}
GameOver = false;
Paused = false;
}
void Game::GameMenu()
{
cout << "1. Start Game\n2. Instructions\n3. Close Game\nChoose an option:";
}
void Game::Instructions()
{
Console::Clear();
cout << "Left arrow = left (duh)\nRight arrow = right (surprise)\nSpace Bar = Shoot\nEsc = Close Game\nP Key = Pause\n ";
system("pause");
}
void Game::fire(Player a)
{
a.mX;
}
void Game::Run()
{
while (!GameOver)
{
if (GetAsyncKeyState(VK_ESCAPE))
{
GameOver = true;
}
else if (GetAsyncKeyState((int)'P'))
{
Paused = !Paused;
}
}
}
void Game::Update()
{
if (!Paused)
{
mPlayer.Update();
for (int i = 0; i < Game::Enemies; i++)
{
Game::vector.at(i).Update();
if (Game::vector.at(i).alivez())
{
Game::vector.erase(Game::vector.begin() + i);
i--;
Game::Enemies--;
}
}
}
}
Game.h:
#pragma once
#include "stdafx.h"
#include "targetver.h"
#include <vector>
class Enemy;
class Game
{
int Enemies = 30;
bool Paused;
bool GameOver;
int Score;
Player mPlayer = Player();
std::vector<Enemy> vector;
public:
void Init();
void GameMenu();
void Instructions();
void fire(Player a);
void Run();
void Update();
};
Enemy.h:
class Enemy
{
enum Enemy_type {NormalEnemy};
Game game;
float mX;
float mY;
float speed;
Enemy_type type;
public:
bool alive;
Enemy(int type, int x, int y, float _speed)
{
switch (type)
{
case 0:
type = Enemy_type::NormalEnemy;
break;
}
mX = (float)x;
mY = (float)y;
speed = _speed;
alive = true;
}
float GetX() { return mX; }
float GetY() { return mY; }
bool alivez() { return alive; }
void Kill() { alive = false; }
void Update();
void Draw();
};
This is what I have so far and I want to save pcd file from it
I know I have to do something like this but not exactly sure
pcl::PointCloud::PointPointXYZRGBA> cloud;
pcl::io:;savePCDFileASCII("test.pcd",cloud);
what do i have to add in my current code that i will have test.pcd
Thanks
#include <pcl/point_cloud.h>
#include <pcl/point_types.h>
#include <pcl/io/openni_grabber.h>
#include <pcl/visualization/cloud_viewer.h>
#include <pcl/common/time.h>
class SimpleOpenNIProcessor
{
public:
SimpleOpenNIProcessor () : viewer ("PCL OpenNI Viewer") {}
void cloud_cb_ (const pcl::PointCloud<pcl::PointXYZRGBA>::ConstPtr &cloud)
{
static unsigned count = 0;
static double last = pcl::getTime ();
if (++count == 30)
{
double now = pcl::getTime ();
std::cout << "distance of center pixel :" << cloud->points [(cloud->width >> 1) * (cloud->height + 1)].z << " mm. Average framerate: " << double(count)/double(now - last) << " Hz" << std::endl;
count = 0;
last = now;
}
if (!viewer.wasStopped())
viewer.showCloud (cloud);
}
void run ()
{
// create a new grabber for OpenNI devices
pcl::Grabber* interface = new pcl::OpenNIGrabber();
// make callback function from member function
boost::function<void (const pcl::PointCloud<pcl::PointXYZRGBA>::ConstPtr&)> f =
boost::bind (&SimpleOpenNIProcessor::cloud_cb_, this, _1);
// connect callback function for desired signal. In this case its a point cloud with color values
boost::signals2::connection c = interface->registerCallback (f);
// start receiving point clouds
interface->start ();
// wait until user quits program with Ctrl-C, but no busy-waiting -> sleep (1);
while (true)
boost::this_thread::sleep (boost::posix_time::seconds (1));
// stop the grabber
interface->stop ();
}
pcl::visualization::CloudViewer viewer;
};
int main ()
{
SimpleOpenNIProcessor v;
v.run ();
return (0);
}
#include <iostream>
#include <string>
#include <sstream>
#include <pcl/io/pcd_io.h>
#include <pcl/point_types.h>
#include <pcl/io/openni_grabber.h>
#include <pcl/visualization/cloud_viewer.h>
using namespace std;
const string OUT_DIR = "D:\\frame_saver_output\\";
class SimpleOpenNIViewer
{
public:
SimpleOpenNIViewer () : viewer ("PCL Viewer")
{
frames_saved = 0;
save_one = false;
}
void cloud_cb_ (const pcl::PointCloud<pcl::PointXYZRGB>::ConstPtr &cloud)
{
if (!viewer.wasStopped()) {
viewer.showCloud (cloud);
if( save_one ) {
save_one = false;
std::stringstream out;
out << frames_saved;
std::string name = OUT_DIR + "cloud" + out.str() + ".pcd";
pcl::io::savePCDFileASCII( name, *cloud );
}
}
}
void run ()
{
pcl::Grabber* interface = new pcl::OpenNIGrabber();
boost::function<void (const pcl::PointCloud<pcl::PointXYZRGB>::ConstPtr&)> f =
boost::bind (&SimpleOpenNIViewer::cloud_cb_, this, _1);
interface->registerCallback (f);
interface->start ();
char c;
while (!viewer.wasStopped())
{
//sleep (1);
c = getchar();
if( c == 's' ) {
cout << "Saving frame " << frames_saved << ".\n";
frames_saved++;
save_one = true;
}
}
interface->stop ();
}
pcl::visualization::CloudViewer viewer;
private:
int frames_saved;
bool save_one;
};
int main ()
{
SimpleOpenNIViewer v;
v.run ();
return 0;
}
Here you go.