java处理信号

A. java有没有类似matlab的数字信号处理库

java有没有类似matlab的数字信号处理库
如果不是比较前沿的知识,要用到它最新支持的库函数
,用旧的一点版本也是可以的了。

B. 有没有哪位大侠用java实现过将数字信号转换为模拟信号的指点下或给个实例 谢了！！

网卡不能将数字信号转换成模拟信号，他只能传输数字信号，调制解调器的意思有两个，调制的意思是把模拟信号转换成数字信号，解调的意思是把数字信号转换成模拟信号。调制解调器主要在使用拨号上网的时候才用的到。

C. 用java如何传出信号

控制寄存器，用协议通信。

D. java 进程间通讯的有几种方法

进程间通信的方法主要有以下几种：

（1）管道（Pipe）：管道可用于具有亲缘关系进程间的通信，允许一个进程和另一个与它有共同祖先的进程之间进行通信。
（2）命名管道（named pipe）：命名管道克服了管道没有名字的限制，因此，除具有管道所具有的功能外，它还允许无亲缘关 系进程间的通信。命名管道在文件系统中有对应的文件名。命名管道通过命令mkfifo或系统调用mkfifo来创建。
（3）信号（Signal）：信号是比较复杂的通信方式，用于通知接受进程有某种事件发生，除了用于进程间通信外，进程还可以发送 信号给进程本身；linux除了支持Unix早期信号语义函数sigal外，还支持语义符合Posix.1标准的信号函数sigaction（实际上，该函数是基于BSD的，BSD为了实现可靠信号机制，又能够统一对外接口，用sigaction函数重新实现了signal函数）。
（4）消息（Message）队列：消息队列是消息的链接表，包括Posix消息队列system V消息队列。有足够权限的进程可以向队列中添加消息，被赋予读权限的进程则可以读走队列中的消息。消息队列克服了信号承载信息量少，管道只能承载无格式字节流以及缓冲区大小受限等缺
（5）共享内存：使得多个进程可以访问同一块内存空间，是最快的可用IPC形式。是针对其他通信机制运行效率较低而设计的。往往与其它通信机制，如信号量结合使用，来达到进程间的同步及互斥。
（6）内存映射（mapped memory）：内存映射允许任何多个进程间通信，每一个使用该机制的进程通过把一个共享的文件映射到自己的进程地址空间来实现它。
（7）信号量（semaphore）：主要作为进程间以及同一进程不同线程之间的同步手段。
（8）套接口（Socket）：更为一般的进程间通信机制，可用于不同机器之间的进程间通信。起初是由Unix系统的BSD分支开发出来的，但现在一般可以移植到其它类Unix系统上：Linux和System V的变种都支持套接字。

而在java中我们实现多线程间通信则主要采用"共享变量"和"管道流"这两种方法

方法一 通过访问共享变量的方式(注:需要处理同步问题)
方法二 通过管道流

其中方法一有两种实现方法,即
方法一a)通过内部类实现线程的共享变量
代码如下:

public class Innersharethread {
public static void main(String[] args) {
Mythread mythread = new Mythread();
mythread.getThread().start();
mythread.getThread().start();
mythread.getThread().start();
mythread.getThread().start();
}
}
class Mythread {
int index = 0;
private class InnerThread extends Thread {
public synchronized void run() {
while (true) {
System.out.println(Thread.currentThread().getName()
+ "is running and index is " + index++);
}
}
}
public Thread getThread() {
return new InnerThread();
}
}
/**
* 通过内部类实现线程的共享变量
*
*/
public class Innersharethread {
public static void main(String[] args) {
Mythread mythread = new Mythread();
mythread.getThread().start();
mythread.getThread().start();
mythread.getThread().start();
mythread.getThread().start();
}
}
class Mythread {
int index = 0;
private class InnerThread extends Thread {
public synchronized void run() {
while (true) {
System.out.println(Thread.currentThread().getName()
+ "is running and index is " + index++);
}
}
}
public Thread getThread() {
return new InnerThread();
}
}

b)通过实现Runnable接口实现线程的共享变量
代码如下：

