# FFTE

**Repository Path**: thubcc/ffte

## Basic Information

- **Project Name**: FFTE
- **Description**: 生成定点FFT程序
- **Primary Language**: Scala
- **License**: MIT
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2021-09-16
- **Last Updated**: 2025-11-11

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# FFTE - Fixed-point FFT Generator

[![Documentation](https://img.shields.io/badge/Documentation-Complete-brightgreen.svg)](docs/README.md)
[![Version](https://img.shields.io/badge/Version-1.0.0-blue.svg)](#version-100-documentation-system)
[![License](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)
[![Scala](https://img.shields.io/badge/Scala-2.13.14-red.svg)](https://www.scala-lang.org/)
[![SpinalHDL](https://img.shields.io/badge/SpinalHDL-1.12.0-orange.svg)](https://github.com/SpinalHDL/SpinalHDL)

## 🚀 Project Overview

FFTE (Fixed-point FFT Generator) is a comprehensive high-performance hardware generator for Fast Fourier Transform (FFT) implementations based on Scala and SpinalHDL. The project generates optimized fixed-point FFT hardware implementations suitable for FPGA and ASIC designs.

**🎯 Current Status**: v1.0.0 - Complete documentation system implemented
- ✅ **Complete Documentation System** (18 comprehensive files)
- ✅ **Progressive Learning Path** from beginner to expert
- ✅ **Chinese Language** with technical precision
- ✅ **Mathematical Formulas** and visual diagrams
- ✅ **Real-world Integration** scenarios and optimization guides

## 📚 Quick Start

**🚀 5-Minute Quick Start**:
```bash
# 1. Clone and setup
git clone [repository-url] && cd ffte
sbt compile

# 2. Run basic FFT test
sbt "runMain test.NativeStudy 1 false 64 10"

# 3. Generate hardware
sbt "runMain ffte.generate.MyGenerate"
```

**📖 Complete Documentation**: See [docs/README.md](docs/README.md) for comprehensive guides

## ✨ Key Features

- **🧮 Multiple Algorithm Support** - DFT, Winograd, Prime Factor Decomposition
- **🏗️ Flexible Implementation Modes** - Flat, Mixed, and Streamed architectures
- **🎯 Fixed-point Precision Control** - Configurable I/O bit widths and scaling
- **⚡ Automatic Optimization** - Intelligent decomposition strategy selection
- **🔬 Comprehensive Validation** - Reference implementations and test vectors
- **📚 Professional Documentation** - Complete Chinese documentation system
- **🎓 Learning Resources** - Tutorials, API reference, integration guides
- **🔧 Configuration Management** - Advanced configuration and runtime control

## 📋 Documentation Structure

### 📖 Learning Path

**🚀 For Beginners**:
1. [Installation Guide](docs/getting-started/installation.md) - Complete setup instructions
2. [Quick Start](docs/getting-started/quick-start.md) - 5-minute getting started tutorial
3. [Basic Examples](docs/getting-started/basic-examples.md) - Practical usage examples

**🎯 For Intermediate Users**:
1. [System Architecture](docs/architecture/system-overview.md) - Understanding the 5-layer design
2. [FFT Principles](docs/algorithms/fft-principles.md) - Mathematical foundations
3. [Core API Reference](docs/api-reference/core-api.md) - Complete API documentation

**⚡ For Advanced Users**:
1. [Performance Optimization](docs/tutorials/performance-optimization.md) - System-level optimization
2. [Integration Guide](docs/tutorials/integration-guide.md) - Complete system integration
3. [Custom Configuration](docs/tutorials/custom-configuration.md) - Advanced configuration

### 📁 Directory Structure

```
├── 📚 docs/                          # Complete documentation system
│   ├── README.md                     # Documentation center
│   ├── getting-started/              # Beginner guides (3 files)
│   ├── architecture/                 # System architecture (5 files)
│   ├── algorithms/                   # Algorithm documentation (3 files)
│   ├── api-reference/                # API documentation (4 files)
│   └── tutorials/                    # Tutorial series (4 files)
├── 🚀 hw/spinal/ffte/               # Core hardware implementation
│   ├── abstract/                     # Abstract FFT algorithms
│   ├── core/                         # Core implementations
│   │   ├── flat/                     # Non-pipelined FFT
│   │   ├── mixed/                    # Mixed-radix FFT
│   │   └── streamed/                 # Pipelined FFT
│   ├── algorithm/                    # Generation algorithms
│   ├── types/                        # Data type definitions
│   ├── property/                     # Configuration management
│   ├── evaluate/                     # Validation framework
│   ├── native/                       # Reference implementations
│   ├── misc/                         # Utility components
│   └── default/                      # Default configurations
├── 🧪 src/main/scala/test/           # Test harnesses
├── 📋 plans/                         # Project planning
└── 📦 archived/                      # Archived documents
```

## 🛠️ Installation & Setup

### Requirements
- **Java 8+** - Development environment
- **SBT 1.10.2+** - Build tool
- **Scala 2.13.14** - Language version

### Quick Installation
```bash
# Clone the repository
git clone [repository-url] && cd ffte

# Compile the project
sbt compile

# Run tests to verify installation
sbt test

# Run your first FFT test
sbt "runMain test.NativeStudy 1 false 64 10"
```

**📖 Complete Guide**: See [Installation Guide](docs/getting-started/installation.md) for detailed instructions

## 🚀 Basic Usage

### Running FFT Tests
```bash
# Algorithm validation tests
sbt "runMain test.NativeStudy 1 false 64 10"

# Hardware implementation tests
sbt "runMain ffte.test.FlatStudy 0 64 10"      # Flat architecture
sbt "runMain ffte.test.MixedStudy 2 64 10"     # Mixed architecture
sbt "runMain ffte.test.StreamedStudy 0 64 10" # Streamed architecture

```

### Algorithm Selection
- **Winograd**: Optimal for prime factorizations, high performance
- **FlattenDFT**: Simple implementation, predictable resource usage
- **Prime**: Specialized for prime-sized FFTs

**📖 Complete Tutorial**: See [Basic FFT Generation Tutorial](docs/tutorials/basic-fft-generation.md)

## 🤝 Contributing

We welcome contributions! Please follow these steps:

1. **Fork** this repository
2. **Create** a feature branch (`git checkout -b feature/AmazingFeature`)
3. **Commit** your changes (`git commit -m 'Add some AmazingFeature'`)
4. **Push** to the branch (`git push origin feature/AmazingFeature`)
5. **Open** a Pull Request

### 📋 Development Guidelines
- Follow the existing code style and documentation standards
- Add tests for new features
- Update relevant documentation
- Ensure all tests pass before submitting

## 📄 License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

## 🆘 Support & Contact

- **📖 Documentation**: [Complete Guide](docs/README.md)
- **🐛 Issues**: [GitHub Issues](https://github.com/your-repo/ffte/issues)
- **💬 Discussions**: [GitHub Discussions](https://github.com/your-repo/ffte/discussions)
- **📧 Email**: [your-email@example.com](mailto:your-email@example.com)

## 🎯 Version History

### v1.0.0 - Documentation System (Current)
- ✅ **Complete Documentation System** (18 files)
- ✅ **Progressive Learning Path** from beginner to expert
- ✅ **Chinese Language** with technical precision
- ✅ **Mathematical Formulas** and visual diagrams
- ✅ **Real-world Integration** scenarios

### Previous Milestones
- **Architecture Migration**: Complete migration to `hw/spinal/` structure
- **Testing Framework**: Comprehensive automated testing implementation
- **Performance Optimization**: Advanced optimization techniques

---

**🚀 Ready to get started? Check out our [Quick Start Guide](docs/getting-started/quick-start.md)!**

**📚 Want to learn more? Explore our [complete documentation](docs/README.md).**

**⭐ Like this project? Give us a star and help spread the word!**