public class Interfacaesharethread {
public static void main(String[] args) {
Mythread mythread = new Mythread();
new Thread(mythread).start();
new Thread(mythread).start();
new Thread(mythread).start();
new Thread(mythread).start();
}
}
/* 实现Runnable接口 */
class Mythread implements Runnable {
int index = 0;
public synchronized void run() {
while (true)
System.out.println(Thread.currentThread().getName() + "is running and
the index is " + index++);
}
}
/**
* 通过实现Runnable接口实现线程的共享变量
*/
public class Interfacaesharethread {
public static void main(String[] args) {
Mythread mythread = new Mythread();
new Thread(mythread).start();
new Thread(mythread).start();
new Thread(mythread).start();
new Thread(mythread).start();
}
}
/* 实现Runnable接口 */
class Mythread implements Runnable {
int index = 0;
public synchronized void run() {
while (true)
System.out.println(Thread.currentThread().getName() + "is running and
the index is " + index++);
}
}

方法二(通过管道流）:
代码如下：

public class CommunicateWhitPiping {
public static void main(String[] args) {
/**
* 创建管道输出流
*/
PipedOutputStream pos = new PipedOutputStream();
/**
* 创建管道输入流
*/
PipedInputStream pis = new PipedInputStream();
try {
/**
* 将管道输入流与输出流连接 此过程也可通过重载的构造函数来实现
*/
pos.connect(pis);
} catch (IOException e) {
e.printStackTrace();
}
/**
* 创建生产者线程
*/
Procer p = new Procer(pos);
/**
* 创建消费者线程
*/
Consumer c = new Consumer(pis);
/**
* 启动线程
*/
p.start();
c.start();
}
}
/**
* 生产者线程(与一个管道输入流相关联)
*
*/
class Procer extends Thread {
private PipedOutputStream pos;
public Procer(PipedOutputStream pos) {
this.pos = pos;
}
public void run() {
int i = 8;
try {
pos.write(i);
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
* 消费者线程(与一个管道输入流相关联)
*
*/
class Consumer extends Thread {
private PipedInputStream pis;
public Consumer(PipedInputStream pis) {
this.pis = pis;
}
public void run() {
try {
System.out.println(pis.read());
} catch (IOException e) {
e.printStackTrace();
}
}
}

E. java程序怎么接受压力传感器信号

非标准信号输出，要接变送器转换成标准输出。
已经是标准输出可以选择接有232口 usb口，或者485口的采集卡，数显表，采集器等仪表，

F. java如何实现信号量集，请注意，是信号量集，而不是信号量，求大神指点

信号量：一个整数；
大于或等于0时代表可供并发进程使用的资源实体数；
小于0时代表正在等待使用临界区的进程数；
用于互斥的信号量初始值应大于0；
只能通过P、V原语操作而改变；
信号量元素组成：
1、表示信号量元素的值；
2、最后操作信号量元素的进程ID
3、等待信号量元素值+1的进程数；
4、等待信号量元素值为0的进程数；

二、主要函数

1.1 创建信号量
int semget(
key_t key, //标识信号量的关键字，有三种方法：1、使用IPC——PRIVATE让系统产生，
// 2、挑选一个随机数，3、使用ftok从文件路径名中产生
int nSemes, //信号量集中元素个数
int flag //IPC_CREAT；IPC_EXCL 只有在信号量集不存在时创建
)
成功：返回信号量句柄
失败：返回-1

1.2 使用ftok函数根据文件路径名产生一个关键字
key_t ftok(const char *pathname,int proj_id);
路径名称必须有相应权限

1.3 控制信号量
int semctl(
int semid, //信号量集的句柄
int semnum, //信号量集的元素数
int cmd, //命令
/*union senum arg */... //
)
成功：返回相应的值
失败：返回-1

命令详细说明:
cmd: IPC_RMID 删除一个信号量
IPC_EXCL 只有在信号量集不存在时创建
IPC_SET 设置信号量的许可权
SETVAL 设置指定信号量的元素的值为 agc.val
GETVAL 获得一个指定信号量的值
GETPID 获得最后操纵此元素的最后进程ID
GETNCNT 获得等待元素变为1的进程数
GETZCNT 获得等待元素变为0的进程数

G. 如何用java实现信号量

package synchronization;

public class Semaphore {
private int value;

public Semaphore(){
this.value = 0;
}
public Semaphore(int v){
this.value = v;
}

public synchronized void down(){
while(value <= 0 ){
try{
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
value--;
}

public synchronized void up(){
value++;
notify();
}
}

使用的时候Semophore s;
while(true){
s.wait();
//临界区
s.signal();
}

H. 怎么用Java程序语言模拟手机信号发射器和接收器

考虑用多线程试一试

I. JAVA程序“信号灯”问题

package com.ifeng.test;
import java.awt.BorderLayout;
import java.awt.Canvas;
import java.awt.Choice;
import java.awt.Color;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.Label;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

public class SingalCanvas extends Canvas {
private static final long serialVersionUID = -5305107739145145221L;
int red, green, yellow, x, y, r;
SingalCanvas() {
setBackground(Color.CYAN);
}

public void setRed(int r) {
red = r;
}

public void setGreen(int g) {
green = g;
}

public void setYellow(int y) {
yellow = y;
}

public void setPosition(int x, int y) {
this.x = x;
this.y = y;
}

public void setRadius(int r) {
this.r = r;
}

public void paint(Graphics g) {
if (red == 1) {
g.setColor(Color.red);
} else if (green == 1) {
g.setColor(Color.green);
} else if (yellow == 1) {
g.setColor(Color.yellow);
}
g.fillOval(x, y, 2 * r, 2 * r);// 从x,y位置处画一个实心的圆
}

class SignalFrame extends Frame implements ItemListener
{
private static final long serialVersionUID = 7614643759272879177L;
Choice choice;// 菜单选项
SingalCanvas signal = null;
String itemRed = "Red", itemYellow = "Yellow", itemGreen = "Green";

public SignalFrame(SingalCanvas one)
{
choice = new Choice();
choice.add(itemRed);// 增加选项
choice.add(itemYellow);
choice.add(itemGreen);
add(choice, BorderLayout.NORTH);
try {
// Class cs = Class.forName("SingalCanvas");// 调用，路径
signal = one;
add(signal, BorderLayout.CENTER);
} catch (Exception e) {
add(new Label("SingalCanvas has no Instance"), BorderLayout.CENTER);
}
setBounds(100, 100, 360, 300);
setVisible(true);
validate();
choice.addItemListener(this);

choice.select(0);
new Thread(){
public void run() {
while(true){
for (int i=0;i<choice.getItemCount();i++)
{
System.out.println(i);
choice.select(i);
String item = choice.getSelectedItem(); // choice返回被选中的条目
int w = signal.getBounds().width;
int h = signal.getBounds().height;
int m = Math.min(w, h);
signal.setRadius(m / 6);
if (item.equals(itemRed))
{
if (signal != null) {
signal.setRed(1);
signal.setYellow(0);
signal.setGreen(0);
signal.setPosition(w / 3, 0);
signal.repaint();
}
}
else if (item.equals(itemYellow))
{
if (signal != null) {
signal.setRed(0);
signal.setYellow(1);
signal.setGreen(0);
signal.setPosition(w / 3, h / 3);
signal.repaint();
}
}
else if (item.equals(itemGreen))
{
if (signal != null)
{
signal.setRed(0);
signal.setYellow(0);
signal.setGreen(1);
signal.setPosition(w / 3, 2 * h / 3);
signal.repaint();
}
}
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
}.start();

addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
}

public void itemStateChanged(ItemEvent e)
{
String item = choice.getSelectedItem(); // choice返回被选中的条目
int w = signal.getBounds().width;
int h = signal.getBounds().height;
int m = Math.min(w, h);
signal.setRadius(m / 6);
if (item.equals(itemRed))
{
if (signal != null) {
signal.setRed(1);
signal.setYellow(0);
signal.setGreen(0);
signal.setPosition(w / 3, 0);
signal.repaint();
}
}
else if (item.equals(itemYellow))
{
if (signal != null) {
signal.setRed(0);
signal.setYellow(1);
signal.setGreen(0);
signal.setPosition(w / 3, h / 3);
signal.repaint();
}
}
else if (item.equals(itemGreen))
{
if (signal != null)
{
signal.setRed(0);
signal.setYellow(0);
signal.setGreen(1);
signal.setPosition(w / 3, 2 * h / 3);
signal.repaint();
}
}
}

}

public void crate(SingalCanvas one)
{
SignalFrame frame = new SignalFrame(one);
frame.setTitle("信号灯");
}

public static void main(String[] arg){
SingalCanvas one = new SingalCanvas();
one.crate(one);
}
}

J. 用java编写交通信号灯

按照你的要求编写的红绿灯程序，你看看吧，比较简单。
完整的程序如下：
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.awt.Graphics;
public class TrafficLight extends JFrame{
JRadioButton jrbYellow,jrbGreen,jrbRed;
int flag=0;
jpNewPanel jpNewPanel;
public static void main(String[] args){
TrafficLight frame=new TrafficLight();
frame.setSize(500,200);
frame.setLocationRelativeTo(null);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setTitle("TrafficLight");
frame.setVisible(true);
}
public TrafficLight(){
jpNewPanel=new jpNewPanel();
add(jpNewPanel,BorderLayout.CENTER);
JPanel jpRadioButtons=new JPanel();
jpRadioButtons.setLayout(new GridLayout(1,3));
jpRadioButtons.add(jrbYellow=new JRadioButton("Yellow"));
jpRadioButtons.add(jrbGreen=new JRadioButton("Green"));
jpRadioButtons.add(jrbRed=new JRadioButton("Red"));
add(jpRadioButtons,BorderLayout.SOUTH);
ButtonGroup group=new ButtonGroup();
group.add(jrbYellow);
group.add(jrbGreen);
group.add(jrbRed);

jrbYellow.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e){
flag=2;
jpNewPanel.repaint();
}
});
jrbGreen.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e){
flag=1;
jpNewPanel.repaint();
}
});
jrbRed.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e){
flag=3;
jpNewPanel.repaint();
}
});
}
class jpNewPanel extends JPanel{
protected void paintComponent(Graphics g){
super.paintComponent(g);
g.drawRect(0,0,40,100);
g.drawOval(10,10,20,20);
g.drawOval(10,40,20,20);
g.drawOval(10,70,20,20);
if(flag==1){
g.setColor(Color.GREEN);
g.fillOval(10, 70, 20, 20);
}
else if(flag==2){
g.setColor(Color.YELLOW);
g.fillOval(10, 40, 20, 20);
}
else if(flag==3){
g.setColor(Color.RED);
g.fillOval(10, 10, 20, 20);
}
}
}
}